@webiny/api-headless-cms-storage 0.0.0-unstable.9f53ea597d → 6.6.0-alpha.0

package/dist/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/dist/handlers/plainObjectPathHandler.d.ts

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

package/dist/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/dist/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/dist/handlers/refFilterCreateHandler.d.ts

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

package/dist/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/dist/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/dist/handlers/searchableJsonFilterCreateHandler.d.ts

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

package/dist/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/dist/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 → dist/index.d.ts}

@@ -17,3 +17,8 @@ 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 → dist/index.js}

@@ -12,3 +12,8 @@ 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/dist/package.json

@@ -0,0 +1,30 @@
+{
+	"name": "@webiny/api-headless-cms-storage",
+	"version": "0.0.0",
+	"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",
+		"@webiny/api-headless-cms": "0.0.0",
+		"@webiny/db-utils": "0.0.0",
+		"@webiny/di": "1.0.2",
+		"@webiny/error": "0.0.0",
+		"@webiny/feature": "0.0.0",
+		"@webiny/plugins": "0.0.0",
+		"date-fns": "4.4.0",
+		"dot-prop": "10.2.0",
+		"lodash": "4.18.1"
+	},
+	"devDependencies": {
+		"@webiny/build-tools": "0.0.0",
+		"@webiny/project-utils": "0.0.0",
+		"typescript": "7.0.2",
+		"vitest": "4.1.10"
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/api-headless-cms-storage",
-	"version": "0.0.0-unstable.9f53ea597d",
+	"version": "6.6.0-alpha.0",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"type": "module",
@@ -10,25 +10,21 @@
 		"directory": "packages/api-headless-cms-storage"
 	},
 	"dependencies": {
-		"@webiny/api": "0.0.0-unstable.9f53ea597d",
-		"@webiny/api-headless-cms": "0.0.0-unstable.9f53ea597d",
-		"@webiny/db-utils": "0.0.0-unstable.9f53ea597d",
-		"@webiny/error": "0.0.0-unstable.9f53ea597d",
-		"@webiny/plugins": "0.0.0-unstable.9f53ea597d",
-		"date-fns": "4.4.0",
-		"dot-prop": "10.2.0",
-		"lodash": "4.18.1"
+		"@webiny/api": "6.6.0-alpha.0",
+		"@webiny/api-headless-cms": "6.6.0-alpha.0",
+		"@webiny/db-utils": "6.6.0-alpha.0",
+		"@webiny/di": "^1.0.2",
+		"@webiny/error": "6.6.0-alpha.0",
+		"@webiny/feature": "6.6.0-alpha.0",
+		"@webiny/plugins": "6.6.0-alpha.0",
+		"date-fns": "^4.4.0",
+		"dot-prop": "^10.2.0",
+		"lodash": "^4.18.1"
 	},
 	"devDependencies": {
-		"@webiny/build-tools": "0.0.0-unstable.9f53ea597d",
-		"@webiny/project-utils": "0.0.0-unstable.9f53ea597d",
-		"typescript": "7.0.2",
-		"vitest": "4.1.10"
-	},
-	"webiny": {
-		"publishFrom": "dist"
-	},
-	"publishConfig": {
-		"access": "public"
+		"@webiny/build-tools": "6.6.0-alpha.0",
+		"@webiny/project-utils": "6.6.0-alpha.0",
+		"typescript": "^7.0.2",
+		"vitest": "^4.1.10"
 	}
 }

package/src/cms/storageHelpers.ts

