@webiny/api-headless-cms-storage 0.0.0-unstable.0156a4c312

package/handlers/datetimeTransformHandler.d.ts

@@ -0,0 +1,2 @@
+import type { FieldFilterValueTransformRegistry } from "../features/fieldFilterValueTransform/abstractions.js";
+export declare const createDatetimeTransformHandler: () => FieldFilterValueTransformRegistry.Handler;

package/handlers/datetimeTransformHandler.js

@@ -0,0 +1,34 @@
+import { parseISO } from "date-fns";
+const transformTime = (value)=>{
+    if (null == value) throw new Error("Time value is null or undefined.");
+    else if ("boolean" == typeof value || "" === value || Array.isArray(value)) throw new Error("Field value must be a string because field is defined as time.");
+    const converted = Number(`${value}`);
+    if ("number" == typeof value || false === isNaN(converted)) return Number(value);
+    else if ("string" != typeof value) throw new Error("Field value must be a string because field is defined as time.");
+    const [time, milliseconds = 0] = value.split(".");
+    const values = time.split(":").map(Number);
+    if (values.length < 2) throw new Error("Time must contain at least hours and minutes.");
+    const [hours, minutes, seconds = 0] = values;
+    return (60 * hours * 60 + 60 * minutes + seconds) * 1000 + Number(milliseconds);
+};
+const transformDateTime = (value)=>{
+    if (null == value) return null;
+    else if ("string" == typeof value) {
+        const parsedDateTime = parseISO(value).getTime();
+        if (false === isNaN(parsedDateTime)) return parsedDateTime;
+    } else if (value instanceof Date || "function" == typeof value?.getTime) return value.getTime();
+    console.warn("Could not parse given dateTime value.", "PARSE_DATE_ERROR", {
+        value
+    });
+    return null;
+};
+const createDatetimeTransformHandler = ()=>({
+        transform: ({ field, value })=>{
+            const { type } = field.settings || {};
+            if ("time" === type) return transformTime(value);
+            return transformDateTime(value);
+        }
+    });
+export { createDatetimeTransformHandler };
+
+//# sourceMappingURL=datetimeTransformHandler.js.map

package/handlers/datetimeTransformHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers/datetimeTransformHandler.js","sources":["../../src/handlers/datetimeTransformHandler.ts"],"sourcesContent":["import { parseISO } from \"date-fns\";\nimport type { FieldFilterValueTransformRegistry } from \"../features/fieldFilterValueTransform/abstractions.js\";\n\nconst transformTime = (value: any): number => {\n    if (value === undefined || value === null) {\n        throw new Error(`Time value is null or undefined.`);\n    } else if (typeof value === \"boolean\" || value === \"\" || Array.isArray(value)) {\n        throw new Error(\"Field value must be a string because field is defined as time.\");\n    }\n    const converted = Number(`${value}`);\n    if (typeof value === \"number\" || isNaN(converted) === false) {\n        return Number(value);\n    } else if (typeof value !== \"string\") {\n        throw new Error(\"Field value must be a string because field is defined as time.\");\n    }\n    const [time, milliseconds = 0] = value.split(\".\");\n    const values = time.split(\":\").map(Number);\n    if (values.length < 2) {\n        throw new Error(\"Time must contain at least hours and minutes.\");\n    }\n    const [hours, minutes, seconds = 0] = values;\n    return (hours * 60 * 60 + minutes * 60 + seconds) * 1000 + Number(milliseconds);\n};\n\nconst transformDateTime = (value: any): number | null => {\n    if (value === null || value === undefined) {\n        return null;\n    } else if (typeof value === \"string\") {\n        const parsedDateTime = parseISO(value).getTime();\n        if (isNaN(parsedDateTime) === false) {\n            return parsedDateTime;\n        }\n    } else if (value instanceof Date || typeof (value as unknown as Date)?.getTime === \"function\") {\n        return value.getTime();\n    }\n    console.warn(\"Could not parse given dateTime value.\", \"PARSE_DATE_ERROR\", {\n        value\n    });\n    return null;\n};\n\nexport const createDatetimeTransformHandler = (): FieldFilterValueTransformRegistry.Handler => {\n    return {\n        transform: ({ field, value }) => {\n            const { type } = field.settings || {};\n            if (type === \"time\") {\n                return transformTime(value);\n            }\n            return transformDateTime(value);\n        }\n    };\n};\n"],"names":["transformTime","value","Error","Array","converted","Number","isNaN","time","milliseconds","values","hours","minutes","seconds","transformDateTime","parsedDateTime","parseISO","Date","console","createDatetimeTransformHandler","field","type"],"mappings":";AAGA,MAAMA,gBAAgB,CAACC;IACnB,IAAIA,QAAAA,OACA,MAAM,IAAIC,MAAM;SACb,IAAI,AAAiB,aAAjB,OAAOD,SAAuBA,AAAU,OAAVA,SAAgBE,MAAM,OAAO,CAACF,QACnE,MAAM,IAAIC,MAAM;IAEpB,MAAME,YAAYC,OAAO,GAAGJ,OAAO;IACnC,IAAI,AAAiB,YAAjB,OAAOA,SAAsBK,AAAqB,UAArBA,MAAMF,YACnC,OAAOC,OAAOJ;SACX,IAAI,AAAiB,YAAjB,OAAOA,OACd,MAAM,IAAIC,MAAM;IAEpB,MAAM,CAACK,MAAMC,eAAe,CAAC,CAAC,GAAGP,MAAM,KAAK,CAAC;IAC7C,MAAMQ,SAASF,KAAK,KAAK,CAAC,KAAK,GAAG,CAACF;IACnC,IAAII,OAAO,MAAM,GAAG,GAChB,MAAM,IAAIP,MAAM;IAEpB,MAAM,CAACQ,OAAOC,SAASC,UAAU,CAAC,CAAC,GAAGH;IACtC,OAAQC,AAAAA,CAAAA,AAAQ,KAARA,QAAa,KAAKC,AAAU,KAAVA,UAAeC,OAAM,IAAK,OAAOP,OAAOG;AACtE;AAEA,MAAMK,oBAAoB,CAACZ;IACvB,IAAIA,QAAAA,OACA,OAAO;SACJ,IAAI,AAAiB,YAAjB,OAAOA,OAAoB;QAClC,MAAMa,iBAAiBC,SAASd,OAAO,OAAO;QAC9C,IAAIK,AAA0B,UAA1BA,MAAMQ,iBACN,OAAOA;IAEf,OAAO,IAAIb,iBAAiBe,QAAQ,AAA+C,cAA/C,OAAQf,OAA2B,SACnE,OAAOA,MAAM,OAAO;IAExBgB,QAAQ,IAAI,CAAC,yCAAyC,oBAAoB;QACtEhB;IACJ;IACA,OAAO;AACX;AAEO,MAAMiB,iCAAiC,IACnC;QACH,WAAW,CAAC,EAAEC,KAAK,EAAElB,KAAK,EAAE;YACxB,MAAM,EAAEmB,IAAI,EAAE,GAAGD,MAAM,QAAQ,IAAI,CAAC;YACpC,IAAIC,AAAS,WAATA,MACA,OAAOpB,cAAcC;YAEzB,OAAOY,kBAAkBZ;QAC7B;IACJ"}

package/handlers/defaultFilterCreateHandler.d.ts

