@strapi/utils 5.12.1 → 5.12.3

package/dist/traverse/query-fields.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var fp = require('lodash/fp');
+var factory = require('./factory.js');
+
+const isStringArray = (value)=>{
+    return fp.isArray(value) && value.every(fp.isString);
+};
+const fields = factory()// Intercept array of strings
+// e.g. fields=['title', 'description']
+.intercept(isStringArray, async (visitor, options, fields, { recurse })=>{
+    return Promise.all(fields.map((field)=>recurse(visitor, options, field)));
+})// Intercept comma separated fields (as string)
+// e.g. fields='title,description'
+.intercept((value)=>fp.isString(value) && value.includes(','), (visitor, options, fields, { recurse })=>{
+    return Promise.all(fields.split(',').map((field)=>recurse(visitor, options, field)));
+})// Return wildcards as is
+.intercept((value)=>fp.eq('*', value), fp.constant('*'))// Parse string values
+// Since we're parsing strings only, each value should be an attribute name (and it's value, undefined),
+// thus it shouldn't be possible to set a new value, and get should return the whole data if key === data
+.parse(fp.isString, ()=>({
+        transform: fp.trim,
+        remove (key, data) {
+            return data === key ? undefined : data;
+        },
+        set (_key, _value, data) {
+            return data;
+        },
+        keys (data) {
+            return [
+                data
+            ];
+        },
+        get (key, data) {
+            return key === data ? data : undefined;
+        }
+    }));
+var traverseQueryFields = fp.curry(fields.traverse);
+
+module.exports = traverseQueryFields;
+//# sourceMappingURL=query-fields.js.map

package/dist/traverse/query-fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-fields.js","sources":["../../src/traverse/query-fields.ts"],"sourcesContent":["import { curry, isArray, isString, eq, trim, constant } from 'lodash/fp';\n\nimport traverseFactory from './factory';\n\nconst isStringArray = (value: unknown): value is string[] => {\n  return isArray(value) && value.every(isString);\n};\n\nconst fields = traverseFactory()\n  // Intercept array of strings\n  // e.g. fields=['title', 'description']\n  .intercept(isStringArray, async (visitor, options, fields, { recurse }) => {\n    return Promise.all(fields.map((field) => recurse(visitor, options, field)));\n  })\n  // Intercept comma separated fields (as string)\n  // e.g. fields='title,description'\n  .intercept(\n    (value): value is string => isString(value) && value.includes(','),\n    (visitor, options, fields, { recurse }) => {\n      return Promise.all(fields.split(',').map((field) => recurse(visitor, options, field)));\n    }\n  )\n  // Return wildcards as is\n  .intercept((value): value is string => eq('*', value), constant('*'))\n  // Parse string values\n  // Since we're parsing strings only, each value should be an attribute name (and it's value, undefined),\n  // thus it shouldn't be possible to set a new value, and get should return the whole data if key === data\n  .parse(isString, () => ({\n    transform: trim,\n\n    remove(key, data) {\n      return data === key ? undefined : data;\n    },\n\n    set(_key, _value, data) {\n      return data;\n    },\n\n    keys(data) {\n      return [data];\n    },\n\n    get(key, data) {\n      return key === data ? data : undefined;\n    },\n  }));\n\nexport default curry(fields.traverse);\n"],"names":["isStringArray","value","isArray","every","isString","fields","traverseFactory","intercept","visitor","options","recurse","Promise","all","map","field","includes","split","eq","constant","parse","transform","trim","remove","key","data","undefined","set","_key","_value","keys","get","curry","traverse"],"mappings":";;;;;AAIA,MAAMA,gBAAgB,CAACC,KAAAA,GAAAA;AACrB,IAAA,OAAOC,UAAQD,CAAAA,KAAAA,CAAAA,IAAUA,KAAME,CAAAA,KAAK,CAACC,WAAAA,CAAAA;AACvC,CAAA;AAEA,MAAMC,MAAAA,GAASC,SACb;AACA;CACCC,SAAS,CAACP,eAAe,OAAOQ,OAAAA,EAASC,SAASJ,MAAQ,EAAA,EAAEK,OAAO,EAAE,GAAA;IACpE,OAAOC,OAAAA,CAAQC,GAAG,CAACP,MAAOQ,CAAAA,GAAG,CAAC,CAACC,KAAAA,GAAUJ,OAAQF,CAAAA,OAAAA,EAASC,OAASK,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA;AACrE,CAAA,CACA;AACA;AACCP,CAAAA,SAAS,CACR,CAACN,KAA2BG,GAAAA,WAAAA,CAASH,UAAUA,KAAMc,CAAAA,QAAQ,CAAC,GAAA,CAAA,EAC9D,CAACP,OAASC,EAAAA,OAAAA,EAASJ,MAAQ,EAAA,EAAEK,OAAO,EAAE,GAAA;AACpC,IAAA,OAAOC,OAAQC,CAAAA,GAAG,CAACP,MAAAA,CAAOW,KAAK,CAAC,GAAKH,CAAAA,CAAAA,GAAG,CAAC,CAACC,KAAUJ,GAAAA,OAAAA,CAAQF,SAASC,OAASK,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA;AAChF,CAAA,CAEF;CACCP,SAAS,CAAC,CAACN,KAA2BgB,GAAAA,KAAAA,CAAG,KAAKhB,KAAQiB,CAAAA,EAAAA,WAAAA,CAAS,KAChE;AACA;AACA;CACCC,KAAK,CAACf,WAAU,EAAA,KAAO;QACtBgB,SAAWC,EAAAA,OAAAA;QAEXC,MAAOC,CAAAA,CAAAA,GAAG,EAAEC,IAAI,EAAA;YACd,OAAOA,IAAAA,KAASD,MAAME,SAAYD,GAAAA,IAAAA;AACpC,SAAA;AAEAE,QAAAA,GAAAA,CAAAA,CAAIC,IAAI,EAAEC,MAAM,EAAEJ,IAAI,EAAA;YACpB,OAAOA,IAAAA;AACT,SAAA;AAEAK,QAAAA,IAAAA,CAAAA,CAAKL,IAAI,EAAA;YACP,OAAO;AAACA,gBAAAA;AAAK,aAAA;AACf,SAAA;QAEAM,GAAIP,CAAAA,CAAAA,GAAG,EAAEC,IAAI,EAAA;YACX,OAAOD,GAAAA,KAAQC,OAAOA,IAAOC,GAAAA,SAAAA;AAC/B;KACF,CAAA,CAAA;AAEF,0BAAeM,QAAAA,CAAM1B,MAAO2B,CAAAA,QAAQ,CAAE;;;;"}