@@ -0,0 +1,92 @@
+import type {
+    CmsEntry,
+    CmsEntryUniqueValue,
+    CmsEntryValues,
+    CmsModel,
+    CmsModelField,
+    StorageOperationsCmsModel
+} from "@webiny/api-headless-cms/types/index.js";
+import type { Container } from "@webiny/di";
+import { CmsStorageModelProvider } from "@webiny/api-headless-cms/features/shared/abstractions.js";
+import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
+import type { StorageTransformRegistry } from "@webiny/api-headless-cms/exports/api/cms/storage.js";
+import type { FilterItemFromStorage } from "../filtering/fields/types.js";
+
+/* Creates a lazy-cached getter for the storage representation of a CMS model. */
+export const createStorageModelAccessor = (container: Container) => {
+    let cached: CmsStorageModelProvider.Interface | undefined;
+
+    const getProvider = () => {
+        if (!cached) {
+            cached = container.resolve(CmsStorageModelProvider);
+        }
+        return cached;
+    };
+
+    const getModel = <T extends CmsEntryValues = CmsEntryValues>(
+        model: CmsModel
+    ): StorageOperationsCmsModel<T> => {
+        return getProvider().getModel<T>(model);
+    };
+
+    return { getModel };
+};
+
+/* Creates a fromStorage transform callable for a given model. */
+export const createStorageTransformCallable = (
+    storageTransformRegistry: StorageTransformRegistry.Interface,
+    model: StorageOperationsCmsModel
+): FilterItemFromStorage => {
+    return async (field: CmsModelField, value: unknown) => {
+        const fieldType = getBaseFieldType(field);
+        const storageTransform = storageTransformRegistry.get(fieldType);
+
+        if (!storageTransform) {
+            return value;
+        }
+
+        const result = await storageTransform.fromStorage({
+            model,
+            field,
+            value,
+            getStorageTransform(ft: string) {
+                return storageTransformRegistry.get(ft) || storageTransformRegistry.get("*")!;
+            }
+        });
+
+        return result;
+    };
+};
+
+/* Aggregates unique values for a given field across a list of CMS entries. */
+export const aggregateUniqueFieldValues = <T extends CmsEntryValues = CmsEntryValues>(
+    items: CmsEntry<T>[],
+    fieldId: string
+): CmsEntryUniqueValue[] => {
+    const result: Record<string, CmsEntryUniqueValue> = {};
+
+    for (const item of items) {
+        const fieldValue = item.values[fieldId] as string[] | string | undefined;
+
+        if (fieldValue == null) {
+            continue;
+        }
+
+        const values = Array.isArray(fieldValue) ? fieldValue : [fieldValue];
+
+        if (values.length === 0) {
+            continue;
+        }
+
+        for (const value of values) {
+            result[value] = {
+                value,
+                count: (result[value]?.count || 0) + 1
+            };
+        }
+    }
+
+    return Object.values(result)
+        .sort((a, b) => (a.value > b.value ? 1 : b.value > a.value ? -1 : 0))
+        .sort((a, b) => b.count - a.count);
+};

package/src/features/FilterRegistriesFeature.ts

@@ -0,0 +1,40 @@
+import { createFeature } from "@webiny/feature/api/index.js";
+import { FieldFilterPathRegistry } from "./fieldFilterPath/abstractions.js";
+import { FieldFilterValueTransformRegistry } from "./fieldFilterValueTransform/abstractions.js";
+import { FieldFilterCreateRegistry } from "./fieldFilterCreate/abstractions.js";
+import { FieldSortingRegistry } from "./fieldSorting/abstractions.js";
+import { FieldFilterPathRegistryImpl } from "./fieldFilterPath/FieldFilterPathRegistry.js";
+import { FieldFilterValueTransformRegistryImpl } from "./fieldFilterValueTransform/FieldFilterValueTransformRegistry.js";
+import { FieldFilterCreateRegistryImpl } from "./fieldFilterCreate/FieldFilterCreateRegistry.js";
+import { FieldSortingRegistryImpl } from "./fieldSorting/FieldSortingRegistry.js";
+import { createPlainObjectPathHandler } from "../handlers/plainObjectPathHandler.js";
+import { createLocationFolderIdPathHandler } from "../handlers/locationFolderIdPathHandler.js";
+import { createDatetimeTransformHandler } from "../handlers/datetimeTransformHandler.js";
+import { createDefaultFilterCreateHandler } from "../handlers/defaultFilterCreateHandler.js";
+import { createRefFilterCreateHandler } from "../handlers/refFilterCreateHandler.js";
+import { createObjectFilterCreateHandler } from "../handlers/objectFilterCreateHandler.js";
+import { createSearchableJsonFilterCreateHandler } from "../handlers/searchableJsonFilterCreateHandler.js";
+
+export const FilterRegistriesFeature = createFeature({
+    name: "cms.storage.filterRegistries",
+    register: container => {
+        const pathRegistry = new FieldFilterPathRegistryImpl();
+        pathRegistry.register("plainObject", createPlainObjectPathHandler());
+        pathRegistry.register("text", createLocationFolderIdPathHandler());
+        container.registerInstance(FieldFilterPathRegistry, pathRegistry);
+
+        const transformRegistry = new FieldFilterValueTransformRegistryImpl();
+        transformRegistry.register("datetime", createDatetimeTransformHandler());
+        container.registerInstance(FieldFilterValueTransformRegistry, transformRegistry);
+
+        const filterCreateRegistry = new FieldFilterCreateRegistryImpl();
+        filterCreateRegistry.register("*", createDefaultFilterCreateHandler());
+        filterCreateRegistry.register("ref", createRefFilterCreateHandler());
+        filterCreateRegistry.register("object", createObjectFilterCreateHandler());
+        filterCreateRegistry.register("searchable-json", createSearchableJsonFilterCreateHandler());
+        container.registerInstance(FieldFilterCreateRegistry, filterCreateRegistry);
+
+        const sortingRegistry = new FieldSortingRegistryImpl();
+        container.registerInstance(FieldSortingRegistry, sortingRegistry);
+    }
+});