@@ -0,0 +1,2 @@
+import type { FieldFilterCreateRegistry } from "../features/fieldFilterCreate/abstractions.js";
+export declare const createDefaultFilterCreateHandler: () => FieldFilterCreateRegistry.Handler;

package/handlers/defaultFilterCreateHandler.js

@@ -0,0 +1,27 @@
+import error from "@webiny/error";
+const createDefaultFilterCreateHandler = ()=>({
+        create: (params)=>{
+            const { negate, transformValue, field, compareValue, valueFilterRegistry } = params;
+            const filter = valueFilterRegistry.get(params.operation);
+            if (!filter) throw new error(`Missing ValueFilterPlugin for operation "${params.operation}".`, "MISSING_OPERATION_PLUGIN", {
+                operation: params.operation
+            });
+            return {
+                negate,
+                transformValue,
+                field,
+                compareValue,
+                fieldPathId: [
+                    ...field.parents.map((f)=>f.fieldId),
+                    field.fieldId
+                ].join("."),
+                path: field.createPath({
+                    field
+                }),
+                filter
+            };
+        }
+    });
+export { createDefaultFilterCreateHandler };
+
+//# sourceMappingURL=defaultFilterCreateHandler.js.map

package/handlers/defaultFilterCreateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers/defaultFilterCreateHandler.js","sources":["../../src/handlers/defaultFilterCreateHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { FieldFilterCreateRegistry } from \"../features/fieldFilterCreate/abstractions.js\";\n\nexport const createDefaultFilterCreateHandler = (): FieldFilterCreateRegistry.Handler => {\n    return {\n        create: params => {\n            const { negate, transformValue, field, compareValue, valueFilterRegistry } = params;\n            const filter = valueFilterRegistry.get(params.operation);\n            if (!filter) {\n                throw new WebinyError(\n                    `Missing ValueFilterPlugin for operation \"${params.operation}\".`,\n                    \"MISSING_OPERATION_PLUGIN\",\n                    {\n                        operation: params.operation\n                    }\n                );\n            }\n            return {\n                negate,\n                transformValue,\n                field,\n                compareValue,\n                fieldPathId: [...field.parents.map(f => f.fieldId), field.fieldId].join(\".\"),\n                path: field.createPath({\n                    field\n                }),\n                filter\n            };\n        }\n    };\n};\n"],"names":["createDefaultFilterCreateHandler","params","negate","transformValue","field","compareValue","valueFilterRegistry","filter","WebinyError","f"],"mappings":";AAGO,MAAMA,mCAAmC,IACrC;QACH,QAAQC,CAAAA;YACJ,MAAM,EAAEC,MAAM,EAAEC,cAAc,EAAEC,KAAK,EAAEC,YAAY,EAAEC,mBAAmB,EAAE,GAAGL;YAC7E,MAAMM,SAASD,oBAAoB,GAAG,CAACL,OAAO,SAAS;YACvD,IAAI,CAACM,QACD,MAAM,IAAIC,MACN,CAAC,yCAAyC,EAAEP,OAAO,SAAS,CAAC,EAAE,CAAC,EAChE,4BACA;gBACI,WAAWA,OAAO,SAAS;YAC/B;YAGR,OAAO;gBACHC;gBACAC;gBACAC;gBACAC;gBACA,aAAa;uBAAID,MAAM,OAAO,CAAC,GAAG,CAACK,CAAAA,IAAKA,EAAE,OAAO;oBAAGL,MAAM,OAAO;iBAAC,CAAC,IAAI,CAAC;gBACxE,MAAMA,MAAM,UAAU,CAAC;oBACnBA;gBACJ;gBACAG;YACJ;QACJ;IACJ"}

package/handlers/locationFolderIdPathHandler.d.ts

@@ -0,0 +1,2 @@
+import type { FieldFilterPathRegistry } from "../features/fieldFilterPath/abstractions.js";
+export declare const createLocationFolderIdPathHandler: () => FieldFilterPathRegistry.Handler;

package/handlers/locationFolderIdPathHandler.js

@@ -0,0 +1,18 @@
+import error from "@webiny/error";
+const createLocationFolderIdPathHandler = ()=>({
+        canUse: (field, parents)=>{
+            if ("folderId" !== field.fieldId) return false;
+            else if (!parents?.length) return false;
+            return "wbyAco_location" === parents[0];
+        },
+        createPath: ({ field })=>{
+            const { path } = field.settings || {};
+            if (!path) throw new error("Missing path settings value.", "FIELD_SETTINGS_ERROR", {
+                field
+            });
+            return path;
+        }
+    });
+export { createLocationFolderIdPathHandler };
+
+//# sourceMappingURL=locationFolderIdPathHandler.js.map

package/handlers/locationFolderIdPathHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers/locationFolderIdPathHandler.js","sources":["../../src/handlers/locationFolderIdPathHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { FieldFilterPathRegistry } from \"../features/fieldFilterPath/abstractions.js\";\n\nexport const createLocationFolderIdPathHandler = (): FieldFilterPathRegistry.Handler => {\n    return {\n        canUse: (field, parents) => {\n            if (field.fieldId !== \"folderId\") {\n                return false;\n            } else if (!parents?.length) {\n                return false;\n            }\n            return parents[0] === \"wbyAco_location\";\n        },\n        createPath: ({ field }) => {\n            const { path } = field.settings || {};\n            if (!path) {\n                throw new WebinyError(\"Missing path settings value.\", \"FIELD_SETTINGS_ERROR\", {\n                    field\n                });\n            }\n            return path;\n        }\n    };\n};\n"],"names":["createLocationFolderIdPathHandler","field","parents","path","WebinyError"],"mappings":";AAGO,MAAMA,oCAAoC,IACtC;QACH,QAAQ,CAACC,OAAOC;YACZ,IAAID,AAAkB,eAAlBA,MAAM,OAAO,EACb,OAAO;iBACJ,IAAI,CAACC,SAAS,QACjB,OAAO;YAEX,OAAOA,AAAe,sBAAfA,OAAO,CAAC,EAAE;QACrB;QACA,YAAY,CAAC,EAAED,KAAK,EAAE;YAClB,MAAM,EAAEE,IAAI,EAAE,GAAGF,MAAM,QAAQ,IAAI,CAAC;YACpC,IAAI,CAACE,MACD,MAAM,IAAIC,MAAY,gCAAgC,wBAAwB;gBAC1EH;YACJ;YAEJ,OAAOE;QACX;IACJ"}

package/handlers/objectFilterCreateHandler.d.ts

@@ -0,0 +1,2 @@
+import type { FieldFilterCreateRegistry } from "../features/fieldFilterCreate/abstractions.js";
+export declare const createObjectFilterCreateHandler: () => FieldFilterCreateRegistry.Handler;

package/handlers/objectFilterCreateHandler.js

