node_modules ignore

server/node_modules/@strapi/utils/LICENSE

@@ -0,0 +1,37 @@
+Copyright (c) 2015-present Strapi Solutions SAS
+
+Portions of the Strapi software are licensed as follows:
+
+* All software that resides under an "ee/" directory (the “EE Software”), if that directory exists, is licensed under the license defined below.
+
+Enterprise License
+
+If you or the company you represent has entered into a written agreement referencing the Enterprise Edition of the Strapi source code available at
+https://github.com/strapi/strapi, then such agreement applies to your use of the Enterprise Edition of the Strapi Software. If you or the company you
+represent is using the Enterprise Edition of the Strapi Software in connection with a subscription to our cloud offering, then the agreement you have
+agreed to with respect to our cloud offering and the licenses included in such agreement apply to your use of the Enterprise Edition of the Strapi Software.
+Otherwise, the Strapi Enterprise Software License Agreement (found here https://strapi.io/enterprise-terms) applies to your use of the Enterprise Edition of the Strapi Software.
+
+BY ACCESSING OR USING THE ENTERPRISE EDITION OF THE STRAPI SOFTWARE, YOU ARE AGREEING TO BE BOUND BY THE RELEVANT REFERENCED AGREEMENT.
+IF YOU ARE NOT AUTHORIZED TO ACCEPT THESE TERMS ON BEHALF OF THE COMPANY YOU REPRESENT OR IF YOU DO NOT AGREE TO ALL OF THE RELEVANT TERMS AND CONDITIONS REFERENCED AND YOU
+HAVE NOT OTHERWISE EXECUTED A WRITTEN AGREEMENT WITH STRAPI, YOU ARE NOT AUTHORIZED TO ACCESS OR USE OR ALLOW ANY USER TO ACCESS OR USE ANY PART OF
+THE ENTERPRISE EDITION OF THE STRAPI SOFTWARE.  YOUR ACCESS RIGHTS ARE CONDITIONAL ON YOUR CONSENT TO THE RELEVANT REFERENCED TERMS TO THE EXCLUSION OF ALL OTHER TERMS;
+IF THE RELEVANT REFERENCED TERMS ARE CONSIDERED AN OFFER BY YOU, ACCEPTANCE IS EXPRESSLY LIMITED TO THE RELEVANT REFERENCED TERMS.
+
+* All software outside of the above-mentioned directories or restrictions above is available under the "MIT Expat" license as set forth below.
+
+MIT Expat License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

server/node_modules/@strapi/utils/README.md

@@ -0,0 +1,16 @@
+# strapi-utils
+
+[![npm version](https://img.shields.io/npm/v/@strapi/utils.svg)](https://www.npmjs.org/package/@strapi/utils)
+[![npm downloads](https://img.shields.io/npm/dm/@strapi/utils.svg)](https://www.npmjs.org/package/@strapi/utils)
+
+Shared utilities between Strapi packages.
+
+## Resources
+
+- [License](LICENSE)
+
+## Links
+
+- [Strapi website](https://strapi.io/)
+- [Strapi community on Slack](https://slack.strapi.io)
+- [Strapi news on Twitter](https://twitter.com/strapijs)

server/node_modules/@strapi/utils/dist/async.d.ts

@@ -0,0 +1,8 @@
+type AnyFunc<TA extends any[] = any[], TR = any> = (...args: TA) => TR;
+type MakeProm<T> = Promise<T extends PromiseLike<infer I> ? I : T>;
+type PipeReturn<F extends AnyFunc[]> = MakeProm<ReturnType<F[0]>>;
+export declare function pipe<T extends AnyFunc[]>(...fns: PipeReturn<T> extends never ? never : T): (...args: Parameters<T[0]>) => PipeReturn<T>;
+export declare const map: (...args: any[]) => any;
+export declare const reduce: (mixedArray: any[]) => <T>(iteratee: AnyFunc, initialValue?: T) => Promise<T | undefined>;
+export {};
+//# sourceMappingURL=async.d.ts.map

server/node_modules/@strapi/utils/dist/async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../src/async.ts"],"names":[],"mappings":"AAGA,KAAK,OAAO,CAAC,EAAE,SAAS,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC;AAEvE,KAAK,QAAQ,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,SAAS,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;AAKnE,KAAK,UAAU,CAAC,CAAC,SAAS,OAAO,EAAE,IAAI,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAElE,wBAAgB,IAAI,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,GAAG,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,GAAG,CAAC,gDAYxF;AAED,eAAO,MAAM,GAAG,yBAAc,CAAC;AAE/B,eAAO,MAAM,MAAM,eACJ,GAAG,EAAE,mBACE,OAAO,iBAAiB,CAAC,2BAM5C,CAAC"}

server/node_modules/@strapi/utils/dist/async.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var pMap = require('p-map');
+var fp = require('lodash/fp');
+
+function pipe(...fns) {
+    const [firstFn, ...fnRest] = fns;
+    return async (...args)=>{
+        let res = await firstFn.apply(firstFn, args);
+        for(let i = 0; i < fnRest.length; i += 1){
+            res = await fnRest[i](res);
+        }
+        return res;
+    };
+}
+const map = fp.curry(pMap);
+const reduce = (mixedArray)=>async (iteratee, initialValue)=>{
+        let acc = initialValue;
+        for(let i = 0; i < mixedArray.length; i += 1){
+            acc = await iteratee(acc, await mixedArray[i], i);
+        }
+        return acc;
+    };
+
+exports.map = map;
+exports.pipe = pipe;
+exports.reduce = reduce;
+//# sourceMappingURL=async.js.map

server/node_modules/@strapi/utils/dist/async.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.js","sources":["../src/async.ts"],"sourcesContent":["import pMap from 'p-map';\nimport { curry } from 'lodash/fp';\n\ntype AnyFunc<TA extends any[] = any[], TR = any> = (...args: TA) => TR;\n\ntype MakeProm<T> = Promise<T extends PromiseLike<infer I> ? I : T>;\n\ntype PipedFunc<T extends AnyFunc[]> =\n  PipeReturn<T> extends never ? never : (...args: Parameters<T[0]>) => PipeReturn<T>;\n\ntype PipeReturn<F extends AnyFunc[]> = MakeProm<ReturnType<F[0]>>;\n\nexport function pipe<T extends AnyFunc[]>(...fns: PipeReturn<T> extends never ? never : T) {\n  const [firstFn, ...fnRest] = fns;\n\n  return (async (...args: any[]) => {\n    let res = await firstFn.apply(firstFn, args);\n\n    for (let i = 0; i < fnRest.length; i += 1) {\n      res = await fnRest[i](res);\n    }\n\n    return res;\n  }) as PipedFunc<T>;\n}\n\nexport const map = curry(pMap);\n\nexport const reduce =\n  (mixedArray: any[]) =>\n  async <T>(iteratee: AnyFunc, initialValue?: T) => {\n    let acc = initialValue;\n    for (let i = 0; i < mixedArray.length; i += 1) {\n      acc = await iteratee(acc, await mixedArray[i], i);\n    }\n    return acc;\n  };\n"],"names":["pipe","fns","firstFn","fnRest","args","res","apply","i","length","map","curry","pMap","reduce","mixedArray","iteratee","initialValue","acc"],"mappings":";;;;;AAYO,SAASA,IAA0B,CAAA,GAAGC,GAA4C,EAAA;AACvF,IAAA,MAAM,CAACC,OAAAA,EAAS,GAAGC,MAAAA,CAAO,GAAGF,GAAAA;AAE7B,IAAA,OAAQ,OAAO,GAAGG,IAAAA,GAAAA;AAChB,QAAA,IAAIC,GAAM,GAAA,MAAMH,OAAQI,CAAAA,KAAK,CAACJ,OAASE,EAAAA,IAAAA,CAAAA;QAEvC,IAAK,IAAIG,IAAI,CAAGA,EAAAA,CAAAA,GAAIJ,OAAOK,MAAM,EAAED,KAAK,CAAG,CAAA;AACzCF,YAAAA,GAAAA,GAAM,MAAMF,MAAM,CAACI,CAAAA,CAAE,CAACF,GAAAA,CAAAA;AACxB;QAEA,OAAOA,GAAAA;AACT,KAAA;AACF;AAEO,MAAMI,GAAMC,GAAAA,QAAAA,CAAMC,IAAM;AAElBC,MAAAA,MAAAA,GACX,CAACC,UAAAA,GACD,OAAUC,QAAmBC,EAAAA,YAAAA,GAAAA;AAC3B,QAAA,IAAIC,GAAMD,GAAAA,YAAAA;QACV,IAAK,IAAIR,IAAI,CAAGA,EAAAA,CAAAA,GAAIM,WAAWL,MAAM,EAAED,KAAK,CAAG,CAAA;AAC7CS,YAAAA,GAAAA,GAAM,MAAMF,QAASE,CAAAA,GAAAA,EAAK,MAAMH,UAAU,CAACN,EAAE,EAAEA,CAAAA,CAAAA;AACjD;QACA,OAAOS,GAAAA;;;;;;;"}

server/node_modules/@strapi/utils/dist/async.mjs

@@ -0,0 +1,24 @@
+import pMap from 'p-map';
+import { curry } from 'lodash/fp';
+
+function pipe(...fns) {
+    const [firstFn, ...fnRest] = fns;
+    return async (...args)=>{
+        let res = await firstFn.apply(firstFn, args);
+        for(let i = 0; i < fnRest.length; i += 1){
+            res = await fnRest[i](res);
+        }
+        return res;
+    };
+}
+const map = curry(pMap);
+const reduce = (mixedArray)=>async (iteratee, initialValue)=>{
+        let acc = initialValue;
+        for(let i = 0; i < mixedArray.length; i += 1){
+            acc = await iteratee(acc, await mixedArray[i], i);
+        }
+        return acc;
+    };
+
+export { map, pipe, reduce };
+//# sourceMappingURL=async.mjs.map

server/node_modules/@strapi/utils/dist/async.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.mjs","sources":["../src/async.ts"],"sourcesContent":["import pMap from 'p-map';\nimport { curry } from 'lodash/fp';\n\ntype AnyFunc<TA extends any[] = any[], TR = any> = (...args: TA) => TR;\n\ntype MakeProm<T> = Promise<T extends PromiseLike<infer I> ? I : T>;\n\ntype PipedFunc<T extends AnyFunc[]> =\n  PipeReturn<T> extends never ? never : (...args: Parameters<T[0]>) => PipeReturn<T>;\n\ntype PipeReturn<F extends AnyFunc[]> = MakeProm<ReturnType<F[0]>>;\n\nexport function pipe<T extends AnyFunc[]>(...fns: PipeReturn<T> extends never ? never : T) {\n  const [firstFn, ...fnRest] = fns;\n\n  return (async (...args: any[]) => {\n    let res = await firstFn.apply(firstFn, args);\n\n    for (let i = 0; i < fnRest.length; i += 1) {\n      res = await fnRest[i](res);\n    }\n\n    return res;\n  }) as PipedFunc<T>;\n}\n\nexport const map = curry(pMap);\n\nexport const reduce =\n  (mixedArray: any[]) =>\n  async <T>(iteratee: AnyFunc, initialValue?: T) => {\n    let acc = initialValue;\n    for (let i = 0; i < mixedArray.length; i += 1) {\n      acc = await iteratee(acc, await mixedArray[i], i);\n    }\n    return acc;\n  };\n"],"names":["pipe","fns","firstFn","fnRest","args","res","apply","i","length","map","curry","pMap","reduce","mixedArray","iteratee","initialValue","acc"],"mappings":";;;AAYO,SAASA,IAA0B,CAAA,GAAGC,GAA4C,EAAA;AACvF,IAAA,MAAM,CAACC,OAAAA,EAAS,GAAGC,MAAAA,CAAO,GAAGF,GAAAA;AAE7B,IAAA,OAAQ,OAAO,GAAGG,IAAAA,GAAAA;AAChB,QAAA,IAAIC,GAAM,GAAA,MAAMH,OAAQI,CAAAA,KAAK,CAACJ,OAASE,EAAAA,IAAAA,CAAAA;QAEvC,IAAK,IAAIG,IAAI,CAAGA,EAAAA,CAAAA,GAAIJ,OAAOK,MAAM,EAAED,KAAK,CAAG,CAAA;AACzCF,YAAAA,GAAAA,GAAM,MAAMF,MAAM,CAACI,CAAAA,CAAE,CAACF,GAAAA,CAAAA;AACxB;QAEA,OAAOA,GAAAA;AACT,KAAA;AACF;AAEO,MAAMI,GAAMC,GAAAA,KAAAA,CAAMC,IAAM;AAElBC,MAAAA,MAAAA,GACX,CAACC,UAAAA,GACD,OAAUC,QAAmBC,EAAAA,YAAAA,GAAAA;AAC3B,QAAA,IAAIC,GAAMD,GAAAA,YAAAA;QACV,IAAK,IAAIR,IAAI,CAAGA,EAAAA,CAAAA,GAAIM,WAAWL,MAAM,EAAED,KAAK,CAAG,CAAA;AAC7CS,YAAAA,GAAAA,GAAM,MAAMF,QAASE,CAAAA,GAAAA,EAAK,MAAMH,UAAU,CAACN,EAAE,EAAEA,CAAAA,CAAAA;AACjD;QACA,OAAOS,GAAAA;;;;;"}

server/node_modules/@strapi/utils/dist/content-types.d.ts

@@ -0,0 +1,71 @@
+import type { Model, Kind, Attribute, RelationalAttribute, ComponentAttribute, DynamicZoneAttribute, WithRequired } from './types';
+declare const constants: {
+    ID_ATTRIBUTE: string;
+    DOC_ID_ATTRIBUTE: string;
+    PUBLISHED_AT_ATTRIBUTE: string;
+    CREATED_BY_ATTRIBUTE: string;
+    UPDATED_BY_ATTRIBUTE: string;
+    CREATED_AT_ATTRIBUTE: string;
+    UPDATED_AT_ATTRIBUTE: string;
+    SINGLE_TYPE: string;
+    COLLECTION_TYPE: string;
+};
+declare const getTimestamps: (model: Model) => string[];
+declare const getCreatorFields: (model: Model) => string[];
+declare const getNonWritableAttributes: (model: Model) => string[];
+declare const getWritableAttributes: (model: Model) => string[];
+declare const isWritableAttribute: (model: Model, attributeName: string) => boolean;
+declare const getNonVisibleAttributes: (model: Model) => string[];
+declare const getVisibleAttributes: (model: Model) => string[];
+declare const isVisibleAttribute: (model: Model, attributeName: string) => boolean;
+declare const getOptions: (model: Model) => {
+    draftAndPublish: boolean;
+} | ({
+    draftAndPublish: boolean;
+} & {
+    populateCreatorFields?: boolean | undefined;
+    draftAndPublish?: boolean | undefined;
+});
+declare const hasDraftAndPublish: (model: Model) => boolean;
+declare const isDraft: <T extends object>(data: T, model: Model) => boolean;
+declare const isSchema: (data: unknown) => data is Model;
+declare const isComponentSchema: (data: unknown) => data is Model & {
+    modelType: 'component';
+};
+declare const isContentTypeSchema: (data: unknown) => data is Model & {
+    modelType: 'contentType';
+};
+declare const isSingleType: ({ kind }: {
+    kind?: string | undefined;
+}) => boolean;
+declare const isCollectionType: ({ kind }: {
+    kind?: string | undefined;
+}) => boolean;
+declare const isKind: (kind: Kind) => (model: Model) => boolean;
+declare const getPrivateAttributes: (model: Model) => string[];
+declare const isPrivateAttribute: (model: Model, attributeName: string) => boolean;
+declare const isScalarAttribute: (attribute?: Attribute) => boolean | undefined;
+declare const getDoesAttributeRequireValidation: (attribute: Attribute) => any;
+declare const isMediaAttribute: (attribute?: Attribute) => boolean;
+declare const isRelationalAttribute: (attribute?: Attribute) => attribute is RelationalAttribute;
+declare const hasRelationReordering: (attribute?: Attribute) => boolean;
+declare const isComponentAttribute: (attribute: Attribute) => attribute is ComponentAttribute | DynamicZoneAttribute;
+declare const isDynamicZoneAttribute: (attribute?: Attribute) => attribute is DynamicZoneAttribute;
+declare const isMorphToRelationalAttribute: (attribute?: Attribute) => boolean;
+declare const getComponentAttributes: (schema: Model) => string[];
+declare const getScalarAttributes: (schema: Model) => string[];
+declare const getRelationalAttributes: (schema: Model) => string[];
+/**
+ * Checks if an attribute is of type `type`
+ * @param {object} attribute
+ * @param {string} type
+ */
+declare const isTypedAttribute: (attribute: Attribute, type: string) => boolean;
+/**
+ *  Returns a route prefix for a contentType
+ * @param {object} contentType
+ * @returns {string}
+ */
+declare const getContentTypeRoutePrefix: (contentType: WithRequired<Model, 'info'>) => string;
+export { isSchema, isContentTypeSchema, isComponentSchema, isScalarAttribute, isMediaAttribute, isRelationalAttribute, hasRelationReordering, isComponentAttribute, isDynamicZoneAttribute, isMorphToRelationalAttribute, isTypedAttribute, getPrivateAttributes, isPrivateAttribute, constants, getNonWritableAttributes, getComponentAttributes, getScalarAttributes, getRelationalAttributes, getWritableAttributes, isWritableAttribute, getNonVisibleAttributes, getVisibleAttributes, getTimestamps, getCreatorFields, isVisibleAttribute, getOptions, isDraft, hasDraftAndPublish, isSingleType, isCollectionType, isKind, getContentTypeRoutePrefix, getDoesAttributeRequireValidation, };
+//# sourceMappingURL=content-types.d.ts.map

server/node_modules/@strapi/utils/dist/content-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-types.d.ts","sourceRoot":"","sources":["../src/content-types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,KAAK,EACL,IAAI,EACJ,SAAS,EACT,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACb,MAAM,SAAS,CAAC;AAejB,QAAA,MAAM,SAAS;;;;;;;;;;CAUd,CAAC;AAEF,QAAA,MAAM,aAAa,UAAW,KAAK,aAYlC,CAAC;AAEF,QAAA,MAAM,gBAAgB,UAAW,KAAK,aAYrC,CAAC;AAEF,QAAA,MAAM,wBAAwB,UAAW,KAAK,aAe7C,CAAC;AAEF,QAAA,MAAM,qBAAqB,UAAW,KAAK,aAI1C,CAAC;AAEF,QAAA,MAAM,mBAAmB,UAAW,KAAK,iBAAiB,MAAM,YAE/D,CAAC;AAEF,QAAA,MAAM,uBAAuB,UAAW,KAAK,aAQ5C,CAAC;AAEF,QAAA,MAAM,oBAAoB,UAAW,KAAK,aAEzC,CAAC;AAEF,QAAA,MAAM,kBAAkB,UAAW,KAAK,iBAAiB,MAAM,YAE9D,CAAC;AAEF,QAAA,MAAM,UAAU,UAAW,KAAK;;;;;;;EACmC,CAAC;AAEpE,QAAA,MAAM,kBAAkB,UAAW,KAAK,YACiB,CAAC;AAE1D,QAAA,MAAM,OAAO,2BAA4B,CAAC,SAAS,KAAK,YACmB,CAAC;AAE5E,QAAA,MAAM,QAAQ,SAAU,OAAO,kBAQ9B,CAAC;AAEF,QAAA,MAAM,iBAAiB,SAAU,OAAO;eAAgC,WAAW;CAElF,CAAC;AAEF,QAAA,MAAM,mBAAmB,SAAU,OAAO;eAAgC,aAAa;CAEtF,CAAC;AAEF,QAAA,MAAM,YAAY;;aAAuD,CAAC;AAC1E,QAAA,MAAM,gBAAgB;;aAA2D,CAAC;AAClF,QAAA,MAAM,MAAM,SAAU,IAAI,aAAa,KAAK,YAAwB,CAAC;AAQrE,QAAA,MAAM,oBAAoB,UAAW,KAAK,aAKzC,CAAC;AAEF,QAAA,MAAM,kBAAkB,UAAW,KAAK,iBAAiB,MAAM,YAK9D,CAAC;AAEF,QAAA,MAAM,iBAAiB,eAAgB,SAAS,wBAE/C,CAAC;AAEF,QAAA,MAAM,iCAAiC,cAAe,SAAS,QAS9D,CAAC;AACF,QAAA,MAAM,gBAAgB,eAAgB,SAAS,YAAgC,CAAC;AAChF,QAAA,MAAM,qBAAqB,eAAgB,SAAS,qCACpB,CAAC;AAGjC,QAAA,MAAM,qBAAqB,eAAgB,SAAS,YACsC,CAAC;AAE3F,QAAA,MAAM,oBAAoB,cACb,SAAS,2DAEkC,CAAC;AAEzD,QAAA,MAAM,sBAAsB,eAAgB,SAAS,sCACJ,CAAC;AAClD,QAAA,MAAM,4BAA4B,eAAgB,SAAS,YAI1D,CAAC;AAEF,QAAA,MAAM,sBAAsB,WAAY,KAAK,aAS5C,CAAC;AAEF,QAAA,MAAM,mBAAmB,WAAY,KAAK,aASzC,CAAC;AAEF,QAAA,MAAM,uBAAuB,WAAY,KAAK,aAS7C,CAAC;AAEF;;;;GAIG;AACH,QAAA,MAAM,gBAAgB,cAAe,SAAS,QAAQ,MAAM,YAE3D,CAAC;AAEF;;;;GAIG;AACH,QAAA,MAAM,yBAAyB,gBAAiB,aAAa,KAAK,EAAE,MAAM,CAAC,WAI1E,CAAC;AAEF,OAAO,EACL,QAAQ,EACR,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACpB,sBAAsB,EACtB,4BAA4B,EAC5B,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,EAClB,SAAS,EACT,wBAAwB,EACxB,sBAAsB,EACtB,mBAAmB,EACnB,uBAAuB,EACvB,qBAAqB,EACrB,mBAAmB,EACnB,uBAAuB,EACvB,oBAAoB,EACpB,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,UAAU,EACV,OAAO,EACP,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,MAAM,EACN,yBAAyB,EACzB,iCAAiC,GAClC,CAAC"}

server/node_modules/@strapi/utils/dist/content-types.js

@@ -0,0 +1,201 @@
+'use strict';
+
+var _ = require('lodash');
+var fp = require('lodash/fp');
+
+const SINGLE_TYPE = 'singleType';
+const COLLECTION_TYPE = 'collectionType';
+const ID_ATTRIBUTE = 'id';
+const DOC_ID_ATTRIBUTE = 'documentId';
+const PUBLISHED_AT_ATTRIBUTE = 'publishedAt';
+const CREATED_BY_ATTRIBUTE = 'createdBy';
+const UPDATED_BY_ATTRIBUTE = 'updatedBy';
+const CREATED_AT_ATTRIBUTE = 'createdAt';
+const UPDATED_AT_ATTRIBUTE = 'updatedAt';
+const constants = {
+    ID_ATTRIBUTE,
+    DOC_ID_ATTRIBUTE,
+    PUBLISHED_AT_ATTRIBUTE,
+    CREATED_BY_ATTRIBUTE,
+    UPDATED_BY_ATTRIBUTE,
+    CREATED_AT_ATTRIBUTE,
+    UPDATED_AT_ATTRIBUTE,
+    SINGLE_TYPE,
+    COLLECTION_TYPE
+};
+const getTimestamps = (model)=>{
+    const attributes = [];
+    if (fp.has(CREATED_AT_ATTRIBUTE, model.attributes)) {
+        attributes.push(CREATED_AT_ATTRIBUTE);
+    }
+    if (fp.has(UPDATED_AT_ATTRIBUTE, model.attributes)) {
+        attributes.push(UPDATED_AT_ATTRIBUTE);
+    }
+    return attributes;
+};
+const getCreatorFields = (model)=>{
+    const attributes = [];
+    if (fp.has(CREATED_BY_ATTRIBUTE, model.attributes)) {
+        attributes.push(CREATED_BY_ATTRIBUTE);
+    }
+    if (fp.has(UPDATED_BY_ATTRIBUTE, model.attributes)) {
+        attributes.push(UPDATED_BY_ATTRIBUTE);
+    }
+    return attributes;
+};
+const getNonWritableAttributes = (model)=>{
+    if (!model) return [];
+    const nonWritableAttributes = _.reduce(model.attributes, (acc, attr, attrName)=>attr.writable === false ? acc.concat(attrName) : acc, []);
+    return _.uniq([
+        ID_ATTRIBUTE,
+        DOC_ID_ATTRIBUTE,
+        ...getTimestamps(model),
+        ...nonWritableAttributes
+    ]);
+};
+const getWritableAttributes = (model)=>{
+    if (!model) return [];
+    return _.difference(Object.keys(model.attributes), getNonWritableAttributes(model));
+};
+const isWritableAttribute = (model, attributeName)=>{
+    return getWritableAttributes(model).includes(attributeName);
+};
+const getNonVisibleAttributes = (model)=>{
+    const nonVisibleAttributes = _.reduce(model.attributes, (acc, attr, attrName)=>attr.visible === false ? acc.concat(attrName) : acc, []);
+    return _.uniq([
+        ID_ATTRIBUTE,
+        DOC_ID_ATTRIBUTE,
+        ...getTimestamps(model),
+        ...nonVisibleAttributes
+    ]);
+};
+const getVisibleAttributes = (model)=>{
+    return _.difference(_.keys(model.attributes), getNonVisibleAttributes(model));
+};
+const isVisibleAttribute = (model, attributeName)=>{
+    return getVisibleAttributes(model).includes(attributeName);
+};
+const getOptions = (model)=>_.assign({
+        draftAndPublish: false
+    }, _.get(model, 'options', {}));
+const hasDraftAndPublish = (model)=>_.get(model, 'options.draftAndPublish', false) === true;
+const isDraft = (data, model)=>hasDraftAndPublish(model) && _.get(data, PUBLISHED_AT_ATTRIBUTE) === null;
+const isSchema = (data)=>{
+    return typeof data === 'object' && data !== null && 'modelType' in data && typeof data.modelType === 'string' && [
+        'component',
+        'contentType'
+    ].includes(data.modelType);
+};
+const isComponentSchema = (data)=>{
+    return isSchema(data) && data.modelType === 'component';
+};
+const isContentTypeSchema = (data)=>{
+    return isSchema(data) && data.modelType === 'contentType';
+};
+const isSingleType = ({ kind = COLLECTION_TYPE })=>kind === SINGLE_TYPE;
+const isCollectionType = ({ kind = COLLECTION_TYPE })=>kind === COLLECTION_TYPE;
+const isKind = (kind)=>(model)=>model.kind === kind;
+const getStoredPrivateAttributes = (model)=>fp.union(strapi?.config?.get('api.responses.privateAttributes', []) ?? [], fp.getOr([], 'options.privateAttributes', model));
+const getPrivateAttributes = (model)=>{
+    return _.union(getStoredPrivateAttributes(model), _.keys(_.pickBy(model.attributes, (attr)=>!!attr.private)));
+};
+const isPrivateAttribute = (model, attributeName)=>{
+    if (model?.attributes?.[attributeName]?.private === true) {
+        return true;
+    }
+    return getStoredPrivateAttributes(model).includes(attributeName);
+};
+const isScalarAttribute = (attribute)=>{
+    return attribute && ![
+        'media',
+        'component',
+        'relation',
+        'dynamiczone'
+    ].includes(attribute.type);
+};
+const getDoesAttributeRequireValidation = (attribute)=>{
+    return attribute.required || attribute.unique || Object.prototype.hasOwnProperty.call(attribute, 'max') || Object.prototype.hasOwnProperty.call(attribute, 'min') || Object.prototype.hasOwnProperty.call(attribute, 'maxLength') || Object.prototype.hasOwnProperty.call(attribute, 'minLength');
+};
+const isMediaAttribute = (attribute)=>attribute?.type === 'media';
+const isRelationalAttribute = (attribute)=>attribute?.type === 'relation';
+const HAS_RELATION_REORDERING = [
+    'manyToMany',
+    'manyToOne',
+    'oneToMany'
+];
+const hasRelationReordering = (attribute)=>isRelationalAttribute(attribute) && HAS_RELATION_REORDERING.includes(attribute.relation);
+const isComponentAttribute = (attribute)=>[
+        'component',
+        'dynamiczone'
+    ].includes(attribute?.type);
+const isDynamicZoneAttribute = (attribute)=>!!attribute && attribute.type === 'dynamiczone';
+const isMorphToRelationalAttribute = (attribute)=>{
+    return !!attribute && isRelationalAttribute(attribute) && attribute.relation?.startsWith?.('morphTo');
+};
+const getComponentAttributes = (schema)=>{
+    return _.reduce(schema.attributes, (acc, attr, attrName)=>{
+        if (isComponentAttribute(attr)) acc.push(attrName);
+        return acc;
+    }, []);
+};
+const getScalarAttributes = (schema)=>{
+    return _.reduce(schema.attributes, (acc, attr, attrName)=>{
+        if (isScalarAttribute(attr)) acc.push(attrName);
+        return acc;
+    }, []);
+};
+const getRelationalAttributes = (schema)=>{
+    return _.reduce(schema.attributes, (acc, attr, attrName)=>{
+        if (isRelationalAttribute(attr)) acc.push(attrName);
+        return acc;
+    }, []);
+};
+/**
+ * Checks if an attribute is of type `type`
+ * @param {object} attribute
+ * @param {string} type
+ */ const isTypedAttribute = (attribute, type)=>{
+    return _.has(attribute, 'type') && attribute.type === type;
+};
+/**
+ *  Returns a route prefix for a contentType
+ * @param {object} contentType
+ * @returns {string}
+ */ const getContentTypeRoutePrefix = (contentType)=>{
+    return isSingleType(contentType) ? _.kebabCase(contentType.info.singularName) : _.kebabCase(contentType.info.pluralName);
+};
+
+exports.constants = constants;
+exports.getComponentAttributes = getComponentAttributes;
+exports.getContentTypeRoutePrefix = getContentTypeRoutePrefix;
+exports.getCreatorFields = getCreatorFields;
+exports.getDoesAttributeRequireValidation = getDoesAttributeRequireValidation;
+exports.getNonVisibleAttributes = getNonVisibleAttributes;
+exports.getNonWritableAttributes = getNonWritableAttributes;
+exports.getOptions = getOptions;
+exports.getPrivateAttributes = getPrivateAttributes;
+exports.getRelationalAttributes = getRelationalAttributes;
+exports.getScalarAttributes = getScalarAttributes;
+exports.getTimestamps = getTimestamps;
+exports.getVisibleAttributes = getVisibleAttributes;
+exports.getWritableAttributes = getWritableAttributes;
+exports.hasDraftAndPublish = hasDraftAndPublish;
+exports.hasRelationReordering = hasRelationReordering;
+exports.isCollectionType = isCollectionType;
+exports.isComponentAttribute = isComponentAttribute;
+exports.isComponentSchema = isComponentSchema;
+exports.isContentTypeSchema = isContentTypeSchema;
+exports.isDraft = isDraft;
+exports.isDynamicZoneAttribute = isDynamicZoneAttribute;
+exports.isKind = isKind;
+exports.isMediaAttribute = isMediaAttribute;
+exports.isMorphToRelationalAttribute = isMorphToRelationalAttribute;
+exports.isPrivateAttribute = isPrivateAttribute;
+exports.isRelationalAttribute = isRelationalAttribute;
+exports.isScalarAttribute = isScalarAttribute;
+exports.isSchema = isSchema;
+exports.isSingleType = isSingleType;
+exports.isTypedAttribute = isTypedAttribute;
+exports.isVisibleAttribute = isVisibleAttribute;
+exports.isWritableAttribute = isWritableAttribute;
+//# sourceMappingURL=content-types.js.map

server/node_modules/@strapi/utils/dist/content-types.mjs

@@ -0,0 +1,167 @@
+import ___default from 'lodash';
+import { has, union, getOr } from 'lodash/fp';
+
+const SINGLE_TYPE = 'singleType';
+const COLLECTION_TYPE = 'collectionType';
+const ID_ATTRIBUTE = 'id';
+const DOC_ID_ATTRIBUTE = 'documentId';
+const PUBLISHED_AT_ATTRIBUTE = 'publishedAt';
+const CREATED_BY_ATTRIBUTE = 'createdBy';
+const UPDATED_BY_ATTRIBUTE = 'updatedBy';
+const CREATED_AT_ATTRIBUTE = 'createdAt';
+const UPDATED_AT_ATTRIBUTE = 'updatedAt';
+const constants = {
+    ID_ATTRIBUTE,
+    DOC_ID_ATTRIBUTE,
+    PUBLISHED_AT_ATTRIBUTE,
+    CREATED_BY_ATTRIBUTE,
+    UPDATED_BY_ATTRIBUTE,
+    CREATED_AT_ATTRIBUTE,
+    UPDATED_AT_ATTRIBUTE,
+    SINGLE_TYPE,
+    COLLECTION_TYPE
+};
+const getTimestamps = (model)=>{
+    const attributes = [];
+    if (has(CREATED_AT_ATTRIBUTE, model.attributes)) {
+        attributes.push(CREATED_AT_ATTRIBUTE);
+    }
+    if (has(UPDATED_AT_ATTRIBUTE, model.attributes)) {
+        attributes.push(UPDATED_AT_ATTRIBUTE);
+    }
+    return attributes;
+};
+const getCreatorFields = (model)=>{
+    const attributes = [];
+    if (has(CREATED_BY_ATTRIBUTE, model.attributes)) {
+        attributes.push(CREATED_BY_ATTRIBUTE);
+    }
+    if (has(UPDATED_BY_ATTRIBUTE, model.attributes)) {
+        attributes.push(UPDATED_BY_ATTRIBUTE);
+    }
+    return attributes;
+};
+const getNonWritableAttributes = (model)=>{
+    if (!model) return [];
+    const nonWritableAttributes = ___default.reduce(model.attributes, (acc, attr, attrName)=>attr.writable === false ? acc.concat(attrName) : acc, []);
+    return ___default.uniq([
+        ID_ATTRIBUTE,
+        DOC_ID_ATTRIBUTE,
+        ...getTimestamps(model),
+        ...nonWritableAttributes
+    ]);
+};
+const getWritableAttributes = (model)=>{
+    if (!model) return [];
+    return ___default.difference(Object.keys(model.attributes), getNonWritableAttributes(model));
+};
+const isWritableAttribute = (model, attributeName)=>{
+    return getWritableAttributes(model).includes(attributeName);
+};
+const getNonVisibleAttributes = (model)=>{
+    const nonVisibleAttributes = ___default.reduce(model.attributes, (acc, attr, attrName)=>attr.visible === false ? acc.concat(attrName) : acc, []);
+    return ___default.uniq([
+        ID_ATTRIBUTE,
+        DOC_ID_ATTRIBUTE,
+        ...getTimestamps(model),
+        ...nonVisibleAttributes
+    ]);
+};
+const getVisibleAttributes = (model)=>{
+    return ___default.difference(___default.keys(model.attributes), getNonVisibleAttributes(model));
+};
+const isVisibleAttribute = (model, attributeName)=>{
+    return getVisibleAttributes(model).includes(attributeName);
+};
+const getOptions = (model)=>___default.assign({
+        draftAndPublish: false
+    }, ___default.get(model, 'options', {}));
+const hasDraftAndPublish = (model)=>___default.get(model, 'options.draftAndPublish', false) === true;
+const isDraft = (data, model)=>hasDraftAndPublish(model) && ___default.get(data, PUBLISHED_AT_ATTRIBUTE) === null;
+const isSchema = (data)=>{
+    return typeof data === 'object' && data !== null && 'modelType' in data && typeof data.modelType === 'string' && [
+        'component',
+        'contentType'
+    ].includes(data.modelType);
+};
+const isComponentSchema = (data)=>{
+    return isSchema(data) && data.modelType === 'component';
+};
+const isContentTypeSchema = (data)=>{
+    return isSchema(data) && data.modelType === 'contentType';
+};
+const isSingleType = ({ kind = COLLECTION_TYPE })=>kind === SINGLE_TYPE;
+const isCollectionType = ({ kind = COLLECTION_TYPE })=>kind === COLLECTION_TYPE;
+const isKind = (kind)=>(model)=>model.kind === kind;
+const getStoredPrivateAttributes = (model)=>union(strapi?.config?.get('api.responses.privateAttributes', []) ?? [], getOr([], 'options.privateAttributes', model));
+const getPrivateAttributes = (model)=>{
+    return ___default.union(getStoredPrivateAttributes(model), ___default.keys(___default.pickBy(model.attributes, (attr)=>!!attr.private)));
+};
+const isPrivateAttribute = (model, attributeName)=>{
+    if (model?.attributes?.[attributeName]?.private === true) {
+        return true;
+    }
+    return getStoredPrivateAttributes(model).includes(attributeName);
+};
+const isScalarAttribute = (attribute)=>{
+    return attribute && ![
+        'media',
+        'component',
+        'relation',
+        'dynamiczone'
+    ].includes(attribute.type);
+};
+const getDoesAttributeRequireValidation = (attribute)=>{
+    return attribute.required || attribute.unique || Object.prototype.hasOwnProperty.call(attribute, 'max') || Object.prototype.hasOwnProperty.call(attribute, 'min') || Object.prototype.hasOwnProperty.call(attribute, 'maxLength') || Object.prototype.hasOwnProperty.call(attribute, 'minLength');
+};
+const isMediaAttribute = (attribute)=>attribute?.type === 'media';
+const isRelationalAttribute = (attribute)=>attribute?.type === 'relation';
+const HAS_RELATION_REORDERING = [
+    'manyToMany',
+    'manyToOne',
+    'oneToMany'
+];
+const hasRelationReordering = (attribute)=>isRelationalAttribute(attribute) && HAS_RELATION_REORDERING.includes(attribute.relation);
+const isComponentAttribute = (attribute)=>[
+        'component',
+        'dynamiczone'
+    ].includes(attribute?.type);
+const isDynamicZoneAttribute = (attribute)=>!!attribute && attribute.type === 'dynamiczone';
+const isMorphToRelationalAttribute = (attribute)=>{
+    return !!attribute && isRelationalAttribute(attribute) && attribute.relation?.startsWith?.('morphTo');
+};
+const getComponentAttributes = (schema)=>{
+    return ___default.reduce(schema.attributes, (acc, attr, attrName)=>{
+        if (isComponentAttribute(attr)) acc.push(attrName);
+        return acc;
+    }, []);
+};
+const getScalarAttributes = (schema)=>{
+    return ___default.reduce(schema.attributes, (acc, attr, attrName)=>{
+        if (isScalarAttribute(attr)) acc.push(attrName);
+        return acc;
+    }, []);
+};
+const getRelationalAttributes = (schema)=>{
+    return ___default.reduce(schema.attributes, (acc, attr, attrName)=>{
+        if (isRelationalAttribute(attr)) acc.push(attrName);
+        return acc;
+    }, []);
+};
+/**
+ * Checks if an attribute is of type `type`
+ * @param {object} attribute
+ * @param {string} type
+ */ const isTypedAttribute = (attribute, type)=>{
+    return ___default.has(attribute, 'type') && attribute.type === type;
+};
+/**
+ *  Returns a route prefix for a contentType
+ * @param {object} contentType
+ * @returns {string}
+ */ const getContentTypeRoutePrefix = (contentType)=>{
+    return isSingleType(contentType) ? ___default.kebabCase(contentType.info.singularName) : ___default.kebabCase(contentType.info.pluralName);
+};
+
+export { constants, getComponentAttributes, getContentTypeRoutePrefix, getCreatorFields, getDoesAttributeRequireValidation, getNonVisibleAttributes, getNonWritableAttributes, getOptions, getPrivateAttributes, getRelationalAttributes, getScalarAttributes, getTimestamps, getVisibleAttributes, getWritableAttributes, hasDraftAndPublish, hasRelationReordering, isCollectionType, isComponentAttribute, isComponentSchema, isContentTypeSchema, isDraft, isDynamicZoneAttribute, isKind, isMediaAttribute, isMorphToRelationalAttribute, isPrivateAttribute, isRelationalAttribute, isScalarAttribute, isSchema, isSingleType, isTypedAttribute, isVisibleAttribute, isWritableAttribute };
+//# sourceMappingURL=content-types.mjs.map

server/node_modules/@strapi/utils/dist/convert-query-params.d.ts

@@ -0,0 +1,82 @@
+import { Model } from './types';
+type SortOrder = 'asc' | 'desc';
+export interface SortMap {
+    [key: string]: SortOrder | SortMap;
+}
+export interface SortParamsObject {
+    [key: string]: SortOrder | SortParamsObject;
+}
+type SortParams = string | string[] | SortParamsObject | SortParamsObject[];
+type FieldsParams = string | string[];
+type FiltersParams = unknown;
+export interface PopulateAttributesParams {
+    [key: string]: boolean | PopulateObjectParams;
+}
+export interface PopulateObjectParams {
+    sort?: SortParams;
+    fields?: FieldsParams;
+    filters?: FiltersParams;
+    populate?: string | string[] | PopulateAttributesParams;
+    on?: PopulateAttributesParams;
+    count?: boolean;
+    ordering?: unknown;
+    _q?: string;
+    limit?: number | string;
+    start?: number | string;
+    page?: number | string;
+    pageSize?: number | string;
+}
+type PopulateParams = string | string[] | PopulateAttributesParams;
+export interface Params {
+    sort?: SortParams;
+    fields?: FieldsParams;
+    filters?: FiltersParams;
+    populate?: PopulateParams;
+    count?: boolean;
+    ordering?: unknown;
+    _q?: string;
+    limit?: number | string;
+    start?: number | string;
+    page?: number | string;
+    pageSize?: number | string;
+    status?: 'draft' | 'published';
+}
+type FiltersQuery = (options: {
+    meta: Model;
+}) => WhereQuery | undefined;
+type OrderByQuery = SortMap | SortMap[];
+type SelectQuery = string | string[];
+export interface WhereQuery {
+    [key: string]: any;
+}
+type PopulateQuery = boolean | string[] | {
+    [key: string]: PopulateQuery;
+};
+export interface Query {
+    orderBy?: OrderByQuery;
+    select?: SelectQuery;
+    where?: WhereQuery;
+    filters?: FiltersQuery;
+    populate?: PopulateQuery;
+    count?: boolean;
+    ordering?: unknown;
+    _q?: string;
+    limit?: number;
+    offset?: number;
+    page?: number;
+    pageSize?: number;
+}
+interface TransformerOptions {
+    getModel: (uid: string) => Model | undefined;
+}
+declare const createTransformer: ({ getModel }: TransformerOptions) => {
+    private_convertSortQueryParams: (sortQuery: SortParams) => OrderByQuery;
+    private_convertStartQueryParams: (startQuery: unknown) => number;
+    private_convertLimitQueryParams: (limitQuery: unknown) => number | undefined;
+    private_convertPopulateQueryParams: (populate: PopulateParams, schema?: Model, depth?: number) => PopulateQuery;
+    private_convertFiltersQueryParams: (filters: FiltersParams, schema?: Model) => WhereQuery;
+    private_convertFieldsQueryParams: (fields: FieldsParams, schema?: Model, depth?: number) => SelectQuery | undefined;
+    transformQueryParams: (uid: string, params: Params) => Query;
+};
+export { createTransformer };
+//# sourceMappingURL=convert-query-params.d.ts.map

server/node_modules/@strapi/utils/dist/convert-query-params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-query-params.d.ts","sourceRoot":"","sources":["../src/convert-query-params.ts"],"names":[],"mappings":"AA6BA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAIhC,KAAK,SAAS,GAAG,KAAK,GAAG,MAAM,CAAC;AAEhC,MAAM,WAAW,OAAO;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;CACpC;AAED,MAAM,WAAW,gBAAgB;IAC/B,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,CAAC;CAC7C;AAED,KAAK,UAAU,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,gBAAgB,GAAG,gBAAgB,EAAE,CAAC;AAC5E,KAAK,YAAY,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;AAEtC,KAAK,aAAa,GAAG,OAAO,CAAC;AAE7B,MAAM,WAAW,wBAAwB;IACvC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,oBAAoB,CAAC;CAC/C;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,wBAAwB,CAAC;IACxD,EAAE,CAAC,EAAE,wBAAwB,CAAC;IAC9B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC5B;AAED,KAAK,cAAc,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,wBAAwB,CAAC;AAEnE,MAAM,WAAW,MAAM;IACrB,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,MAAM,CAAC,EAAE,OAAO,GAAG,WAAW,CAAC;CAChC;AAED,KAAK,YAAY,GAAG,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,KAAK,UAAU,GAAG,SAAS,CAAC;AACzE,KAAK,YAAY,GAAG,OAAO,GAAG,OAAO,EAAE,CAAC;AACxC,KAAK,WAAW,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;AAErC,MAAM,WAAW,UAAU;IACzB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,KAAK,aAAa,GACd,OAAO,GACP,MAAM,EAAE,GACR;IACE,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAAC;CAC9B,CAAC;AAEN,MAAM,WAAW,KAAK;IACpB,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,KAAK,CAAC,EAAE,UAAU,CAAC;IAEnB,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAmCD,UAAU,kBAAkB;IAC1B,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,KAAK,GAAG,SAAS,CAAC;CAC9C;AAED,QAAA,MAAM,iBAAiB,iBAAkB,kBAAkB;gDAId,UAAU,KAAG,YAAY;kDAqEvB,OAAO,KAAG,MAAM;kDAahB,OAAO,KAAG,MAAM,GAAG,SAAS;mDAgE7D,cAAc,WACf,KAAK,qBAEb,aAAa;iDA0R4B,aAAa,WAAW,KAAK,KAAG,UAAU;+CA9C5E,YAAY,WACX,KAAK,qBAEb,WAAW,GAAG,SAAS;gCAiJS,MAAM,UAAU,MAAM,KAAG,KAAK;CAkElE,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

server/node_modules/@strapi/utils/dist/convert-query-params.js

@@ -0,0 +1,512 @@
+'use strict';
+
+var _ = require('lodash');
+var fp = require('lodash/fp');
+var contentTypes = require('./content-types.js');
+var errors = require('./errors.js');
+var operators = require('./operators.js');
+var parseType = require('./parse-type.js');
+
+const { ID_ATTRIBUTE, DOC_ID_ATTRIBUTE, PUBLISHED_AT_ATTRIBUTE } = contentTypes.constants;
+class InvalidOrderError extends Error {
+    constructor(){
+        super();
+        this.message = 'Invalid order. order can only be one of asc|desc|ASC|DESC';
+    }
+}
+class InvalidSortError extends Error {
+    constructor(){
+        super();
+        this.message = 'Invalid sort parameter. Expected a string, an array of strings, a sort object or an array of sort objects';
+    }
+}
+function validateOrder(order) {
+    if (!fp.isString(order) || ![
+        'asc',
+        'desc'
+    ].includes(order.toLocaleLowerCase())) {
+        throw new InvalidOrderError();
+    }
+}
+const convertCountQueryParams = (countQuery)=>{
+    return parseType({
+        type: 'boolean',
+        value: countQuery
+    });
+};
+const convertOrderingQueryParams = (ordering)=>{
+    return ordering;
+};
+const isPlainObject = (value)=>_.isPlainObject(value);
+const isStringArray = (value)=>fp.isArray(value) && value.every(fp.isString);
+const createTransformer = ({ getModel })=>{
+    /**
+   * Sort query parser
+   */ const convertSortQueryParams = (sortQuery)=>{
+        if (typeof sortQuery === 'string') {
+            return convertStringSortQueryParam(sortQuery);
+        }
+        if (isStringArray(sortQuery)) {
+            return sortQuery.flatMap((sortValue)=>convertStringSortQueryParam(sortValue));
+        }
+        if (Array.isArray(sortQuery)) {
+            return sortQuery.map((sortValue)=>convertNestedSortQueryParam(sortValue));
+        }
+        if (isPlainObject(sortQuery)) {
+            return convertNestedSortQueryParam(sortQuery);
+        }
+        throw new InvalidSortError();
+    };
+    const convertStringSortQueryParam = (sortQuery)=>{
+        return sortQuery.split(',').map((value)=>convertSingleSortQueryParam(value));
+    };
+    const convertSingleSortQueryParam = (sortQuery)=>{
+        if (!sortQuery) {
+            return {};
+        }
+        if (!fp.isString(sortQuery)) {
+            throw new Error('Invalid sort query');
+        }
+        // split field and order param with default order to ascending
+        const [field, order = 'asc'] = sortQuery.split(':');
+        if (field.length === 0) {
+            throw new Error('Field cannot be empty');
+        }
+        validateOrder(order);
+        // TODO: field should be a valid path on an object model
+        return _.set({}, field, order);
+    };
+    const convertNestedSortQueryParam = (sortQuery)=>{
+        const transformedSort = {};
+        for (const field of Object.keys(sortQuery)){
+            const order = sortQuery[field];
+            // this is a deep sort
+            if (isPlainObject(order)) {
+                transformedSort[field] = convertNestedSortQueryParam(order);
+            } else if (typeof order === 'string') {
+                validateOrder(order);
+                transformedSort[field] = order;
+            } else {
+                throw Error(`Invalid sort type expected object or string got ${typeof order}`);
+            }
+        }
+        return transformedSort;
+    };
+    /**
+   * Start query parser
+   */ const convertStartQueryParams = (startQuery)=>{
+        const startAsANumber = fp.toNumber(startQuery);
+        if (!_.isInteger(startAsANumber) || startAsANumber < 0) {
+            throw new Error(`convertStartQueryParams expected a positive integer got ${startAsANumber}`);
+        }
+        return startAsANumber;
+    };
+    /**
+   * Limit query parser
+   */ const convertLimitQueryParams = (limitQuery)=>{
+        const limitAsANumber = fp.toNumber(limitQuery);
+        if (!_.isInteger(limitAsANumber) || limitAsANumber !== -1 && limitAsANumber < 0) {
+            throw new Error(`convertLimitQueryParams expected a positive integer got ${limitAsANumber}`);
+        }
+        if (limitAsANumber === -1) {
+            return undefined;
+        }
+        return limitAsANumber;
+    };
+    const convertPageQueryParams = (page)=>{
+        const pageVal = fp.toNumber(page);
+        if (!fp.isInteger(pageVal) || pageVal <= 0) {
+            throw new errors.PaginationError(`Invalid 'page' parameter. Expected an integer > 0, received: ${page}`);
+        }
+        return pageVal;
+    };
+    const convertPageSizeQueryParams = (pageSize, page)=>{
+        const pageSizeVal = fp.toNumber(pageSize);
+        if (!fp.isInteger(pageSizeVal) || pageSizeVal <= 0) {
+            throw new errors.PaginationError(`Invalid 'pageSize' parameter. Expected an integer > 0, received: ${page}`);
+        }
+        return pageSizeVal;
+    };
+    const validatePaginationParams = (page, pageSize, start, limit)=>{
+        const isPagePagination = !fp.isNil(page) || !fp.isNil(pageSize);
+        const isOffsetPagination = !fp.isNil(start) || !fp.isNil(limit);
+        if (isPagePagination && isOffsetPagination) {
+            throw new errors.PaginationError('Invalid pagination attributes. The page parameters are incorrect and must be in the pagination object');
+        }
+    };
+    class InvalidPopulateError extends Error {
+        constructor(){
+            super();
+            this.message = 'Invalid populate parameter. Expected a string, an array of strings, a populate object';
+        }
+    }
+    // NOTE: we could support foo.* or foo.bar.* etc later on
+    const convertPopulateQueryParams = (populate, schema, depth = 0)=>{
+        if (depth === 0 && populate === '*') {
+            return true;
+        }
+        if (typeof populate === 'string') {
+            return populate.split(',').map((value)=>_.trim(value));
+        }
+        if (Array.isArray(populate)) {
+            // map convert
+            return _.uniq(populate.flatMap((value)=>{
+                if (typeof value !== 'string') {
+                    throw new InvalidPopulateError();
+                }
+                return value.split(',').map((value)=>_.trim(value));
+            }));
+        }
+        if (_.isPlainObject(populate)) {
+            return convertPopulateObject(populate, schema);
+        }
+        throw new InvalidPopulateError();
+    };
+    const hasPopulateFragmentDefined = (populate)=>{
+        return typeof populate === 'object' && 'on' in populate && !fp.isNil(populate.on);
+    };
+    const hasCountDefined = (populate)=>{
+        return typeof populate === 'object' && 'count' in populate && typeof populate.count === 'boolean';
+    };
+    const convertPopulateObject = (populate, schema)=>{
+        if (!schema) {
+            return {};
+        }
+        const { attributes } = schema;
+        return Object.entries(populate).reduce((acc, [key, subPopulate])=>{
+            // Try converting strings to regular booleans if possible
+            if (_.isString(subPopulate)) {
+                try {
+                    const subPopulateAsBoolean = parseType({
+                        type: 'boolean',
+                        value: subPopulate
+                    });
+                    // Only true is accepted as a boolean populate value
+                    return subPopulateAsBoolean ? {
+                        ...acc,
+                        [key]: true
+                    } : acc;
+                } catch  {
+                // ignore
+                }
+            }
+            if (_.isBoolean(subPopulate)) {
+                // Only true is accepted as a boolean populate value
+                return subPopulate === true ? {
+                    ...acc,
+                    [key]: true
+                } : acc;
+            }
+            const attribute = attributes[key];
+            if (!attribute) {
+                return acc;
+            }
+            // Allow adding an 'on' strategy to populate queries for morphTo relations and dynamic zones
+            const isMorphLikeRelationalAttribute = contentTypes.isDynamicZoneAttribute(attribute) || contentTypes.isMorphToRelationalAttribute(attribute);
+            if (isMorphLikeRelationalAttribute) {
+                const hasInvalidProperties = Object.keys(subPopulate).some((key)=>![
+                        'populate',
+                        'on',
+                        'count'
+                    ].includes(key));
+                if (hasInvalidProperties) {
+                    throw new Error(`Invalid nested populate for ${schema.info?.singularName}.${key} (${schema.uid}). Expected a fragment ("on") or "count" but found ${JSON.stringify(subPopulate)}`);
+                }
+                /**
+         * Validate nested population queries in the context of a polymorphic attribute (dynamic zone, morph relation).
+         *
+         * If 'populate' exists in subPopulate, its value should be constrained to a wildcard ('*').
+         */ if ('populate' in subPopulate && subPopulate.populate !== '*') {
+                    throw new Error(`Invalid nested population query detected. When using 'populate' within polymorphic structures, ` + `its value must be '*' to indicate all second level links. Specific field targeting is not supported here. ` + `Consider using the fragment API for more granular population control.`);
+                }
+                // TODO: Remove the possibility to have multiple properties at the same time (on/count/populate)
+                const newSubPopulate = {};
+                // case: { populate: '*' }
+                if ('populate' in subPopulate) {
+                    Object.assign(newSubPopulate, {
+                        populate: true
+                    });
+                }
+                // case: { on: { <clauses> } }
+                if (hasPopulateFragmentDefined(subPopulate)) {
+                    // If the fragment API is used, it applies the transformation to every
+                    // sub-populate, then assign the result to the new sub-populate
+                    Object.assign(newSubPopulate, {
+                        on: Object.entries(subPopulate.on).reduce((acc, [type, typeSubPopulate])=>({
+                                ...acc,
+                                [type]: convertNestedPopulate(typeSubPopulate, getModel(type))
+                            }), {})
+                    });
+                }
+                // case: { count: true | false }
+                if (hasCountDefined(subPopulate)) {
+                    Object.assign(newSubPopulate, {
+                        count: subPopulate.count
+                    });
+                }
+                return {
+                    ...acc,
+                    [key]: newSubPopulate
+                };
+            }
+            // Edge case when trying to use the fragment ('on') on a non-morph like attribute
+            if (!isMorphLikeRelationalAttribute && hasPopulateFragmentDefined(subPopulate)) {
+                throw new Error(`Using fragments is not permitted to populate "${key}" in "${schema.uid}"`);
+            }
+            // NOTE: Retrieve the target schema UID.
+            // Only handles basic relations, medias and component since it's not possible
+            // to populate with options for a dynamic zone or a polymorphic relation
+            let targetSchemaUID;
+            if (attribute.type === 'relation') {
+                targetSchemaUID = attribute.target;
+            } else if (attribute.type === 'component') {
+                targetSchemaUID = attribute.component;
+            } else if (attribute.type === 'media') {
+                targetSchemaUID = 'plugin::upload.file';
+            } else {
+                return acc;
+            }
+            const targetSchema = getModel(targetSchemaUID);
+            // ignore the sub-populate for the current key if there is no schema associated
+            if (!targetSchema) {
+                return acc;
+            }
+            const populateObject = convertNestedPopulate(subPopulate, targetSchema);
+            if (!populateObject) {
+                return acc;
+            }
+            return {
+                ...acc,
+                [key]: populateObject
+            };
+        }, {});
+    };
+    const convertNestedPopulate = (subPopulate, schema)=>{
+        if (_.isString(subPopulate)) {
+            return parseType({
+                type: 'boolean',
+                value: subPopulate,
+                forceCast: true
+            });
+        }
+        if (_.isBoolean(subPopulate)) {
+            return subPopulate;
+        }
+        if (!isPlainObject(subPopulate)) {
+            throw new Error(`Invalid nested populate. Expected '*' or an object`);
+        }
+        const { sort, filters, fields, populate, count, ordering, page, pageSize, start, limit } = subPopulate;
+        const query = {};
+        if (sort) {
+            query.orderBy = convertSortQueryParams(sort);
+        }
+        if (filters) {
+            query.where = convertFiltersQueryParams(filters, schema);
+        }
+        if (fields) {
+            query.select = convertFieldsQueryParams(fields, schema);
+        }
+        if (populate) {
+            query.populate = convertPopulateQueryParams(populate, schema);
+        }
+        if (count) {
+            query.count = convertCountQueryParams(count);
+        }
+        if (ordering) {
+            query.ordering = convertOrderingQueryParams(ordering);
+        }
+        validatePaginationParams(page, pageSize, start, limit);
+        if (!fp.isNil(page)) {
+            query.page = convertPageQueryParams(page);
+        }
+        if (!fp.isNil(pageSize)) {
+            query.pageSize = convertPageSizeQueryParams(pageSize, page);
+        }
+        if (!fp.isNil(start)) {
+            query.offset = convertStartQueryParams(start);
+        }
+        if (!fp.isNil(limit)) {
+            query.limit = convertLimitQueryParams(limit);
+        }
+        return query;
+    };
+    // TODO: ensure field is valid in content types (will probably have to check strapi.contentTypes since it can be a string.path)
+    const convertFieldsQueryParams = (fields, schema, depth = 0)=>{
+        if (depth === 0 && fields === '*') {
+            return undefined;
+        }
+        if (typeof fields === 'string') {
+            const fieldsValues = fields.split(',').map((value)=>_.trim(value));
+            // NOTE: Only include the doc id if it's a content type
+            if (schema?.modelType === 'contentType') {
+                return _.uniq([
+                    ID_ATTRIBUTE,
+                    DOC_ID_ATTRIBUTE,
+                    ...fieldsValues
+                ]);
+            }
+            return _.uniq([
+                ID_ATTRIBUTE,
+                ...fieldsValues
+            ]);
+        }
+        if (isStringArray(fields)) {
+            // map convert
+            const fieldsValues = fields.flatMap((value)=>convertFieldsQueryParams(value, schema, depth + 1)).filter((v)=>!fp.isNil(v));
+            // NOTE: Only include the doc id if it's a content type
+            if (schema?.modelType === 'contentType') {
+                return _.uniq([
+                    ID_ATTRIBUTE,
+                    DOC_ID_ATTRIBUTE,
+                    ...fieldsValues
+                ]);
+            }
+            return _.uniq([
+                ID_ATTRIBUTE,
+                ...fieldsValues
+            ]);
+        }
+        throw new Error('Invalid fields parameter. Expected a string or an array of strings');
+    };
+    const isValidSchemaAttribute = (key, schema)=>{
+        if ([
+            DOC_ID_ATTRIBUTE,
+            ID_ATTRIBUTE
+        ].includes(key)) {
+            return true;
+        }
+        if (!schema) {
+            return false;
+        }
+        return Object.keys(schema.attributes).includes(key);
+    };
+    const convertFiltersQueryParams = (filters, schema)=>{
+        // Filters need to be either an array or an object
+        // Here we're only checking for 'object' type since typeof [] => object and typeof {} => object
+        if (!fp.isObject(filters)) {
+            throw new Error('The filters parameter must be an object or an array');
+        }
+        // Don't mutate the original object
+        const filtersCopy = fp.cloneDeep(filters);
+        return convertAndSanitizeFilters(filtersCopy, schema);
+    };
+    const convertAndSanitizeFilters = (filters, schema)=>{
+        if (Array.isArray(filters)) {
+            return filters// Sanitize each filter
+            .map((filter)=>convertAndSanitizeFilters(filter, schema))// Filter out empty filters
+            .filter((filter)=>!isPlainObject(filter) || !fp.isEmpty(filter));
+        }
+        if (!isPlainObject(filters)) {
+            return filters;
+        }
+        const removeOperator = (operator)=>delete filters[operator];
+        // Here, `key` can either be an operator or an attribute name
+        for (const [key, value] of Object.entries(filters)){
+            const attribute = fp.get(key, schema?.attributes);
+            const validKey = operators.isOperator(key) || isValidSchemaAttribute(key, schema);
+            if (!validKey) {
+                removeOperator(key);
+            } else if (attribute) {
+                // Relations
+                if (attribute.type === 'relation') {
+                    filters[key] = convertAndSanitizeFilters(value, getModel(attribute.target));
+                } else if (attribute.type === 'component') {
+                    filters[key] = convertAndSanitizeFilters(value, getModel(attribute.component));
+                } else if (attribute.type === 'media') {
+                    filters[key] = convertAndSanitizeFilters(value, getModel('plugin::upload.file'));
+                } else if (attribute.type === 'dynamiczone') {
+                    removeOperator(key);
+                } else if (attribute.type === 'password') {
+                    // Always remove password attributes from filters object
+                    removeOperator(key);
+                } else {
+                    filters[key] = convertAndSanitizeFilters(value, schema);
+                }
+            } else if ([
+                '$null',
+                '$notNull'
+            ].includes(key)) {
+                filters[key] = parseType({
+                    type: 'boolean',
+                    value: filters[key],
+                    forceCast: true
+                });
+            } else if (fp.isObject(value)) {
+                filters[key] = convertAndSanitizeFilters(value, schema);
+            }
+            // Remove empty objects & arrays
+            if (isPlainObject(filters[key]) && fp.isEmpty(filters[key])) {
+                removeOperator(key);
+            }
+        }
+        return filters;
+    };
+    const convertStatusParams = (status, query = {})=>{
+        // NOTE: this is the query layer filters not the document/entity service filters
+        query.filters = ({ meta })=>{
+            const contentType = getModel(meta.uid);
+            // Ignore if target model has disabled DP, as it doesn't make sense to filter by its status
+            if (!contentType || !contentTypes.hasDraftAndPublish(contentType)) {
+                return {};
+            }
+            return {
+                [PUBLISHED_AT_ATTRIBUTE]: {
+                    $null: status === 'draft'
+                }
+            };
+        };
+    };
+    const transformQueryParams = (uid, params)=>{
+        // NOTE: can be a CT, a Compo or nothing in the case of polymorphism (DZ & morph relations)
+        const schema = getModel(uid);
+        const query = {};
+        const { _q, sort, filters, fields, populate, page, pageSize, start, limit, status, ...rest } = params;
+        if (!fp.isNil(status)) {
+            convertStatusParams(status, query);
+        }
+        if (!fp.isNil(_q)) {
+            query._q = _q;
+        }
+        if (!fp.isNil(sort)) {
+            query.orderBy = convertSortQueryParams(sort);
+        }
+        if (!fp.isNil(filters)) {
+            query.where = convertFiltersQueryParams(filters, schema);
+        }
+        if (!fp.isNil(fields)) {
+            query.select = convertFieldsQueryParams(fields, schema);
+        }
+        if (!fp.isNil(populate)) {
+            query.populate = convertPopulateQueryParams(populate, schema);
+        }
+        validatePaginationParams(page, pageSize, start, limit);
+        if (!fp.isNil(page)) {
+            query.page = convertPageQueryParams(page);
+        }
+        if (!fp.isNil(pageSize)) {
+            query.pageSize = convertPageSizeQueryParams(pageSize, page);
+        }
+        if (!fp.isNil(start)) {
+            query.offset = convertStartQueryParams(start);
+        }
+        if (!fp.isNil(limit)) {
+            query.limit = convertLimitQueryParams(limit);
+        }
+        return {
+            ...rest,
+            ...query
+        };
+    };
+    return {
+        private_convertSortQueryParams: convertSortQueryParams,
+        private_convertStartQueryParams: convertStartQueryParams,
+        private_convertLimitQueryParams: convertLimitQueryParams,
+        private_convertPopulateQueryParams: convertPopulateQueryParams,
+        private_convertFiltersQueryParams: convertFiltersQueryParams,
+        private_convertFieldsQueryParams: convertFieldsQueryParams,
+        transformQueryParams
+    };
+};
+
+exports.createTransformer = createTransformer;
+//# sourceMappingURL=convert-query-params.js.map

server/node_modules/@strapi/utils/dist/convert-query-params.mjs

@@ -0,0 +1,510 @@
+import ___default from 'lodash';
+import { isString, toNumber, isNil, isObject, cloneDeep, isEmpty, get, isArray, isInteger } from 'lodash/fp';
+import { isDynamicZoneAttribute, isMorphToRelationalAttribute, constants, hasDraftAndPublish } from './content-types.mjs';
+import { PaginationError } from './errors.mjs';
+import { isOperator } from './operators.mjs';
+import parseType from './parse-type.mjs';
+
+const { ID_ATTRIBUTE, DOC_ID_ATTRIBUTE, PUBLISHED_AT_ATTRIBUTE } = constants;
+class InvalidOrderError extends Error {
+    constructor(){
+        super();
+        this.message = 'Invalid order. order can only be one of asc|desc|ASC|DESC';
+    }
+}
+class InvalidSortError extends Error {
+    constructor(){
+        super();
+        this.message = 'Invalid sort parameter. Expected a string, an array of strings, a sort object or an array of sort objects';
+    }
+}
+function validateOrder(order) {
+    if (!isString(order) || ![
+        'asc',
+        'desc'
+    ].includes(order.toLocaleLowerCase())) {
+        throw new InvalidOrderError();
+    }
+}
+const convertCountQueryParams = (countQuery)=>{
+    return parseType({
+        type: 'boolean',
+        value: countQuery
+    });
+};
+const convertOrderingQueryParams = (ordering)=>{
+    return ordering;
+};
+const isPlainObject = (value)=>___default.isPlainObject(value);
+const isStringArray = (value)=>isArray(value) && value.every(isString);
+const createTransformer = ({ getModel })=>{
+    /**
+   * Sort query parser
+   */ const convertSortQueryParams = (sortQuery)=>{
+        if (typeof sortQuery === 'string') {
+            return convertStringSortQueryParam(sortQuery);
+        }
+        if (isStringArray(sortQuery)) {
+            return sortQuery.flatMap((sortValue)=>convertStringSortQueryParam(sortValue));
+        }
+        if (Array.isArray(sortQuery)) {
+            return sortQuery.map((sortValue)=>convertNestedSortQueryParam(sortValue));
+        }
+        if (isPlainObject(sortQuery)) {
+            return convertNestedSortQueryParam(sortQuery);
+        }
+        throw new InvalidSortError();
+    };
+    const convertStringSortQueryParam = (sortQuery)=>{
+        return sortQuery.split(',').map((value)=>convertSingleSortQueryParam(value));
+    };
+    const convertSingleSortQueryParam = (sortQuery)=>{
+        if (!sortQuery) {
+            return {};
+        }
+        if (!isString(sortQuery)) {
+            throw new Error('Invalid sort query');
+        }
+        // split field and order param with default order to ascending
+        const [field, order = 'asc'] = sortQuery.split(':');
+        if (field.length === 0) {
+            throw new Error('Field cannot be empty');
+        }
+        validateOrder(order);
+        // TODO: field should be a valid path on an object model
+        return ___default.set({}, field, order);
+    };
+    const convertNestedSortQueryParam = (sortQuery)=>{
+        const transformedSort = {};
+        for (const field of Object.keys(sortQuery)){
+            const order = sortQuery[field];
+            // this is a deep sort
+            if (isPlainObject(order)) {
+                transformedSort[field] = convertNestedSortQueryParam(order);
+            } else if (typeof order === 'string') {
+                validateOrder(order);
+                transformedSort[field] = order;
+            } else {
+                throw Error(`Invalid sort type expected object or string got ${typeof order}`);
+            }
+        }
+        return transformedSort;
+    };
+    /**
+   * Start query parser
+   */ const convertStartQueryParams = (startQuery)=>{
+        const startAsANumber = toNumber(startQuery);
+        if (!___default.isInteger(startAsANumber) || startAsANumber < 0) {
+            throw new Error(`convertStartQueryParams expected a positive integer got ${startAsANumber}`);
+        }
+        return startAsANumber;
+    };
+    /**
+   * Limit query parser
+   */ const convertLimitQueryParams = (limitQuery)=>{
+        const limitAsANumber = toNumber(limitQuery);
+        if (!___default.isInteger(limitAsANumber) || limitAsANumber !== -1 && limitAsANumber < 0) {
+            throw new Error(`convertLimitQueryParams expected a positive integer got ${limitAsANumber}`);
+        }
+        if (limitAsANumber === -1) {
+            return undefined;
+        }
+        return limitAsANumber;
+    };
+    const convertPageQueryParams = (page)=>{
+        const pageVal = toNumber(page);
+        if (!isInteger(pageVal) || pageVal <= 0) {
+            throw new PaginationError(`Invalid 'page' parameter. Expected an integer > 0, received: ${page}`);
+        }
+        return pageVal;
+    };
+    const convertPageSizeQueryParams = (pageSize, page)=>{
+        const pageSizeVal = toNumber(pageSize);
+        if (!isInteger(pageSizeVal) || pageSizeVal <= 0) {
+            throw new PaginationError(`Invalid 'pageSize' parameter. Expected an integer > 0, received: ${page}`);
+        }
+        return pageSizeVal;
+    };
+    const validatePaginationParams = (page, pageSize, start, limit)=>{
+        const isPagePagination = !isNil(page) || !isNil(pageSize);
+        const isOffsetPagination = !isNil(start) || !isNil(limit);
+        if (isPagePagination && isOffsetPagination) {
+            throw new PaginationError('Invalid pagination attributes. The page parameters are incorrect and must be in the pagination object');
+        }
+    };
+    class InvalidPopulateError extends Error {
+        constructor(){
+            super();
+            this.message = 'Invalid populate parameter. Expected a string, an array of strings, a populate object';
+        }
+    }
+    // NOTE: we could support foo.* or foo.bar.* etc later on
+    const convertPopulateQueryParams = (populate, schema, depth = 0)=>{
+        if (depth === 0 && populate === '*') {
+            return true;
+        }
+        if (typeof populate === 'string') {
+            return populate.split(',').map((value)=>___default.trim(value));
+        }
+        if (Array.isArray(populate)) {
+            // map convert
+            return ___default.uniq(populate.flatMap((value)=>{
+                if (typeof value !== 'string') {
+                    throw new InvalidPopulateError();
+                }
+                return value.split(',').map((value)=>___default.trim(value));
+            }));
+        }
+        if (___default.isPlainObject(populate)) {
+            return convertPopulateObject(populate, schema);
+        }
+        throw new InvalidPopulateError();
+    };
+    const hasPopulateFragmentDefined = (populate)=>{
+        return typeof populate === 'object' && 'on' in populate && !isNil(populate.on);
+    };
+    const hasCountDefined = (populate)=>{
+        return typeof populate === 'object' && 'count' in populate && typeof populate.count === 'boolean';
+    };
+    const convertPopulateObject = (populate, schema)=>{
+        if (!schema) {
+            return {};
+        }
+        const { attributes } = schema;
+        return Object.entries(populate).reduce((acc, [key, subPopulate])=>{
+            // Try converting strings to regular booleans if possible
+            if (___default.isString(subPopulate)) {
+                try {
+                    const subPopulateAsBoolean = parseType({
+                        type: 'boolean',
+                        value: subPopulate
+                    });
+                    // Only true is accepted as a boolean populate value
+                    return subPopulateAsBoolean ? {
+                        ...acc,
+                        [key]: true
+                    } : acc;
+                } catch  {
+                // ignore
+                }
+            }
+            if (___default.isBoolean(subPopulate)) {
+                // Only true is accepted as a boolean populate value
+                return subPopulate === true ? {
+                    ...acc,
+                    [key]: true
+                } : acc;
+            }
+            const attribute = attributes[key];
+            if (!attribute) {
+                return acc;
+            }
+            // Allow adding an 'on' strategy to populate queries for morphTo relations and dynamic zones
+            const isMorphLikeRelationalAttribute = isDynamicZoneAttribute(attribute) || isMorphToRelationalAttribute(attribute);
+            if (isMorphLikeRelationalAttribute) {
+                const hasInvalidProperties = Object.keys(subPopulate).some((key)=>![
+                        'populate',
+                        'on',
+                        'count'
+                    ].includes(key));
+                if (hasInvalidProperties) {
+                    throw new Error(`Invalid nested populate for ${schema.info?.singularName}.${key} (${schema.uid}). Expected a fragment ("on") or "count" but found ${JSON.stringify(subPopulate)}`);
+                }
+                /**
+         * Validate nested population queries in the context of a polymorphic attribute (dynamic zone, morph relation).
+         *
+         * If 'populate' exists in subPopulate, its value should be constrained to a wildcard ('*').
+         */ if ('populate' in subPopulate && subPopulate.populate !== '*') {
+                    throw new Error(`Invalid nested population query detected. When using 'populate' within polymorphic structures, ` + `its value must be '*' to indicate all second level links. Specific field targeting is not supported here. ` + `Consider using the fragment API for more granular population control.`);
+                }
+                // TODO: Remove the possibility to have multiple properties at the same time (on/count/populate)
+                const newSubPopulate = {};
+                // case: { populate: '*' }
+                if ('populate' in subPopulate) {
+                    Object.assign(newSubPopulate, {
+                        populate: true
+                    });
+                }
+                // case: { on: { <clauses> } }
+                if (hasPopulateFragmentDefined(subPopulate)) {
+                    // If the fragment API is used, it applies the transformation to every
+                    // sub-populate, then assign the result to the new sub-populate
+                    Object.assign(newSubPopulate, {
+                        on: Object.entries(subPopulate.on).reduce((acc, [type, typeSubPopulate])=>({
+                                ...acc,
+                                [type]: convertNestedPopulate(typeSubPopulate, getModel(type))
+                            }), {})
+                    });
+                }
+                // case: { count: true | false }
+                if (hasCountDefined(subPopulate)) {
+                    Object.assign(newSubPopulate, {
+                        count: subPopulate.count
+                    });
+                }
+                return {
+                    ...acc,
+                    [key]: newSubPopulate
+                };
+            }
+            // Edge case when trying to use the fragment ('on') on a non-morph like attribute
+            if (!isMorphLikeRelationalAttribute && hasPopulateFragmentDefined(subPopulate)) {
+                throw new Error(`Using fragments is not permitted to populate "${key}" in "${schema.uid}"`);
+            }
+            // NOTE: Retrieve the target schema UID.
+            // Only handles basic relations, medias and component since it's not possible
+            // to populate with options for a dynamic zone or a polymorphic relation
+            let targetSchemaUID;
+            if (attribute.type === 'relation') {
+                targetSchemaUID = attribute.target;
+            } else if (attribute.type === 'component') {
+                targetSchemaUID = attribute.component;
+            } else if (attribute.type === 'media') {
+                targetSchemaUID = 'plugin::upload.file';
+            } else {
+                return acc;
+            }
+            const targetSchema = getModel(targetSchemaUID);
+            // ignore the sub-populate for the current key if there is no schema associated
+            if (!targetSchema) {
+                return acc;
+            }
+            const populateObject = convertNestedPopulate(subPopulate, targetSchema);
+            if (!populateObject) {
+                return acc;
+            }
+            return {
+                ...acc,
+                [key]: populateObject
+            };
+        }, {});
+    };
+    const convertNestedPopulate = (subPopulate, schema)=>{
+        if (___default.isString(subPopulate)) {
+            return parseType({
+                type: 'boolean',
+                value: subPopulate,
+                forceCast: true
+            });
+        }
+        if (___default.isBoolean(subPopulate)) {
+            return subPopulate;
+        }
+        if (!isPlainObject(subPopulate)) {
+            throw new Error(`Invalid nested populate. Expected '*' or an object`);
+        }
+        const { sort, filters, fields, populate, count, ordering, page, pageSize, start, limit } = subPopulate;
+        const query = {};
+        if (sort) {
+            query.orderBy = convertSortQueryParams(sort);
+        }
+        if (filters) {
+            query.where = convertFiltersQueryParams(filters, schema);
+        }
+        if (fields) {
+            query.select = convertFieldsQueryParams(fields, schema);
+        }
+        if (populate) {
+            query.populate = convertPopulateQueryParams(populate, schema);
+        }
+        if (count) {
+            query.count = convertCountQueryParams(count);
+        }
+        if (ordering) {
+            query.ordering = convertOrderingQueryParams(ordering);
+        }
+        validatePaginationParams(page, pageSize, start, limit);
+        if (!isNil(page)) {
+            query.page = convertPageQueryParams(page);
+        }
+        if (!isNil(pageSize)) {
+            query.pageSize = convertPageSizeQueryParams(pageSize, page);
+        }
+        if (!isNil(start)) {
+            query.offset = convertStartQueryParams(start);
+        }
+        if (!isNil(limit)) {
+            query.limit = convertLimitQueryParams(limit);
+        }
+        return query;
+    };
+    // TODO: ensure field is valid in content types (will probably have to check strapi.contentTypes since it can be a string.path)
+    const convertFieldsQueryParams = (fields, schema, depth = 0)=>{
+        if (depth === 0 && fields === '*') {
+            return undefined;
+        }
+        if (typeof fields === 'string') {
+            const fieldsValues = fields.split(',').map((value)=>___default.trim(value));
+            // NOTE: Only include the doc id if it's a content type
+            if (schema?.modelType === 'contentType') {
+                return ___default.uniq([
+                    ID_ATTRIBUTE,
+                    DOC_ID_ATTRIBUTE,
+                    ...fieldsValues
+                ]);
+            }
+            return ___default.uniq([
+                ID_ATTRIBUTE,
+                ...fieldsValues
+            ]);
+        }
+        if (isStringArray(fields)) {
+            // map convert
+            const fieldsValues = fields.flatMap((value)=>convertFieldsQueryParams(value, schema, depth + 1)).filter((v)=>!isNil(v));
+            // NOTE: Only include the doc id if it's a content type
+            if (schema?.modelType === 'contentType') {
+                return ___default.uniq([
+                    ID_ATTRIBUTE,
+                    DOC_ID_ATTRIBUTE,
+                    ...fieldsValues
+                ]);
+            }
+            return ___default.uniq([
+                ID_ATTRIBUTE,
+                ...fieldsValues
+            ]);
+        }
+        throw new Error('Invalid fields parameter. Expected a string or an array of strings');
+    };
+    const isValidSchemaAttribute = (key, schema)=>{
+        if ([
+            DOC_ID_ATTRIBUTE,
+            ID_ATTRIBUTE
+        ].includes(key)) {
+            return true;
+        }
+        if (!schema) {
+            return false;
+        }
+        return Object.keys(schema.attributes).includes(key);
+    };
+    const convertFiltersQueryParams = (filters, schema)=>{
+        // Filters need to be either an array or an object
+        // Here we're only checking for 'object' type since typeof [] => object and typeof {} => object
+        if (!isObject(filters)) {
+            throw new Error('The filters parameter must be an object or an array');
+        }
+        // Don't mutate the original object
+        const filtersCopy = cloneDeep(filters);
+        return convertAndSanitizeFilters(filtersCopy, schema);
+    };
+    const convertAndSanitizeFilters = (filters, schema)=>{
+        if (Array.isArray(filters)) {
+            return filters// Sanitize each filter
+            .map((filter)=>convertAndSanitizeFilters(filter, schema))// Filter out empty filters
+            .filter((filter)=>!isPlainObject(filter) || !isEmpty(filter));
+        }
+        if (!isPlainObject(filters)) {
+            return filters;
+        }
+        const removeOperator = (operator)=>delete filters[operator];
+        // Here, `key` can either be an operator or an attribute name
+        for (const [key, value] of Object.entries(filters)){
+            const attribute = get(key, schema?.attributes);
+            const validKey = isOperator(key) || isValidSchemaAttribute(key, schema);
+            if (!validKey) {
+                removeOperator(key);
+            } else if (attribute) {
+                // Relations
+                if (attribute.type === 'relation') {
+                    filters[key] = convertAndSanitizeFilters(value, getModel(attribute.target));
+                } else if (attribute.type === 'component') {
+                    filters[key] = convertAndSanitizeFilters(value, getModel(attribute.component));
+                } else if (attribute.type === 'media') {
+                    filters[key] = convertAndSanitizeFilters(value, getModel('plugin::upload.file'));
+                } else if (attribute.type === 'dynamiczone') {
+                    removeOperator(key);
+                } else if (attribute.type === 'password') {
+                    // Always remove password attributes from filters object
+                    removeOperator(key);
+                } else {
+                    filters[key] = convertAndSanitizeFilters(value, schema);
+                }
+            } else if ([
+                '$null',
+                '$notNull'
+            ].includes(key)) {
+                filters[key] = parseType({
+                    type: 'boolean',
+                    value: filters[key],
+                    forceCast: true
+                });
+            } else if (isObject(value)) {
+                filters[key] = convertAndSanitizeFilters(value, schema);
+            }
+            // Remove empty objects & arrays
+            if (isPlainObject(filters[key]) && isEmpty(filters[key])) {
+                removeOperator(key);
+            }
+        }
+        return filters;
+    };
+    const convertStatusParams = (status, query = {})=>{
+        // NOTE: this is the query layer filters not the document/entity service filters
+        query.filters = ({ meta })=>{
+            const contentType = getModel(meta.uid);
+            // Ignore if target model has disabled DP, as it doesn't make sense to filter by its status
+            if (!contentType || !hasDraftAndPublish(contentType)) {
+                return {};
+            }
+            return {
+                [PUBLISHED_AT_ATTRIBUTE]: {
+                    $null: status === 'draft'
+                }
+            };
+        };
+    };
+    const transformQueryParams = (uid, params)=>{
+        // NOTE: can be a CT, a Compo or nothing in the case of polymorphism (DZ & morph relations)
+        const schema = getModel(uid);
+        const query = {};
+        const { _q, sort, filters, fields, populate, page, pageSize, start, limit, status, ...rest } = params;
+        if (!isNil(status)) {
+            convertStatusParams(status, query);
+        }
+        if (!isNil(_q)) {
+            query._q = _q;
+        }
+        if (!isNil(sort)) {
+            query.orderBy = convertSortQueryParams(sort);
+        }
+        if (!isNil(filters)) {
+            query.where = convertFiltersQueryParams(filters, schema);
+        }
+        if (!isNil(fields)) {
+            query.select = convertFieldsQueryParams(fields, schema);
+        }
+        if (!isNil(populate)) {
+            query.populate = convertPopulateQueryParams(populate, schema);
+        }
+        validatePaginationParams(page, pageSize, start, limit);
+        if (!isNil(page)) {
+            query.page = convertPageQueryParams(page);
+        }
+        if (!isNil(pageSize)) {
+            query.pageSize = convertPageSizeQueryParams(pageSize, page);
+        }
+        if (!isNil(start)) {
+            query.offset = convertStartQueryParams(start);
+        }
+        if (!isNil(limit)) {
+            query.limit = convertLimitQueryParams(limit);
+        }
+        return {
+            ...rest,
+            ...query
+        };
+    };
+    return {
+        private_convertSortQueryParams: convertSortQueryParams,
+        private_convertStartQueryParams: convertStartQueryParams,
+        private_convertLimitQueryParams: convertLimitQueryParams,
+        private_convertPopulateQueryParams: convertPopulateQueryParams,
+        private_convertFiltersQueryParams: convertFiltersQueryParams,
+        private_convertFieldsQueryParams: convertFieldsQueryParams,
+        transformQueryParams
+    };
+};
+
+export { createTransformer };
+//# sourceMappingURL=convert-query-params.mjs.map

server/node_modules/@strapi/utils/dist/env-helper.d.ts

@@ -0,0 +1,21 @@
+export type Env = typeof envFn & typeof utils;
+declare function envFn<T>(key: string, defaultValue?: T): string | T | undefined;
+declare const utils: {
+    int(key: string, defaultValue?: number): number | undefined;
+    float(key: string, defaultValue?: number): number | undefined;
+    bool(key: string, defaultValue?: boolean): boolean | undefined;
+    json(key: string, defaultValue?: object): any;
+    array(key: string, defaultValue?: string[]): string[] | undefined;
+    date(key: string, defaultValue?: Date): Date | undefined;
+    /**
+     * Gets a value from env that matches oneOf provided values
+     * @param {string} key
+     * @param {string[]} expectedValues
+     * @param {string|undefined} defaultValue
+     * @returns {string|undefined}
+     */
+    oneOf(key: string, expectedValues?: unknown[], defaultValue?: unknown): unknown;
+};
+declare const env: Env;
+export default env;
+//# sourceMappingURL=env-helper.d.ts.map

server/node_modules/@strapi/utils/dist/env-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-helper.d.ts","sourceRoot":"","sources":["../src/env-helper.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,GAAG,GAAG,OAAO,KAAK,GAAG,OAAO,KAAK,CAAC;AAE9C,iBAAS,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,MAAM,GAAG,CAAC,GAAG,SAAS,CAEvE;AAMD,QAAA,MAAM,KAAK;aACA,MAAM,iBAAiB,MAAM,GAAG,MAAM,GAAG,SAAS;eAQhD,MAAM,iBAAiB,MAAM,GAAG,MAAM,GAAG,SAAS;cAQnD,MAAM,iBAAiB,OAAO,GAAG,OAAO,GAAG,SAAS;cAQpD,MAAM,iBAAiB,MAAM;eAgB5B,MAAM,iBAAiB,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,SAAS;cAgBvD,MAAM,iBAAiB,IAAI,GAAG,IAAI,GAAG,SAAS;IAQxD;;;;;;OAMG;eACQ,MAAM,mBAAmB,OAAO,EAAE,iBAAiB,OAAO;CAYtE,CAAC;AAEF,QAAA,MAAM,GAAG,EAAE,GAAiC,CAAC;AAE7C,eAAe,GAAG,CAAC"}

server/node_modules/@strapi/utils/dist/env-helper.js

@@ -0,0 +1,81 @@
+'use strict';
+
+var _ = require('lodash');
+
+function envFn(key, defaultValue) {
+    return _.has(process.env, key) ? process.env[key] : defaultValue;
+}
+function getKey(key) {
+    return process.env[key] ?? '';
+}
+const utils = {
+    int (key, defaultValue) {
+        if (!_.has(process.env, key)) {
+            return defaultValue;
+        }
+        return parseInt(getKey(key), 10);
+    },
+    float (key, defaultValue) {
+        if (!_.has(process.env, key)) {
+            return defaultValue;
+        }
+        return parseFloat(getKey(key));
+    },
+    bool (key, defaultValue) {
+        if (!_.has(process.env, key)) {
+            return defaultValue;
+        }
+        return getKey(key) === 'true';
+    },
+    json (key, defaultValue) {
+        if (!_.has(process.env, key)) {
+            return defaultValue;
+        }
+        try {
+            return JSON.parse(getKey(key));
+        } catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Invalid json environment variable ${key}: ${error.message}`);
+            }
+            throw error;
+        }
+    },
+    array (key, defaultValue) {
+        if (!_.has(process.env, key)) {
+            return defaultValue;
+        }
+        let value = getKey(key);
+        if (value.startsWith('[') && value.endsWith(']')) {
+            value = value.substring(1, value.length - 1);
+        }
+        return value.split(',').map((v)=>{
+            return _.trim(_.trim(v, ' '), '"');
+        });
+    },
+    date (key, defaultValue) {
+        if (!_.has(process.env, key)) {
+            return defaultValue;
+        }
+        return new Date(getKey(key));
+    },
+    /**
+   * Gets a value from env that matches oneOf provided values
+   * @param {string} key
+   * @param {string[]} expectedValues
+   * @param {string|undefined} defaultValue
+   * @returns {string|undefined}
+   */ oneOf (key, expectedValues, defaultValue) {
+        if (!expectedValues) {
+            throw new Error(`env.oneOf requires expectedValues`);
+        }
+        if (defaultValue && !expectedValues.includes(defaultValue)) {
+            throw new Error(`env.oneOf requires defaultValue to be included in expectedValues`);
+        }
+        const rawValue = env(key, defaultValue);
+        return expectedValues.includes(rawValue) ? rawValue : defaultValue;
+    }
+};
+const env = Object.assign(envFn, utils);
+
+module.exports = env;
+//# sourceMappingURL=env-helper.js.map

server/node_modules/@strapi/utils/dist/env-helper.mjs

@@ -0,0 +1,79 @@
+import ___default from 'lodash';
+
+function envFn(key, defaultValue) {
+    return ___default.has(process.env, key) ? process.env[key] : defaultValue;
+}
+function getKey(key) {
+    return process.env[key] ?? '';
+}
+const utils = {
+    int (key, defaultValue) {
+        if (!___default.has(process.env, key)) {
+            return defaultValue;
+        }
+        return parseInt(getKey(key), 10);
+    },
+    float (key, defaultValue) {
+        if (!___default.has(process.env, key)) {
+            return defaultValue;
+        }
+        return parseFloat(getKey(key));
+    },
+    bool (key, defaultValue) {
+        if (!___default.has(process.env, key)) {
+            return defaultValue;
+        }
+        return getKey(key) === 'true';
+    },
+    json (key, defaultValue) {
+        if (!___default.has(process.env, key)) {
+            return defaultValue;
+        }
+        try {
+            return JSON.parse(getKey(key));
+        } catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Invalid json environment variable ${key}: ${error.message}`);
+            }
+            throw error;
+        }
+    },
+    array (key, defaultValue) {
+        if (!___default.has(process.env, key)) {
+            return defaultValue;
+        }
+        let value = getKey(key);
+        if (value.startsWith('[') && value.endsWith(']')) {
+            value = value.substring(1, value.length - 1);
+        }
+        return value.split(',').map((v)=>{
+            return ___default.trim(___default.trim(v, ' '), '"');
+        });
+    },
+    date (key, defaultValue) {
+        if (!___default.has(process.env, key)) {
+            return defaultValue;
+        }
+        return new Date(getKey(key));
+    },
+    /**
+   * Gets a value from env that matches oneOf provided values
+   * @param {string} key
+   * @param {string[]} expectedValues
+   * @param {string|undefined} defaultValue
+   * @returns {string|undefined}
+   */ oneOf (key, expectedValues, defaultValue) {
+        if (!expectedValues) {
+            throw new Error(`env.oneOf requires expectedValues`);
+        }
+        if (defaultValue && !expectedValues.includes(defaultValue)) {
+            throw new Error(`env.oneOf requires defaultValue to be included in expectedValues`);
+        }
+        const rawValue = env(key, defaultValue);
+        return expectedValues.includes(rawValue) ? rawValue : defaultValue;
+    }
+};
+const env = Object.assign(envFn, utils);
+
+export { env as default };
+//# sourceMappingURL=env-helper.mjs.map

server/node_modules/@strapi/utils/dist/errors.d.ts

@@ -0,0 +1,48 @@
+import yup from 'yup';
+import { HttpError } from 'http-errors';
+declare class ApplicationError<TName extends string = 'ApplicationError', TMessage extends string = string, TDetails = unknown> extends Error {
+    name: TName;
+    details: TDetails;
+    message: TMessage;
+    constructor(message?: TMessage, details?: TDetails);
+}
+declare class ValidationError<TMessage extends string = string, TDetails = unknown> extends ApplicationError<'ValidationError', TMessage, TDetails> {
+    constructor(message: TMessage, details?: TDetails);
+}
+interface YupFormattedError {
+    path: string[];
+    message: string;
+    name: string;
+    value: string;
+}
+declare class YupValidationError<TMessage extends string = string> extends ValidationError<TMessage, {
+    errors: YupFormattedError[];
+}> {
+    constructor(yupError: yup.ValidationError, message?: TMessage);
+}
+declare class PaginationError<TMessage extends string = string, TDetails = unknown> extends ApplicationError<'PaginationError', TMessage, TDetails> {
+    constructor(message?: TMessage, details?: TDetails);
+}
+declare class NotFoundError<TMessage extends string = string, TDetails = unknown> extends ApplicationError<'NotFoundError', TMessage, TDetails> {
+    constructor(message?: TMessage, details?: TDetails);
+}
+declare class ForbiddenError<TName extends string = 'ForbiddenError', TMessage extends string = string, TDetails = unknown> extends ApplicationError<TName, TMessage, TDetails> {
+    constructor(message?: TMessage, details?: TDetails);
+}
+declare class UnauthorizedError<TMessage extends string = string, TDetails = unknown> extends ApplicationError<'UnauthorizedError', TMessage, TDetails> {
+    constructor(message?: TMessage, details?: TDetails);
+}
+declare class RateLimitError<TMessage extends string = string, TDetails = unknown> extends ApplicationError<'RateLimitError', TMessage, TDetails> {
+    constructor(message?: TMessage, details?: TDetails);
+}
+declare class PayloadTooLargeError<TMessage extends string = string, TDetails = unknown> extends ApplicationError<'PayloadTooLargeError', TMessage, TDetails> {
+    constructor(message?: TMessage, details?: TDetails);
+}
+declare class PolicyError<TMessage extends string = string, TDetails = unknown> extends ForbiddenError<'PolicyError', TMessage, TDetails> {
+    constructor(message?: TMessage, details?: TDetails);
+}
+declare class NotImplementedError<TMessage extends string = string, TDetails = unknown> extends ApplicationError<'NotImplementedError', TMessage, TDetails> {
+    constructor(message?: TMessage, details?: TDetails);
+}
+export { HttpError, ApplicationError, ValidationError, YupValidationError, PaginationError, NotFoundError, ForbiddenError, UnauthorizedError, RateLimitError, PayloadTooLargeError, PolicyError, NotImplementedError, };
+//# sourceMappingURL=errors.d.ts.map

server/node_modules/@strapi/utils/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAEA,OAAO,GAAG,MAAM,KAAK,CAAC;AACtB,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAIxC,cAAM,gBAAgB,CACpB,KAAK,SAAS,MAAM,GAAG,kBAAkB,EACzC,QAAQ,SAAS,MAAM,GAAG,MAAM,EAChC,QAAQ,GAAG,OAAO,CAClB,SAAQ,KAAK;IACb,IAAI,EAAE,KAAK,CAAC;IAEZ,OAAO,EAAE,QAAQ,CAAC;IAElB,OAAO,EAAE,QAAQ,CAAC;gBAGhB,OAAO,WAA6C,EACpD,OAAO,GAAE,QAAyB;CAOrC;AAED,cAAM,eAAe,CACnB,QAAQ,SAAS,MAAM,GAAG,MAAM,EAChC,QAAQ,GAAG,OAAO,CAClB,SAAQ,gBAAgB,CAAC,iBAAiB,EAAE,QAAQ,EAAE,QAAQ,CAAC;gBACnD,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,QAAQ;CAIlD;AAED,UAAU,iBAAiB;IACzB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,cAAM,kBAAkB,CAAC,QAAQ,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,eAAe,CAChF,QAAQ,EACR;IAAE,MAAM,EAAE,iBAAiB,EAAE,CAAA;CAAE,CAChC;gBACa,QAAQ,EAAE,GAAG,CAAC,eAAe,EAAE,OAAO,CAAC,EAAE,QAAQ;CAM9D;AAED,cAAM,eAAe,CACnB,QAAQ,SAAS,MAAM,GAAG,MAAM,EAChC,QAAQ,GAAG,OAAO,CAClB,SAAQ,gBAAgB,CAAC,iBAAiB,EAAE,QAAQ,EAAE,QAAQ,CAAC;gBACnD,OAAO,WAAmC,EAAE,OAAO,CAAC,EAAE,QAAQ;CAK3E;AAED,cAAM,aAAa,CAAC,QAAQ,SAAS,MAAM,GAAG,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAE,SAAQ,gBAAgB,CAChG,eAAe,EACf,QAAQ,EACR,QAAQ,CACT;gBACa,OAAO,WAAiC,EAAE,OAAO,CAAC,EAAE,QAAQ;CAKzE;AAED,cAAM,cAAc,CAClB,KAAK,SAAS,MAAM,GAAG,gBAAgB,EACvC,QAAQ,SAAS,MAAM,GAAG,MAAM,EAChC,QAAQ,GAAG,OAAO,CAClB,SAAQ,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,CAAC;gBACvC,OAAO,WAAiC,EAAE,OAAO,CAAC,EAAE,QAAQ;CAKzE;AAED,cAAM,iBAAiB,CACrB,QAAQ,SAAS,MAAM,GAAG,MAAM,EAChC,QAAQ,GAAG,OAAO,CAClB,SAAQ,gBAAgB,CAAC,mBAAmB,EAAE,QAAQ,EAAE,QAAQ,CAAC;gBACrD,OAAO,WAA6B,EAAE,OAAO,CAAC,EAAE,QAAQ;CAKrE;AAED,cAAM,cAAc,CAAC,QAAQ,SAAS,MAAM,GAAG,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAE,SAAQ,gBAAgB,CACjG,gBAAgB,EAChB,QAAQ,EACR,QAAQ,CACT;gBAEG,OAAO,WAA2D,EAClE,OAAO,CAAC,EAAE,QAAQ;CAOrB;AAED,cAAM,oBAAoB,CACxB,QAAQ,SAAS,MAAM,GAAG,MAAM,EAChC,QAAQ,GAAG,OAAO,CAClB,SAAQ,gBAAgB,CAAC,sBAAsB,EAAE,QAAQ,EAAE,QAAQ,CAAC;gBACxD,OAAO,WAAiC,EAAE,OAAO,CAAC,EAAE,QAAQ;CAKzE;AAED,cAAM,WAAW,CAAC,QAAQ,SAAS,MAAM,GAAG,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAE,SAAQ,cAAc,CAC5F,aAAa,EACb,QAAQ,EACR,QAAQ,CACT;gBACa,OAAO,WAA8B,EAAE,OAAO,CAAC,EAAE,QAAQ;CAMtE;AAED,cAAM,mBAAmB,CACvB,QAAQ,SAAS,MAAM,GAAG,MAAM,EAChC,QAAQ,GAAG,OAAO,CAClB,SAAQ,gBAAgB,CAAC,qBAAqB,EAAE,QAAQ,EAAE,QAAQ,CAAC;gBACvD,OAAO,WAAoD,EAAE,OAAO,CAAC,EAAE,QAAQ;CAK5F;AAED,OAAO,EACL,SAAS,EACT,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,cAAc,EACd,oBAAoB,EACpB,WAAW,EACX,mBAAmB,GACpB,CAAC"}

server/node_modules/@strapi/utils/dist/errors.js

@@ -0,0 +1,104 @@
+'use strict';
+
+var httpErrors = require('http-errors');
+var formatYupError = require('./format-yup-error.js');
+
+/* ApplicationError */ class ApplicationError extends Error {
+    constructor(message = 'An application error occured', details = {}){
+        super();
+        this.name = 'ApplicationError';
+        this.message = message;
+        this.details = details;
+    }
+}
+class ValidationError extends ApplicationError {
+    constructor(message, details){
+        super(message, details);
+        this.name = 'ValidationError';
+    }
+}
+class YupValidationError extends ValidationError {
+    constructor(yupError, message){
+        super('Validation');
+        const { errors, message: yupMessage } = formatYupError.formatYupErrors(yupError);
+        this.message = message || yupMessage;
+        this.details = {
+            errors
+        };
+    }
+}
+class PaginationError extends ApplicationError {
+    constructor(message = 'Invalid pagination', details){
+        super(message, details);
+        this.name = 'PaginationError';
+        this.message = message;
+    }
+}
+class NotFoundError extends ApplicationError {
+    constructor(message = 'Entity not found', details){
+        super(message, details);
+        this.name = 'NotFoundError';
+        this.message = message;
+    }
+}
+class ForbiddenError extends ApplicationError {
+    constructor(message = 'Forbidden access', details){
+        super(message, details);
+        this.name = 'ForbiddenError';
+        this.message = message;
+    }
+}
+class UnauthorizedError extends ApplicationError {
+    constructor(message = 'Unauthorized', details){
+        super(message, details);
+        this.name = 'UnauthorizedError';
+        this.message = message;
+    }
+}
+class RateLimitError extends ApplicationError {
+    constructor(message = 'Too many requests, please try again later.', details){
+        super(message, details);
+        this.name = 'RateLimitError';
+        this.message = message;
+        this.details = details || {};
+    }
+}
+class PayloadTooLargeError extends ApplicationError {
+    constructor(message = 'Entity too large', details){
+        super(message, details);
+        this.name = 'PayloadTooLargeError';
+        this.message = message;
+    }
+}
+class PolicyError extends ForbiddenError {
+    constructor(message = 'Policy Failed', details){
+        super(message, details);
+        this.name = 'PolicyError';
+        this.message = message;
+        this.details = details || {};
+    }
+}
+class NotImplementedError extends ApplicationError {
+    constructor(message = 'This feature is not implemented yet', details){
+        super(message, details);
+        this.name = 'NotImplementedError';
+        this.message = message;
+    }
+}
+
+Object.defineProperty(exports, "HttpError", {
+  enumerable: true,
+  get: function () { return httpErrors.HttpError; }
+});
+exports.ApplicationError = ApplicationError;
+exports.ForbiddenError = ForbiddenError;
+exports.NotFoundError = NotFoundError;
+exports.NotImplementedError = NotImplementedError;
+exports.PaginationError = PaginationError;
+exports.PayloadTooLargeError = PayloadTooLargeError;
+exports.PolicyError = PolicyError;
+exports.RateLimitError = RateLimitError;
+exports.UnauthorizedError = UnauthorizedError;
+exports.ValidationError = ValidationError;
+exports.YupValidationError = YupValidationError;
+//# sourceMappingURL=errors.js.map

server/node_modules/@strapi/utils/dist/errors.mjs

@@ -0,0 +1,88 @@
+export { HttpError } from 'http-errors';
+import { formatYupErrors } from './format-yup-error.mjs';
+
+/* ApplicationError */ class ApplicationError extends Error {
+    constructor(message = 'An application error occured', details = {}){
+        super();
+        this.name = 'ApplicationError';
+        this.message = message;
+        this.details = details;
+    }
+}
+class ValidationError extends ApplicationError {
+    constructor(message, details){
+        super(message, details);
+        this.name = 'ValidationError';
+    }
+}
+class YupValidationError extends ValidationError {
+    constructor(yupError, message){
+        super('Validation');
+        const { errors, message: yupMessage } = formatYupErrors(yupError);
+        this.message = message || yupMessage;
+        this.details = {
+            errors
+        };
+    }
+}
+class PaginationError extends ApplicationError {
+    constructor(message = 'Invalid pagination', details){
+        super(message, details);
+        this.name = 'PaginationError';
+        this.message = message;
+    }
+}
+class NotFoundError extends ApplicationError {
+    constructor(message = 'Entity not found', details){
+        super(message, details);
+        this.name = 'NotFoundError';
+        this.message = message;
+    }
+}
+class ForbiddenError extends ApplicationError {
+    constructor(message = 'Forbidden access', details){
+        super(message, details);
+        this.name = 'ForbiddenError';
+        this.message = message;
+    }
+}
+class UnauthorizedError extends ApplicationError {
+    constructor(message = 'Unauthorized', details){
+        super(message, details);
+        this.name = 'UnauthorizedError';
+        this.message = message;
+    }
+}
+class RateLimitError extends ApplicationError {
+    constructor(message = 'Too many requests, please try again later.', details){
+        super(message, details);
+        this.name = 'RateLimitError';
+        this.message = message;
+        this.details = details || {};
+    }
+}
+class PayloadTooLargeError extends ApplicationError {
+    constructor(message = 'Entity too large', details){
+        super(message, details);
+        this.name = 'PayloadTooLargeError';
+        this.message = message;
+    }
+}
+class PolicyError extends ForbiddenError {
+    constructor(message = 'Policy Failed', details){
+        super(message, details);
+        this.name = 'PolicyError';
+        this.message = message;
+        this.details = details || {};
+    }
+}
+class NotImplementedError extends ApplicationError {
+    constructor(message = 'This feature is not implemented yet', details){
+        super(message, details);
+        this.name = 'NotImplementedError';
+        this.message = message;
+    }
+}
+
+export { ApplicationError, ForbiddenError, NotFoundError, NotImplementedError, PaginationError, PayloadTooLargeError, PolicyError, RateLimitError, UnauthorizedError, ValidationError, YupValidationError };
+//# sourceMappingURL=errors.mjs.map

server/node_modules/@strapi/utils/dist/file.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * Utils file containing file treatment utils
+ */
+import { Writable, WritableOptions } from 'node:stream';
+declare const kbytesToBytes: (kbytes: number) => number;
+declare const bytesToKbytes: (bytes: number) => number;
+declare const bytesToHumanReadable: (bytes: number) => string;
+declare const streamToBuffer: (stream: NodeJS.ReadableStream) => Promise<Buffer>;
+declare const getStreamSize: (stream: NodeJS.ReadableStream) => Promise<unknown>;
+/**
+ * Create a writeable Node.js stream that discards received data.
+ * Useful for testing, draining a stream of data, etc.
+ */
+declare function writableDiscardStream(options?: WritableOptions): Writable;
+export { streamToBuffer, bytesToHumanReadable, bytesToKbytes, kbytesToBytes, getStreamSize, writableDiscardStream, };
+//# sourceMappingURL=file.d.ts.map

server/node_modules/@strapi/utils/dist/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../src/file.ts"],"names":[],"mappings":";;;;;;AAAA;;GAEG;AACH,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAExD,QAAA,MAAM,aAAa,WAAY,MAAM,WAAkB,CAAC;AACxD,QAAA,MAAM,aAAa,UAAW,MAAM,WAA2C,CAAC;AAChF,QAAA,MAAM,oBAAoB,UAAW,MAAM,WAK1C,CAAC;AAEF,QAAA,MAAM,cAAc,WAAY,qBAAqB,KAAG,QAAQ,MAAM,CAUlE,CAAC;AAEL,QAAA,MAAM,aAAa,WAAY,qBAAqB,qBAShD,CAAC;AAEL;;;GAGG;AACH,iBAAS,qBAAqB,CAAC,OAAO,CAAC,EAAE,eAAe,YAOvD;AAED,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,aAAa,EACb,aAAa,EACb,qBAAqB,GACtB,CAAC"}

server/node_modules/@strapi/utils/dist/file.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var node_stream = require('node:stream');
+
+const kbytesToBytes = (kbytes)=>kbytes * 1000;
+const bytesToKbytes = (bytes)=>Math.round(bytes / 1000 * 100) / 100;
+const bytesToHumanReadable = (bytes)=>{
+    const sizes = [
+        'Bytes',
+        'KB',
+        'MB',
+        'GB',
+        'TB',
+        'PB'
+    ];
+    if (bytes === 0) return '0 Bytes';
+    const i = parseInt(`${Math.floor(Math.log(bytes) / Math.log(1000))}`, 10);
+    return `${Math.round(bytes / 1000 ** i)} ${sizes[i]}`;
+};
+const streamToBuffer = (stream)=>new Promise((resolve, reject)=>{
+        const chunks = [];
+        stream.on('data', (chunk)=>{
+            chunks.push(chunk);
+        });
+        stream.on('end', ()=>{
+            resolve(Buffer.concat(chunks));
+        });
+        stream.on('error', reject);
+    });
+const getStreamSize = (stream)=>new Promise((resolve, reject)=>{
+        let size = 0;
+        stream.on('data', (chunk)=>{
+            size += Buffer.byteLength(chunk);
+        });
+        stream.on('close', ()=>resolve(size));
+        stream.on('error', reject);
+        stream.resume();
+    });
+/**
+ * Create a writeable Node.js stream that discards received data.
+ * Useful for testing, draining a stream of data, etc.
+ */ function writableDiscardStream(options) {
+    return new node_stream.Writable({
+        ...options,
+        write (chunk, encding, callback) {
+            setImmediate(callback);
+        }
+    });
+}
+
+exports.bytesToHumanReadable = bytesToHumanReadable;
+exports.bytesToKbytes = bytesToKbytes;
+exports.getStreamSize = getStreamSize;
+exports.kbytesToBytes = kbytesToBytes;
+exports.streamToBuffer = streamToBuffer;
+exports.writableDiscardStream = writableDiscardStream;
+//# sourceMappingURL=file.js.map

server/node_modules/@strapi/utils/dist/file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.js","sources":["../src/file.ts"],"sourcesContent":["/**\n * Utils file containing file treatment utils\n */\nimport { Writable, WritableOptions } from 'node:stream';\n\nconst kbytesToBytes = (kbytes: number) => kbytes * 1000;\nconst bytesToKbytes = (bytes: number) => Math.round((bytes / 1000) * 100) / 100;\nconst bytesToHumanReadable = (bytes: number) => {\n  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB'];\n  if (bytes === 0) return '0 Bytes';\n  const i = parseInt(`${Math.floor(Math.log(bytes) / Math.log(1000))}`, 10);\n  return `${Math.round(bytes / 1000 ** i)} ${sizes[i]}`;\n};\n\nconst streamToBuffer = (stream: NodeJS.ReadableStream): Promise<Buffer> =>\n  new Promise((resolve, reject) => {\n    const chunks: Uint8Array[] = [];\n    stream.on('data', (chunk) => {\n      chunks.push(chunk);\n    });\n    stream.on('end', () => {\n      resolve(Buffer.concat(chunks));\n    });\n    stream.on('error', reject);\n  });\n\nconst getStreamSize = (stream: NodeJS.ReadableStream) =>\n  new Promise((resolve, reject) => {\n    let size = 0;\n    stream.on('data', (chunk) => {\n      size += Buffer.byteLength(chunk);\n    });\n    stream.on('close', () => resolve(size));\n    stream.on('error', reject);\n    stream.resume();\n  });\n\n/**\n * Create a writeable Node.js stream that discards received data.\n * Useful for testing, draining a stream of data, etc.\n */\nfunction writableDiscardStream(options?: WritableOptions) {\n  return new Writable({\n    ...options,\n    write(chunk, encding, callback) {\n      setImmediate(callback);\n    },\n  });\n}\n\nexport {\n  streamToBuffer,\n  bytesToHumanReadable,\n  bytesToKbytes,\n  kbytesToBytes,\n  getStreamSize,\n  writableDiscardStream,\n};\n"],"names":["kbytesToBytes","kbytes","bytesToKbytes","bytes","Math","round","bytesToHumanReadable","sizes","i","parseInt","floor","log","streamToBuffer","stream","Promise","resolve","reject","chunks","on","chunk","push","Buffer","concat","getStreamSize","size","byteLength","resume","writableDiscardStream","options","Writable","write","encding","callback","setImmediate"],"mappings":";;;;AAKMA,MAAAA,aAAAA,GAAgB,CAACC,MAAAA,GAAmBA,MAAS,GAAA;AAC7CC,MAAAA,aAAAA,GAAgB,CAACC,KAAkBC,GAAAA,IAAAA,CAAKC,KAAK,CAAEF,KAAQ,GAAA,IAAA,GAAQ,GAAO,CAAA,GAAA;AAC5E,MAAMG,uBAAuB,CAACH,KAAAA,GAAAA;AAC5B,IAAA,MAAMI,KAAQ,GAAA;AAAC,QAAA,OAAA;AAAS,QAAA,IAAA;AAAM,QAAA,IAAA;AAAM,QAAA,IAAA;AAAM,QAAA,IAAA;AAAM,QAAA;AAAK,KAAA;IACrD,IAAIJ,KAAAA,KAAU,GAAG,OAAO,SAAA;AACxB,IAAA,MAAMK,IAAIC,QAAS,CAAA,CAAC,EAAEL,IAAAA,CAAKM,KAAK,CAACN,IAAAA,CAAKO,GAAG,CAACR,SAASC,IAAKO,CAAAA,GAAG,CAAC,IAAA,CAAA,CAAA,CAAO,CAAC,EAAE,EAAA,CAAA;AACtE,IAAA,OAAO,CAAC,EAAEP,IAAKC,CAAAA,KAAK,CAACF,KAAQ,GAAA,IAAA,IAAQK,CAAG,CAAA,CAAA,CAAC,EAAED,KAAK,CAACC,CAAAA,CAAE,CAAC,CAAC;AACvD;AAEA,MAAMI,iBAAiB,CAACC,MAAAA,GACtB,IAAIC,OAAAA,CAAQ,CAACC,OAASC,EAAAA,MAAAA,GAAAA;AACpB,QAAA,MAAMC,SAAuB,EAAE;QAC/BJ,MAAOK,CAAAA,EAAE,CAAC,MAAA,EAAQ,CAACC,KAAAA,GAAAA;AACjBF,YAAAA,MAAAA,CAAOG,IAAI,CAACD,KAAAA,CAAAA;AACd,SAAA,CAAA;QACAN,MAAOK,CAAAA,EAAE,CAAC,KAAO,EAAA,IAAA;YACfH,OAAQM,CAAAA,MAAAA,CAAOC,MAAM,CAACL,MAAAA,CAAAA,CAAAA;AACxB,SAAA,CAAA;QACAJ,MAAOK,CAAAA,EAAE,CAAC,OAASF,EAAAA,MAAAA,CAAAA;AACrB,KAAA;AAEF,MAAMO,gBAAgB,CAACV,MAAAA,GACrB,IAAIC,OAAAA,CAAQ,CAACC,OAASC,EAAAA,MAAAA,GAAAA;AACpB,QAAA,IAAIQ,IAAO,GAAA,CAAA;QACXX,MAAOK,CAAAA,EAAE,CAAC,MAAA,EAAQ,CAACC,KAAAA,GAAAA;YACjBK,IAAQH,IAAAA,MAAAA,CAAOI,UAAU,CAACN,KAAAA,CAAAA;AAC5B,SAAA,CAAA;AACAN,QAAAA,MAAAA,CAAOK,EAAE,CAAC,OAAS,EAAA,IAAMH,OAAQS,CAAAA,IAAAA,CAAAA,CAAAA;QACjCX,MAAOK,CAAAA,EAAE,CAAC,OAASF,EAAAA,MAAAA,CAAAA;AACnBH,QAAAA,MAAAA,CAAOa,MAAM,EAAA;AACf,KAAA;AAEF;;;IAIA,SAASC,sBAAsBC,OAAyB,EAAA;AACtD,IAAA,OAAO,IAAIC,oBAAS,CAAA;AAClB,QAAA,GAAGD,OAAO;AACVE,QAAAA,KAAAA,CAAAA,CAAMX,KAAK,EAAEY,OAAO,EAAEC,QAAQ,EAAA;YAC5BC,YAAaD,CAAAA,QAAAA,CAAAA;AACf;AACF,KAAA,CAAA;AACF;;;;;;;;;"}

server/node_modules/@strapi/utils/dist/file.mjs

@@ -0,0 +1,50 @@
+import { Writable } from 'node:stream';
+
+const kbytesToBytes = (kbytes)=>kbytes * 1000;
+const bytesToKbytes = (bytes)=>Math.round(bytes / 1000 * 100) / 100;
+const bytesToHumanReadable = (bytes)=>{
+    const sizes = [
+        'Bytes',
+        'KB',
+        'MB',
+        'GB',
+        'TB',
+        'PB'
+    ];
+    if (bytes === 0) return '0 Bytes';
+    const i = parseInt(`${Math.floor(Math.log(bytes) / Math.log(1000))}`, 10);
+    return `${Math.round(bytes / 1000 ** i)} ${sizes[i]}`;
+};
+const streamToBuffer = (stream)=>new Promise((resolve, reject)=>{
+        const chunks = [];
+        stream.on('data', (chunk)=>{
+            chunks.push(chunk);
+        });
+        stream.on('end', ()=>{
+            resolve(Buffer.concat(chunks));
+        });
+        stream.on('error', reject);
+    });
+const getStreamSize = (stream)=>new Promise((resolve, reject)=>{
+        let size = 0;
+        stream.on('data', (chunk)=>{
+            size += Buffer.byteLength(chunk);
+        });
+        stream.on('close', ()=>resolve(size));
+        stream.on('error', reject);
+        stream.resume();
+    });
+/**
+ * Create a writeable Node.js stream that discards received data.
+ * Useful for testing, draining a stream of data, etc.
+ */ function writableDiscardStream(options) {
+    return new Writable({
+        ...options,
+        write (chunk, encding, callback) {
+            setImmediate(callback);
+        }
+    });
+}
+
+export { bytesToHumanReadable, bytesToKbytes, getStreamSize, kbytesToBytes, streamToBuffer, writableDiscardStream };
+//# sourceMappingURL=file.mjs.map

server/node_modules/@strapi/utils/dist/file.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.mjs","sources":["../src/file.ts"],"sourcesContent":["/**\n * Utils file containing file treatment utils\n */\nimport { Writable, WritableOptions } from 'node:stream';\n\nconst kbytesToBytes = (kbytes: number) => kbytes * 1000;\nconst bytesToKbytes = (bytes: number) => Math.round((bytes / 1000) * 100) / 100;\nconst bytesToHumanReadable = (bytes: number) => {\n  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB'];\n  if (bytes === 0) return '0 Bytes';\n  const i = parseInt(`${Math.floor(Math.log(bytes) / Math.log(1000))}`, 10);\n  return `${Math.round(bytes / 1000 ** i)} ${sizes[i]}`;\n};\n\nconst streamToBuffer = (stream: NodeJS.ReadableStream): Promise<Buffer> =>\n  new Promise((resolve, reject) => {\n    const chunks: Uint8Array[] = [];\n    stream.on('data', (chunk) => {\n      chunks.push(chunk);\n    });\n    stream.on('end', () => {\n      resolve(Buffer.concat(chunks));\n    });\n    stream.on('error', reject);\n  });\n\nconst getStreamSize = (stream: NodeJS.ReadableStream) =>\n  new Promise((resolve, reject) => {\n    let size = 0;\n    stream.on('data', (chunk) => {\n      size += Buffer.byteLength(chunk);\n    });\n    stream.on('close', () => resolve(size));\n    stream.on('error', reject);\n    stream.resume();\n  });\n\n/**\n * Create a writeable Node.js stream that discards received data.\n * Useful for testing, draining a stream of data, etc.\n */\nfunction writableDiscardStream(options?: WritableOptions) {\n  return new Writable({\n    ...options,\n    write(chunk, encding, callback) {\n      setImmediate(callback);\n    },\n  });\n}\n\nexport {\n  streamToBuffer,\n  bytesToHumanReadable,\n  bytesToKbytes,\n  kbytesToBytes,\n  getStreamSize,\n  writableDiscardStream,\n};\n"],"names":["kbytesToBytes","kbytes","bytesToKbytes","bytes","Math","round","bytesToHumanReadable","sizes","i","parseInt","floor","log","streamToBuffer","stream","Promise","resolve","reject","chunks","on","chunk","push","Buffer","concat","getStreamSize","size","byteLength","resume","writableDiscardStream","options","Writable","write","encding","callback","setImmediate"],"mappings":";;AAKMA,MAAAA,aAAAA,GAAgB,CAACC,MAAAA,GAAmBA,MAAS,GAAA;AAC7CC,MAAAA,aAAAA,GAAgB,CAACC,KAAkBC,GAAAA,IAAAA,CAAKC,KAAK,CAAEF,KAAQ,GAAA,IAAA,GAAQ,GAAO,CAAA,GAAA;AAC5E,MAAMG,uBAAuB,CAACH,KAAAA,GAAAA;AAC5B,IAAA,MAAMI,KAAQ,GAAA;AAAC,QAAA,OAAA;AAAS,QAAA,IAAA;AAAM,QAAA,IAAA;AAAM,QAAA,IAAA;AAAM,QAAA,IAAA;AAAM,QAAA;AAAK,KAAA;IACrD,IAAIJ,KAAAA,KAAU,GAAG,OAAO,SAAA;AACxB,IAAA,MAAMK,IAAIC,QAAS,CAAA,CAAC,EAAEL,IAAAA,CAAKM,KAAK,CAACN,IAAAA,CAAKO,GAAG,CAACR,SAASC,IAAKO,CAAAA,GAAG,CAAC,IAAA,CAAA,CAAA,CAAO,CAAC,EAAE,EAAA,CAAA;AACtE,IAAA,OAAO,CAAC,EAAEP,IAAKC,CAAAA,KAAK,CAACF,KAAQ,GAAA,IAAA,IAAQK,CAAG,CAAA,CAAA,CAAC,EAAED,KAAK,CAACC,CAAAA,CAAE,CAAC,CAAC;AACvD;AAEA,MAAMI,iBAAiB,CAACC,MAAAA,GACtB,IAAIC,OAAAA,CAAQ,CAACC,OAASC,EAAAA,MAAAA,GAAAA;AACpB,QAAA,MAAMC,SAAuB,EAAE;QAC/BJ,MAAOK,CAAAA,EAAE,CAAC,MAAA,EAAQ,CAACC,KAAAA,GAAAA;AACjBF,YAAAA,MAAAA,CAAOG,IAAI,CAACD,KAAAA,CAAAA;AACd,SAAA,CAAA;QACAN,MAAOK,CAAAA,EAAE,CAAC,KAAO,EAAA,IAAA;YACfH,OAAQM,CAAAA,MAAAA,CAAOC,MAAM,CAACL,MAAAA,CAAAA,CAAAA;AACxB,SAAA,CAAA;QACAJ,MAAOK,CAAAA,EAAE,CAAC,OAASF,EAAAA,MAAAA,CAAAA;AACrB,KAAA;AAEF,MAAMO,gBAAgB,CAACV,MAAAA,GACrB,IAAIC,OAAAA,CAAQ,CAACC,OAASC,EAAAA,MAAAA,GAAAA;AACpB,QAAA,IAAIQ,IAAO,GAAA,CAAA;QACXX,MAAOK,CAAAA,EAAE,CAAC,MAAA,EAAQ,CAACC,KAAAA,GAAAA;YACjBK,IAAQH,IAAAA,MAAAA,CAAOI,UAAU,CAACN,KAAAA,CAAAA;AAC5B,SAAA,CAAA;AACAN,QAAAA,MAAAA,CAAOK,EAAE,CAAC,OAAS,EAAA,IAAMH,OAAQS,CAAAA,IAAAA,CAAAA,CAAAA;QACjCX,MAAOK,CAAAA,EAAE,CAAC,OAASF,EAAAA,MAAAA,CAAAA;AACnBH,QAAAA,MAAAA,CAAOa,MAAM,EAAA;AACf,KAAA;AAEF;;;IAIA,SAASC,sBAAsBC,OAAyB,EAAA;AACtD,IAAA,OAAO,IAAIC,QAAS,CAAA;AAClB,QAAA,GAAGD,OAAO;AACVE,QAAAA,KAAAA,CAAAA,CAAMX,KAAK,EAAEY,OAAO,EAAEC,QAAQ,EAAA;YAC5BC,YAAaD,CAAAA,QAAAA,CAAAA;AACf;AACF,KAAA,CAAA;AACF;;;;"}

server/node_modules/@strapi/utils/dist/format-yup-error.d.ts

@@ -0,0 +1,12 @@
+import { ValidationError } from 'yup';
+declare const formatYupErrors: (yupError: ValidationError) => {
+    errors: {
+        path: string[];
+        message: string;
+        name: string;
+        value: any;
+    }[];
+    message: string;
+};
+export { formatYupErrors };
+//# sourceMappingURL=format-yup-error.d.ts.map

server/node_modules/@strapi/utils/dist/format-yup-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-yup-error.d.ts","sourceRoot":"","sources":["../src/format-yup-error.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,KAAK,CAAC;AAStC,QAAA,MAAM,eAAe,aAAc,eAAe;;;;;;;;CAKhD,CAAC;AAEH,OAAO,EAAE,eAAe,EAAE,CAAC"}

server/node_modules/@strapi/utils/dist/format-yup-error.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var fp = require('lodash/fp');
+
+const formatYupInnerError = (yupError)=>({
+        path: fp.toPath(yupError.path),
+        message: yupError.message,
+        name: yupError.name,
+        value: yupError.value
+    });
+const formatYupErrors = (yupError)=>({
+        errors: fp.isEmpty(yupError.inner) ? [
+            formatYupInnerError(yupError)
+        ] : yupError.inner.map(formatYupInnerError),
+        message: yupError.message
+    });
+
+exports.formatYupErrors = formatYupErrors;
+//# sourceMappingURL=format-yup-error.js.map

server/node_modules/@strapi/utils/dist/format-yup-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-yup-error.js","sources":["../src/format-yup-error.ts"],"sourcesContent":["import { isEmpty, toPath } from 'lodash/fp';\nimport { ValidationError } from 'yup';\n\nconst formatYupInnerError = (yupError: ValidationError) => ({\n  path: toPath(yupError.path),\n  message: yupError.message,\n  name: yupError.name,\n  value: yupError.value,\n});\n\nconst formatYupErrors = (yupError: ValidationError) => ({\n  errors: isEmpty(yupError.inner)\n    ? [formatYupInnerError(yupError)]\n    : yupError.inner.map(formatYupInnerError),\n  message: yupError.message,\n});\n\nexport { formatYupErrors };\n"],"names":["formatYupInnerError","yupError","path","toPath","message","name","value","formatYupErrors","errors","isEmpty","inner","map"],"mappings":";;;;AAGA,MAAMA,mBAAAA,GAAsB,CAACC,QAAAA,IAA+B;QAC1DC,IAAMC,EAAAA,SAAAA,CAAOF,SAASC,IAAI,CAAA;AAC1BE,QAAAA,OAAAA,EAASH,SAASG,OAAO;AACzBC,QAAAA,IAAAA,EAAMJ,SAASI,IAAI;AACnBC,QAAAA,KAAAA,EAAOL,SAASK;KAClB,CAAA;AAEMC,MAAAA,eAAAA,GAAkB,CAACN,QAAAA,IAA+B;QACtDO,MAAQC,EAAAA,UAAAA,CAAQR,QAASS,CAAAA,KAAK,CAC1B,GAAA;YAACV,mBAAoBC,CAAAA,QAAAA;AAAU,SAAA,GAC/BA,QAASS,CAAAA,KAAK,CAACC,GAAG,CAACX,mBAAAA,CAAAA;AACvBI,QAAAA,OAAAA,EAASH,SAASG;KACpB;;;;"}

server/node_modules/@strapi/utils/dist/format-yup-error.mjs

@@ -0,0 +1,17 @@
+import { isEmpty, toPath } from 'lodash/fp';
+
+const formatYupInnerError = (yupError)=>({
+        path: toPath(yupError.path),
+        message: yupError.message,
+        name: yupError.name,
+        value: yupError.value
+    });
+const formatYupErrors = (yupError)=>({
+        errors: isEmpty(yupError.inner) ? [
+            formatYupInnerError(yupError)
+        ] : yupError.inner.map(formatYupInnerError),
+        message: yupError.message
+    });
+
+export { formatYupErrors };
+//# sourceMappingURL=format-yup-error.mjs.map

server/node_modules/@strapi/utils/dist/format-yup-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-yup-error.mjs","sources":["../src/format-yup-error.ts"],"sourcesContent":["import { isEmpty, toPath } from 'lodash/fp';\nimport { ValidationError } from 'yup';\n\nconst formatYupInnerError = (yupError: ValidationError) => ({\n  path: toPath(yupError.path),\n  message: yupError.message,\n  name: yupError.name,\n  value: yupError.value,\n});\n\nconst formatYupErrors = (yupError: ValidationError) => ({\n  errors: isEmpty(yupError.inner)\n    ? [formatYupInnerError(yupError)]\n    : yupError.inner.map(formatYupInnerError),\n  message: yupError.message,\n});\n\nexport { formatYupErrors };\n"],"names":["formatYupInnerError","yupError","path","toPath","message","name","value","formatYupErrors","errors","isEmpty","inner","map"],"mappings":";;AAGA,MAAMA,mBAAAA,GAAsB,CAACC,QAAAA,IAA+B;QAC1DC,IAAMC,EAAAA,MAAAA,CAAOF,SAASC,IAAI,CAAA;AAC1BE,QAAAA,OAAAA,EAASH,SAASG,OAAO;AACzBC,QAAAA,IAAAA,EAAMJ,SAASI,IAAI;AACnBC,QAAAA,KAAAA,EAAOL,SAASK;KAClB,CAAA;AAEMC,MAAAA,eAAAA,GAAkB,CAACN,QAAAA,IAA+B;QACtDO,MAAQC,EAAAA,OAAAA,CAAQR,QAASS,CAAAA,KAAK,CAC1B,GAAA;YAACV,mBAAoBC,CAAAA,QAAAA;AAAU,SAAA,GAC/BA,QAASS,CAAAA,KAAK,CAACC,GAAG,CAACX,mBAAAA,CAAAA;AACvBI,QAAAA,OAAAA,EAASH,SAASG;KACpB;;;;"}

server/node_modules/@strapi/utils/dist/hooks.d.ts

@@ -0,0 +1,64 @@
+export type Handler = (...args: any[]) => any;
+export interface Hook<T extends Handler = Handler> {
+    getHandlers(): Handler[];
+    register(handler: T): Hook<T>;
+    delete(handler: T): Hook<T>;
+    call(...args: any[]): void;
+}
+export interface AsyncSeriesHook extends Hook {
+    call(...args: any[]): Promise<void>;
+}
+export interface AsyncSeriesWaterfallHook extends Hook {
+    call(...args: any[]): Promise<any>;
+}
+export interface AsyncParallelHook extends Hook {
+    call(...args: any[]): Promise<any[]>;
+}
+export interface AsyncBailHook extends Hook {
+    call(...args: any[]): Promise<any>;
+}
+/**
+ * Create an async series hook.
+ * Upon execution, it will execute every handler in order with the same context
+ */
+declare const createAsyncSeriesHook: <T extends Handler = Handler>() => {
+    call(context: unknown): Promise<void>;
+    getHandlers(): Handler[];
+    register(handler: T): Hook<T>;
+    delete(handler: T): Hook<T>;
+};
+/**
+ * Create an async series waterfall hook.
+ * Upon execution, it will execute every handler in order and pass the return value of the last handler to the next one
+ */
+declare const createAsyncSeriesWaterfallHook: <T extends Handler = Handler>() => {
+    call(param: unknown): Promise<unknown>;
+    getHandlers(): Handler[];
+    register(handler: T): Hook<T>;
+    delete(handler: T): Hook<T>;
+};
+/**
+ * Create an async parallel hook.
+ * Upon execution, it will execute every registered handler in band.
+ */
+declare const createAsyncParallelHook: <T extends Handler = Handler>() => {
+    call(context: unknown): Promise<any[]>;
+    getHandlers(): Handler[];
+    register(handler: T): Hook<T>;
+    delete(handler: T): Hook<T>;
+};
+/**
+ * Create an async parallel hook.
+ * Upon execution, it will execute every registered handler in serie and return the first result found.
+ */
+declare const createAsyncBailHook: <T extends Handler = Handler>() => {
+    call(context: unknown): Promise<any>;
+    getHandlers(): Handler[];
+    register(handler: T): Hook<T>;
+    delete(handler: T): Hook<T>;
+};
+export declare const internals: {
+    createHook: <T extends Handler = Handler>() => Hook<T>;
+};
+export { createAsyncSeriesHook, createAsyncSeriesWaterfallHook, createAsyncParallelHook, createAsyncBailHook, };
+//# sourceMappingURL=hooks.d.ts.map

server/node_modules/@strapi/utils/dist/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,OAAO,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AAE9C,MAAM,WAAW,IAAI,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO;IAC/C,WAAW,IAAI,OAAO,EAAE,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IAC9B,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IAC5B,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,eAAgB,SAAQ,IAAI;IAC3C,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACrC;AACD,MAAM,WAAW,wBAAyB,SAAQ,IAAI;IACpD,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,iBAAkB,SAAQ,IAAI;IAC7C,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;CACpC;AAqCD;;;GAGG;AACH,QAAA,MAAM,qBAAqB;kBAGL,OAAO;mBA/DZ,OAAO,EAAE;;;CAoExB,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,8BAA8B;gBAGhB,OAAO;mBA7EV,OAAO,EAAE;;;CAsFxB,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,uBAAuB;kBAGP,OAAO;mBA/FZ,OAAO,EAAE;;;CAoGxB,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,mBAAmB;kBAGH,OAAO;mBA7GZ,OAAO,EAAE;;;CAsHxB,CAAC;AAEH,eAAO,MAAM,SAAS;mDAhG8B,KAAK,CAAC,CAAC;CAmG1D,CAAC;AAEF,OAAO,EACL,qBAAqB,EACrB,8BAA8B,EAC9B,uBAAuB,EACvB,mBAAmB,GACpB,CAAC"}

server/node_modules/@strapi/utils/dist/hooks.js

@@ -0,0 +1,86 @@
+'use strict';
+
+var fp = require('lodash/fp');
+
+/**
+ * Create a default Strapi hook
+ */ const createHook = ()=>{
+    const state = {
+        handlers: []
+    };
+    return {
+        getHandlers () {
+            return state.handlers;
+        },
+        register (handler) {
+            state.handlers.push(handler);
+            return this;
+        },
+        delete (handler) {
+            state.handlers = fp.remove(fp.eq(handler), state.handlers);
+            return this;
+        },
+        call () {
+            throw new Error('Method not implemented');
+        }
+    };
+};
+/**
+ * Create an async series hook.
+ * Upon execution, it will execute every handler in order with the same context
+ */ const createAsyncSeriesHook = ()=>({
+        ...createHook(),
+        async call (context) {
+            for (const handler of this.getHandlers()){
+                await handler(context);
+            }
+        }
+    });
+/**
+ * Create an async series waterfall hook.
+ * Upon execution, it will execute every handler in order and pass the return value of the last handler to the next one
+ */ const createAsyncSeriesWaterfallHook = ()=>({
+        ...createHook(),
+        async call (param) {
+            let res = param;
+            for (const handler of this.getHandlers()){
+                res = await handler(res);
+            }
+            return res;
+        }
+    });
+/**
+ * Create an async parallel hook.
+ * Upon execution, it will execute every registered handler in band.
+ */ const createAsyncParallelHook = ()=>({
+        ...createHook(),
+        async call (context) {
+            const promises = this.getHandlers().map((handler)=>handler(fp.cloneDeep(context)));
+            return Promise.all(promises);
+        }
+    });
+/**
+ * Create an async parallel hook.
+ * Upon execution, it will execute every registered handler in serie and return the first result found.
+ */ const createAsyncBailHook = ()=>({
+        ...createHook(),
+        async call (context) {
+            for (const handler of this.getHandlers()){
+                const result = await handler(context);
+                if (result !== undefined) {
+                    return result;
+                }
+            }
+        }
+    });
+const internals = {
+    // Internal utils
+    createHook
+};
+
+exports.createAsyncBailHook = createAsyncBailHook;
+exports.createAsyncParallelHook = createAsyncParallelHook;
+exports.createAsyncSeriesHook = createAsyncSeriesHook;
+exports.createAsyncSeriesWaterfallHook = createAsyncSeriesWaterfallHook;
+exports.internals = internals;
+//# sourceMappingURL=hooks.js.map

server/node_modules/@strapi/utils/dist/hooks.mjs

@@ -0,0 +1,80 @@
+import { cloneDeep, remove, eq } from 'lodash/fp';
+
+/**
+ * Create a default Strapi hook
+ */ const createHook = ()=>{
+    const state = {
+        handlers: []
+    };
+    return {
+        getHandlers () {
+            return state.handlers;
+        },
+        register (handler) {
+            state.handlers.push(handler);
+            return this;
+        },
+        delete (handler) {
+            state.handlers = remove(eq(handler), state.handlers);
+            return this;
+        },
+        call () {
+            throw new Error('Method not implemented');
+        }
+    };
+};
+/**
+ * Create an async series hook.
+ * Upon execution, it will execute every handler in order with the same context
+ */ const createAsyncSeriesHook = ()=>({
+        ...createHook(),
+        async call (context) {
+            for (const handler of this.getHandlers()){
+                await handler(context);
+            }
+        }
+    });
+/**
+ * Create an async series waterfall hook.
+ * Upon execution, it will execute every handler in order and pass the return value of the last handler to the next one
+ */ const createAsyncSeriesWaterfallHook = ()=>({
+        ...createHook(),
+        async call (param) {
+            let res = param;
+            for (const handler of this.getHandlers()){
+                res = await handler(res);
+            }
+            return res;
+        }
+    });
+/**
+ * Create an async parallel hook.
+ * Upon execution, it will execute every registered handler in band.
+ */ const createAsyncParallelHook = ()=>({
+        ...createHook(),
+        async call (context) {
+            const promises = this.getHandlers().map((handler)=>handler(cloneDeep(context)));
+            return Promise.all(promises);
+        }
+    });
+/**
+ * Create an async parallel hook.
+ * Upon execution, it will execute every registered handler in serie and return the first result found.
+ */ const createAsyncBailHook = ()=>({
+        ...createHook(),
+        async call (context) {
+            for (const handler of this.getHandlers()){
+                const result = await handler(context);
+                if (result !== undefined) {
+                    return result;
+                }
+            }
+        }
+    });
+const internals = {
+    // Internal utils
+    createHook
+};
+
+export { createAsyncBailHook, createAsyncParallelHook, createAsyncSeriesHook, createAsyncSeriesWaterfallHook, internals };
+//# sourceMappingURL=hooks.mjs.map

server/node_modules/@strapi/utils/dist/import-default.d.ts

@@ -0,0 +1,2 @@
+export default function importDefault(modName: string): any;
+//# sourceMappingURL=import-default.d.ts.map

server/node_modules/@strapi/utils/dist/import-default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-default.d.ts","sourceRoot":"","sources":["../src/import-default.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,OAAO,EAAE,MAAM,OAGpD"}

server/node_modules/@strapi/utils/dist/import-default.js

@@ -0,0 +1,9 @@
+'use strict';
+
+/* eslint-disable @typescript-eslint/no-var-requires */ function importDefault(modName) {
+    const mod = require(modName);
+    return mod && mod.__esModule ? mod.default : mod;
+}
+
+module.exports = importDefault;
+//# sourceMappingURL=import-default.js.map

server/node_modules/@strapi/utils/dist/import-default.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-default.js","sources":["../src/import-default.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-var-requires */\n\nexport default function importDefault(modName: string) {\n  const mod = require(modName);\n  return mod && mod.__esModule ? mod.default : mod;\n}\n"],"names":["importDefault","modName","mod","require","__esModule","default"],"mappings":";;AAAA,wDAEe,SAASA,aAAAA,CAAcC,OAAe,EAAA;AACnD,IAAA,MAAMC,MAAMC,OAAQF,CAAAA,OAAAA,CAAAA;AACpB,IAAA,OAAOC,OAAOA,GAAIE,CAAAA,UAAU,GAAGF,GAAAA,CAAIG,OAAO,GAAGH,GAAAA;AAC/C;;;;"}

server/node_modules/@strapi/utils/dist/import-default.mjs

@@ -0,0 +1,7 @@
+/* eslint-disable @typescript-eslint/no-var-requires */ function importDefault(modName) {
+    const mod = require(modName);
+    return mod && mod.__esModule ? mod.default : mod;
+}
+
+export { importDefault as default };
+//# sourceMappingURL=import-default.mjs.map

server/node_modules/@strapi/utils/dist/import-default.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-default.mjs","sources":["../src/import-default.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-var-requires */\n\nexport default function importDefault(modName: string) {\n  const mod = require(modName);\n  return mod && mod.__esModule ? mod.default : mod;\n}\n"],"names":["importDefault","modName","mod","require","__esModule","default"],"mappings":"AAAA,wDAEe,SAASA,aAAAA,CAAcC,OAAe,EAAA;AACnD,IAAA,MAAMC,MAAMC,OAAQF,CAAAA,OAAAA,CAAAA;AACpB,IAAA,OAAOC,OAAOA,GAAIE,CAAAA,UAAU,GAAGF,GAAAA,CAAIG,OAAO,GAAGH,GAAAA;AAC/C;;;;"}

server/node_modules/@strapi/utils/dist/index.d.ts

@@ -0,0 +1,27 @@
+export { default as parseType } from './parse-type';
+export { default as env } from './env-helper';
+export { default as setCreatorFields } from './set-creator-fields';
+export { default as providerFactory } from './provider-factory';
+export { default as traverseEntity } from './traverse-entity';
+export { default as importDefault } from './import-default';
+export { generateInstallId } from './install-id';
+export { validateYupSchema, validateYupSchemaSync } from './validators';
+export { isOperator, isOperatorOfType } from './operators';
+export * as queryParams from './convert-query-params';
+export * as sanitize from './sanitize';
+export * as validate from './validate';
+export * as pagination from './pagination';
+export * as packageManager from './package-manager';
+export * as traverse from './traverse';
+export * as template from './template';
+export * as file from './file';
+export * as async from './async';
+export * as policy from './policy';
+export * as yup from './yup';
+export * as errors from './errors';
+export * as contentTypes from './content-types';
+export * as relations from './relations';
+export * as hooks from './hooks';
+export * from './zod';
+export * from './primitives';
+//# sourceMappingURL=index.d.ts.map

server/node_modules/@strapi/utils/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjD,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE3D,OAAO,KAAK,WAAW,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,cAAc,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC;AAC7B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,YAAY,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,cAAc,OAAO,CAAC;AAEtB,cAAc,cAAc,CAAC"}

server/node_modules/@strapi/utils/dist/index.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var parseType = require('./parse-type.js');
+var envHelper = require('./env-helper.js');
+var setCreatorFields = require('./set-creator-fields.js');
+var providerFactory = require('./provider-factory.js');
+var traverseEntity = require('./traverse-entity.js');
+var importDefault = require('./import-default.js');
+var installId = require('./install-id.js');
+var validators = require('./validators.js');
+var operators = require('./operators.js');
+var convertQueryParams = require('./convert-query-params.js');
+var index = require('./sanitize/index.js');
+var index$1 = require('./validate/index.js');
+var pagination = require('./pagination.js');
+var packageManager = require('./package-manager.js');
+var index$2 = require('./traverse/index.js');
+var template = require('./template.js');
+var file = require('./file.js');
+var async = require('./async.js');
+var policy = require('./policy.js');
+var yup = require('./yup.js');
+var errors = require('./errors.js');
+var contentTypes = require('./content-types.js');
+var relations = require('./relations.js');
+var hooks = require('./hooks.js');
+var zod = require('./zod.js');
+var strings = require('./primitives/strings.js');
+var arrays = require('./primitives/arrays.js');
+var objects = require('./primitives/objects.js');
+var dates = require('./primitives/dates.js');
+
+
+
+exports.parseType = parseType;
+exports.env = envHelper;
+exports.setCreatorFields = setCreatorFields;
+exports.providerFactory = providerFactory;
+exports.traverseEntity = traverseEntity;
+exports.importDefault = importDefault;
+exports.generateInstallId = installId.generateInstallId;
+exports.validateYupSchema = validators.validateYupSchema;
+exports.validateYupSchemaSync = validators.validateYupSchemaSync;
+exports.isOperator = operators.isOperator;
+exports.isOperatorOfType = operators.isOperatorOfType;
+exports.queryParams = convertQueryParams;
+exports.sanitize = index;
+exports.validate = index$1;
+exports.pagination = pagination;
+exports.packageManager = packageManager;
+exports.traverse = index$2;
+exports.template = template;
+exports.file = file;
+exports.async = async;
+exports.policy = policy;
+exports.yup = yup;
+exports.errors = errors;
+exports.contentTypes = contentTypes;
+exports.relations = relations;
+exports.hooks = hooks;
+exports.validateZod = zod.validateZod;
+exports.strings = strings;
+exports.arrays = arrays;
+exports.objects = objects;
+exports.dates = dates;
+//# sourceMappingURL=index.js.map

server/node_modules/@strapi/utils/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

server/node_modules/@strapi/utils/dist/index.mjs

@@ -0,0 +1,49 @@
+export { default as parseType } from './parse-type.mjs';
+export { default as env } from './env-helper.mjs';
+export { default as setCreatorFields } from './set-creator-fields.mjs';
+export { default as providerFactory } from './provider-factory.mjs';
+export { default as traverseEntity } from './traverse-entity.mjs';
+export { default as importDefault } from './import-default.mjs';
+export { generateInstallId } from './install-id.mjs';
+export { validateYupSchema, validateYupSchemaSync } from './validators.mjs';
+export { isOperator, isOperatorOfType } from './operators.mjs';
+import * as convertQueryParams from './convert-query-params.mjs';
+export { convertQueryParams as queryParams };
+import * as index from './sanitize/index.mjs';
+export { index as sanitize };
+import * as index$1 from './validate/index.mjs';
+export { index$1 as validate };
+import * as pagination from './pagination.mjs';
+export { pagination };
+import * as packageManager from './package-manager.mjs';
+export { packageManager };
+import * as index$2 from './traverse/index.mjs';
+export { index$2 as traverse };
+import * as template from './template.mjs';
+export { template };
+import * as file from './file.mjs';
+export { file };
+import * as async from './async.mjs';
+export { async };
+import * as policy from './policy.mjs';
+export { policy };
+import * as yup from './yup.mjs';
+export { yup };
+import * as errors from './errors.mjs';
+export { errors };
+import * as contentTypes from './content-types.mjs';
+export { contentTypes };
+import * as relations from './relations.mjs';
+export { relations };
+import * as hooks from './hooks.mjs';
+export { hooks };
+export { validateZod } from './zod.mjs';
+import * as strings from './primitives/strings.mjs';
+export { strings };
+import * as arrays from './primitives/arrays.mjs';
+export { arrays };
+import * as objects from './primitives/objects.mjs';
+export { objects };
+import * as dates from './primitives/dates.mjs';
+export { dates };
+//# sourceMappingURL=index.mjs.map

server/node_modules/@strapi/utils/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

server/node_modules/@strapi/utils/dist/install-id.d.ts

@@ -0,0 +1,2 @@
+export declare const generateInstallId: (projectId: string, installId: string) => string;
+//# sourceMappingURL=install-id.d.ts.map

server/node_modules/@strapi/utils/dist/install-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-id.d.ts","sourceRoot":"","sources":["../src/install-id.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,cAAe,MAAM,aAAa,MAAM,WAUrE,CAAC"}

server/node_modules/@strapi/utils/dist/install-id.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var crypto = require('crypto');
+var nodeMachineId = require('node-machine-id');
+
+const generateInstallId = (projectId, installId)=>{
+    if (installId) return installId;
+    try {
+        const machineId = nodeMachineId.machineIdSync();
+        return projectId ? crypto.createHash('sha256').update(`${machineId}-${projectId}`).digest('hex') : crypto.randomUUID();
+    } catch (error) {
+        return crypto.randomUUID();
+    }
+};
+
+exports.generateInstallId = generateInstallId;
+//# sourceMappingURL=install-id.js.map

server/node_modules/@strapi/utils/dist/install-id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-id.js","sources":["../src/install-id.ts"],"sourcesContent":["import crypto from 'crypto';\nimport { machineIdSync } from 'node-machine-id';\n\nexport const generateInstallId = (projectId: string, installId: string) => {\n  if (installId) return installId;\n  try {\n    const machineId = machineIdSync();\n    return projectId\n      ? crypto.createHash('sha256').update(`${machineId}-${projectId}`).digest('hex')\n      : crypto.randomUUID();\n  } catch (error) {\n    return crypto.randomUUID();\n  }\n};\n"],"names":["generateInstallId","projectId","installId","machineId","machineIdSync","crypto","createHash","update","digest","randomUUID","error"],"mappings":";;;;;AAGO,MAAMA,iBAAoB,GAAA,CAACC,SAAmBC,EAAAA,SAAAA,GAAAA;AACnD,IAAA,IAAIA,WAAW,OAAOA,SAAAA;IACtB,IAAI;AACF,QAAA,MAAMC,SAAYC,GAAAA,2BAAAA,EAAAA;AAClB,QAAA,OAAOH,YACHI,MAAOC,CAAAA,UAAU,CAAC,QAAUC,CAAAA,CAAAA,MAAM,CAAC,CAAC,EAAEJ,UAAU,CAAC,EAAEF,UAAU,CAAC,CAAA,CAAEO,MAAM,CAAC,KAAA,CAAA,GACvEH,OAAOI,UAAU,EAAA;AACvB,KAAA,CAAE,OAAOC,KAAO,EAAA;AACd,QAAA,OAAOL,OAAOI,UAAU,EAAA;AAC1B;AACF;;;;"}

server/node_modules/@strapi/utils/dist/install-id.mjs

@@ -0,0 +1,15 @@
+import crypto from 'crypto';
+import { machineIdSync } from 'node-machine-id';
+
+const generateInstallId = (projectId, installId)=>{
+    if (installId) return installId;
+    try {
+        const machineId = machineIdSync();
+        return projectId ? crypto.createHash('sha256').update(`${machineId}-${projectId}`).digest('hex') : crypto.randomUUID();
+    } catch (error) {
+        return crypto.randomUUID();
+    }
+};
+
+export { generateInstallId };
+//# sourceMappingURL=install-id.mjs.map

server/node_modules/@strapi/utils/dist/install-id.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-id.mjs","sources":["../src/install-id.ts"],"sourcesContent":["import crypto from 'crypto';\nimport { machineIdSync } from 'node-machine-id';\n\nexport const generateInstallId = (projectId: string, installId: string) => {\n  if (installId) return installId;\n  try {\n    const machineId = machineIdSync();\n    return projectId\n      ? crypto.createHash('sha256').update(`${machineId}-${projectId}`).digest('hex')\n      : crypto.randomUUID();\n  } catch (error) {\n    return crypto.randomUUID();\n  }\n};\n"],"names":["generateInstallId","projectId","installId","machineId","machineIdSync","crypto","createHash","update","digest","randomUUID","error"],"mappings":";;;AAGO,MAAMA,iBAAoB,GAAA,CAACC,SAAmBC,EAAAA,SAAAA,GAAAA;AACnD,IAAA,IAAIA,WAAW,OAAOA,SAAAA;IACtB,IAAI;AACF,QAAA,MAAMC,SAAYC,GAAAA,aAAAA,EAAAA;AAClB,QAAA,OAAOH,YACHI,MAAOC,CAAAA,UAAU,CAAC,QAAUC,CAAAA,CAAAA,MAAM,CAAC,CAAC,EAAEJ,UAAU,CAAC,EAAEF,UAAU,CAAC,CAAA,CAAEO,MAAM,CAAC,KAAA,CAAA,GACvEH,OAAOI,UAAU,EAAA;AACvB,KAAA,CAAE,OAAOC,KAAO,EAAA;AACd,QAAA,OAAOL,OAAOI,UAAU,EAAA;AAC1B;AACF;;;;"}

server/node_modules/@strapi/utils/dist/operators.d.ts

@@ -0,0 +1,3 @@
+export declare const isOperatorOfType: (type: string, key: string, ignoreCase?: boolean) => boolean;
+export declare const isOperator: (key: string, ignoreCase?: boolean) => boolean;
+//# sourceMappingURL=operators.d.ts.map

server/node_modules/@strapi/utils/dist/operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.d.ts","sourceRoot":"","sources":["../src/operators.ts"],"names":[],"mappings":"AA+DA,eAAO,MAAM,gBAAgB,SAAU,MAAM,OAAO,MAAM,kCAUzD,CAAC;AAEF,eAAO,MAAM,UAAU,QAAS,MAAM,kCAErC,CAAC"}

server/node_modules/@strapi/utils/dist/operators.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const GROUP_OPERATORS = [
+    '$and',
+    '$or'
+];
+const WHERE_OPERATORS = [
+    '$not',
+    '$in',
+    '$notIn',
+    '$eq',
+    '$eqi',
+    '$ne',
+    '$nei',
+    '$gt',
+    '$gte',
+    '$lt',
+    '$lte',
+    '$null',
+    '$notNull',
+    '$between',
+    '$startsWith',
+    '$endsWith',
+    '$startsWithi',
+    '$endsWithi',
+    '$contains',
+    '$notContains',
+    '$containsi',
+    '$notContainsi',
+    // Experimental, only for internal use
+    '$jsonSupersetOf'
+];
+const CAST_OPERATORS = [
+    '$not',
+    '$in',
+    '$notIn',
+    '$eq',
+    '$ne',
+    '$gt',
+    '$gte',
+    '$lt',
+    '$lte',
+    '$between'
+];
+const ARRAY_OPERATORS = [
+    '$in',
+    '$notIn',
+    '$between'
+];
+const OPERATORS = {
+    where: WHERE_OPERATORS,
+    cast: CAST_OPERATORS,
+    group: GROUP_OPERATORS,
+    array: ARRAY_OPERATORS
+};
+// for performance, cache all operators in lowercase
+const OPERATORS_LOWERCASE = Object.fromEntries(Object.entries(OPERATORS).map(([key, values])=>[
+        key,
+        values.map((value)=>value.toLowerCase())
+    ]));
+const isObjKey = (key, obj)=>{
+    return key in obj;
+};
+const isOperatorOfType = (type, key, ignoreCase = false)=>{
+    if (ignoreCase) {
+        return OPERATORS_LOWERCASE[type]?.includes(key.toLowerCase()) ?? false;
+    }
+    if (isObjKey(type, OPERATORS)) {
+        return OPERATORS[type]?.includes(key) ?? false;
+    }
+    return false;
+};
+const isOperator = (key, ignoreCase = false)=>{
+    return Object.keys(OPERATORS).some((type)=>isOperatorOfType(type, key, ignoreCase));
+};
+
+exports.isOperator = isOperator;
+exports.isOperatorOfType = isOperatorOfType;
+//# sourceMappingURL=operators.js.map

server/node_modules/@strapi/utils/dist/operators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.js","sources":["../src/operators.ts"],"sourcesContent":["const GROUP_OPERATORS = ['$and', '$or'];\n\nconst WHERE_OPERATORS = [\n  '$not',\n  '$in',\n  '$notIn',\n  '$eq',\n  '$eqi',\n  '$ne',\n  '$nei',\n  '$gt',\n  '$gte',\n  '$lt',\n  '$lte',\n  '$null',\n  '$notNull',\n  '$between',\n  '$startsWith',\n  '$endsWith',\n  '$startsWithi',\n  '$endsWithi',\n  '$contains',\n  '$notContains',\n  '$containsi',\n  '$notContainsi',\n  // Experimental, only for internal use\n  '$jsonSupersetOf',\n];\n\nconst CAST_OPERATORS = [\n  '$not',\n  '$in',\n  '$notIn',\n  '$eq',\n  '$ne',\n  '$gt',\n  '$gte',\n  '$lt',\n  '$lte',\n  '$between',\n];\n\nconst ARRAY_OPERATORS = ['$in', '$notIn', '$between'];\n\nconst OPERATORS = {\n  where: WHERE_OPERATORS,\n  cast: CAST_OPERATORS,\n  group: GROUP_OPERATORS,\n  array: ARRAY_OPERATORS,\n};\n\n// for performance, cache all operators in lowercase\nconst OPERATORS_LOWERCASE = Object.fromEntries(\n  Object.entries(OPERATORS).map(([key, values]) => [\n    key,\n    values.map((value) => value.toLowerCase()),\n  ])\n);\n\nconst isObjKey = <T extends object>(key: string | symbol | number, obj: T): key is keyof T => {\n  return key in obj;\n};\n\nexport const isOperatorOfType = (type: string, key: string, ignoreCase = false) => {\n  if (ignoreCase) {\n    return OPERATORS_LOWERCASE[type]?.includes(key.toLowerCase()) ?? false;\n  }\n\n  if (isObjKey(type, OPERATORS)) {\n    return OPERATORS[type]?.includes(key) ?? false;\n  }\n\n  return false;\n};\n\nexport const isOperator = (key: string, ignoreCase = false) => {\n  return Object.keys(OPERATORS).some((type) => isOperatorOfType(type, key, ignoreCase));\n};\n"],"names":["GROUP_OPERATORS","WHERE_OPERATORS","CAST_OPERATORS","ARRAY_OPERATORS","OPERATORS","where","cast","group","array","OPERATORS_LOWERCASE","Object","fromEntries","entries","map","key","values","value","toLowerCase","isObjKey","obj","isOperatorOfType","type","ignoreCase","includes","isOperator","keys","some"],"mappings":";;AAAA,MAAMA,eAAkB,GAAA;AAAC,IAAA,MAAA;AAAQ,IAAA;AAAM,CAAA;AAEvC,MAAMC,eAAkB,GAAA;AACtB,IAAA,MAAA;AACA,IAAA,KAAA;AACA,IAAA,QAAA;AACA,IAAA,KAAA;AACA,IAAA,MAAA;AACA,IAAA,KAAA;AACA,IAAA,MAAA;AACA,IAAA,KAAA;AACA,IAAA,MAAA;AACA,IAAA,KAAA;AACA,IAAA,MAAA;AACA,IAAA,OAAA;AACA,IAAA,UAAA;AACA,IAAA,UAAA;AACA,IAAA,aAAA;AACA,IAAA,WAAA;AACA,IAAA,cAAA;AACA,IAAA,YAAA;AACA,IAAA,WAAA;AACA,IAAA,cAAA;AACA,IAAA,YAAA;AACA,IAAA,eAAA;;AAEA,IAAA;AACD,CAAA;AAED,MAAMC,cAAiB,GAAA;AACrB,IAAA,MAAA;AACA,IAAA,KAAA;AACA,IAAA,QAAA;AACA,IAAA,KAAA;AACA,IAAA,KAAA;AACA,IAAA,KAAA;AACA,IAAA,MAAA;AACA,IAAA,KAAA;AACA,IAAA,MAAA;AACA,IAAA;AACD,CAAA;AAED,MAAMC,eAAkB,GAAA;AAAC,IAAA,KAAA;AAAO,IAAA,QAAA;AAAU,IAAA;AAAW,CAAA;AAErD,MAAMC,SAAY,GAAA;IAChBC,KAAOJ,EAAAA,eAAAA;IACPK,IAAMJ,EAAAA,cAAAA;IACNK,KAAOP,EAAAA,eAAAA;IACPQ,KAAOL,EAAAA;AACT,CAAA;AAEA;AACA,MAAMM,mBAAsBC,GAAAA,MAAAA,CAAOC,WAAW,CAC5CD,OAAOE,OAAO,CAACR,SAAWS,CAAAA,CAAAA,GAAG,CAAC,CAAC,CAACC,GAAAA,EAAKC,OAAO,GAAK;AAC/CD,QAAAA,GAAAA;AACAC,QAAAA,MAAAA,CAAOF,GAAG,CAAC,CAACG,KAAAA,GAAUA,MAAMC,WAAW,EAAA;AACxC,KAAA,CAAA,CAAA;AAGH,MAAMC,QAAAA,GAAW,CAAmBJ,GAA+BK,EAAAA,GAAAA,GAAAA;AACjE,IAAA,OAAOL,GAAOK,IAAAA,GAAAA;AAChB,CAAA;MAEaC,gBAAmB,GAAA,CAACC,IAAcP,EAAAA,GAAAA,EAAaQ,aAAa,KAAK,GAAA;AAC5E,IAAA,IAAIA,UAAY,EAAA;AACd,QAAA,OAAOb,mBAAmB,CAACY,IAAAA,CAAK,EAAEE,QAAST,CAAAA,GAAAA,CAAIG,WAAW,EAAO,CAAA,IAAA,KAAA;AACnE;IAEA,IAAIC,QAAAA,CAASG,MAAMjB,SAAY,CAAA,EAAA;AAC7B,QAAA,OAAOA,SAAS,CAACiB,IAAK,CAAA,EAAEE,SAAST,GAAQ,CAAA,IAAA,KAAA;AAC3C;IAEA,OAAO,KAAA;AACT;AAEaU,MAAAA,UAAAA,GAAa,CAACV,GAAAA,EAAaQ,aAAa,KAAK,GAAA;IACxD,OAAOZ,MAAAA,CAAOe,IAAI,CAACrB,SAAWsB,CAAAA,CAAAA,IAAI,CAAC,CAACL,IAAAA,GAASD,gBAAiBC,CAAAA,IAAAA,EAAMP,GAAKQ,EAAAA,UAAAA,CAAAA,CAAAA;AAC3E;;;;;"}

server/node_modules/@strapi/utils/dist/operators.mjs

@@ -0,0 +1,76 @@
+const GROUP_OPERATORS = [
+    '$and',
+    '$or'
+];
+const WHERE_OPERATORS = [
+    '$not',
+    '$in',
+    '$notIn',
+    '$eq',
+    '$eqi',
+    '$ne',
+    '$nei',
+    '$gt',
+    '$gte',
+    '$lt',
+    '$lte',
+    '$null',
+    '$notNull',
+    '$between',
+    '$startsWith',
+    '$endsWith',
+    '$startsWithi',
+    '$endsWithi',
+    '$contains',
+    '$notContains',
+    '$containsi',
+    '$notContainsi',
+    // Experimental, only for internal use
+    '$jsonSupersetOf'
+];
+const CAST_OPERATORS = [
+    '$not',
+    '$in',
+    '$notIn',
+    '$eq',
+    '$ne',
+    '$gt',
+    '$gte',
+    '$lt',
+    '$lte',
+    '$between'
+];
+const ARRAY_OPERATORS = [
+    '$in',
+    '$notIn',
+    '$between'
+];
+const OPERATORS = {
+    where: WHERE_OPERATORS,
+    cast: CAST_OPERATORS,
+    group: GROUP_OPERATORS,
+    array: ARRAY_OPERATORS
+};
+// for performance, cache all operators in lowercase
+const OPERATORS_LOWERCASE = Object.fromEntries(Object.entries(OPERATORS).map(([key, values])=>[
+        key,
+        values.map((value)=>value.toLowerCase())
+    ]));
+const isObjKey = (key, obj)=>{
+    return key in obj;
+};
+const isOperatorOfType = (type, key, ignoreCase = false)=>{
+    if (ignoreCase) {
+        return OPERATORS_LOWERCASE[type]?.includes(key.toLowerCase()) ?? false;
+    }
+    if (isObjKey(type, OPERATORS)) {
+        return OPERATORS[type]?.includes(key) ?? false;
+    }
+    return false;
+};
+const isOperator = (key, ignoreCase = false)=>{
+    return Object.keys(OPERATORS).some((type)=>isOperatorOfType(type, key, ignoreCase));
+};
+
+export { isOperator, isOperatorOfType };
+//# sourceMappingURL=operators.mjs.map

server/node_modules/@strapi/utils/dist/operators.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.mjs","sources":["../src/operators.ts"],"sourcesContent":["const GROUP_OPERATORS = ['$and', '$or'];\n\nconst WHERE_OPERATORS = [\n  '$not',\n  '$in',\n  '$notIn',\n  '$eq',\n  '$eqi',\n  '$ne',\n  '$nei',\n  '$gt',\n  '$gte',\n  '$lt',\n  '$lte',\n  '$null',\n  '$notNull',\n  '$between',\n  '$startsWith',\n  '$endsWith',\n  '$startsWithi',\n  '$endsWithi',\n  '$contains',\n  '$notContains',\n  '$containsi',\n  '$notContainsi',\n  // Experimental, only for internal use\n  '$jsonSupersetOf',\n];\n\nconst CAST_OPERATORS = [\n  '$not',\n  '$in',\n  '$notIn',\n  '$eq',\n  '$ne',\n  '$gt',\n  '$gte',\n  '$lt',\n  '$lte',\n  '$between',\n];\n\nconst ARRAY_OPERATORS = ['$in', '$notIn', '$between'];\n\nconst OPERATORS = {\n  where: WHERE_OPERATORS,\n  cast: CAST_OPERATORS,\n  group: GROUP_OPERATORS,\n  array: ARRAY_OPERATORS,\n};\n\n// for performance, cache all operators in lowercase\nconst OPERATORS_LOWERCASE = Object.fromEntries(\n  Object.entries(OPERATORS).map(([key, values]) => [\n    key,\n    values.map((value) => value.toLowerCase()),\n  ])\n);\n\nconst isObjKey = <T extends object>(key: string | symbol | number, obj: T): key is keyof T => {\n  return key in obj;\n};\n\nexport const isOperatorOfType = (type: string, key: string, ignoreCase = false) => {\n  if (ignoreCase) {\n    return OPERATORS_LOWERCASE[type]?.includes(key.toLowerCase()) ?? false;\n  }\n\n  if (isObjKey(type, OPERATORS)) {\n    return OPERATORS[type]?.includes(key) ?? false;\n  }\n\n  return false;\n};\n\nexport const isOperator = (key: string, ignoreCase = false) => {\n  return Object.keys(OPERATORS).some((type) => isOperatorOfType(type, key, ignoreCase));\n};\n"],"names":["GROUP_OPERATORS","WHERE_OPERATORS","CAST_OPERATORS","ARRAY_OPERATORS","OPERATORS","where","cast","group","array","OPERATORS_LOWERCASE","Object","fromEntries","entries","map","key","values","value","toLowerCase","isObjKey","obj","isOperatorOfType","type","ignoreCase","includes","isOperator","keys","some"],"mappings":"AAAA,MAAMA,eAAkB,GAAA;AAAC,IAAA,MAAA;AAAQ,IAAA;AAAM,CAAA;AAEvC,MAAMC,eAAkB,GAAA;AACtB,IAAA,MAAA;AACA,IAAA,KAAA;AACA,IAAA,QAAA;AACA,IAAA,KAAA;AACA,IAAA,MAAA;AACA,IAAA,KAAA;AACA,IAAA,MAAA;AACA,IAAA,KAAA;AACA,IAAA,MAAA;AACA,IAAA,KAAA;AACA,IAAA,MAAA;AACA,IAAA,OAAA;AACA,IAAA,UAAA;AACA,IAAA,UAAA;AACA,IAAA,aAAA;AACA,IAAA,WAAA;AACA,IAAA,cAAA;AACA,IAAA,YAAA;AACA,IAAA,WAAA;AACA,IAAA,cAAA;AACA,IAAA,YAAA;AACA,IAAA,eAAA;;AAEA,IAAA;AACD,CAAA;AAED,MAAMC,cAAiB,GAAA;AACrB,IAAA,MAAA;AACA,IAAA,KAAA;AACA,IAAA,QAAA;AACA,IAAA,KAAA;AACA,IAAA,KAAA;AACA,IAAA,KAAA;AACA,IAAA,MAAA;AACA,IAAA,KAAA;AACA,IAAA,MAAA;AACA,IAAA;AACD,CAAA;AAED,MAAMC,eAAkB,GAAA;AAAC,IAAA,KAAA;AAAO,IAAA,QAAA;AAAU,IAAA;AAAW,CAAA;AAErD,MAAMC,SAAY,GAAA;IAChBC,KAAOJ,EAAAA,eAAAA;IACPK,IAAMJ,EAAAA,cAAAA;IACNK,KAAOP,EAAAA,eAAAA;IACPQ,KAAOL,EAAAA;AACT,CAAA;AAEA;AACA,MAAMM,mBAAsBC,GAAAA,MAAAA,CAAOC,WAAW,CAC5CD,OAAOE,OAAO,CAACR,SAAWS,CAAAA,CAAAA,GAAG,CAAC,CAAC,CAACC,GAAAA,EAAKC,OAAO,GAAK;AAC/CD,QAAAA,GAAAA;AACAC,QAAAA,MAAAA,CAAOF,GAAG,CAAC,CAACG,KAAAA,GAAUA,MAAMC,WAAW,EAAA;AACxC,KAAA,CAAA,CAAA;AAGH,MAAMC,QAAAA,GAAW,CAAmBJ,GAA+BK,EAAAA,GAAAA,GAAAA;AACjE,IAAA,OAAOL,GAAOK,IAAAA,GAAAA;AAChB,CAAA;MAEaC,gBAAmB,GAAA,CAACC,IAAcP,EAAAA,GAAAA,EAAaQ,aAAa,KAAK,GAAA;AAC5E,IAAA,IAAIA,UAAY,EAAA;AACd,QAAA,OAAOb,mBAAmB,CAACY,IAAAA,CAAK,EAAEE,QAAST,CAAAA,GAAAA,CAAIG,WAAW,EAAO,CAAA,IAAA,KAAA;AACnE;IAEA,IAAIC,QAAAA,CAASG,MAAMjB,SAAY,CAAA,EAAA;AAC7B,QAAA,OAAOA,SAAS,CAACiB,IAAK,CAAA,EAAEE,SAAST,GAAQ,CAAA,IAAA,KAAA;AAC3C;IAEA,OAAO,KAAA;AACT;AAEaU,MAAAA,UAAAA,GAAa,CAACV,GAAAA,EAAaQ,aAAa,KAAK,GAAA;IACxD,OAAOZ,MAAAA,CAAOe,IAAI,CAACrB,SAAWsB,CAAAA,CAAAA,IAAI,CAAC,CAACL,IAAAA,GAASD,gBAAiBC,CAAAA,IAAAA,EAAMP,GAAKQ,EAAAA,UAAAA,CAAAA,CAAAA;AAC3E;;;;"}

server/node_modules/@strapi/utils/dist/package-manager.d.ts

@@ -0,0 +1,7 @@
+import execa from 'execa';
+import type { Options as ProcessOptions } from 'execa';
+type SupportedPackageManagerName = 'npm' | 'yarn';
+export declare const getPreferred: (pkgPath: string) => Promise<SupportedPackageManagerName>;
+export declare const installDependencies: (path: string, packageManager: SupportedPackageManagerName, options?: ProcessOptions<string>) => execa.ExecaChildProcess<string>;
+export {};
+//# sourceMappingURL=package-manager.d.ts.map

server/node_modules/@strapi/utils/dist/package-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-manager.d.ts","sourceRoot":"","sources":["../src/package-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,OAAO,KAAK,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,OAAO,CAAC;AAKvD,KAAK,2BAA2B,GAAG,KAAK,GAAG,MAAM,CAAC;AAElD,eAAO,MAAM,YAAY,YAAmB,MAAM,KAAG,QAAQ,2BAA2B,CAkBvF,CAAC;AAEF,eAAO,MAAM,mBAAmB,SACxB,MAAM,kBACI,2BAA2B,YAClC,eAAe,MAAM,CAAC,oCAGhC,CAAC"}

server/node_modules/@strapi/utils/dist/package-manager.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var execa = require('execa');
+var preferredPM = require('preferred-pm');
+
+const SUPPORTED_PACKAGE_MANAGERS = [
+    'npm',
+    'yarn'
+];
+const DEFAULT_PACKAGE_MANAGER = 'npm';
+const getPreferred = async (pkgPath)=>{
+    const pm = await preferredPM(pkgPath);
+    const hasPackageManager = pm !== undefined;
+    if (!hasPackageManager) {
+        throw new Error(`Couldn't find a package manager in your project.`);
+    }
+    const isPackageManagerSupported = SUPPORTED_PACKAGE_MANAGERS.includes(pm.name);
+    if (!isPackageManagerSupported) {
+        process.emitWarning(`We detected your package manager (${pm.name} v${pm.version}), but it's not officially supported by Strapi yet. Defaulting to npm instead.`);
+        return DEFAULT_PACKAGE_MANAGER;
+    }
+    return pm.name;
+};
+const installDependencies = (path, packageManager, options = {})=>{
+    return execa(packageManager, [
+        'install'
+    ], {
+        ...options,
+        cwd: path,
+        stdin: 'ignore'
+    });
+};
+
+exports.getPreferred = getPreferred;
+exports.installDependencies = installDependencies;
+//# sourceMappingURL=package-manager.js.map

server/node_modules/@strapi/utils/dist/package-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-manager.js","sources":["../src/package-manager.ts"],"sourcesContent":["import execa from 'execa';\nimport preferredPM from 'preferred-pm';\n\nimport type { Options as ProcessOptions } from 'execa';\n\nconst SUPPORTED_PACKAGE_MANAGERS = ['npm', 'yarn'];\nconst DEFAULT_PACKAGE_MANAGER = 'npm' as const;\n\ntype SupportedPackageManagerName = 'npm' | 'yarn';\n\nexport const getPreferred = async (pkgPath: string): Promise<SupportedPackageManagerName> => {\n  const pm = await preferredPM(pkgPath);\n\n  const hasPackageManager = pm !== undefined;\n  if (!hasPackageManager) {\n    throw new Error(`Couldn't find a package manager in your project.`);\n  }\n\n  const isPackageManagerSupported = SUPPORTED_PACKAGE_MANAGERS.includes(pm.name);\n  if (!isPackageManagerSupported) {\n    process.emitWarning(\n      `We detected your package manager (${pm.name} v${pm.version}), but it's not officially supported by Strapi yet. Defaulting to npm instead.`\n    );\n\n    return DEFAULT_PACKAGE_MANAGER;\n  }\n\n  return pm.name as SupportedPackageManagerName;\n};\n\nexport const installDependencies = (\n  path: string,\n  packageManager: SupportedPackageManagerName,\n  options: ProcessOptions<string> = {}\n) => {\n  return execa(packageManager, ['install'], { ...options, cwd: path, stdin: 'ignore' });\n};\n"],"names":["SUPPORTED_PACKAGE_MANAGERS","DEFAULT_PACKAGE_MANAGER","getPreferred","pkgPath","pm","preferredPM","hasPackageManager","undefined","Error","isPackageManagerSupported","includes","name","process","emitWarning","version","installDependencies","path","packageManager","options","execa","cwd","stdin"],"mappings":";;;;;AAKA,MAAMA,0BAA6B,GAAA;AAAC,IAAA,KAAA;AAAO,IAAA;AAAO,CAAA;AAClD,MAAMC,uBAA0B,GAAA,KAAA;AAIzB,MAAMC,eAAe,OAAOC,OAAAA,GAAAA;IACjC,MAAMC,EAAAA,GAAK,MAAMC,WAAYF,CAAAA,OAAAA,CAAAA;AAE7B,IAAA,MAAMG,oBAAoBF,EAAOG,KAAAA,SAAAA;AACjC,IAAA,IAAI,CAACD,iBAAmB,EAAA;AACtB,QAAA,MAAM,IAAIE,KAAAA,CAAM,CAAC,gDAAgD,CAAC,CAAA;AACpE;AAEA,IAAA,MAAMC,yBAA4BT,GAAAA,0BAAAA,CAA2BU,QAAQ,CAACN,GAAGO,IAAI,CAAA;AAC7E,IAAA,IAAI,CAACF,yBAA2B,EAAA;AAC9BG,QAAAA,OAAAA,CAAQC,WAAW,CACjB,CAAC,kCAAkC,EAAET,EAAGO,CAAAA,IAAI,CAAC,EAAE,EAAEP,EAAAA,CAAGU,OAAO,CAAC,8EAA8E,CAAC,CAAA;QAG7I,OAAOb,uBAAAA;AACT;AAEA,IAAA,OAAOG,GAAGO,IAAI;AAChB;MAEaI,mBAAsB,GAAA,CACjCC,MACAC,cACAC,EAAAA,OAAAA,GAAkC,EAAE,GAAA;AAEpC,IAAA,OAAOC,MAAMF,cAAgB,EAAA;AAAC,QAAA;KAAU,EAAE;AAAE,QAAA,GAAGC,OAAO;QAAEE,GAAKJ,EAAAA,IAAAA;QAAMK,KAAO,EAAA;AAAS,KAAA,CAAA;AACrF;;;;;"}

server/node_modules/@strapi/utils/dist/package-manager.mjs

@@ -0,0 +1,33 @@
+import execa from 'execa';
+import preferredPM from 'preferred-pm';
+
+const SUPPORTED_PACKAGE_MANAGERS = [
+    'npm',
+    'yarn'
+];
+const DEFAULT_PACKAGE_MANAGER = 'npm';
+const getPreferred = async (pkgPath)=>{
+    const pm = await preferredPM(pkgPath);
+    const hasPackageManager = pm !== undefined;
+    if (!hasPackageManager) {
+        throw new Error(`Couldn't find a package manager in your project.`);
+    }
+    const isPackageManagerSupported = SUPPORTED_PACKAGE_MANAGERS.includes(pm.name);
+    if (!isPackageManagerSupported) {
+        process.emitWarning(`We detected your package manager (${pm.name} v${pm.version}), but it's not officially supported by Strapi yet. Defaulting to npm instead.`);
+        return DEFAULT_PACKAGE_MANAGER;
+    }
+    return pm.name;
+};
+const installDependencies = (path, packageManager, options = {})=>{
+    return execa(packageManager, [
+        'install'
+    ], {
+        ...options,
+        cwd: path,
+        stdin: 'ignore'
+    });
+};
+
+export { getPreferred, installDependencies };
+//# sourceMappingURL=package-manager.mjs.map

server/node_modules/@strapi/utils/dist/package-manager.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-manager.mjs","sources":["../src/package-manager.ts"],"sourcesContent":["import execa from 'execa';\nimport preferredPM from 'preferred-pm';\n\nimport type { Options as ProcessOptions } from 'execa';\n\nconst SUPPORTED_PACKAGE_MANAGERS = ['npm', 'yarn'];\nconst DEFAULT_PACKAGE_MANAGER = 'npm' as const;\n\ntype SupportedPackageManagerName = 'npm' | 'yarn';\n\nexport const getPreferred = async (pkgPath: string): Promise<SupportedPackageManagerName> => {\n  const pm = await preferredPM(pkgPath);\n\n  const hasPackageManager = pm !== undefined;\n  if (!hasPackageManager) {\n    throw new Error(`Couldn't find a package manager in your project.`);\n  }\n\n  const isPackageManagerSupported = SUPPORTED_PACKAGE_MANAGERS.includes(pm.name);\n  if (!isPackageManagerSupported) {\n    process.emitWarning(\n      `We detected your package manager (${pm.name} v${pm.version}), but it's not officially supported by Strapi yet. Defaulting to npm instead.`\n    );\n\n    return DEFAULT_PACKAGE_MANAGER;\n  }\n\n  return pm.name as SupportedPackageManagerName;\n};\n\nexport const installDependencies = (\n  path: string,\n  packageManager: SupportedPackageManagerName,\n  options: ProcessOptions<string> = {}\n) => {\n  return execa(packageManager, ['install'], { ...options, cwd: path, stdin: 'ignore' });\n};\n"],"names":["SUPPORTED_PACKAGE_MANAGERS","DEFAULT_PACKAGE_MANAGER","getPreferred","pkgPath","pm","preferredPM","hasPackageManager","undefined","Error","isPackageManagerSupported","includes","name","process","emitWarning","version","installDependencies","path","packageManager","options","execa","cwd","stdin"],"mappings":";;;AAKA,MAAMA,0BAA6B,GAAA;AAAC,IAAA,KAAA;AAAO,IAAA;AAAO,CAAA;AAClD,MAAMC,uBAA0B,GAAA,KAAA;AAIzB,MAAMC,eAAe,OAAOC,OAAAA,GAAAA;IACjC,MAAMC,EAAAA,GAAK,MAAMC,WAAYF,CAAAA,OAAAA,CAAAA;AAE7B,IAAA,MAAMG,oBAAoBF,EAAOG,KAAAA,SAAAA;AACjC,IAAA,IAAI,CAACD,iBAAmB,EAAA;AACtB,QAAA,MAAM,IAAIE,KAAAA,CAAM,CAAC,gDAAgD,CAAC,CAAA;AACpE;AAEA,IAAA,MAAMC,yBAA4BT,GAAAA,0BAAAA,CAA2BU,QAAQ,CAACN,GAAGO,IAAI,CAAA;AAC7E,IAAA,IAAI,CAACF,yBAA2B,EAAA;AAC9BG,QAAAA,OAAAA,CAAQC,WAAW,CACjB,CAAC,kCAAkC,EAAET,EAAGO,CAAAA,IAAI,CAAC,EAAE,EAAEP,EAAAA,CAAGU,OAAO,CAAC,8EAA8E,CAAC,CAAA;QAG7I,OAAOb,uBAAAA;AACT;AAEA,IAAA,OAAOG,GAAGO,IAAI;AAChB;MAEaI,mBAAsB,GAAA,CACjCC,MACAC,cACAC,EAAAA,OAAAA,GAAkC,EAAE,GAAA;AAEpC,IAAA,OAAOC,MAAMF,cAAgB,EAAA;AAAC,QAAA;KAAU,EAAE;AAAE,QAAA,GAAGC,OAAO;QAAEE,GAAKJ,EAAAA,IAAAA;QAAMK,KAAO,EAAA;AAAS,KAAA,CAAA;AACrF;;;;"}

server/node_modules/@strapi/utils/dist/pagination.d.ts

@@ -0,0 +1,49 @@
+interface PaginationArgs {
+    page: number;
+    pageSize: number;
+    start: number;
+    limit: number;
+}
+export interface Pagination {
+    start: number;
+    limit: number;
+}
+export interface PagePatinationInformation {
+    page: number;
+    pageSize: number;
+    pageCount: number;
+    total: number;
+}
+export interface OffsetPaginationInformation {
+    start: number;
+    limit: number;
+    total: number;
+}
+declare const withDefaultPagination: <T extends Partial<PaginationArgs>>(args: T, { defaults, maxLimit }?: {
+    defaults?: {} | undefined;
+    maxLimit?: number | undefined;
+}) => {
+    start: number;
+    limit: number;
+} & Partial<T>;
+/**
+ * Transform pagination information into a paginated response:
+ * {
+ *    page: number,
+ *    pageSize: number,
+ *    pageCount: number,
+ *    total: number
+ * }
+ */
+declare const transformPagedPaginationInfo: (paginationInfo: Partial<PaginationArgs>, total: number) => PagePatinationInformation;
+/**
+ * Transform pagination information into a offset response:
+ * {
+ *    start: number,
+ *    limit: number,
+ *    total: number
+ * }
+ */
+declare const transformOffsetPaginationInfo: (paginationInfo: Partial<PaginationArgs>, total: number) => OffsetPaginationInformation;
+export { withDefaultPagination, transformPagedPaginationInfo, transformOffsetPaginationInfo };
+//# sourceMappingURL=pagination.d.ts.map

server/node_modules/@strapi/utils/dist/pagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../src/pagination.ts"],"names":[],"mappings":"AAGA,UAAU,cAAc;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AA0CD,QAAA,MAAM,qBAAqB,4CACnB,CAAC;;;;;;cAwDR,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,4BAA4B,mBAChB,QAAQ,cAAc,CAAC,SAChC,MAAM,KACZ,yBAkCF,CAAC;AAEF;;;;;;;GAOG;AACH,QAAA,MAAM,6BAA6B,mBACjB,QAAQ,cAAc,CAAC,SAChC,MAAM,KACZ,2BAuBF,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,4BAA4B,EAAE,6BAA6B,EAAE,CAAC"}

server/node_modules/@strapi/utils/dist/pagination.js

@@ -0,0 +1,163 @@
+'use strict';
+
+var fp = require('lodash/fp');
+var errors = require('./errors.js');
+
+const STRAPI_DEFAULTS = {
+    offset: {
+        start: 0,
+        limit: 10
+    },
+    page: {
+        page: 1,
+        pageSize: 10
+    }
+};
+const paginationAttributes = [
+    'start',
+    'limit',
+    'page',
+    'pageSize'
+];
+const withMaxLimit = (limit, maxLimit = -1)=>{
+    if (maxLimit === -1 || limit < maxLimit) {
+        return limit;
+    }
+    return maxLimit;
+};
+// Ensure minimum page & pageSize values (page >= 1, pageSize >= 0, start >= 0, limit >= 0)
+const ensureMinValues = ({ start, limit })=>({
+        start: Math.max(start, 0),
+        limit: limit === -1 ? limit : Math.max(limit, 1)
+    });
+const ensureMaxValues = (maxLimit = -1)=>({ start, limit })=>({
+            start,
+            limit: withMaxLimit(limit, maxLimit)
+        });
+// Apply maxLimit as the limit when limit is -1
+const withNoLimit = (pagination, maxLimit = -1)=>({
+        ...pagination,
+        limit: pagination.limit === -1 ? maxLimit : pagination.limit
+    });
+const withDefaultPagination = (args, { defaults = {}, maxLimit = -1 } = {})=>{
+    const defaultValues = fp.merge(STRAPI_DEFAULTS, defaults);
+    const usePagePagination = !fp.isNil(args.page) || !fp.isNil(args.pageSize);
+    const useOffsetPagination = !fp.isNil(args.start) || !fp.isNil(args.limit);
+    const ensureValidValues = fp.pipe(ensureMinValues, ensureMaxValues(maxLimit));
+    // If there is no pagination attribute, don't modify the payload
+    if (!usePagePagination && !useOffsetPagination) {
+        return fp.merge(args, ensureValidValues(defaultValues.offset));
+    }
+    // If there is page & offset pagination attributes, throw an error
+    if (usePagePagination && useOffsetPagination) {
+        throw new errors.PaginationError('Cannot use both page & offset pagination in the same query');
+    }
+    const pagination = {
+        start: 0,
+        limit: 0
+    };
+    // Start / Limit
+    if (useOffsetPagination) {
+        const { start, limit } = fp.merge(defaultValues.offset, args);
+        Object.assign(pagination, {
+            start,
+            limit
+        });
+    }
+    // Page / PageSize
+    if (usePagePagination) {
+        const { page, pageSize } = fp.merge(defaultValues.page, {
+            ...args,
+            pageSize: Math.max(1, args.pageSize ?? 0)
+        });
+        Object.assign(pagination, {
+            start: (page - 1) * pageSize,
+            limit: pageSize
+        });
+    }
+    // Handle -1 limit
+    Object.assign(pagination, withNoLimit(pagination, maxLimit));
+    const replacePaginationAttributes = fp.pipe(// Remove pagination attributes
+    fp.omit(paginationAttributes), // Merge the object with the new pagination + ensure minimum & maximum values
+    fp.merge(ensureValidValues(pagination)));
+    return replacePaginationAttributes(args);
+};
+/**
+ * Transform pagination information into a paginated response:
+ * {
+ *    page: number,
+ *    pageSize: number,
+ *    pageCount: number,
+ *    total: number
+ * }
+ */ const transformPagedPaginationInfo = (paginationInfo, total)=>{
+    if (!fp.isNil(paginationInfo.page)) {
+        const page = paginationInfo.page;
+        const pageSize = paginationInfo.pageSize ?? total;
+        return {
+            page,
+            pageSize,
+            pageCount: pageSize > 0 ? Math.ceil(total / pageSize) : 0,
+            total
+        };
+    }
+    if (!fp.isNil(paginationInfo.start)) {
+        const start = paginationInfo.start;
+        const limit = paginationInfo.limit ?? total;
+        // Start limit to page page size
+        return {
+            page: Math.floor(start / limit) + 1,
+            pageSize: limit,
+            pageCount: limit > 0 ? Math.ceil(total / limit) : 0,
+            total
+        };
+    }
+    // Default pagination
+    return {
+        ...paginationInfo,
+        page: 1,
+        pageSize: 10,
+        pageCount: 1,
+        total
+    };
+};
+/**
+ * Transform pagination information into a offset response:
+ * {
+ *    start: number,
+ *    limit: number,
+ *    total: number
+ * }
+ */ const transformOffsetPaginationInfo = (paginationInfo, total)=>{
+    if (!fp.isNil(paginationInfo.page)) {
+        const limit = paginationInfo.pageSize ?? total;
+        const start = (paginationInfo.page - 1) * limit;
+        return {
+            start,
+            limit,
+            total
+        };
+    }
+    if (!fp.isNil(paginationInfo.start)) {
+        const start = paginationInfo.start;
+        const limit = paginationInfo.limit ?? total;
+        // Start limit to page page size
+        return {
+            start,
+            limit,
+            total
+        };
+    }
+    // Default pagination
+    return {
+        ...paginationInfo,
+        start: 0,
+        limit: 10,
+        total
+    };
+};
+
+exports.transformOffsetPaginationInfo = transformOffsetPaginationInfo;
+exports.transformPagedPaginationInfo = transformPagedPaginationInfo;
+exports.withDefaultPagination = withDefaultPagination;
+//# sourceMappingURL=pagination.js.map

server/node_modules/@strapi/utils/dist/pagination.mjs

@@ -0,0 +1,159 @@
+import { merge, isNil, pipe, omit } from 'lodash/fp';
+import { PaginationError } from './errors.mjs';
+
+const STRAPI_DEFAULTS = {
+    offset: {
+        start: 0,
+        limit: 10
+    },
+    page: {
+        page: 1,
+        pageSize: 10
+    }
+};
+const paginationAttributes = [
+    'start',
+    'limit',
+    'page',
+    'pageSize'
+];
+const withMaxLimit = (limit, maxLimit = -1)=>{
+    if (maxLimit === -1 || limit < maxLimit) {
+        return limit;
+    }
+    return maxLimit;
+};
+// Ensure minimum page & pageSize values (page >= 1, pageSize >= 0, start >= 0, limit >= 0)
+const ensureMinValues = ({ start, limit })=>({
+        start: Math.max(start, 0),
+        limit: limit === -1 ? limit : Math.max(limit, 1)
+    });
+const ensureMaxValues = (maxLimit = -1)=>({ start, limit })=>({
+            start,
+            limit: withMaxLimit(limit, maxLimit)
+        });
+// Apply maxLimit as the limit when limit is -1
+const withNoLimit = (pagination, maxLimit = -1)=>({
+        ...pagination,
+        limit: pagination.limit === -1 ? maxLimit : pagination.limit
+    });
+const withDefaultPagination = (args, { defaults = {}, maxLimit = -1 } = {})=>{
+    const defaultValues = merge(STRAPI_DEFAULTS, defaults);
+    const usePagePagination = !isNil(args.page) || !isNil(args.pageSize);
+    const useOffsetPagination = !isNil(args.start) || !isNil(args.limit);
+    const ensureValidValues = pipe(ensureMinValues, ensureMaxValues(maxLimit));
+    // If there is no pagination attribute, don't modify the payload
+    if (!usePagePagination && !useOffsetPagination) {
+        return merge(args, ensureValidValues(defaultValues.offset));
+    }
+    // If there is page & offset pagination attributes, throw an error
+    if (usePagePagination && useOffsetPagination) {
+        throw new PaginationError('Cannot use both page & offset pagination in the same query');
+    }
+    const pagination = {
+        start: 0,
+        limit: 0
+    };
+    // Start / Limit
+    if (useOffsetPagination) {
+        const { start, limit } = merge(defaultValues.offset, args);
+        Object.assign(pagination, {
+            start,
+            limit
+        });
+    }
+    // Page / PageSize
+    if (usePagePagination) {
+        const { page, pageSize } = merge(defaultValues.page, {
+            ...args,
+            pageSize: Math.max(1, args.pageSize ?? 0)
+        });
+        Object.assign(pagination, {
+            start: (page - 1) * pageSize,
+            limit: pageSize
+        });
+    }
+    // Handle -1 limit
+    Object.assign(pagination, withNoLimit(pagination, maxLimit));
+    const replacePaginationAttributes = pipe(// Remove pagination attributes
+    omit(paginationAttributes), // Merge the object with the new pagination + ensure minimum & maximum values
+    merge(ensureValidValues(pagination)));
+    return replacePaginationAttributes(args);
+};
+/**
+ * Transform pagination information into a paginated response:
+ * {
+ *    page: number,
+ *    pageSize: number,
+ *    pageCount: number,
+ *    total: number
+ * }
+ */ const transformPagedPaginationInfo = (paginationInfo, total)=>{
+    if (!isNil(paginationInfo.page)) {
+        const page = paginationInfo.page;
+        const pageSize = paginationInfo.pageSize ?? total;
+        return {
+            page,
+            pageSize,
+            pageCount: pageSize > 0 ? Math.ceil(total / pageSize) : 0,
+            total
+        };
+    }
+    if (!isNil(paginationInfo.start)) {
+        const start = paginationInfo.start;
+        const limit = paginationInfo.limit ?? total;
+        // Start limit to page page size
+        return {
+            page: Math.floor(start / limit) + 1,
+            pageSize: limit,
+            pageCount: limit > 0 ? Math.ceil(total / limit) : 0,
+            total
+        };
+    }
+    // Default pagination
+    return {
+        ...paginationInfo,
+        page: 1,
+        pageSize: 10,
+        pageCount: 1,
+        total
+    };
+};
+/**
+ * Transform pagination information into a offset response:
+ * {
+ *    start: number,
+ *    limit: number,
+ *    total: number
+ * }
+ */ const transformOffsetPaginationInfo = (paginationInfo, total)=>{
+    if (!isNil(paginationInfo.page)) {
+        const limit = paginationInfo.pageSize ?? total;
+        const start = (paginationInfo.page - 1) * limit;
+        return {
+            start,
+            limit,
+            total
+        };
+    }
+    if (!isNil(paginationInfo.start)) {
+        const start = paginationInfo.start;
+        const limit = paginationInfo.limit ?? total;
+        // Start limit to page page size
+        return {
+            start,
+            limit,
+            total
+        };
+    }
+    // Default pagination
+    return {
+        ...paginationInfo,
+        start: 0,
+        limit: 10,
+        total
+    };
+};
+
+export { transformOffsetPaginationInfo, transformPagedPaginationInfo, withDefaultPagination };
+//# sourceMappingURL=pagination.mjs.map

server/node_modules/@strapi/utils/dist/parse-type.d.ts

@@ -0,0 +1,22 @@
+type TypeMap = {
+    boolean: boolean;
+    integer: number;
+    biginteger: number;
+    float: number;
+    decimal: number;
+    time: string;
+    date: string;
+    timestamp: Date;
+    datetime: Date;
+};
+export interface ParseTypeOptions<T extends keyof TypeMap> {
+    type: T;
+    value: unknown;
+    forceCast?: boolean;
+}
+/**
+ * Cast basic values based on attribute type
+ */
+declare const parseType: <Type extends keyof TypeMap>(options: ParseTypeOptions<Type>) => TypeMap[Type];
+export default parseType;
+//# sourceMappingURL=parse-type.d.ts.map

server/node_modules/@strapi/utils/dist/parse-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-type.d.ts","sourceRoot":"","sources":["../src/parse-type.ts"],"names":[],"mappings":"AAuEA,KAAK,OAAO,GAAG;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,IAAI,CAAC;IAChB,QAAQ,EAAE,IAAI,CAAC;CAChB,CAAC;AAEF,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,MAAM,OAAO;IACvD,IAAI,EAAE,CAAC,CAAC;IACR,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AA0BD;;GAEG;AACH,QAAA,MAAM,SAAS,wCAAyC,iBAAiB,IAAI,CAAC,KAAG,OAAO,CAAC,IAAI,CAyB5F,CAAC;AAEF,eAAe,SAAS,CAAC"}

server/node_modules/@strapi/utils/dist/parse-type.js

@@ -0,0 +1,140 @@
+'use strict';
+
+var _ = require('lodash');
+var dates = require('date-fns');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var ___namespace = /*#__PURE__*/_interopNamespaceDefault(_);
+var dates__namespace = /*#__PURE__*/_interopNamespaceDefault(dates);
+
+const timeRegex = /^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(.[0-9]{1,3})?$/;
+const isDate = (v)=>{
+    return dates__namespace.isDate(v);
+};
+const parseTime = (value)=>{
+    if (isDate(value)) {
+        return dates__namespace.format(value, 'HH:mm:ss.SSS');
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`Expected a string, got a ${typeof value}`);
+    }
+    const result = value.match(timeRegex);
+    if (result === null) {
+        throw new Error('Invalid time format, expected HH:mm:ss.SSS');
+    }
+    const [, hours, minutes, seconds, fraction = '.000'] = result;
+    const fractionPart = ___namespace.padEnd(fraction.slice(1), 3, '0');
+    return `${hours}:${minutes}:${seconds}.${fractionPart}`;
+};
+const parseDate = (value)=>{
+    if (isDate(value)) {
+        return dates__namespace.format(value, 'yyyy-MM-dd');
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`Expected a string, got a ${typeof value}`);
+    }
+    try {
+        const date = dates__namespace.parseISO(value);
+        if (dates__namespace.isValid(date)) return dates__namespace.format(date, 'yyyy-MM-dd');
+        throw new Error(`Invalid format, expected an ISO compatible date`);
+    } catch (error) {
+        throw new Error(`Invalid format, expected an ISO compatible date`);
+    }
+};
+const parseDateTimeOrTimestamp = (value)=>{
+    if (isDate(value)) {
+        return value;
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`Expected a string, got a ${typeof value}`);
+    }
+    try {
+        const date = dates__namespace.parseISO(value);
+        if (dates__namespace.isValid(date)) return date;
+        const milliUnixDate = dates__namespace.parse(value, 'T', new Date());
+        if (dates__namespace.isValid(milliUnixDate)) return milliUnixDate;
+        throw new Error(`Invalid format, expected a timestamp or an ISO date`);
+    } catch (error) {
+        throw new Error(`Invalid format, expected a timestamp or an ISO date`);
+    }
+};
+const parseBoolean = (value, options)=>{
+    const { forceCast = false } = options;
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string' || typeof value === 'number') {
+        if ([
+            'true',
+            't',
+            '1',
+            1
+        ].includes(value)) {
+            return true;
+        }
+        if ([
+            'false',
+            'f',
+            '0',
+            0
+        ].includes(value)) {
+            return false;
+        }
+    }
+    if (forceCast) {
+        return Boolean(value);
+    }
+    throw new Error('Invalid boolean input. Expected "t","1","true","false","0","f"');
+};
+/**
+ * Cast basic values based on attribute type
+ */ const parseType = (options)=>{
+    const { type, value, forceCast } = options;
+    switch(type){
+        case 'boolean':
+            return parseBoolean(value, {
+                forceCast
+            });
+        case 'integer':
+        case 'biginteger':
+        case 'float':
+        case 'decimal':
+            {
+                return ___namespace.toNumber(value);
+            }
+        case 'time':
+            {
+                return parseTime(value);
+            }
+        case 'date':
+            {
+                return parseDate(value);
+            }
+        case 'timestamp':
+        case 'datetime':
+            {
+                return parseDateTimeOrTimestamp(value);
+            }
+        default:
+            return value;
+    }
+};
+
+module.exports = parseType;
+//# sourceMappingURL=parse-type.js.map

server/node_modules/@strapi/utils/dist/parse-type.mjs

@@ -0,0 +1,118 @@
+import * as _ from 'lodash';
+import * as dates from 'date-fns';
+
+const timeRegex = /^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(.[0-9]{1,3})?$/;
+const isDate = (v)=>{
+    return dates.isDate(v);
+};
+const parseTime = (value)=>{
+    if (isDate(value)) {
+        return dates.format(value, 'HH:mm:ss.SSS');
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`Expected a string, got a ${typeof value}`);
+    }
+    const result = value.match(timeRegex);
+    if (result === null) {
+        throw new Error('Invalid time format, expected HH:mm:ss.SSS');
+    }
+    const [, hours, minutes, seconds, fraction = '.000'] = result;
+    const fractionPart = _.padEnd(fraction.slice(1), 3, '0');
+    return `${hours}:${minutes}:${seconds}.${fractionPart}`;
+};
+const parseDate = (value)=>{
+    if (isDate(value)) {
+        return dates.format(value, 'yyyy-MM-dd');
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`Expected a string, got a ${typeof value}`);
+    }
+    try {
+        const date = dates.parseISO(value);
+        if (dates.isValid(date)) return dates.format(date, 'yyyy-MM-dd');
+        throw new Error(`Invalid format, expected an ISO compatible date`);
+    } catch (error) {
+        throw new Error(`Invalid format, expected an ISO compatible date`);
+    }
+};
+const parseDateTimeOrTimestamp = (value)=>{
+    if (isDate(value)) {
+        return value;
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`Expected a string, got a ${typeof value}`);
+    }
+    try {
+        const date = dates.parseISO(value);
+        if (dates.isValid(date)) return date;
+        const milliUnixDate = dates.parse(value, 'T', new Date());
+        if (dates.isValid(milliUnixDate)) return milliUnixDate;
+        throw new Error(`Invalid format, expected a timestamp or an ISO date`);
+    } catch (error) {
+        throw new Error(`Invalid format, expected a timestamp or an ISO date`);
+    }
+};
+const parseBoolean = (value, options)=>{
+    const { forceCast = false } = options;
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string' || typeof value === 'number') {
+        if ([
+            'true',
+            't',
+            '1',
+            1
+        ].includes(value)) {
+            return true;
+        }
+        if ([
+            'false',
+            'f',
+            '0',
+            0
+        ].includes(value)) {
+            return false;
+        }
+    }
+    if (forceCast) {
+        return Boolean(value);
+    }
+    throw new Error('Invalid boolean input. Expected "t","1","true","false","0","f"');
+};
+/**
+ * Cast basic values based on attribute type
+ */ const parseType = (options)=>{
+    const { type, value, forceCast } = options;
+    switch(type){
+        case 'boolean':
+            return parseBoolean(value, {
+                forceCast
+            });
+        case 'integer':
+        case 'biginteger':
+        case 'float':
+        case 'decimal':
+            {
+                return _.toNumber(value);
+            }
+        case 'time':
+            {
+                return parseTime(value);
+            }
+        case 'date':
+            {
+                return parseDate(value);
+            }
+        case 'timestamp':
+        case 'datetime':
+            {
+                return parseDateTimeOrTimestamp(value);
+            }
+        default:
+            return value;
+    }
+};
+
+export { parseType as default };
+//# sourceMappingURL=parse-type.mjs.map

server/node_modules/@strapi/utils/dist/policy.d.ts

@@ -0,0 +1,16 @@
+interface Options {
+    name: string;
+    validator?(config: unknown): void;
+    handler(...args: any[]): any;
+}
+declare const createPolicy: (options: Options) => {
+    name: string;
+    validator: (config: unknown) => void;
+    handler: (...args: any[]) => any;
+};
+declare const createPolicyContext: (type: string, ctx: object) => {
+    is: import("lodash/fp").LodashEq1x1;
+    readonly type: string;
+} & object;
+export { createPolicy, createPolicyContext };
+//# sourceMappingURL=policy.d.ts.map

server/node_modules/@strapi/utils/dist/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../src/policy.ts"],"names":[],"mappings":"AAEA,UAAU,OAAO;IACf,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IAClC,OAAO,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,CAAC;CAC9B;AAED,QAAA,MAAM,YAAY,YAAa,OAAO;;wBAGF,OAAO;uBANxB,GAAG,EAAE,KAAG,GAAG;CAqB7B,CAAC;AAEF,QAAA,MAAM,mBAAmB,SAAU,MAAM,OAAO,MAAM;;;UAUrD,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,CAAC"}

server/node_modules/@strapi/utils/dist/policy.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var fp = require('lodash/fp');
+
+const createPolicy = (options)=>{
+    const { name = 'unnamed', validator, handler } = options;
+    const wrappedValidator = (config)=>{
+        if (validator) {
+            try {
+                validator(config);
+            } catch (e) {
+                throw new Error(`Invalid config passed to "${name}" policy.`);
+            }
+        }
+    };
+    return {
+        name,
+        validator: wrappedValidator,
+        handler
+    };
+};
+const createPolicyContext = (type, ctx)=>{
+    return Object.assign({
+        is: fp.eq(type),
+        get type () {
+            return type;
+        }
+    }, ctx);
+};
+
+exports.createPolicy = createPolicy;
+exports.createPolicyContext = createPolicyContext;
+//# sourceMappingURL=policy.js.map

server/node_modules/@strapi/utils/dist/policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.js","sources":["../src/policy.ts"],"sourcesContent":["import { eq } from 'lodash/fp';\n\ninterface Options {\n  name: string;\n  validator?(config: unknown): void;\n  handler(...args: any[]): any;\n}\n\nconst createPolicy = (options: Options) => {\n  const { name = 'unnamed', validator, handler } = options;\n\n  const wrappedValidator = (config: unknown) => {\n    if (validator) {\n      try {\n        validator(config);\n      } catch (e) {\n        throw new Error(`Invalid config passed to \"${name}\" policy.`);\n      }\n    }\n  };\n\n  return {\n    name,\n    validator: wrappedValidator,\n    handler,\n  };\n};\n\nconst createPolicyContext = (type: string, ctx: object) => {\n  return Object.assign(\n    {\n      is: eq(type),\n      get type() {\n        return type;\n      },\n    },\n    ctx\n  );\n};\n\nexport { createPolicy, createPolicyContext };\n"],"names":["createPolicy","options","name","validator","handler","wrappedValidator","config","e","Error","createPolicyContext","type","ctx","Object","assign","is","eq"],"mappings":";;;;AAQA,MAAMA,eAAe,CAACC,OAAAA,GAAAA;IACpB,MAAM,EAAEC,OAAO,SAAS,EAAEC,SAAS,EAAEC,OAAO,EAAE,GAAGH,OAAAA;AAEjD,IAAA,MAAMI,mBAAmB,CAACC,MAAAA,GAAAA;AACxB,QAAA,IAAIH,SAAW,EAAA;YACb,IAAI;gBACFA,SAAUG,CAAAA,MAAAA,CAAAA;AACZ,aAAA,CAAE,OAAOC,CAAG,EAAA;AACV,gBAAA,MAAM,IAAIC,KAAM,CAAA,CAAC,0BAA0B,EAAEN,IAAAA,CAAK,SAAS,CAAC,CAAA;AAC9D;AACF;AACF,KAAA;IAEA,OAAO;AACLA,QAAAA,IAAAA;QACAC,SAAWE,EAAAA,gBAAAA;AACXD,QAAAA;AACF,KAAA;AACF;AAEMK,MAAAA,mBAAAA,GAAsB,CAACC,IAAcC,EAAAA,GAAAA,GAAAA;IACzC,OAAOC,MAAAA,CAAOC,MAAM,CAClB;AACEC,QAAAA,EAAAA,EAAIC,KAAGL,CAAAA,IAAAA,CAAAA;AACP,QAAA,IAAIA,IAAO,CAAA,GAAA;YACT,OAAOA,IAAAA;AACT;KAEFC,EAAAA,GAAAA,CAAAA;AAEJ;;;;;"}

server/node_modules/@strapi/utils/dist/policy.mjs

@@ -0,0 +1,30 @@
+import { eq } from 'lodash/fp';
+
+const createPolicy = (options)=>{
+    const { name = 'unnamed', validator, handler } = options;
+    const wrappedValidator = (config)=>{
+        if (validator) {
+            try {
+                validator(config);
+            } catch (e) {
+                throw new Error(`Invalid config passed to "${name}" policy.`);
+            }
+        }
+    };
+    return {
+        name,
+        validator: wrappedValidator,
+        handler
+    };
+};
+const createPolicyContext = (type, ctx)=>{
+    return Object.assign({
+        is: eq(type),
+        get type () {
+            return type;
+        }
+    }, ctx);
+};
+
+export { createPolicy, createPolicyContext };
+//# sourceMappingURL=policy.mjs.map

server/node_modules/@strapi/utils/dist/policy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.mjs","sources":["../src/policy.ts"],"sourcesContent":["import { eq } from 'lodash/fp';\n\ninterface Options {\n  name: string;\n  validator?(config: unknown): void;\n  handler(...args: any[]): any;\n}\n\nconst createPolicy = (options: Options) => {\n  const { name = 'unnamed', validator, handler } = options;\n\n  const wrappedValidator = (config: unknown) => {\n    if (validator) {\n      try {\n        validator(config);\n      } catch (e) {\n        throw new Error(`Invalid config passed to \"${name}\" policy.`);\n      }\n    }\n  };\n\n  return {\n    name,\n    validator: wrappedValidator,\n    handler,\n  };\n};\n\nconst createPolicyContext = (type: string, ctx: object) => {\n  return Object.assign(\n    {\n      is: eq(type),\n      get type() {\n        return type;\n      },\n    },\n    ctx\n  );\n};\n\nexport { createPolicy, createPolicyContext };\n"],"names":["createPolicy","options","name","validator","handler","wrappedValidator","config","e","Error","createPolicyContext","type","ctx","Object","assign","is","eq"],"mappings":";;AAQA,MAAMA,eAAe,CAACC,OAAAA,GAAAA;IACpB,MAAM,EAAEC,OAAO,SAAS,EAAEC,SAAS,EAAEC,OAAO,EAAE,GAAGH,OAAAA;AAEjD,IAAA,MAAMI,mBAAmB,CAACC,MAAAA,GAAAA;AACxB,QAAA,IAAIH,SAAW,EAAA;YACb,IAAI;gBACFA,SAAUG,CAAAA,MAAAA,CAAAA;AACZ,aAAA,CAAE,OAAOC,CAAG,EAAA;AACV,gBAAA,MAAM,IAAIC,KAAM,CAAA,CAAC,0BAA0B,EAAEN,IAAAA,CAAK,SAAS,CAAC,CAAA;AAC9D;AACF;AACF,KAAA;IAEA,OAAO;AACLA,QAAAA,IAAAA;QACAC,SAAWE,EAAAA,gBAAAA;AACXD,QAAAA;AACF,KAAA;AACF;AAEMK,MAAAA,mBAAAA,GAAsB,CAACC,IAAcC,EAAAA,GAAAA,GAAAA;IACzC,OAAOC,MAAAA,CAAOC,MAAM,CAClB;AACEC,QAAAA,EAAAA,EAAIC,EAAGL,CAAAA,IAAAA,CAAAA;AACP,QAAA,IAAIA,IAAO,CAAA,GAAA;YACT,OAAOA,IAAAA;AACT;KAEFC,EAAAA,GAAAA,CAAAA;AAEJ;;;;"}

server/node_modules/@strapi/utils/dist/primitives/arrays.d.ts

@@ -0,0 +1,3 @@
+declare const includesString: (arr: unknown[], val: unknown) => boolean;
+export { includesString };
+//# sourceMappingURL=arrays.d.ts.map

server/node_modules/@strapi/utils/dist/primitives/arrays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrays.d.ts","sourceRoot":"","sources":["../../src/primitives/arrays.ts"],"names":[],"mappings":"AAGA,QAAA,MAAM,cAAc,QAAS,OAAO,EAAE,OAAO,OAAO,YAAmC,CAAC;AAExF,OAAO,EAAE,cAAc,EAAE,CAAC"}