package/dist/traverse/query-fields.mjs

@@ -0,0 +1,39 @@
+import { isString, eq, constant, trim, curry, isArray } from 'lodash/fp';
+import traverseFactory from './factory.mjs';
+
+const isStringArray = (value)=>{
+    return isArray(value) && value.every(isString);
+};
+const fields = traverseFactory()// Intercept array of strings
+// e.g. fields=['title', 'description']
+.intercept(isStringArray, async (visitor, options, fields, { recurse })=>{
+    return Promise.all(fields.map((field)=>recurse(visitor, options, field)));
+})// Intercept comma separated fields (as string)
+// e.g. fields='title,description'
+.intercept((value)=>isString(value) && value.includes(','), (visitor, options, fields, { recurse })=>{
+    return Promise.all(fields.split(',').map((field)=>recurse(visitor, options, field)));
+})// Return wildcards as is
+.intercept((value)=>eq('*', value), constant('*'))// Parse string values
+// Since we're parsing strings only, each value should be an attribute name (and it's value, undefined),
+// thus it shouldn't be possible to set a new value, and get should return the whole data if key === data
+.parse(isString, ()=>({
+        transform: trim,
+        remove (key, data) {
+            return data === key ? undefined : data;
+        },
+        set (_key, _value, data) {
+            return data;
+        },
+        keys (data) {
+            return [
+                data
+            ];
+        },
+        get (key, data) {
+            return key === data ? data : undefined;
+        }
+    }));
+var traverseQueryFields = curry(fields.traverse);
+
+export { traverseQueryFields as default };
+//# sourceMappingURL=query-fields.mjs.map

package/dist/traverse/query-fields.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-fields.mjs","sources":["../../src/traverse/query-fields.ts"],"sourcesContent":["import { curry, isArray, isString, eq, trim, constant } from 'lodash/fp';\n\nimport traverseFactory from './factory';\n\nconst isStringArray = (value: unknown): value is string[] => {\n  return isArray(value) && value.every(isString);\n};\n\nconst fields = traverseFactory()\n  // Intercept array of strings\n  // e.g. fields=['title', 'description']\n  .intercept(isStringArray, async (visitor, options, fields, { recurse }) => {\n    return Promise.all(fields.map((field) => recurse(visitor, options, field)));\n  })\n  // Intercept comma separated fields (as string)\n  // e.g. fields='title,description'\n  .intercept(\n    (value): value is string => isString(value) && value.includes(','),\n    (visitor, options, fields, { recurse }) => {\n      return Promise.all(fields.split(',').map((field) => recurse(visitor, options, field)));\n    }\n  )\n  // Return wildcards as is\n  .intercept((value): value is string => eq('*', value), constant('*'))\n  // Parse string values\n  // Since we're parsing strings only, each value should be an attribute name (and it's value, undefined),\n  // thus it shouldn't be possible to set a new value, and get should return the whole data if key === data\n  .parse(isString, () => ({\n    transform: trim,\n\n    remove(key, data) {\n      return data === key ? undefined : data;\n    },\n\n    set(_key, _value, data) {\n      return data;\n    },\n\n    keys(data) {\n      return [data];\n    },\n\n    get(key, data) {\n      return key === data ? data : undefined;\n    },\n  }));\n\nexport default curry(fields.traverse);\n"],"names":["isStringArray","value","isArray","every","isString","fields","traverseFactory","intercept","visitor","options","recurse","Promise","all","map","field","includes","split","eq","constant","parse","transform","trim","remove","key","data","undefined","set","_key","_value","keys","get","curry","traverse"],"mappings":";;;AAIA,MAAMA,gBAAgB,CAACC,KAAAA,GAAAA;AACrB,IAAA,OAAOC,OAAQD,CAAAA,KAAAA,CAAAA,IAAUA,KAAME,CAAAA,KAAK,CAACC,QAAAA,CAAAA;AACvC,CAAA;AAEA,MAAMC,MAAAA,GAASC,iBACb;AACA;CACCC,SAAS,CAACP,eAAe,OAAOQ,OAAAA,EAASC,SAASJ,MAAQ,EAAA,EAAEK,OAAO,EAAE,GAAA;IACpE,OAAOC,OAAAA,CAAQC,GAAG,CAACP,MAAOQ,CAAAA,GAAG,CAAC,CAACC,KAAAA,GAAUJ,OAAQF,CAAAA,OAAAA,EAASC,OAASK,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA;AACrE,CAAA,CACA;AACA;AACCP,CAAAA,SAAS,CACR,CAACN,KAA2BG,GAAAA,QAAAA,CAASH,UAAUA,KAAMc,CAAAA,QAAQ,CAAC,GAAA,CAAA,EAC9D,CAACP,OAASC,EAAAA,OAAAA,EAASJ,MAAQ,EAAA,EAAEK,OAAO,EAAE,GAAA;AACpC,IAAA,OAAOC,OAAQC,CAAAA,GAAG,CAACP,MAAAA,CAAOW,KAAK,CAAC,GAAKH,CAAAA,CAAAA,GAAG,CAAC,CAACC,KAAUJ,GAAAA,OAAAA,CAAQF,SAASC,OAASK,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA;AAChF,CAAA,CAEF;CACCP,SAAS,CAAC,CAACN,KAA2BgB,GAAAA,EAAAA,CAAG,KAAKhB,KAAQiB,CAAAA,EAAAA,QAAAA,CAAS,KAChE;AACA;AACA;CACCC,KAAK,CAACf,QAAU,EAAA,KAAO;QACtBgB,SAAWC,EAAAA,IAAAA;QAEXC,MAAOC,CAAAA,CAAAA,GAAG,EAAEC,IAAI,EAAA;YACd,OAAOA,IAAAA,KAASD,MAAME,SAAYD,GAAAA,IAAAA;AACpC,SAAA;AAEAE,QAAAA,GAAAA,CAAAA,CAAIC,IAAI,EAAEC,MAAM,EAAEJ,IAAI,EAAA;YACpB,OAAOA,IAAAA;AACT,SAAA;AAEAK,QAAAA,IAAAA,CAAAA,CAAKL,IAAI,EAAA;YACP,OAAO;AAACA,gBAAAA;AAAK,aAAA;AACf,SAAA;QAEAM,GAAIP,CAAAA,CAAAA,GAAG,EAAEC,IAAI,EAAA;YACX,OAAOD,GAAAA,KAAQC,OAAOA,IAAOC,GAAAA,SAAAA;AAC/B;KACF,CAAA,CAAA;AAEF,0BAAeM,KAAAA,CAAM1B,MAAO2B,CAAAA,QAAQ,CAAE;;;;"}