@@ -0,0 +1,62 @@
+import error from "@webiny/error";
+import { extractWhereParams } from "../filtering/where.js";
+import { transformValue } from "../filtering/transform.js";
+import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
+const createObjectFilterCreateHandler = ()=>({
+        create: (params)=>{
+            const { value: objectValue, valueFilterRegistry, transformRegistry, getHandler, field: parentField, fields } = params;
+            const filters = [];
+            for(const key in objectValue){
+                const value = objectValue[key];
+                if (void 0 === value) continue;
+                const whereParams = extractWhereParams(key);
+                if (!whereParams) continue;
+                const { negate, fieldId, operation } = whereParams;
+                const fieldPath = parentField.parents.map((p)=>p.fieldId).concat([
+                    parentField.fieldId,
+                    fieldId
+                ]).join(".");
+                const field = fields[fieldPath];
+                if (!field) throw new error(`There is no field with the field path "${fieldPath}".`, "FIELD_ERROR", {
+                    fieldId
+                });
+                const fieldType = getBaseFieldType(field);
+                const handler = getHandler(fieldType);
+                const transformHandler = transformRegistry.get(fieldType);
+                const transformValueCallable = (value)=>{
+                    if (!transformHandler) return value;
+                    return transformHandler.transform({
+                        field,
+                        value
+                    });
+                };
+                const result = handler.create({
+                    key,
+                    value,
+                    valueFilterRegistry,
+                    transformRegistry,
+                    getHandler,
+                    operation,
+                    negate,
+                    field,
+                    fields,
+                    compareValue: transformValue({
+                        value,
+                        transform: transformValueCallable
+                    }),
+                    transformValue: transformValueCallable
+                });
+                if (result) {
+                    if (Array.isArray(result)) {
+                        filters.push(...result);
+                        continue;
+                    }
+                    filters.push(result);
+                }
+            }
+            return filters;
+        }
+    });
+export { createObjectFilterCreateHandler };
+
+//# sourceMappingURL=objectFilterCreateHandler.js.map

package/handlers/objectFilterCreateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers/objectFilterCreateHandler.js","sources":["../../src/handlers/objectFilterCreateHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { FieldFilterCreateRegistry } from \"../features/fieldFilterCreate/abstractions.js\";\nimport { extractWhereParams } from \"../filtering/where.js\";\nimport { transformValue } from \"../filtering/transform.js\";\nimport { getBaseFieldType } from \"@webiny/api-headless-cms/utils/getBaseFieldType.js\";\n\nexport const createObjectFilterCreateHandler = (): FieldFilterCreateRegistry.Handler => {\n    return {\n        create: params => {\n            const {\n                value: objectValue,\n                valueFilterRegistry,\n                transformRegistry,\n                getHandler,\n                field: parentField,\n                fields\n            } = params;\n\n            const filters: FieldFilterCreateRegistry.Result[] = [];\n\n            for (const key in objectValue) {\n                const value = objectValue[key];\n                if (value === undefined) {\n                    continue;\n                }\n                const whereParams = extractWhereParams(key);\n                if (!whereParams) {\n                    continue;\n                }\n                const { negate, fieldId, operation } = whereParams;\n\n                const fieldPath = parentField.parents\n                    .map(p => p.fieldId)\n                    .concat([parentField.fieldId, fieldId])\n                    .join(\".\");\n\n                const field = fields[fieldPath];\n                if (!field) {\n                    throw new WebinyError(\n                        `There is no field with the field path \"${fieldPath}\".`,\n                        \"FIELD_ERROR\",\n                        { fieldId }\n                    );\n                }\n\n                const fieldType = getBaseFieldType(field);\n                const handler = getHandler(fieldType);\n                const transformHandler = transformRegistry.get(fieldType);\n\n                const transformValueCallable = (value: any) => {\n                    if (!transformHandler) {\n                        return value;\n                    }\n                    return transformHandler.transform({ field, value });\n                };\n\n                const result = handler.create({\n                    key,\n                    value,\n                    valueFilterRegistry,\n                    transformRegistry,\n                    getHandler,\n                    operation,\n                    negate,\n                    field,\n                    fields,\n                    compareValue: transformValue({\n                        value,\n                        transform: transformValueCallable\n                    }),\n                    transformValue: transformValueCallable\n                });\n                if (!result) {\n                    continue;\n                }\n                if (Array.isArray(result)) {\n                    filters.push(...result);\n                    continue;\n                }\n\n                filters.push(result);\n            }\n            return filters;\n        }\n    };\n};\n"],"names":["createObjectFilterCreateHandler","params","objectValue","valueFilterRegistry","transformRegistry","getHandler","parentField","fields","filters","key","value","undefined","whereParams","extractWhereParams","negate","fieldId","operation","fieldPath","p","field","WebinyError","fieldType","getBaseFieldType","handler","transformHandler","transformValueCallable","result","transformValue","Array"],"mappings":";;;;AAMO,MAAMA,kCAAkC,IACpC;QACH,QAAQC,CAAAA;YACJ,MAAM,EACF,OAAOC,WAAW,EAClBC,mBAAmB,EACnBC,iBAAiB,EACjBC,UAAU,EACV,OAAOC,WAAW,EAClBC,MAAM,EACT,GAAGN;YAEJ,MAAMO,UAA8C,EAAE;YAEtD,IAAK,MAAMC,OAAOP,YAAa;gBAC3B,MAAMQ,QAAQR,WAAW,CAACO,IAAI;gBAC9B,IAAIC,AAAUC,WAAVD,OACA;gBAEJ,MAAME,cAAcC,mBAAmBJ;gBACvC,IAAI,CAACG,aACD;gBAEJ,MAAM,EAAEE,MAAM,EAAEC,OAAO,EAAEC,SAAS,EAAE,GAAGJ;gBAEvC,MAAMK,YAAYX,YAAY,OAAO,CAChC,GAAG,CAACY,CAAAA,IAAKA,EAAE,OAAO,EAClB,MAAM,CAAC;oBAACZ,YAAY,OAAO;oBAAES;iBAAQ,EACrC,IAAI,CAAC;gBAEV,MAAMI,QAAQZ,MAAM,CAACU,UAAU;gBAC/B,IAAI,CAACE,OACD,MAAM,IAAIC,MACN,CAAC,uCAAuC,EAAEH,UAAU,EAAE,CAAC,EACvD,eACA;oBAAEF;gBAAQ;gBAIlB,MAAMM,YAAYC,iBAAiBH;gBACnC,MAAMI,UAAUlB,WAAWgB;gBAC3B,MAAMG,mBAAmBpB,kBAAkB,GAAG,CAACiB;gBAE/C,MAAMI,yBAAyB,CAACf;oBAC5B,IAAI,CAACc,kBACD,OAAOd;oBAEX,OAAOc,iBAAiB,SAAS,CAAC;wBAAEL;wBAAOT;oBAAM;gBACrD;gBAEA,MAAMgB,SAASH,QAAQ,MAAM,CAAC;oBAC1Bd;oBACAC;oBACAP;oBACAC;oBACAC;oBACAW;oBACAF;oBACAK;oBACAZ;oBACA,cAAcoB,eAAe;wBACzBjB;wBACA,WAAWe;oBACf;oBACA,gBAAgBA;gBACpB;gBACA,IAAKC;oBAGL,IAAIE,MAAM,OAAO,CAACF,SAAS;wBACvBlB,QAAQ,IAAI,IAAIkB;wBAChB;oBACJ;oBAEAlB,QAAQ,IAAI,CAACkB;;YACjB;YACA,OAAOlB;QACX;IACJ"}

package/handlers/plainObjectPathHandler.d.ts

@@ -0,0 +1,2 @@
+import type { FieldFilterPathRegistry } from "../features/fieldFilterPath/abstractions.js";
+export declare const createPlainObjectPathHandler: () => FieldFilterPathRegistry.Handler;

package/handlers/plainObjectPathHandler.js