package/src/features/fieldFilterCreate/FieldFilterCreateRegistry.ts

@@ -0,0 +1,25 @@
+import WebinyError from "@webiny/error";
+import type { FieldFilterCreateRegistry } from "./abstractions.js";
+
+export class FieldFilterCreateRegistryImpl implements FieldFilterCreateRegistry.Interface {
+    private readonly handlers = new Map<string, FieldFilterCreateRegistry.Handler>();
+
+    public register(fieldType: string, handler: FieldFilterCreateRegistry.Handler): void {
+        this.handlers.set(fieldType, handler);
+    }
+
+    public get(fieldType: string): FieldFilterCreateRegistry.Handler | undefined {
+        return this.handlers.get(fieldType);
+    }
+
+    public getDefault(): FieldFilterCreateRegistry.Handler {
+        const handler = this.handlers.get("*");
+        if (!handler) {
+            throw new WebinyError(
+                "No default filter create handler registered.",
+                "MISSING_DEFAULT_HANDLER"
+            );
+        }
+        return handler;
+    }
+}

package/src/features/fieldFilterCreate/abstractions.ts

@@ -0,0 +1,51 @@
+import { Abstraction } from "@webiny/di";
+import type { Field } from "../../filtering/fields/types.js";
+import type { ValueFilterRegistry } from "@webiny/db-utils";
+import type { FieldFilterValueTransformRegistry } from "../fieldFilterValueTransform/abstractions.js";
+
+export interface IFieldFilterCreateResult {
+    field: Field;
+    path: string;
+    fieldPathId: string;
+    filter: ValueFilterRegistry.Filter;
+    negate: boolean;
+    compareValue: any;
+    transformValue: <I = any, O = any>(value: I) => O;
+}
+
+export interface IFieldFilterCreateParams<T = any> {
+    key: string;
+    value: T;
+    field: Field;
+    fields: Record<string, Field>;
+    operation: string;
+    valueFilterRegistry: ValueFilterRegistry.Interface;
+    transformRegistry: FieldFilterValueTransformRegistry.Interface;
+    getHandler: (fieldType: string) => IFieldFilterCreateHandler;
+    negate: boolean;
+    compareValue: any;
+    transformValue: <I = any, O = any>(value: I) => O;
+}
+
+export interface IFieldFilterCreateHandler {
+    create(
+        params: IFieldFilterCreateParams
+    ): null | IFieldFilterCreateResult | IFieldFilterCreateResult[];
+}
+
+export interface IFieldFilterCreateRegistry {
+    register(fieldType: string, handler: IFieldFilterCreateHandler): void;
+    get(fieldType: string): IFieldFilterCreateHandler | undefined;
+    getDefault(): IFieldFilterCreateHandler;
+}
+
+export const FieldFilterCreateRegistry = new Abstraction<IFieldFilterCreateRegistry>(
+    "Cms/Storage/FieldFilterCreateRegistry"
+);
+
+export namespace FieldFilterCreateRegistry {
+    export type Interface = IFieldFilterCreateRegistry;
+    export type Handler = IFieldFilterCreateHandler;
+    export type Params = IFieldFilterCreateParams;
+    export type Result = IFieldFilterCreateResult;
+}

package/src/features/fieldFilterPath/FieldFilterPathRegistry.ts

@@ -0,0 +1,13 @@
+import type { FieldFilterPathRegistry } from "./abstractions.js";
+
+export class FieldFilterPathRegistryImpl implements FieldFilterPathRegistry.Interface {
+    private readonly handlers = new Map<string, FieldFilterPathRegistry.Handler>();
+
+    public register(fieldType: string, handler: FieldFilterPathRegistry.Handler): void {
+        this.handlers.set(fieldType, handler);
+    }
+
+    public get(fieldType: string): FieldFilterPathRegistry.Handler | undefined {
+        return this.handlers.get(fieldType);
+    }
+}

package/src/features/fieldFilterPath/abstractions.ts

@@ -0,0 +1,22 @@
+import { Abstraction } from "@webiny/di";
+import type { CmsModelField } from "@webiny/api-headless-cms/types/index.js";
+import type { CreatePathCallableParams } from "../../plugins/CmsEntryFieldFilterPathPlugin.js";
+
+export interface IFieldFilterPathHandler {
+    canUse(field: Pick<CmsModelField, "fieldId" | "type">, parents: string[]): boolean;
+    createPath(params: CreatePathCallableParams): string;
+}
+
+export interface IFieldFilterPathRegistry {
+    register(fieldType: string, handler: IFieldFilterPathHandler): void;
+    get(fieldType: string): IFieldFilterPathHandler | undefined;
+}
+
+export const FieldFilterPathRegistry = new Abstraction<IFieldFilterPathRegistry>(
+    "Cms/Storage/FieldFilterPathRegistry"
+);
+
+export namespace FieldFilterPathRegistry {
+    export type Interface = IFieldFilterPathRegistry;
+    export type Handler = IFieldFilterPathHandler;
+}