package/dist/traverse/query-filters.js

@@ -0,0 +1,114 @@
+'use strict';
+
+var fp = require('lodash/fp');
+var factory = require('./factory.js');
+
+const isObj = (value)=>fp.isObject(value);
+const filters = factory().intercept(// Intercept filters arrays and apply the traversal to each one individually
+fp.isArray, async (visitor, options, filters, { recurse })=>{
+    return Promise.all(filters.map((filter, i)=>{
+        // In filters, only operators such as $and, $in, $notIn or $or and implicit operators like [...]
+        // can have a value array, thus we can update the raw path but not the attribute one
+        const newPath = options.path ? {
+            ...options.path,
+            raw: `${options.path.raw}[${i}]`
+        } : options.path;
+        return recurse(visitor, {
+            ...options,
+            path: newPath
+        }, filter);
+    })).then((res)=>res.filter((val)=>!(fp.isObject(val) && fp.isEmpty(val))));
+}).intercept(// Ignore non object filters and return the value as-is
+(filters)=>!fp.isObject(filters), (_, __, filters)=>{
+    return filters;
+})// Parse object values
+.parse(isObj, ()=>({
+        transform: fp.cloneDeep,
+        remove (key, data) {
+            return fp.omit(key, data);
+        },
+        set (key, value, data) {
+            return {
+                ...data,
+                [key]: value
+            };
+        },
+        keys (data) {
+            return Object.keys(data);
+        },
+        get (key, data) {
+            return data[key];
+        }
+    }))// Ignore null or undefined values
+.ignore(({ value })=>fp.isNil(value))// Recursion on operators (non attributes)
+.on(({ attribute })=>fp.isNil(attribute), async ({ key, visitor, path, value, schema, getModel, attribute }, { set, recurse })=>{
+    const parent = {
+        key,
+        path,
+        schema,
+        attribute
+    };
+    set(key, await recurse(visitor, {
+        schema,
+        path,
+        getModel,
+        parent
+    }, value));
+})// Handle relation recursion
+.onRelation(async ({ key, attribute, visitor, path, value, schema, getModel }, { set, recurse })=>{
+    const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');
+    if (isMorphRelation) {
+        return;
+    }
+    const parent = {
+        key,
+        path,
+        schema,
+        attribute
+    };
+    const targetSchemaUID = attribute.target;
+    const targetSchema = getModel(targetSchemaUID);
+    const newValue = await recurse(visitor, {
+        schema: targetSchema,
+        path,
+        getModel,
+        parent
+    }, value);
+    set(key, newValue);
+}).onComponent(async ({ key, attribute, visitor, path, schema, value, getModel }, { set, recurse })=>{
+    const parent = {
+        key,
+        path,
+        schema,
+        attribute
+    };
+    const targetSchema = getModel(attribute.component);
+    const newValue = await recurse(visitor, {
+        schema: targetSchema,
+        path,
+        getModel,
+        parent
+    }, value);
+    set(key, newValue);
+})// Handle media recursion
+.onMedia(async ({ key, visitor, path, schema, attribute, value, getModel }, { set, recurse })=>{
+    const parent = {
+        key,
+        path,
+        schema,
+        attribute
+    };
+    const targetSchemaUID = 'plugin::upload.file';
+    const targetSchema = getModel(targetSchemaUID);
+    const newValue = await recurse(visitor, {
+        schema: targetSchema,
+        path,
+        getModel,
+        parent
+    }, value);
+    set(key, newValue);
+});
+var traverseQueryFilters = fp.curry(filters.traverse);
+
+module.exports = traverseQueryFilters;
+//# sourceMappingURL=query-filters.js.map