@@ -0,0 +1,14 @@
+import error from "@webiny/error";
+const createPlainObjectPathHandler = ()=>({
+        canUse: ()=>true,
+        createPath: ({ field })=>{
+            const { path } = field.settings || {};
+            if (!path) throw new error("Missing path settings value.", "FIELD_SETTINGS_ERROR", {
+                field
+            });
+            return path;
+        }
+    });
+export { createPlainObjectPathHandler };
+
+//# sourceMappingURL=plainObjectPathHandler.js.map

package/handlers/plainObjectPathHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers/plainObjectPathHandler.js","sources":["../../src/handlers/plainObjectPathHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { FieldFilterPathRegistry } from \"../features/fieldFilterPath/abstractions.js\";\n\nexport const createPlainObjectPathHandler = (): FieldFilterPathRegistry.Handler => {\n    return {\n        canUse: () => true,\n        createPath: ({ field }) => {\n            const { path } = field.settings || {};\n            if (!path) {\n                throw new WebinyError(\"Missing path settings value.\", \"FIELD_SETTINGS_ERROR\", {\n                    field\n                });\n            }\n            return path;\n        }\n    };\n};\n"],"names":["createPlainObjectPathHandler","field","path","WebinyError"],"mappings":";AAGO,MAAMA,+BAA+B,IACjC;QACH,QAAQ,IAAM;QACd,YAAY,CAAC,EAAEC,KAAK,EAAE;YAClB,MAAM,EAAEC,IAAI,EAAE,GAAGD,MAAM,QAAQ,IAAI,CAAC;YACpC,IAAI,CAACC,MACD,MAAM,IAAIC,MAAY,gCAAgC,wBAAwB;gBAC1EF;YACJ;YAEJ,OAAOC;QACX;IACJ"}

package/handlers/refFilterCreateHandler.d.ts

@@ -0,0 +1,2 @@
+import type { FieldFilterCreateRegistry } from "../features/fieldFilterCreate/abstractions.js";
+export declare const createRefFilterCreateHandler: () => FieldFilterCreateRegistry.Handler;

package/handlers/refFilterCreateHandler.js

@@ -0,0 +1,57 @@
+import error from "@webiny/error";
+import { extractWhereParams } from "../filtering/where.js";
+import { transformValue } from "../filtering/transform.js";
+import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
+const createRefFilterCreateHandler = ()=>({
+        create: (params)=>{
+            const { valueFilterRegistry, transformRegistry, field } = params;
+            let value = params.value;
+            if (!value) value = {
+                entryId: null
+            };
+            const propertyFilters = Object.keys(value);
+            if (0 === propertyFilters.length) return null;
+            const filters = [];
+            for (const propertyFilter of propertyFilters){
+                const whereParams = extractWhereParams(propertyFilter);
+                if (!whereParams) continue;
+                const { fieldId: propertyId, operation: propertyOperation, negate } = whereParams;
+                const fieldType = getBaseFieldType(field);
+                const transformHandler = transformRegistry.get(fieldType);
+                const transformValueCallable = (value)=>{
+                    if (!transformHandler) return value;
+                    return transformHandler.transform({
+                        field,
+                        value
+                    });
+                };
+                const filter = valueFilterRegistry.get(propertyOperation);
+                if (!filter) throw new error(`Missing operation filter for "${propertyOperation}".`, "MISSING_OPERATION_FILTER");
+                const paths = [
+                    field.createPath({
+                        field
+                    }),
+                    propertyId
+                ];
+                filters.push({
+                    field,
+                    path: paths.join("."),
+                    fieldPathId: [
+                        ...field.parents.map((f)=>f.fieldId),
+                        field.fieldId
+                    ].join("."),
+                    filter,
+                    negate,
+                    compareValue: transformValue({
+                        value: value[propertyFilter],
+                        transform: transformValueCallable
+                    }),
+                    transformValue: transformValueCallable
+                });
+            }
+            return filters;
+        }
+    });
+export { createRefFilterCreateHandler };
+
+//# sourceMappingURL=refFilterCreateHandler.js.map

package/handlers/refFilterCreateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers/refFilterCreateHandler.js","sources":["../../src/handlers/refFilterCreateHandler.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { FieldFilterCreateRegistry } from \"../features/fieldFilterCreate/abstractions.js\";\nimport { extractWhereParams } from \"../filtering/where.js\";\nimport { transformValue } from \"../filtering/transform.js\";\nimport { getBaseFieldType } from \"@webiny/api-headless-cms/utils/getBaseFieldType.js\";\n\nexport const createRefFilterCreateHandler = (): FieldFilterCreateRegistry.Handler => {\n    return {\n        create: params => {\n            const { valueFilterRegistry, transformRegistry, field } = params;\n            let value = params.value;\n            if (!value) {\n                value = { entryId: null };\n            }\n            const propertyFilters = Object.keys(value);\n            if (propertyFilters.length === 0) {\n                return null;\n            }\n            const filters: FieldFilterCreateRegistry.Result[] = [];\n\n            for (const propertyFilter of propertyFilters) {\n                const whereParams = extractWhereParams(propertyFilter);\n                if (!whereParams) {\n                    continue;\n                }\n                const { fieldId: propertyId, operation: propertyOperation, negate } = whereParams;\n\n                const fieldType = getBaseFieldType(field);\n                const transformHandler = transformRegistry.get(fieldType);\n\n                const transformValueCallable = (value: any) => {\n                    if (!transformHandler) {\n                        return value;\n                    }\n                    return transformHandler.transform({ field, value });\n                };\n\n                const filter = valueFilterRegistry.get(propertyOperation);\n                if (!filter) {\n                    throw new WebinyError(\n                        `Missing operation filter for \"${propertyOperation}\".`,\n                        \"MISSING_OPERATION_FILTER\"\n                    );\n                }\n\n                const paths = [field.createPath({ field }), propertyId];\n\n                filters.push({\n                    field,\n                    path: paths.join(\".\"),\n                    fieldPathId: [...field.parents.map(f => f.fieldId), field.fieldId].join(\".\"),\n                    filter,\n                    negate,\n                    compareValue: transformValue({\n                        value: value[propertyFilter],\n                        transform: transformValueCallable\n                    }),\n                    transformValue: transformValueCallable\n                });\n            }\n\n            return filters;\n        }\n    };\n};\n"],"names":["createRefFilterCreateHandler","params","valueFilterRegistry","transformRegistry","field","value","propertyFilters","Object","filters","propertyFilter","whereParams","extractWhereParams","propertyId","propertyOperation","negate","fieldType","getBaseFieldType","transformHandler","transformValueCallable","filter","WebinyError","paths","f","transformValue"],"mappings":";;;;AAMO,MAAMA,+BAA+B,IACjC;QACH,QAAQC,CAAAA;YACJ,MAAM,EAAEC,mBAAmB,EAAEC,iBAAiB,EAAEC,KAAK,EAAE,GAAGH;YAC1D,IAAII,QAAQJ,OAAO,KAAK;YACxB,IAAI,CAACI,OACDA,QAAQ;gBAAE,SAAS;YAAK;YAE5B,MAAMC,kBAAkBC,OAAO,IAAI,CAACF;YACpC,IAAIC,AAA2B,MAA3BA,gBAAgB,MAAM,EACtB,OAAO;YAEX,MAAME,UAA8C,EAAE;YAEtD,KAAK,MAAMC,kBAAkBH,gBAAiB;gBAC1C,MAAMI,cAAcC,mBAAmBF;gBACvC,IAAI,CAACC,aACD;gBAEJ,MAAM,EAAE,SAASE,UAAU,EAAE,WAAWC,iBAAiB,EAAEC,MAAM,EAAE,GAAGJ;gBAEtE,MAAMK,YAAYC,iBAAiBZ;gBACnC,MAAMa,mBAAmBd,kBAAkB,GAAG,CAACY;gBAE/C,MAAMG,yBAAyB,CAACb;oBAC5B,IAAI,CAACY,kBACD,OAAOZ;oBAEX,OAAOY,iBAAiB,SAAS,CAAC;wBAAEb;wBAAOC;oBAAM;gBACrD;gBAEA,MAAMc,SAASjB,oBAAoB,GAAG,CAACW;gBACvC,IAAI,CAACM,QACD,MAAM,IAAIC,MACN,CAAC,8BAA8B,EAAEP,kBAAkB,EAAE,CAAC,EACtD;gBAIR,MAAMQ,QAAQ;oBAACjB,MAAM,UAAU,CAAC;wBAAEA;oBAAM;oBAAIQ;iBAAW;gBAEvDJ,QAAQ,IAAI,CAAC;oBACTJ;oBACA,MAAMiB,MAAM,IAAI,CAAC;oBACjB,aAAa;2BAAIjB,MAAM,OAAO,CAAC,GAAG,CAACkB,CAAAA,IAAKA,EAAE,OAAO;wBAAGlB,MAAM,OAAO;qBAAC,CAAC,IAAI,CAAC;oBACxEe;oBACAL;oBACA,cAAcS,eAAe;wBACzB,OAAOlB,KAAK,CAACI,eAAe;wBAC5B,WAAWS;oBACf;oBACA,gBAAgBA;gBACpB;YACJ;YAEA,OAAOV;QACX;IACJ"}