package/src/features/fieldFilterValueTransform/FieldFilterValueTransformRegistry.ts

@@ -0,0 +1,15 @@
+import type { FieldFilterValueTransformRegistry } from "./abstractions.js";
+
+export class FieldFilterValueTransformRegistryImpl
+    implements FieldFilterValueTransformRegistry.Interface
+{
+    private readonly handlers = new Map<string, FieldFilterValueTransformRegistry.Handler>();
+
+    public register(fieldType: string, handler: FieldFilterValueTransformRegistry.Handler): void {
+        this.handlers.set(fieldType, handler);
+    }
+
+    public get(fieldType: string): FieldFilterValueTransformRegistry.Handler | undefined {
+        return this.handlers.get(fieldType);
+    }
+}

package/src/features/fieldFilterValueTransform/abstractions.ts

@@ -0,0 +1,21 @@
+import { Abstraction } from "@webiny/di";
+import type { CmsFieldFilterValueTransformParams } from "../../plugins/CmsFieldFilterValueTransformPlugin.js";
+
+export interface IFieldFilterValueTransformHandler {
+    transform(params: CmsFieldFilterValueTransformParams): any;
+}
+
+export interface IFieldFilterValueTransformRegistry {
+    register(fieldType: string, handler: IFieldFilterValueTransformHandler): void;
+    get(fieldType: string): IFieldFilterValueTransformHandler | undefined;
+}
+
+export const FieldFilterValueTransformRegistry =
+    new Abstraction<IFieldFilterValueTransformRegistry>(
+        "Cms/Storage/FieldFilterValueTransformRegistry"
+    );
+
+export namespace FieldFilterValueTransformRegistry {
+    export type Interface = IFieldFilterValueTransformRegistry;
+    export type Handler = IFieldFilterValueTransformHandler;
+}

package/src/features/fieldSorting/FieldSortingRegistry.ts

@@ -0,0 +1,20 @@
+import type { FieldSortingRegistry } from "./abstractions.js";
+
+export class FieldSortingRegistryImpl implements FieldSortingRegistry.Interface {
+    private readonly handlers: FieldSortingRegistry.Handler[] = [];
+
+    public register(handler: FieldSortingRegistry.Handler): void {
+        this.handlers.push(handler);
+    }
+
+    public find(
+        params: FieldSortingRegistry.CanUseParams
+    ): FieldSortingRegistry.Handler | undefined {
+        for (let i = this.handlers.length - 1; i >= 0; i--) {
+            if (this.handlers[i].canUse(params)) {
+                return this.handlers[i];
+            }
+        }
+        return undefined;
+    }
+}

package/src/features/fieldSorting/abstractions.ts

@@ -0,0 +1,49 @@
+import { Abstraction } from "@webiny/di";
+import type { Field } from "../../filtering/fields/types.js";
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+
+export interface IFieldSortingCanUseParams {
+    model: CmsModel;
+    field?: Field;
+    fieldId: string;
+    order: "ASC" | "DESC";
+    sortBy: string;
+}
+
+export interface IFieldSortingCreateParams {
+    model: CmsModel;
+    fieldId: string;
+    order: "ASC" | "DESC";
+    sortBy: string;
+    fields: Record<string, Field>;
+    field?: Field;
+}
+
+export interface IFieldSortingResult {
+    valuePath: string;
+    reverse: boolean;
+    fieldId: string;
+    field: Field;
+}
+
+export interface IFieldSortingHandler {
+    canUse(params: IFieldSortingCanUseParams): boolean;
+    createSort(params: IFieldSortingCreateParams): IFieldSortingResult;
+}
+
+export interface IFieldSortingRegistry {
+    register(handler: IFieldSortingHandler): void;
+    find(params: IFieldSortingCanUseParams): IFieldSortingHandler | undefined;
+}
+
+export const FieldSortingRegistry = new Abstraction<IFieldSortingRegistry>(
+    "Cms/Storage/FieldSortingRegistry"
+);
+
+export namespace FieldSortingRegistry {
+    export type Interface = IFieldSortingRegistry;
+    export type Handler = IFieldSortingHandler;
+    export type CanUseParams = IFieldSortingCanUseParams;
+    export type CreateParams = IFieldSortingCreateParams;
+    export type Result = IFieldSortingResult;
+}