package/dist/traverse/query-filters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-filters.js","sources":["../../src/traverse/query-filters.ts"],"sourcesContent":["import { curry, isObject, isEmpty, isArray, isNil, cloneDeep, omit } from 'lodash/fp';\n\nimport traverseFactory, { type Parent } from './factory';\n\nconst isObj = (value: unknown): value is Record<string, unknown> => isObject(value);\n\nconst filters = traverseFactory()\n  .intercept(\n    // Intercept filters arrays and apply the traversal to each one individually\n    isArray,\n    async (visitor, options, filters, { recurse }) => {\n      return Promise.all(\n        filters.map((filter, i) => {\n          // In filters, only operators such as $and, $in, $notIn or $or and implicit operators like [...]\n          // can have a value array, thus we can update the raw path but not the attribute one\n          const newPath = options.path\n            ? { ...options.path, raw: `${options.path.raw}[${i}]` }\n            : options.path;\n\n          return recurse(visitor, { ...options, path: newPath }, filter);\n        })\n        // todo: move that to the visitors\n      ).then((res) => res.filter((val) => !(isObject(val) && isEmpty(val))));\n    }\n  )\n  .intercept(\n    // Ignore non object filters and return the value as-is\n    (filters): filters is unknown => !isObject(filters),\n    (_, __, filters) => {\n      return filters;\n    }\n  )\n  // Parse object values\n  .parse(isObj, () => ({\n    transform: cloneDeep,\n\n    remove(key, data) {\n      return omit(key, data);\n    },\n\n    set(key, value, data) {\n      return { ...data, [key]: value };\n    },\n\n    keys(data) {\n      return Object.keys(data);\n    },\n\n    get(key, data) {\n      return data[key];\n    },\n  }))\n  // Ignore null or undefined values\n  .ignore(({ value }) => isNil(value))\n  // Recursion on operators (non attributes)\n  .on(\n    ({ attribute }) => isNil(attribute),\n    async ({ key, visitor, path, value, schema, getModel, attribute }, { set, recurse }) => {\n      const parent: Parent = { key, path, schema, attribute };\n\n      set(key, await recurse(visitor, { schema, path, getModel, parent }, value));\n    }\n  )\n  // Handle relation recursion\n  .onRelation(\n    async ({ key, attribute, visitor, path, value, schema, getModel }, { set, recurse }) => {\n      const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');\n\n      if (isMorphRelation) {\n        return;\n      }\n\n      const parent: Parent = { key, path, schema, attribute };\n\n      const targetSchemaUID = attribute.target;\n      const targetSchema = getModel(targetSchemaUID!);\n\n      const newValue = await recurse(\n        visitor,\n        { schema: targetSchema, path, getModel, parent },\n        value\n      );\n\n      set(key, newValue);\n    }\n  )\n  .onComponent(\n    async ({ key, attribute, visitor, path, schema, value, getModel }, { set, recurse }) => {\n      const parent: Parent = { key, path, schema, attribute };\n      const targetSchema = getModel(attribute.component);\n\n      const newValue = await recurse(\n        visitor,\n        { schema: targetSchema, path, getModel, parent },\n        value\n      );\n\n      set(key, newValue);\n    }\n  )\n  // Handle media recursion\n  .onMedia(async ({ key, visitor, path, schema, attribute, value, getModel }, { set, recurse }) => {\n    const parent: Parent = { key, path, schema, attribute };\n\n    const targetSchemaUID = 'plugin::upload.file';\n    const targetSchema = getModel(targetSchemaUID);\n\n    const newValue = await recurse(\n      visitor,\n      { schema: targetSchema, path, getModel, parent },\n      value\n    );\n\n    set(key, newValue);\n  });\n\nexport default curry(filters.traverse);\n"],"names":["isObj","value","isObject","filters","traverseFactory","intercept","isArray","visitor","options","recurse","Promise","all","map","filter","i","newPath","path","raw","then","res","val","isEmpty","_","__","parse","transform","cloneDeep","remove","key","data","omit","set","keys","Object","get","ignore","isNil","on","attribute","schema","getModel","parent","onRelation","isMorphRelation","relation","toLowerCase","startsWith","targetSchemaUID","target","targetSchema","newValue","onComponent","component","onMedia","curry","traverse"],"mappings":";;;;;AAIA,MAAMA,KAAAA,GAAQ,CAACC,KAAAA,GAAqDC,WAASD,CAAAA,KAAAA,CAAAA;AAE7E,MAAME,OAAUC,GAAAA,OAAAA,EAAAA,CACbC,SAAS;AAERC,UAAAA,EACA,OAAOC,OAASC,EAAAA,OAAAA,EAASL,OAAS,EAAA,EAAEM,OAAO,EAAE,GAAA;AAC3C,IAAA,OAAOC,QAAQC,GAAG,CAChBR,QAAQS,GAAG,CAAC,CAACC,MAAQC,EAAAA,CAAAA,GAAAA;;;QAGnB,MAAMC,OAAAA,GAAUP,OAAQQ,CAAAA,IAAI,GACxB;AAAE,YAAA,GAAGR,QAAQQ,IAAI;YAAEC,GAAK,EAAA,CAAC,EAAET,OAAAA,CAAQQ,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEH,CAAE,CAAA,CAAC;AAAE,SAAA,GACpDN,QAAQQ,IAAI;AAEhB,QAAA,OAAOP,QAAQF,OAAS,EAAA;AAAE,YAAA,GAAGC,OAAO;YAAEQ,IAAMD,EAAAA;SAAWF,EAAAA,MAAAA,CAAAA;AACzD,KAAA,CAAA,CAAA,CAEAK,IAAI,CAAC,CAACC,GAAAA,GAAQA,IAAIN,MAAM,CAAC,CAACO,GAAAA,GAAQ,EAAElB,WAASkB,CAAAA,GAAAA,CAAAA,IAAQC,WAAQD,GAAG,CAAA,CAAA,CAAA,CAAA;AACpE,CAEDf,CAAAA,CAAAA,SAAS;AAER,CAACF,UAAgC,CAACD,WAAAA,CAASC,OAC3C,CAAA,EAAA,CAACmB,GAAGC,EAAIpB,EAAAA,OAAAA,GAAAA;IACN,OAAOA,OAAAA;AACT,CAAA,CAEF;CACCqB,KAAK,CAACxB,KAAO,EAAA,KAAO;QACnByB,SAAWC,EAAAA,YAAAA;QAEXC,MAAOC,CAAAA,CAAAA,GAAG,EAAEC,IAAI,EAAA;AACd,YAAA,OAAOC,QAAKF,GAAKC,EAAAA,IAAAA,CAAAA;AACnB,SAAA;AAEAE,QAAAA,GAAAA,CAAAA,CAAIH,GAAG,EAAE3B,KAAK,EAAE4B,IAAI,EAAA;YAClB,OAAO;AAAE,gBAAA,GAAGA,IAAI;AAAE,gBAAA,CAACD,MAAM3B;AAAM,aAAA;AACjC,SAAA;AAEA+B,QAAAA,IAAAA,CAAAA,CAAKH,IAAI,EAAA;YACP,OAAOI,MAAAA,CAAOD,IAAI,CAACH,IAAAA,CAAAA;AACrB,SAAA;QAEAK,GAAIN,CAAAA,CAAAA,GAAG,EAAEC,IAAI,EAAA;YACX,OAAOA,IAAI,CAACD,GAAI,CAAA;AAClB;AACF,KAAA,EACA;CACCO,MAAM,CAAC,CAAC,EAAElC,KAAK,EAAE,GAAKmC,QAAAA,CAAMnC,OAC7B;AACCoC,CAAAA,EAAE,CACD,CAAC,EAAEC,SAAS,EAAE,GAAKF,QAAME,CAAAA,SAAAA,CAAAA,EACzB,OAAO,EAAEV,GAAG,EAAErB,OAAO,EAAES,IAAI,EAAEf,KAAK,EAAEsC,MAAM,EAAEC,QAAQ,EAAEF,SAAS,EAAE,EAAE,EAAEP,GAAG,EAAEtB,OAAO,EAAE,GAAA;AACjF,IAAA,MAAMgC,MAAiB,GAAA;AAAEb,QAAAA,GAAAA;AAAKZ,QAAAA,IAAAA;AAAMuB,QAAAA,MAAAA;AAAQD,QAAAA;AAAU,KAAA;IAEtDP,GAAIH,CAAAA,GAAAA,EAAK,MAAMnB,OAAAA,CAAQF,OAAS,EAAA;AAAEgC,QAAAA,MAAAA;AAAQvB,QAAAA,IAAAA;AAAMwB,QAAAA,QAAAA;AAAUC,QAAAA;KAAUxC,EAAAA,KAAAA,CAAAA,CAAAA;AACtE,CAAA,CAEF;CACCyC,UAAU,CACT,OAAO,EAAEd,GAAG,EAAEU,SAAS,EAAE/B,OAAO,EAAES,IAAI,EAAEf,KAAK,EAAEsC,MAAM,EAAEC,QAAQ,EAAE,EAAE,EAAET,GAAG,EAAEtB,OAAO,EAAE,GAAA;AACjF,IAAA,MAAMkC,kBAAkBL,SAAUM,CAAAA,QAAQ,CAACC,WAAW,EAAA,CAAGC,UAAU,CAAC,OAAA,CAAA;AAEpE,IAAA,IAAIH,eAAiB,EAAA;AACnB,QAAA;AACF;AAEA,IAAA,MAAMF,MAAiB,GAAA;AAAEb,QAAAA,GAAAA;AAAKZ,QAAAA,IAAAA;AAAMuB,QAAAA,MAAAA;AAAQD,QAAAA;AAAU,KAAA;IAEtD,MAAMS,eAAAA,GAAkBT,UAAUU,MAAM;AACxC,IAAA,MAAMC,eAAeT,QAASO,CAAAA,eAAAA,CAAAA;IAE9B,MAAMG,QAAAA,GAAW,MAAMzC,OAAAA,CACrBF,OACA,EAAA;QAAEgC,MAAQU,EAAAA,YAAAA;AAAcjC,QAAAA,IAAAA;AAAMwB,QAAAA,QAAAA;AAAUC,QAAAA;KACxCxC,EAAAA,KAAAA,CAAAA;AAGF8B,IAAAA,GAAAA,CAAIH,GAAKsB,EAAAA,QAAAA,CAAAA;AACX,CAEDC,CAAAA,CAAAA,WAAW,CACV,OAAO,EAAEvB,GAAG,EAAEU,SAAS,EAAE/B,OAAO,EAAES,IAAI,EAAEuB,MAAM,EAAEtC,KAAK,EAAEuC,QAAQ,EAAE,EAAE,EAAET,GAAG,EAAEtB,OAAO,EAAE,GAAA;AACjF,IAAA,MAAMgC,MAAiB,GAAA;AAAEb,QAAAA,GAAAA;AAAKZ,QAAAA,IAAAA;AAAMuB,QAAAA,MAAAA;AAAQD,QAAAA;AAAU,KAAA;IACtD,MAAMW,YAAAA,GAAeT,QAASF,CAAAA,SAAAA,CAAUc,SAAS,CAAA;IAEjD,MAAMF,QAAAA,GAAW,MAAMzC,OAAAA,CACrBF,OACA,EAAA;QAAEgC,MAAQU,EAAAA,YAAAA;AAAcjC,QAAAA,IAAAA;AAAMwB,QAAAA,QAAAA;AAAUC,QAAAA;KACxCxC,EAAAA,KAAAA,CAAAA;AAGF8B,IAAAA,GAAAA,CAAIH,GAAKsB,EAAAA,QAAAA,CAAAA;AACX,CAAA,CAEF;CACCG,OAAO,CAAC,OAAO,EAAEzB,GAAG,EAAErB,OAAO,EAAES,IAAI,EAAEuB,MAAM,EAAED,SAAS,EAAErC,KAAK,EAAEuC,QAAQ,EAAE,EAAE,EAAET,GAAG,EAAEtB,OAAO,EAAE,GAAA;AAC1F,IAAA,MAAMgC,MAAiB,GAAA;AAAEb,QAAAA,GAAAA;AAAKZ,QAAAA,IAAAA;AAAMuB,QAAAA,MAAAA;AAAQD,QAAAA;AAAU,KAAA;AAEtD,IAAA,MAAMS,eAAkB,GAAA,qBAAA;AACxB,IAAA,MAAME,eAAeT,QAASO,CAAAA,eAAAA,CAAAA;IAE9B,MAAMG,QAAAA,GAAW,MAAMzC,OAAAA,CACrBF,OACA,EAAA;QAAEgC,MAAQU,EAAAA,YAAAA;AAAcjC,QAAAA,IAAAA;AAAMwB,QAAAA,QAAAA;AAAUC,QAAAA;KACxCxC,EAAAA,KAAAA,CAAAA;AAGF8B,IAAAA,GAAAA,CAAIH,GAAKsB,EAAAA,QAAAA,CAAAA;AACX,CAAA,CAAA;AAEF,2BAAeI,QAAAA,CAAMnD,OAAQoD,CAAAA,QAAQ,CAAE;;;;"}

package/dist/traverse/query-filters.mjs

@@ -0,0 +1,112 @@
+import { isArray, isObject, isEmpty, cloneDeep, omit, isNil, curry } from 'lodash/fp';
+import traverseFactory from './factory.mjs';
+
+const isObj = (value)=>isObject(value);
+const filters = traverseFactory().intercept(// Intercept filters arrays and apply the traversal to each one individually
+isArray, async (visitor, options, filters, { recurse })=>{
+    return Promise.all(filters.map((filter, i)=>{
+        // In filters, only operators such as $and, $in, $notIn or $or and implicit operators like [...]
+        // can have a value array, thus we can update the raw path but not the attribute one
+        const newPath = options.path ? {
+            ...options.path,
+            raw: `${options.path.raw}[${i}]`
+        } : options.path;
+        return recurse(visitor, {
+            ...options,
+            path: newPath
+        }, filter);
+    })).then((res)=>res.filter((val)=>!(isObject(val) && isEmpty(val))));
+}).intercept(// Ignore non object filters and return the value as-is
+(filters)=>!isObject(filters), (_, __, filters)=>{
+    return filters;
+})// Parse object values
+.parse(isObj, ()=>({
+        transform: cloneDeep,
+        remove (key, data) {
+            return omit(key, data);
+        },
+        set (key, value, data) {
+            return {
+                ...data,
+                [key]: value
+            };
+        },
+        keys (data) {
+            return Object.keys(data);
+        },
+        get (key, data) {
+            return data[key];
+        }
+    }))// Ignore null or undefined values
+.ignore(({ value })=>isNil(value))// Recursion on operators (non attributes)
+.on(({ attribute })=>isNil(attribute), async ({ key, visitor, path, value, schema, getModel, attribute }, { set, recurse })=>{
+    const parent = {
+        key,
+        path,
+        schema,
+        attribute
+    };
+    set(key, await recurse(visitor, {
+        schema,
+        path,
+        getModel,
+        parent
+    }, value));
+})// Handle relation recursion
+.onRelation(async ({ key, attribute, visitor, path, value, schema, getModel }, { set, recurse })=>{
+    const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');
+    if (isMorphRelation) {
+        return;
+    }
+    const parent = {
+        key,
+        path,
+        schema,
+        attribute
+    };
+    const targetSchemaUID = attribute.target;
+    const targetSchema = getModel(targetSchemaUID);
+    const newValue = await recurse(visitor, {
+        schema: targetSchema,
+        path,
+        getModel,
+        parent
+    }, value);
+    set(key, newValue);
+}).onComponent(async ({ key, attribute, visitor, path, schema, value, getModel }, { set, recurse })=>{
+    const parent = {
+        key,
+        path,
+        schema,
+        attribute
+    };
+    const targetSchema = getModel(attribute.component);
+    const newValue = await recurse(visitor, {
+        schema: targetSchema,
+        path,
+        getModel,
+        parent
+    }, value);
+    set(key, newValue);
+})// Handle media recursion
+.onMedia(async ({ key, visitor, path, schema, attribute, value, getModel }, { set, recurse })=>{
+    const parent = {
+        key,
+        path,
+        schema,
+        attribute
+    };
+    const targetSchemaUID = 'plugin::upload.file';
+    const targetSchema = getModel(targetSchemaUID);
+    const newValue = await recurse(visitor, {
+        schema: targetSchema,
+        path,
+        getModel,
+        parent
+    }, value);
+    set(key, newValue);
+});
+var traverseQueryFilters = curry(filters.traverse);
+
+export { traverseQueryFilters as default };
+//# sourceMappingURL=query-filters.mjs.map

package/dist/traverse/query-filters.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-filters.mjs","sources":["../../src/traverse/query-filters.ts"],"sourcesContent":["import { curry, isObject, isEmpty, isArray, isNil, cloneDeep, omit } from 'lodash/fp';\n\nimport traverseFactory, { type Parent } from './factory';\n\nconst isObj = (value: unknown): value is Record<string, unknown> => isObject(value);\n\nconst filters = traverseFactory()\n  .intercept(\n    // Intercept filters arrays and apply the traversal to each one individually\n    isArray,\n    async (visitor, options, filters, { recurse }) => {\n      return Promise.all(\n        filters.map((filter, i) => {\n          // In filters, only operators such as $and, $in, $notIn or $or and implicit operators like [...]\n          // can have a value array, thus we can update the raw path but not the attribute one\n          const newPath = options.path\n            ? { ...options.path, raw: `${options.path.raw}[${i}]` }\n            : options.path;\n\n          return recurse(visitor, { ...options, path: newPath }, filter);\n        })\n        // todo: move that to the visitors\n      ).then((res) => res.filter((val) => !(isObject(val) && isEmpty(val))));\n    }\n  )\n  .intercept(\n    // Ignore non object filters and return the value as-is\n    (filters): filters is unknown => !isObject(filters),\n    (_, __, filters) => {\n      return filters;\n    }\n  )\n  // Parse object values\n  .parse(isObj, () => ({\n    transform: cloneDeep,\n\n    remove(key, data) {\n      return omit(key, data);\n    },\n\n    set(key, value, data) {\n      return { ...data, [key]: value };\n    },\n\n    keys(data) {\n      return Object.keys(data);\n    },\n\n    get(key, data) {\n      return data[key];\n    },\n  }))\n  // Ignore null or undefined values\n  .ignore(({ value }) => isNil(value))\n  // Recursion on operators (non attributes)\n  .on(\n    ({ attribute }) => isNil(attribute),\n    async ({ key, visitor, path, value, schema, getModel, attribute }, { set, recurse }) => {\n      const parent: Parent = { key, path, schema, attribute };\n\n      set(key, await recurse(visitor, { schema, path, getModel, parent }, value));\n    }\n  )\n  // Handle relation recursion\n  .onRelation(\n    async ({ key, attribute, visitor, path, value, schema, getModel }, { set, recurse }) => {\n      const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');\n\n      if (isMorphRelation) {\n        return;\n      }\n\n      const parent: Parent = { key, path, schema, attribute };\n\n      const targetSchemaUID = attribute.target;\n      const targetSchema = getModel(targetSchemaUID!);\n\n      const newValue = await recurse(\n        visitor,\n        { schema: targetSchema, path, getModel, parent },\n        value\n      );\n\n      set(key, newValue);\n    }\n  )\n  .onComponent(\n    async ({ key, attribute, visitor, path, schema, value, getModel }, { set, recurse }) => {\n      const parent: Parent = { key, path, schema, attribute };\n      const targetSchema = getModel(attribute.component);\n\n      const newValue = await recurse(\n        visitor,\n        { schema: targetSchema, path, getModel, parent },\n        value\n      );\n\n      set(key, newValue);\n    }\n  )\n  // Handle media recursion\n  .onMedia(async ({ key, visitor, path, schema, attribute, value, getModel }, { set, recurse }) => {\n    const parent: Parent = { key, path, schema, attribute };\n\n    const targetSchemaUID = 'plugin::upload.file';\n    const targetSchema = getModel(targetSchemaUID);\n\n    const newValue = await recurse(\n      visitor,\n      { schema: targetSchema, path, getModel, parent },\n      value\n    );\n\n    set(key, newValue);\n  });\n\nexport default curry(filters.traverse);\n"],"names":["isObj","value","isObject","filters","traverseFactory","intercept","isArray","visitor","options","recurse","Promise","all","map","filter","i","newPath","path","raw","then","res","val","isEmpty","_","__","parse","transform","cloneDeep","remove","key","data","omit","set","keys","Object","get","ignore","isNil","on","attribute","schema","getModel","parent","onRelation","isMorphRelation","relation","toLowerCase","startsWith","targetSchemaUID","target","targetSchema","newValue","onComponent","component","onMedia","curry","traverse"],"mappings":"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"}

package/dist/traverse/query-populate.js

@@ -0,0 +1,280 @@
+'use strict';
+
+var fp = require('lodash/fp');
+var factory = require('./factory.js');
+var contentTypes = require('../content-types.js');
+
+const isKeyword = (keyword)=>{
+    return ({ key, attribute })=>{
+        return !attribute && keyword === key;
+    };
+};
+const isWildcard = (value)=>value === '*';
+const isPopulateString = (value)=>{
+    return fp.isString(value) && !isWildcard(value);
+};
+const isStringArray = (value)=>fp.isArray(value) && value.every(fp.isString);
+const isObj = (value)=>fp.isObject(value);
+const populate = factory().intercept(isPopulateString, async (visitor, options, populate, { recurse })=>{
+    /**
+     * Ensure the populate clause its in the extended format ( { populate: { ... } }, and not just a string)
+     * This gives a consistent structure to track the "parent" node of each nested populate clause
+     */ const populateObject = pathsToObjectPopulate([
+        populate
+    ]);
+    const traversedPopulate = await recurse(visitor, options, populateObject);
+    const [result] = objectPopulateToPaths(traversedPopulate);
+    return result;
+})// Array of strings ['foo', 'bar.baz'] => map(recurse), then filter out empty items
+.intercept(isStringArray, async (visitor, options, populate, { recurse })=>{
+    const paths = await Promise.all(populate.map((subClause)=>recurse(visitor, options, subClause)));
+    return paths.filter((item)=>!fp.isNil(item));
+})// for wildcard, generate custom utilities to modify the values
+.parse(isWildcard, ()=>({
+        /**
+     * Since value is '*', we don't need to transform it
+     */ transform: fp.identity,
+        /**
+     * '*' isn't a key/value structure, so regardless
+     *  of the given key, it returns the data ('*')
+     */ get: (_key, data)=>data,
+        /**
+     * '*' isn't a key/value structure, so regardless
+     * of the given `key`, use `value` as the new `data`
+     */ set: (_key, value)=>value,
+        /**
+     * '*' isn't a key/value structure, but we need to simulate at least one to enable
+     * the data traversal. We're using '' since it represents a falsy string value
+     */ keys: fp.constant([
+            ''
+        ]),
+        /**
+     * Removing '*' means setting it to undefined, regardless of the given key
+     */ remove: fp.constant(undefined)
+    }))// Parse string values
+.parse(fp.isString, ()=>{
+    const tokenize = fp.split('.');
+    const recompose = fp.join('.');
+    return {
+        transform: fp.trim,
+        remove (key, data) {
+            const [root] = tokenize(data);
+            return root === key ? undefined : data;
+        },
+        set (key, value, data) {
+            const [root] = tokenize(data);
+            if (root !== key) {
+                return data;
+            }
+            return fp.isNil(value) || fp.isEmpty(value) ? root : `${root}.${value}`;
+        },
+        keys (data) {
+            const v = fp.first(tokenize(data));
+            return v ? [
+                v
+            ] : [];
+        },
+        get (key, data) {
+            const [root, ...rest] = tokenize(data);
+            return key === root ? recompose(rest) : undefined;
+        }
+    };
+})// Parse object values
+.parse(isObj, ()=>({
+        transform: fp.cloneDeep,
+        remove (key, data) {
+            // eslint-disable-next-line no-unused-vars
+            const { [key]: ignored, ...rest } = data;
+            return rest;
+        },
+        set (key, value, data) {
+            return {
+                ...data,
+                [key]: value
+            };
+        },
+        keys (data) {
+            return Object.keys(data);
+        },
+        get (key, data) {
+            return data[key];
+        }
+    })).ignore(({ key, attribute })=>{
+    // we don't want to recurse using traversePopulate and instead let
+    // the visitors recurse with the appropriate traversal (sort, filters, etc...)
+    return [
+        'sort',
+        'filters',
+        'fields'
+    ].includes(key) && !attribute;
+}).on(// Handle recursion on populate."populate"
+isKeyword('populate'), async ({ key, visitor, path, value, schema, getModel, attribute }, { set, recurse })=>{
+    const parent = {
+        key,
+        path,
+        schema,
+        attribute
+    };
+    const newValue = await recurse(visitor, {
+        schema,
+        path,
+        getModel,
+        parent
+    }, value);
+    set(key, newValue);
+}).on(isKeyword('on'), async ({ key, visitor, path, value, getModel, parent }, { set, recurse })=>{
+    const newOn = {};
+    if (!isObj(value)) {
+        return;
+    }
+    for (const [uid, subPopulate] of Object.entries(value)){
+        const model = getModel(uid);
+        const newPath = {
+            ...path,
+            raw: `${path.raw}[${uid}]`
+        };
+        newOn[uid] = await recurse(visitor, {
+            schema: model,
+            path: newPath,
+            getModel,
+            parent
+        }, subPopulate);
+    }
+    set(key, newOn);
+})// Handle populate on relation
+.onRelation(async ({ key, value, attribute, visitor, path, schema, getModel }, { set, recurse })=>{
+    if (fp.isNil(value)) {
+        return;
+    }
+    const parent = {
+        key,
+        path,
+        schema,
+        attribute
+    };
+    if (contentTypes.isMorphToRelationalAttribute(attribute)) {
+        // Don't traverse values that cannot be parsed
+        if (!fp.isObject(value) || !('on' in value && fp.isObject(value?.on))) {
+            return;
+        }
+        // If there is a populate fragment defined, traverse it
+        const newValue = await recurse(visitor, {
+            schema,
+            path,
+            getModel,
+            parent
+        }, {
+            on: value?.on
+        });
+        set(key, newValue);
+        return;
+    }
+    const targetSchemaUID = attribute.target;
+    const targetSchema = getModel(targetSchemaUID);
+    const newValue = await recurse(visitor, {
+        schema: targetSchema,
+        path,
+        getModel,
+        parent
+    }, value);
+    set(key, newValue);
+})// Handle populate on media
+.onMedia(async ({ key, path, schema, attribute, visitor, value, getModel }, { recurse, set })=>{
+    if (fp.isNil(value)) {
+        return;
+    }
+    const parent = {
+        key,
+        path,
+        schema,
+        attribute
+    };
+    const targetSchemaUID = 'plugin::upload.file';
+    const targetSchema = getModel(targetSchemaUID);
+    const newValue = await recurse(visitor, {
+        schema: targetSchema,
+        path,
+        getModel,
+        parent
+    }, value);
+    set(key, newValue);
+})// Handle populate on components
+.onComponent(async ({ key, value, schema, visitor, path, attribute, getModel }, { recurse, set })=>{
+    if (fp.isNil(value)) {
+        return;
+    }
+    const parent = {
+        key,
+        path,
+        schema,
+        attribute
+    };
+    const targetSchema = getModel(attribute.component);
+    const newValue = await recurse(visitor, {
+        schema: targetSchema,
+        path,
+        getModel,
+        parent
+    }, value);
+    set(key, newValue);
+})// Handle populate on dynamic zones
+.onDynamicZone(async ({ key, value, schema, visitor, path, attribute, getModel }, { set, recurse })=>{
+    if (fp.isNil(value) || !fp.isObject(value)) {
+        return;
+    }
+    const parent = {
+        key,
+        path,
+        schema,
+        attribute
+    };
+    // Handle fragment syntax
+    if ('on' in value && value.on) {
+        const newOn = await recurse(visitor, {
+            schema,
+            path,
+            getModel,
+            parent
+        }, {
+            on: value.on
+        });
+        set(key, newOn);
+    }
+});
+var traverseQueryPopulate = fp.curry(populate.traverse);
+const objectPopulateToPaths = (input)=>{
+    const paths = [];
+    function traverse(currentObj, parentPath) {
+        for (const [key, value] of Object.entries(currentObj)){
+            const currentPath = parentPath ? `${parentPath}.${key}` : key;
+            if (value === true) {
+                paths.push(currentPath);
+            } else {
+                traverse(value.populate, currentPath);
+            }
+        }
+    }
+    traverse(input, '');
+    return paths;
+};
+const pathsToObjectPopulate = (input)=>{
+    const result = {};
+    function traverse(object, keys) {
+        const [first, ...rest] = keys;
+        if (rest.length === 0) {
+            object[first] = true;
+        } else {
+            if (!object[first] || typeof object[first] === 'boolean') {
+                object[first] = {
+                    populate: {}
+                };
+            }
+            traverse(object[first].populate, rest);
+        }
+    }
+    input.forEach((clause)=>traverse(result, clause.split('.')));
+    return result;
+};
+
+module.exports = traverseQueryPopulate;
+//# sourceMappingURL=query-populate.js.map