package/handlers/searchableJsonFilterCreateHandler.d.ts

@@ -0,0 +1,2 @@
+import type { FieldFilterCreateRegistry } from "../features/fieldFilterCreate/abstractions.js";
+export declare const createSearchableJsonFilterCreateHandler: () => FieldFilterCreateRegistry.Handler;

package/handlers/searchableJsonFilterCreateHandler.js

@@ -0,0 +1,43 @@
+import { extractWhereParams } from "../filtering/where.js";
+function dotFlatten(obj, prefix = "") {
+    return Object.entries(obj).reduce((acc, [key, val])=>{
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (val && "object" == typeof val && !Array.isArray(val)) Object.assign(acc, dotFlatten(val, path));
+        else acc[path] = val;
+        return acc;
+    }, {});
+}
+const createSearchableJsonFilterCreateHandler = ()=>({
+        create: (params)=>{
+            const { value: objectValue, valueFilterRegistry, field: parentField } = params;
+            const filters = [];
+            const accessPatterns = dotFlatten(objectValue);
+            for(const key in accessPatterns){
+                const value = accessPatterns[key];
+                if (void 0 === value) continue;
+                const whereParams = extractWhereParams(key);
+                if (!whereParams) continue;
+                const { negate, operation } = whereParams;
+                const transformValueCallable = (value)=>value;
+                const fieldId = `${parentField.fieldId}.${whereParams.fieldId ?? key}`;
+                const filter = valueFilterRegistry.get(operation);
+                if (!filter) {
+                    console.error(`Missing operation filter for "${operation}".`);
+                    continue;
+                }
+                filters.push({
+                    field: parentField,
+                    path: `values.${fieldId}`,
+                    fieldPathId: `values.${fieldId}`,
+                    negate,
+                    filter,
+                    compareValue: value,
+                    transformValue: transformValueCallable
+                });
+            }
+            return filters;
+        }
+    });
+export { createSearchableJsonFilterCreateHandler };
+
+//# sourceMappingURL=searchableJsonFilterCreateHandler.js.map

package/handlers/searchableJsonFilterCreateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers/searchableJsonFilterCreateHandler.js","sources":["../../src/handlers/searchableJsonFilterCreateHandler.ts"],"sourcesContent":["import type { FieldFilterCreateRegistry } from \"../features/fieldFilterCreate/abstractions.js\";\nimport { extractWhereParams } from \"../filtering/where.js\";\n\nfunction dotFlatten(obj: Record<string, any>, prefix = \"\"): Record<string, any> {\n    return Object.entries(obj).reduce<Record<string, any>>((acc, [key, val]) => {\n        const path = prefix ? `${prefix}.${key}` : key;\n        if (val && typeof val === \"object\" && !Array.isArray(val)) {\n            Object.assign(acc, dotFlatten(val, path));\n        } else {\n            acc[path] = val;\n        }\n        return acc;\n    }, {});\n}\n\nexport const createSearchableJsonFilterCreateHandler = (): FieldFilterCreateRegistry.Handler => {\n    return {\n        create: params => {\n            const { value: objectValue, valueFilterRegistry, field: parentField } = params;\n\n            const filters: FieldFilterCreateRegistry.Result[] = [];\n            const accessPatterns = dotFlatten(objectValue);\n\n            for (const key in accessPatterns) {\n                const value = accessPatterns[key];\n                if (value === undefined) {\n                    continue;\n                }\n\n                const whereParams = extractWhereParams(key);\n                if (!whereParams) {\n                    continue;\n                }\n                const { negate, operation } = whereParams;\n\n                const transformValueCallable = (value: any) => {\n                    return value;\n                };\n\n                const fieldId = `${parentField.fieldId}.${whereParams.fieldId ?? key}`;\n\n                const filter = valueFilterRegistry.get(operation);\n                if (!filter) {\n                    console.error(`Missing operation filter for \"${operation}\".`);\n                    continue;\n                }\n\n                filters.push({\n                    field: parentField,\n                    path: `values.${fieldId}`,\n                    fieldPathId: `values.${fieldId}`,\n                    negate,\n                    filter,\n                    compareValue: value,\n                    transformValue: transformValueCallable\n                });\n            }\n            return filters;\n        }\n    };\n};\n"],"names":["dotFlatten","obj","prefix","Object","acc","key","val","path","Array","createSearchableJsonFilterCreateHandler","params","objectValue","valueFilterRegistry","parentField","filters","accessPatterns","value","undefined","whereParams","extractWhereParams","negate","operation","transformValueCallable","fieldId","filter","console"],"mappings":";AAGA,SAASA,WAAWC,GAAwB,EAAEC,SAAS,EAAE;IACrD,OAAOC,OAAO,OAAO,CAACF,KAAK,MAAM,CAAsB,CAACG,KAAK,CAACC,KAAKC,IAAI;QACnE,MAAMC,OAAOL,SAAS,GAAGA,OAAO,CAAC,EAAEG,KAAK,GAAGA;QAC3C,IAAIC,OAAO,AAAe,YAAf,OAAOA,OAAoB,CAACE,MAAM,OAAO,CAACF,MACjDH,OAAO,MAAM,CAACC,KAAKJ,WAAWM,KAAKC;aAEnCH,GAAG,CAACG,KAAK,GAAGD;QAEhB,OAAOF;IACX,GAAG,CAAC;AACR;AAEO,MAAMK,0CAA0C,IAC5C;QACH,QAAQC,CAAAA;YACJ,MAAM,EAAE,OAAOC,WAAW,EAAEC,mBAAmB,EAAE,OAAOC,WAAW,EAAE,GAAGH;YAExE,MAAMI,UAA8C,EAAE;YACtD,MAAMC,iBAAiBf,WAAWW;YAElC,IAAK,MAAMN,OAAOU,eAAgB;gBAC9B,MAAMC,QAAQD,cAAc,CAACV,IAAI;gBACjC,IAAIW,AAAUC,WAAVD,OACA;gBAGJ,MAAME,cAAcC,mBAAmBd;gBACvC,IAAI,CAACa,aACD;gBAEJ,MAAM,EAAEE,MAAM,EAAEC,SAAS,EAAE,GAAGH;gBAE9B,MAAMI,yBAAyB,CAACN,QACrBA;gBAGX,MAAMO,UAAU,GAAGV,YAAY,OAAO,CAAC,CAAC,EAAEK,YAAY,OAAO,IAAIb,KAAK;gBAEtE,MAAMmB,SAASZ,oBAAoB,GAAG,CAACS;gBACvC,IAAI,CAACG,QAAQ;oBACTC,QAAQ,KAAK,CAAC,CAAC,8BAA8B,EAAEJ,UAAU,EAAE,CAAC;oBAC5D;gBACJ;gBAEAP,QAAQ,IAAI,CAAC;oBACT,OAAOD;oBACP,MAAM,CAAC,OAAO,EAAEU,SAAS;oBACzB,aAAa,CAAC,OAAO,EAAEA,SAAS;oBAChCH;oBACAI;oBACA,cAAcR;oBACd,gBAAgBM;gBACpB;YACJ;YACA,OAAOR;QACX;IACJ"}

package/index.d.ts

@@ -0,0 +1,24 @@
+export { filter } from "./filtering/filter.js";
+export { sort } from "./filtering/sort.js";
+export { createFields } from "./filtering/fields/createFields.js";
+export { createFilterCreatePlugins } from "./filtering/plugins/index.js";
+export { createExpressions } from "./filtering/expressions/createExpressions.js";
+export type { Expression, ExpressionCondition } from "./filtering/expressions/createExpressions.js";
+export { getValue } from "./filtering/getValue.js";
+export { CmsEntryFieldFilterPlugin } from "./plugins/CmsEntryFieldFilterPlugin.js";
+export type { CmsEntryFieldFilterPluginCreateResponse } from "./plugins/CmsEntryFieldFilterPlugin.js";
+export { CmsEntryFieldSortingPlugin, createCmsEntryFieldSortingPlugin } from "./plugins/CmsEntryFieldSortingPlugin.js";
+export { CmsEntryFieldFilterPathPlugin } from "./plugins/CmsEntryFieldFilterPathPlugin.js";
+export type { CreatePathCallable } from "./plugins/CmsEntryFieldFilterPathPlugin.js";
+export { CmsFieldFilterValueTransformPlugin } from "./plugins/CmsFieldFilterValueTransformPlugin.js";
+export { createPlainObjectPathPlugin } from "./path/plainObject.js";
+export { createLocationFolderIdPathPlugin } from "./path/locationFolderId.js";
+export { createDatetimeTransformValuePlugin } from "./transforms/datetime.js";
+export { createStorageModelAccessor, createStorageTransformCallable, aggregateUniqueFieldValues } from "./cms/storageHelpers.js";
+export type { Field } from "./filtering/fields/types.js";
+export type { FilterItemFromStorage } from "./filtering/fields/types.js";
+export { FieldFilterPathRegistry, type IFieldFilterPathHandler, type IFieldFilterPathRegistry } from "./features/fieldFilterPath/abstractions.js";
+export { FieldFilterValueTransformRegistry, type IFieldFilterValueTransformHandler, type IFieldFilterValueTransformRegistry } from "./features/fieldFilterValueTransform/abstractions.js";
+export { FieldFilterCreateRegistry, type IFieldFilterCreateHandler, type IFieldFilterCreateParams, type IFieldFilterCreateRegistry, type IFieldFilterCreateResult } from "./features/fieldFilterCreate/abstractions.js";
+export { FieldSortingRegistry, type IFieldSortingCanUseParams, type IFieldSortingCreateParams, type IFieldSortingHandler, type IFieldSortingRegistry, type IFieldSortingResult } from "./features/fieldSorting/abstractions.js";
+export { FilterRegistriesFeature } from "./features/FilterRegistriesFeature.js";

package/index.js

@@ -0,0 +1,19 @@
+export { filter } from "./filtering/filter.js";
+export { sort } from "./filtering/sort.js";
+export { createFields } from "./filtering/fields/createFields.js";
+export { createFilterCreatePlugins } from "./filtering/plugins/index.js";
+export { createExpressions } from "./filtering/expressions/createExpressions.js";
+export { getValue } from "./filtering/getValue.js";
+export { CmsEntryFieldFilterPlugin } from "./plugins/CmsEntryFieldFilterPlugin.js";
+export { CmsEntryFieldSortingPlugin, createCmsEntryFieldSortingPlugin } from "./plugins/CmsEntryFieldSortingPlugin.js";
+export { CmsEntryFieldFilterPathPlugin } from "./plugins/CmsEntryFieldFilterPathPlugin.js";
+export { CmsFieldFilterValueTransformPlugin } from "./plugins/CmsFieldFilterValueTransformPlugin.js";
+export { createPlainObjectPathPlugin } from "./path/plainObject.js";
+export { createLocationFolderIdPathPlugin } from "./path/locationFolderId.js";
+export { createDatetimeTransformValuePlugin } from "./transforms/datetime.js";
+export { aggregateUniqueFieldValues, createStorageModelAccessor, createStorageTransformCallable } from "./cms/storageHelpers.js";
+export { FieldFilterPathRegistry } from "./features/fieldFilterPath/abstractions.js";
+export { FieldFilterValueTransformRegistry } from "./features/fieldFilterValueTransform/abstractions.js";
+export { FieldFilterCreateRegistry } from "./features/fieldFilterCreate/abstractions.js";
+export { FieldSortingRegistry } from "./features/fieldSorting/abstractions.js";
+export { FilterRegistriesFeature } from "./features/FilterRegistriesFeature.js";

package/package.json

@@ -0,0 +1,35 @@
+{
+	"name": "@webiny/api-headless-cms-storage",
+	"version": "0.0.0-unstable.0156a4c312",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"type": "module",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/api-headless-cms-storage"
+	},
+	"dependencies": {
+		"@webiny/api": "0.0.0-unstable.0156a4c312",
+		"@webiny/api-headless-cms": "0.0.0-unstable.0156a4c312",
+		"@webiny/db-utils": "0.0.0-unstable.0156a4c312",
+		"@webiny/di": "2.0.0",
+		"@webiny/error": "0.0.0-unstable.0156a4c312",
+		"@webiny/feature": "0.0.0-unstable.0156a4c312",
+		"@webiny/plugins": "0.0.0-unstable.0156a4c312",
+		"date-fns": "4.4.0",
+		"dot-prop": "10.2.0",
+		"lodash": "4.18.1"
+	},
+	"devDependencies": {
+		"@webiny/build-tools": "0.0.0-unstable.0156a4c312",
+		"typescript": "7.0.2",
+		"vitest": "5.0.5"
+	},
+	"webiny": {
+		"publishFrom": "dist"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/path/locationFolderId.d.ts

@@ -0,0 +1,2 @@
+import { CmsEntryFieldFilterPathPlugin } from "../plugins/CmsEntryFieldFilterPathPlugin.js";
+export declare const createLocationFolderIdPathPlugin: () => CmsEntryFieldFilterPathPlugin;

package/path/locationFolderId.js

@@ -0,0 +1,21 @@
+import error from "@webiny/error";
+import { CmsEntryFieldFilterPathPlugin } from "../plugins/CmsEntryFieldFilterPathPlugin.js";
+const createPath = ({ field })=>{
+    const { path } = field.settings || {};
+    if (!path) throw new error("Missing path settings value.", "FIELD_SETTINGS_ERROR", {
+        field
+    });
+    return path;
+};
+const createLocationFolderIdPathPlugin = ()=>new CmsEntryFieldFilterPathPlugin({
+        fieldType: "text",
+        path: createPath,
+        canUse: (field, parents)=>{
+            if ("folderId" !== field.fieldId) return false;
+            else if (!parents?.length) return false;
+            return "wbyAco_location" === parents[0];
+        }
+    });
+export { createLocationFolderIdPathPlugin };
+
+//# sourceMappingURL=locationFolderId.js.map

package/path/locationFolderId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path/locationFolderId.js","sources":["../../src/path/locationFolderId.ts"],"sourcesContent":["/* File is @internal. */\nimport WebinyError from \"@webiny/error\";\nimport type { CreatePathCallable } from \"../plugins/CmsEntryFieldFilterPathPlugin.js\";\nimport { CmsEntryFieldFilterPathPlugin } from \"../plugins/CmsEntryFieldFilterPathPlugin.js\";\n\nconst createPath: CreatePathCallable = ({ field }) => {\n    const { path } = field.settings || {};\n    if (!path) {\n        throw new WebinyError(\"Missing path settings value.\", \"FIELD_SETTINGS_ERROR\", {\n            field\n        });\n    }\n    return path;\n};\n\nexport const createLocationFolderIdPathPlugin = (): CmsEntryFieldFilterPathPlugin => {\n    return new CmsEntryFieldFilterPathPlugin({\n        fieldType: \"text\",\n        path: createPath,\n        canUse: (field, parents) => {\n            if (field.fieldId !== \"folderId\") {\n                return false;\n            } else if (!parents?.length) {\n                return false;\n            }\n            return parents[0] === \"wbyAco_location\";\n        }\n    });\n};\n"],"names":["createPath","field","path","WebinyError","createLocationFolderIdPathPlugin","CmsEntryFieldFilterPathPlugin","parents"],"mappings":";;AAKA,MAAMA,aAAiC,CAAC,EAAEC,KAAK,EAAE;IAC7C,MAAM,EAAEC,IAAI,EAAE,GAAGD,MAAM,QAAQ,IAAI,CAAC;IACpC,IAAI,CAACC,MACD,MAAM,IAAIC,MAAY,gCAAgC,wBAAwB;QAC1EF;IACJ;IAEJ,OAAOC;AACX;AAEO,MAAME,mCAAmC,IACrC,IAAIC,8BAA8B;QACrC,WAAW;QACX,MAAML;QACN,QAAQ,CAACC,OAAOK;YACZ,IAAIL,AAAkB,eAAlBA,MAAM,OAAO,EACb,OAAO;iBACJ,IAAI,CAACK,SAAS,QACjB,OAAO;YAEX,OAAOA,AAAe,sBAAfA,OAAO,CAAC,EAAE;QACrB;IACJ"}

package/path/plainObject.d.ts

@@ -0,0 +1,2 @@
+import { CmsEntryFieldFilterPathPlugin } from "../plugins/CmsEntryFieldFilterPathPlugin.js";
+export declare const createPlainObjectPathPlugin: () => CmsEntryFieldFilterPathPlugin;

package/path/plainObject.js

@@ -0,0 +1,16 @@
+import error from "@webiny/error";
+import { CmsEntryFieldFilterPathPlugin } from "../plugins/CmsEntryFieldFilterPathPlugin.js";
+const createPath = ({ field })=>{
+    const { path } = field.settings || {};
+    if (!path) throw new error("Missing path settings value.", "FIELD_SETTINGS_ERROR", {
+        field
+    });
+    return path;
+};
+const createPlainObjectPathPlugin = ()=>new CmsEntryFieldFilterPathPlugin({
+        fieldType: "plainObject",
+        path: createPath
+    });
+export { createPlainObjectPathPlugin };
+
+//# sourceMappingURL=plainObject.js.map

package/path/plainObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path/plainObject.js","sources":["../../src/path/plainObject.ts"],"sourcesContent":["/* File is @internal. */\nimport WebinyError from \"@webiny/error\";\nimport type { CreatePathCallable } from \"../plugins/CmsEntryFieldFilterPathPlugin.js\";\nimport { CmsEntryFieldFilterPathPlugin } from \"../plugins/CmsEntryFieldFilterPathPlugin.js\";\n\nconst createPath: CreatePathCallable = ({ field }) => {\n    const { path } = field.settings || {};\n    if (!path) {\n        throw new WebinyError(\"Missing path settings value.\", \"FIELD_SETTINGS_ERROR\", {\n            field\n        });\n    }\n    return path;\n};\n\nexport const createPlainObjectPathPlugin = (): CmsEntryFieldFilterPathPlugin => {\n    return new CmsEntryFieldFilterPathPlugin({\n        fieldType: \"plainObject\",\n        path: createPath\n    });\n};\n"],"names":["createPath","field","path","WebinyError","createPlainObjectPathPlugin","CmsEntryFieldFilterPathPlugin"],"mappings":";;AAKA,MAAMA,aAAiC,CAAC,EAAEC,KAAK,EAAE;IAC7C,MAAM,EAAEC,IAAI,EAAE,GAAGD,MAAM,QAAQ,IAAI,CAAC;IACpC,IAAI,CAACC,MACD,MAAM,IAAIC,MAAY,gCAAgC,wBAAwB;QAC1EF;IACJ;IAEJ,OAAOC;AACX;AAEO,MAAME,8BAA8B,IAChC,IAAIC,8BAA8B;QACrC,WAAW;QACX,MAAML;IACV"}

package/plugins/CmsEntryFieldFilterPathPlugin.d.ts

@@ -0,0 +1,23 @@
+import { Plugin } from "@webiny/plugins/Plugin.js";
+import type { CmsModelField } from "@webiny/api-headless-cms/types/index.js";
+export interface CreatePathCallableParams {
+    field: Partial<CmsModelField> & Pick<CmsModelField, "fieldId" | "storageId" | "id">;
+    index?: number;
+}
+export interface CreatePathCallable {
+    (params: CreatePathCallableParams): string;
+}
+export interface CmsEntryFieldFilterPathPluginParams {
+    fieldType: string;
+    fieldId?: string[];
+    path: string | CreatePathCallable;
+    canUse?: (field: Pick<CmsModelField, "fieldId" | "type">, parents?: string[]) => boolean;
+}
+export declare class CmsEntryFieldFilterPathPlugin extends Plugin {
+    static readonly type: string;
+    private readonly config;
+    get fieldType(): string;
+    constructor(config: CmsEntryFieldFilterPathPluginParams);
+    canUse(field: Pick<CmsModelField, "fieldId" | "type">, parents: string[]): boolean;
+    createPath(params: CreatePathCallableParams): string;
+}

package/plugins/CmsEntryFieldFilterPathPlugin.js

@@ -0,0 +1,30 @@
+import error from "@webiny/error";
+import { Plugin } from "@webiny/plugins/Plugin.js";
+class CmsEntryFieldFilterPathPlugin extends Plugin {
+    static{
+        this.type = "cms-field-filter-path";
+    }
+    get fieldType() {
+        return this.config.fieldType;
+    }
+    constructor(config){
+        super();
+        this.config = config;
+        this.name = `${this.constructor.type}-${this.config.fieldType}`;
+    }
+    canUse(field, parents) {
+        if (field.type !== this.config.fieldType) return false;
+        else if (this.config.canUse) return this.config.canUse(field, parents);
+        const fieldId = this.config.fieldId;
+        if (!fieldId || false === Array.isArray(fieldId) || 0 === fieldId.length) return true;
+        return fieldId.includes(field.fieldId);
+    }
+    createPath(params) {
+        if ("function" == typeof this.config.path) return this.config.path(params);
+        else if ("string" == typeof this.config.path) return this.config.path;
+        throw new error(`Missing path in "${this.name}" plugin.`);
+    }
+}
+export { CmsEntryFieldFilterPathPlugin };
+
+//# sourceMappingURL=CmsEntryFieldFilterPathPlugin.js.map

package/plugins/CmsEntryFieldFilterPathPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins/CmsEntryFieldFilterPathPlugin.js","sources":["../../src/plugins/CmsEntryFieldFilterPathPlugin.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { Plugin } from \"@webiny/plugins/Plugin.js\";\nimport type { CmsModelField } from \"@webiny/api-headless-cms/types/index.js\";\n\nexport interface CreatePathCallableParams {\n    field: Partial<CmsModelField> & Pick<CmsModelField, \"fieldId\" | \"storageId\" | \"id\">;\n    index?: number;\n}\nexport interface CreatePathCallable {\n    (params: CreatePathCallableParams): string;\n}\nexport interface CmsEntryFieldFilterPathPluginParams {\n    fieldType: string;\n    fieldId?: string[];\n    path: string | CreatePathCallable;\n    canUse?: (field: Pick<CmsModelField, \"fieldId\" | \"type\">, parents?: string[]) => boolean;\n}\nexport class CmsEntryFieldFilterPathPlugin extends Plugin {\n    public static override readonly type: string = \"cms-field-filter-path\";\n\n    private readonly config: CmsEntryFieldFilterPathPluginParams;\n\n    public get fieldType(): string {\n        return this.config.fieldType;\n    }\n\n    public constructor(config: CmsEntryFieldFilterPathPluginParams) {\n        super();\n\n        this.config = config;\n\n        /* We expect error here because we know that `this.constructor.type` is defined, but TS does not. */\n        // @ts-expect-error\n        this.name = `${this.constructor.type}-${this.config.fieldType}`;\n    }\n\n    public canUse(field: Pick<CmsModelField, \"fieldId\" | \"type\">, parents: string[]): boolean {\n        if (field.type !== this.config.fieldType) {\n            return false;\n        } else if (this.config.canUse) {\n            return this.config.canUse(field, parents);\n        }\n        const fieldId = this.config.fieldId;\n        if (!fieldId || Array.isArray(fieldId) === false || fieldId.length === 0) {\n            return true;\n        }\n        return fieldId.includes(field.fieldId);\n    }\n\n    public createPath(params: CreatePathCallableParams): string {\n        if (typeof this.config.path === \"function\") {\n            return this.config.path(params);\n        } else if (typeof this.config.path === \"string\") {\n            return this.config.path;\n        }\n        throw new WebinyError(`Missing path in \"${this.name}\" plugin.`);\n    }\n}\n"],"names":["CmsEntryFieldFilterPathPlugin","Plugin","config","field","parents","fieldId","Array","params","WebinyError"],"mappings":";;AAiBO,MAAMA,sCAAsCC;;aACf,IAAI,GAAW;;IAI/C,IAAW,YAAoB;QAC3B,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS;IAChC;IAEA,YAAmBC,MAA2C,CAAE;QAC5D,KAAK;QAEL,IAAI,CAAC,MAAM,GAAGA;QAId,IAAI,CAAC,IAAI,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE;IACnE;IAEO,OAAOC,KAA8C,EAAEC,OAAiB,EAAW;QACtF,IAAID,MAAM,IAAI,KAAK,IAAI,CAAC,MAAM,CAAC,SAAS,EACpC,OAAO;aACJ,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,EACzB,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAACA,OAAOC;QAErC,MAAMC,UAAU,IAAI,CAAC,MAAM,CAAC,OAAO;QACnC,IAAI,CAACA,WAAWC,AAA2B,UAA3BA,MAAM,OAAO,CAACD,YAAsBA,AAAmB,MAAnBA,QAAQ,MAAM,EAC9D,OAAO;QAEX,OAAOA,QAAQ,QAAQ,CAACF,MAAM,OAAO;IACzC;IAEO,WAAWI,MAAgC,EAAU;QACxD,IAAI,AAA4B,cAA5B,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,EACvB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAACA;aACrB,IAAI,AAA4B,YAA5B,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,EAC9B,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI;QAE3B,MAAM,IAAIC,MAAY,CAAC,iBAAiB,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC;IAClE;AACJ"}

package/plugins/CmsEntryFieldFilterPlugin.d.ts

@@ -0,0 +1,39 @@
+import { Plugin } from "@webiny/plugins";
+import type { Field } from "../filtering/fields/types.js";
+import type { ICmsFieldFilterValueTransformPlugin } from "./CmsFieldFilterValueTransformPlugin.js";
+import { ValueFilterRegistry } from "@webiny/db-utils";
+interface CmsEntryFieldFilterPluginParams<T = any> {
+    fieldType: string;
+    create: (params: CmsEntryFieldFilterPluginCreateParams<T>) => null | CmsEntryFieldFilterPluginCreateResponse | CmsEntryFieldFilterPluginCreateResponse[];
+}
+interface CmsEntryFieldFilterPluginCreateParams<T = any> {
+    key: string;
+    value: T;
+    field: Field;
+    fields: Record<string, Field>;
+    operation: string;
+    valueFilterRegistry: ValueFilterRegistry.Interface;
+    transformValuePlugins: Record<string, ICmsFieldFilterValueTransformPlugin>;
+    getFilterCreatePlugin: (type: string) => CmsEntryFieldFilterPlugin;
+    negate: boolean;
+    compareValue: any;
+    transformValue: <I = any, O = any>(value: I) => O;
+}
+export interface CmsEntryFieldFilterPluginCreateResponse {
+    field: Field;
+    path: string;
+    fieldPathId: string;
+    filter: ValueFilterRegistry.Filter;
+    negate: boolean;
+    compareValue: any;
+    transformValue: <I = any, O = any>(value: I) => O;
+}
+export declare class CmsEntryFieldFilterPlugin<T = any> extends Plugin {
+    static readonly type: string;
+    static readonly ALL: string;
+    private readonly config;
+    readonly fieldType: string;
+    constructor(config: CmsEntryFieldFilterPluginParams<T>);
+    create(params: CmsEntryFieldFilterPluginCreateParams<T>): CmsEntryFieldFilterPluginCreateResponse[] | CmsEntryFieldFilterPluginCreateResponse | null;
+}
+export {};