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

package/__tests__/filtering/getValue.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import { getValue } from "~/filtering/getValue";
+import { createEntry } from "./mocks/entry.noModel";
+
+describe("value via object-path", () => {
+    it("should find values complex object / array structure", async () => {
+        const title = getValue(createEntry(), "values.title");
+        expect(title).toEqual(createEntry().values.title);
+
+        const options = getValue(createEntry(), "values.options");
+        expect(options).toEqual(createEntry().values.options);
+
+        const variantTitle = getValue(createEntry(), "values.variant.title");
+        expect(variantTitle).toEqual(createEntry().values.variant.title);
+
+        const variantSpecificationsKey = getValue(
+            createEntry(),
+            "values.variant.specifications.key"
+        );
+
+        expect(variantSpecificationsKey).toEqual([
+            "Specification #1",
+            "Specification #2",
+            "Specification #3"
+        ]);
+
+        const variantSpecificationsInfoImages = getValue(
+            createEntry(),
+            "values.variant.specifications.info.images"
+        );
+        expect(variantSpecificationsInfoImages).toEqual([
+            { files: ["image1.jpg", "image2.jpg", "image3.jpg", "image4.jpg"] },
+            { files: ["image31.jpg", "image32.jpg", "image33.jpg", "image34.jpg"] }
+        ]);
+
+        const variantSpecificationsInfoImagesFiles = getValue(
+            createEntry(),
+            "values.variant.specifications.info.images.files"
+        );
+        expect(variantSpecificationsInfoImagesFiles).toEqual([
+            "image1.jpg",
+            "image2.jpg",
+            "image3.jpg",
+            "image4.jpg",
+            "image31.jpg",
+            "image32.jpg",
+            "image33.jpg",
+            "image34.jpg"
+        ]);
+
+        const variantSpecificationsInfoTagsKey = getValue(
+            createEntry(),
+            "values.variant.specifications.info.tags.key"
+        );
+
+        expect(variantSpecificationsInfoTagsKey).toEqual(["size", "weight", "price"]);
+    });
+});

package/__tests__/filtering/mocks/entry.noModel.ts

@@ -0,0 +1,110 @@
+import type { CmsEntry } from "@webiny/api-headless-cms/types";
+
+interface ValuesOption {
+    title: string;
+    value: number;
+}
+
+interface ValuesVariantSpecification {
+    key: string;
+    value: string | number;
+    info?: {
+        [key: string]: any;
+    };
+}
+interface ValuesVariant {
+    title: string;
+    specifications: ValuesVariantSpecification[];
+}
+interface Values {
+    title: string;
+    options: ValuesOption[];
+    variant: ValuesVariant;
+}
+
+type Result = Pick<CmsEntry<Values>, "id" | "createdBy" | "createdOn" | "values">;
+
+const createCreatedOn = (index: number) => {
+    const d = new Date();
+    d.setTime(d.getTime() + index * 1000 * 86400);
+
+    return d.toISOString();
+};
+
+export const createEntry = (index = 0): Result => {
+    return {
+        id: `${index + 100000}#0001`,
+        createdOn: createCreatedOn(index),
+        createdBy: {
+            id: "userId",
+            type: "admin",
+            displayName: "Admin"
+        },
+        values: {
+            title: `Title #${String(index).padStart(5, "t")}`,
+            options: Array.from({ length: 100 }).map((_, optionIndex) => {
+                return {
+                    title: `Option #${index + optionIndex + 1}`,
+                    value: index + optionIndex + 1
+                };
+            }),
+            variant: {
+                title: `Variant title ${String(index).padStart(5, "a")}`,
+                specifications: [
+                    {
+                        key: `Specification #${index === 0 ? 1 : index}`,
+                        value: `${index + 100}`,
+                        info: {
+                            images: {
+                                files: ["image1.jpg", "image2.jpg", "image3.jpg", "image4.jpg"]
+                            },
+                            tags: [
+                                {
+                                    key: "size",
+                                    value: 55
+                                },
+                                {
+                                    key: "weight",
+                                    value: 105
+                                },
+                                {
+                                    key: "price",
+                                    value: 999
+                                }
+                            ]
+                        }
+                    },
+                    {
+                        key: "Specification #2",
+                        value: "2"
+                    },
+                    {
+                        key: "Specification #3",
+                        value: "3",
+                        info: {
+                            images: {
+                                files: ["image31.jpg", "image32.jpg", "image33.jpg", "image34.jpg"]
+                            },
+                            tags: [
+                                {
+                                    key: "size",
+                                    value: 355
+                                },
+                                {
+                                    key: "price",
+                                    value: 3999
+                                }
+                            ]
+                        }
+                    }
+                ]
+            }
+        }
+    };
+};
+
+export const createEntries = (amount: number) => {
+    return [...Array(amount)].map((_, index) => {
+        return createEntry(index);
+    });
+};

package/__tests__/path/plainObject.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { CmsModelField } from "@webiny/api-headless-cms/types";
+import { createPlainObjectPathPlugin } from "~/path/plainObject";
+
+describe("dynamodb path plain object", () => {
+    it("should get the plain object path", () => {
+        const plugin = createPlainObjectPathPlugin();
+
+        const result = plugin.createPath({
+            field: {
+                storageId: "authors",
+                settings: {
+                    path: "createdBy.id"
+                }
+            } as unknown as CmsModelField
+        });
+
+        expect(result).toEqual("createdBy.id");
+    });
+
+    it("should throw an error when no path in the settings", () => {
+        const plugin = createPlainObjectPathPlugin();
+
+        expect(() => {
+            plugin.createPath({
+                field: {
+                    settings: {}
+                } as unknown as CmsModelField
+            });
+        }).toThrow("Missing path settings value.");
+    });
+});

package/__tests__/transforms/datetime.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import { createDatetimeTransformValuePlugin } from "~/transforms/datetime";
+import { CmsModelField } from "@webiny/api-headless-cms/types";
+
+const createField = (fieldType: string): CmsModelField => {
+    return {
+        id: "storageId",
+        storageId: "storageId",
+        type: "datetime",
+        settings: {
+            type: fieldType
+        }
+    } as unknown as CmsModelField;
+};
+
+describe("dynamodb transform datetime", () => {
+    const correctValues: [string | Date, string, number][] = [
+        [new Date("Thu, 13 May 2021 12:32:33.892 GMT"), "date", 1620909153892],
+        [new Date("2021-05-13T12:32:33.892Z"), "date", 1620909153892],
+        ["2021-05-13T12:32:33.892Z", "date", 1620909153892],
+        ["13:57:22", "time", 50242000],
+        ["13:57", "time", 50220000],
+        ["13:57.481", "time", 50220481],
+        ["13:57:22.581", "time", 50242581]
+    ];
+    it.each(correctValues)(
+        "should transform date or time into the milliseconds - %s",
+        (value: Date | string, fieldType: string, expected: number) => {
+            const plugin = createDatetimeTransformValuePlugin();
+
+            const result = plugin.transform({
+                field: createField(fieldType),
+                value
+            });
+
+            expect(result).toEqual(expected);
+        }
+    );
+
+    const incorrectTimeValues: [any][] = [
+        [{}],
+        [[]],
+        [""],
+        [
+            function () {
+                return 1;
+            }
+        ],
+        [true]
+    ];
+
+    it.each(incorrectTimeValues)(
+        "should throw an error when trying to transform time field but value is not a string or a number",
+        value => {
+            expect.assertions(1);
+            const plugin = createDatetimeTransformValuePlugin();
+
+            try {
+                const result = plugin.transform({
+                    field: createField("time"),
+                    value
+                });
+                expect(result).toEqual("SHOULD NOT HAPPEN");
+            } catch (ex) {
+                expect(ex.message).toEqual(
+                    "Field value must be a string because field is defined as time."
+                );
+            }
+        }
+    );
+});

package/{cms → dist/cms}/storageHelpers.d.ts

@@ -1,10 +1,8 @@
 import type { CmsEntry, CmsEntryUniqueValue, CmsEntryValues, CmsModel, StorageOperationsCmsModel } from "@webiny/api-headless-cms/types/index.js";
-import type { PluginsContainer } from "@webiny/plugins";
-import { StorageOperationsCmsModelPlugin } from "@webiny/api-headless-cms";
+import type { Container } from "@webiny/di";
 import type { StorageTransformRegistry } from "@webiny/api-headless-cms/exports/api/cms/storage.js";
 import type { FilterItemFromStorage } from "../filtering/fields/types.js";
-export declare const createStorageModelAccessor: (plugins: PluginsContainer) => {
-    getPlugin: () => StorageOperationsCmsModelPlugin;
+export declare const createStorageModelAccessor: (container: Container) => {
     getModel: <T extends CmsEntryValues = CmsEntryValues>(model: CmsModel) => StorageOperationsCmsModel<T>;
 };
 export declare const createStorageTransformCallable: (storageTransformRegistry: StorageTransformRegistry.Interface, model: StorageOperationsCmsModel) => FilterItemFromStorage;

package/{cms → dist/cms}/storageHelpers.js

@@ -1,18 +1,13 @@
-import { StorageOperationsCmsModelPlugin } from "@webiny/api-headless-cms";
+import { CmsStorageModelProvider } from "@webiny/api-headless-cms/features/shared/abstractions.js";
 import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
-const createStorageModelAccessor = (plugins)=>{
+const createStorageModelAccessor = (container)=>{
     let cached;
-    const getPlugin = ()=>{
-        if (cached) return cached;
-        cached = plugins.oneByType(StorageOperationsCmsModelPlugin.type);
+    const getProvider = ()=>{
+        if (!cached) cached = container.resolve(CmsStorageModelProvider);
         return cached;
     };
-    const getModel = (model)=>{
-        const plugin = getPlugin();
-        return plugin.getModel(model);
-    };
+    const getModel = (model)=>getProvider().getModel(model);
     return {
-        getPlugin,
         getModel
     };
 };

package/dist/cms/storageHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cms/storageHelpers.js","sources":["../../src/cms/storageHelpers.ts"],"sourcesContent":["import type {\n    CmsEntry,\n    CmsEntryUniqueValue,\n    CmsEntryValues,\n    CmsModel,\n    CmsModelField,\n    StorageOperationsCmsModel\n} from \"@webiny/api-headless-cms/types/index.js\";\nimport type { Container } from \"@webiny/di\";\nimport { CmsStorageModelProvider } from \"@webiny/api-headless-cms/features/shared/abstractions.js\";\nimport { getBaseFieldType } from \"@webiny/api-headless-cms/utils/getBaseFieldType.js\";\nimport type { StorageTransformRegistry } from \"@webiny/api-headless-cms/exports/api/cms/storage.js\";\nimport type { FilterItemFromStorage } from \"../filtering/fields/types.js\";\n\n/* Creates a lazy-cached getter for the storage representation of a CMS model. */\nexport const createStorageModelAccessor = (container: Container) => {\n    let cached: CmsStorageModelProvider.Interface | undefined;\n\n    const getProvider = () => {\n        if (!cached) {\n            cached = container.resolve(CmsStorageModelProvider);\n        }\n        return cached;\n    };\n\n    const getModel = <T extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel\n    ): StorageOperationsCmsModel<T> => {\n        return getProvider().getModel<T>(model);\n    };\n\n    return { getModel };\n};\n\n/* Creates a fromStorage transform callable for a given model. */\nexport const createStorageTransformCallable = (\n    storageTransformRegistry: StorageTransformRegistry.Interface,\n    model: StorageOperationsCmsModel\n): FilterItemFromStorage => {\n    return async (field: CmsModelField, value: unknown) => {\n        const fieldType = getBaseFieldType(field);\n        const storageTransform = storageTransformRegistry.get(fieldType);\n\n        if (!storageTransform) {\n            return value;\n        }\n\n        const result = await storageTransform.fromStorage({\n            model,\n            field,\n            value,\n            getStorageTransform(ft: string) {\n                return storageTransformRegistry.get(ft) || storageTransformRegistry.get(\"*\")!;\n            }\n        });\n\n        return result;\n    };\n};\n\n/* Aggregates unique values for a given field across a list of CMS entries. */\nexport const aggregateUniqueFieldValues = <T extends CmsEntryValues = CmsEntryValues>(\n    items: CmsEntry<T>[],\n    fieldId: string\n): CmsEntryUniqueValue[] => {\n    const result: Record<string, CmsEntryUniqueValue> = {};\n\n    for (const item of items) {\n        const fieldValue = item.values[fieldId] as string[] | string | undefined;\n\n        if (fieldValue == null) {\n            continue;\n        }\n\n        const values = Array.isArray(fieldValue) ? fieldValue : [fieldValue];\n\n        if (values.length === 0) {\n            continue;\n        }\n\n        for (const value of values) {\n            result[value] = {\n                value,\n                count: (result[value]?.count || 0) + 1\n            };\n        }\n    }\n\n    return Object.values(result)\n        .sort((a, b) => (a.value > b.value ? 1 : b.value > a.value ? -1 : 0))\n        .sort((a, b) => b.count - a.count);\n};\n"],"names":["createStorageModelAccessor","container","cached","getProvider","CmsStorageModelProvider","getModel","model","createStorageTransformCallable","storageTransformRegistry","field","value","fieldType","getBaseFieldType","storageTransform","result","ft","aggregateUniqueFieldValues","items","fieldId","item","fieldValue","values","Array","Object","a","b"],"mappings":";;AAeO,MAAMA,6BAA6B,CAACC;IACvC,IAAIC;IAEJ,MAAMC,cAAc;QAChB,IAAI,CAACD,QACDA,SAASD,UAAU,OAAO,CAACG;QAE/B,OAAOF;IACX;IAEA,MAAMG,WAAW,CACbC,QAEOH,cAAc,QAAQ,CAAIG;IAGrC,OAAO;QAAED;IAAS;AACtB;AAGO,MAAME,iCAAiC,CAC1CC,0BACAF,QAEO,OAAOG,OAAsBC;QAChC,MAAMC,YAAYC,iBAAiBH;QACnC,MAAMI,mBAAmBL,yBAAyB,GAAG,CAACG;QAEtD,IAAI,CAACE,kBACD,OAAOH;QAGX,MAAMI,SAAS,MAAMD,iBAAiB,WAAW,CAAC;YAC9CP;YACAG;YACAC;YACA,qBAAoBK,EAAU;gBAC1B,OAAOP,yBAAyB,GAAG,CAACO,OAAOP,yBAAyB,GAAG,CAAC;YAC5E;QACJ;QAEA,OAAOM;IACX;AAIG,MAAME,6BAA6B,CACtCC,OACAC;IAEA,MAAMJ,SAA8C,CAAC;IAErD,KAAK,MAAMK,QAAQF,MAAO;QACtB,MAAMG,aAAaD,KAAK,MAAM,CAACD,QAAQ;QAEvC,IAAIE,AAAc,QAAdA,YACA;QAGJ,MAAMC,SAASC,MAAM,OAAO,CAACF,cAAcA,aAAa;YAACA;SAAW;QAEpE,IAAIC,AAAkB,MAAlBA,OAAO,MAAM,EAIjB,KAAK,MAAMX,SAASW,OAChBP,MAAM,CAACJ,MAAM,GAAG;YACZA;YACA,OAAQI,AAAAA,CAAAA,MAAM,CAACJ,MAAM,EAAE,SAAS,KAAK;QACzC;IAER;IAEA,OAAOa,OAAO,MAAM,CAACT,QAChB,IAAI,CAAC,CAACU,GAAGC,IAAOD,EAAE,KAAK,GAAGC,EAAE,KAAK,GAAG,IAAIA,EAAE,KAAK,GAAGD,EAAE,KAAK,GAAG,KAAK,GACjE,IAAI,CAAC,CAACA,GAAGC,IAAMA,EAAE,KAAK,GAAGD,EAAE,KAAK;AACzC"}

package/dist/features/FilterRegistriesFeature.d.ts

@@ -0,0 +1,4 @@
+export declare const FilterRegistriesFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/dist/features/FilterRegistriesFeature.js

@@ -0,0 +1,39 @@
+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";
+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);
+    }
+});
+export { FilterRegistriesFeature };
+
+//# sourceMappingURL=FilterRegistriesFeature.js.map

package/dist/features/FilterRegistriesFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/FilterRegistriesFeature.js","sources":["../../src/features/FilterRegistriesFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api/index.js\";\nimport { FieldFilterPathRegistry } from \"./fieldFilterPath/abstractions.js\";\nimport { FieldFilterValueTransformRegistry } from \"./fieldFilterValueTransform/abstractions.js\";\nimport { FieldFilterCreateRegistry } from \"./fieldFilterCreate/abstractions.js\";\nimport { FieldSortingRegistry } from \"./fieldSorting/abstractions.js\";\nimport { FieldFilterPathRegistryImpl } from \"./fieldFilterPath/FieldFilterPathRegistry.js\";\nimport { FieldFilterValueTransformRegistryImpl } from \"./fieldFilterValueTransform/FieldFilterValueTransformRegistry.js\";\nimport { FieldFilterCreateRegistryImpl } from \"./fieldFilterCreate/FieldFilterCreateRegistry.js\";\nimport { FieldSortingRegistryImpl } from \"./fieldSorting/FieldSortingRegistry.js\";\nimport { createPlainObjectPathHandler } from \"../handlers/plainObjectPathHandler.js\";\nimport { createLocationFolderIdPathHandler } from \"../handlers/locationFolderIdPathHandler.js\";\nimport { createDatetimeTransformHandler } from \"../handlers/datetimeTransformHandler.js\";\nimport { createDefaultFilterCreateHandler } from \"../handlers/defaultFilterCreateHandler.js\";\nimport { createRefFilterCreateHandler } from \"../handlers/refFilterCreateHandler.js\";\nimport { createObjectFilterCreateHandler } from \"../handlers/objectFilterCreateHandler.js\";\nimport { createSearchableJsonFilterCreateHandler } from \"../handlers/searchableJsonFilterCreateHandler.js\";\n\nexport const FilterRegistriesFeature = createFeature({\n    name: \"cms.storage.filterRegistries\",\n    register: container => {\n        const pathRegistry = new FieldFilterPathRegistryImpl();\n        pathRegistry.register(\"plainObject\", createPlainObjectPathHandler());\n        pathRegistry.register(\"text\", createLocationFolderIdPathHandler());\n        container.registerInstance(FieldFilterPathRegistry, pathRegistry);\n\n        const transformRegistry = new FieldFilterValueTransformRegistryImpl();\n        transformRegistry.register(\"datetime\", createDatetimeTransformHandler());\n        container.registerInstance(FieldFilterValueTransformRegistry, transformRegistry);\n\n        const filterCreateRegistry = new FieldFilterCreateRegistryImpl();\n        filterCreateRegistry.register(\"*\", createDefaultFilterCreateHandler());\n        filterCreateRegistry.register(\"ref\", createRefFilterCreateHandler());\n        filterCreateRegistry.register(\"object\", createObjectFilterCreateHandler());\n        filterCreateRegistry.register(\"searchable-json\", createSearchableJsonFilterCreateHandler());\n        container.registerInstance(FieldFilterCreateRegistry, filterCreateRegistry);\n\n        const sortingRegistry = new FieldSortingRegistryImpl();\n        container.registerInstance(FieldSortingRegistry, sortingRegistry);\n    }\n});\n"],"names":["FilterRegistriesFeature","createFeature","container","pathRegistry","FieldFilterPathRegistryImpl","createPlainObjectPathHandler","createLocationFolderIdPathHandler","FieldFilterPathRegistry","transformRegistry","FieldFilterValueTransformRegistryImpl","createDatetimeTransformHandler","FieldFilterValueTransformRegistry","filterCreateRegistry","FieldFilterCreateRegistryImpl","createDefaultFilterCreateHandler","createRefFilterCreateHandler","createObjectFilterCreateHandler","createSearchableJsonFilterCreateHandler","FieldFilterCreateRegistry","sortingRegistry","FieldSortingRegistryImpl","FieldSortingRegistry"],"mappings":";;;;;;;;;;;;;;;;AAiBO,MAAMA,0BAA0BC,cAAc;IACjD,MAAM;IACN,UAAUC,CAAAA;QACN,MAAMC,eAAe,IAAIC;QACzBD,aAAa,QAAQ,CAAC,eAAeE;QACrCF,aAAa,QAAQ,CAAC,QAAQG;QAC9BJ,UAAU,gBAAgB,CAACK,yBAAyBJ;QAEpD,MAAMK,oBAAoB,IAAIC;QAC9BD,kBAAkB,QAAQ,CAAC,YAAYE;QACvCR,UAAU,gBAAgB,CAACS,mCAAmCH;QAE9D,MAAMI,uBAAuB,IAAIC;QACjCD,qBAAqB,QAAQ,CAAC,KAAKE;QACnCF,qBAAqB,QAAQ,CAAC,OAAOG;QACrCH,qBAAqB,QAAQ,CAAC,UAAUI;QACxCJ,qBAAqB,QAAQ,CAAC,mBAAmBK;QACjDf,UAAU,gBAAgB,CAACgB,2BAA2BN;QAEtD,MAAMO,kBAAkB,IAAIC;QAC5BlB,UAAU,gBAAgB,CAACmB,sBAAsBF;IACrD;AACJ"}

package/dist/features/fieldFilterCreate/FieldFilterCreateRegistry.d.ts

@@ -0,0 +1,7 @@
+import type { FieldFilterCreateRegistry } from "./abstractions.js";
+export declare class FieldFilterCreateRegistryImpl implements FieldFilterCreateRegistry.Interface {
+    private readonly handlers;
+    register(fieldType: string, handler: FieldFilterCreateRegistry.Handler): void;
+    get(fieldType: string): FieldFilterCreateRegistry.Handler | undefined;
+    getDefault(): FieldFilterCreateRegistry.Handler;
+}

package/dist/features/fieldFilterCreate/FieldFilterCreateRegistry.js

@@ -0,0 +1,20 @@
+import error from "@webiny/error";
+class FieldFilterCreateRegistryImpl {
+    register(fieldType, handler) {
+        this.handlers.set(fieldType, handler);
+    }
+    get(fieldType) {
+        return this.handlers.get(fieldType);
+    }
+    getDefault() {
+        const handler = this.handlers.get("*");
+        if (!handler) throw new error("No default filter create handler registered.", "MISSING_DEFAULT_HANDLER");
+        return handler;
+    }
+    constructor(){
+        this.handlers = new Map();
+    }
+}
+export { FieldFilterCreateRegistryImpl };
+
+//# sourceMappingURL=FieldFilterCreateRegistry.js.map

package/dist/features/fieldFilterCreate/FieldFilterCreateRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/fieldFilterCreate/FieldFilterCreateRegistry.js","sources":["../../../src/features/fieldFilterCreate/FieldFilterCreateRegistry.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { FieldFilterCreateRegistry } from \"./abstractions.js\";\n\nexport class FieldFilterCreateRegistryImpl implements FieldFilterCreateRegistry.Interface {\n    private readonly handlers = new Map<string, FieldFilterCreateRegistry.Handler>();\n\n    public register(fieldType: string, handler: FieldFilterCreateRegistry.Handler): void {\n        this.handlers.set(fieldType, handler);\n    }\n\n    public get(fieldType: string): FieldFilterCreateRegistry.Handler | undefined {\n        return this.handlers.get(fieldType);\n    }\n\n    public getDefault(): FieldFilterCreateRegistry.Handler {\n        const handler = this.handlers.get(\"*\");\n        if (!handler) {\n            throw new WebinyError(\n                \"No default filter create handler registered.\",\n                \"MISSING_DEFAULT_HANDLER\"\n            );\n        }\n        return handler;\n    }\n}\n"],"names":["FieldFilterCreateRegistryImpl","fieldType","handler","WebinyError","Map"],"mappings":";AAGO,MAAMA;IAGF,SAASC,SAAiB,EAAEC,OAA0C,EAAQ;QACjF,IAAI,CAAC,QAAQ,CAAC,GAAG,CAACD,WAAWC;IACjC;IAEO,IAAID,SAAiB,EAAiD;QACzE,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAACA;IAC7B;IAEO,aAAgD;QACnD,MAAMC,UAAU,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;QAClC,IAAI,CAACA,SACD,MAAM,IAAIC,MACN,gDACA;QAGR,OAAOD;IACX;;aAnBiB,QAAQ,GAAG,IAAIE;;AAoBpC"}

package/dist/features/fieldFilterCreate/abstractions.d.ts

@@ -0,0 +1,41 @@
+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 declare const FieldFilterCreateRegistry: Abstraction<IFieldFilterCreateRegistry>;
+export declare namespace FieldFilterCreateRegistry {
+    type Interface = IFieldFilterCreateRegistry;
+    type Handler = IFieldFilterCreateHandler;
+    type Params = IFieldFilterCreateParams;
+    type Result = IFieldFilterCreateResult;
+}

package/dist/features/fieldFilterCreate/abstractions.js

@@ -0,0 +1,5 @@
+import { Abstraction } from "@webiny/di";
+const FieldFilterCreateRegistry = new Abstraction("Cms/Storage/FieldFilterCreateRegistry");
+export { FieldFilterCreateRegistry };
+
+//# sourceMappingURL=abstractions.js.map

package/dist/features/fieldFilterCreate/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/fieldFilterCreate/abstractions.js","sources":["../../../src/features/fieldFilterCreate/abstractions.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\nimport type { Field } from \"../../filtering/fields/types.js\";\nimport type { ValueFilterRegistry } from \"@webiny/db-utils\";\nimport type { FieldFilterValueTransformRegistry } from \"../fieldFilterValueTransform/abstractions.js\";\n\nexport interface IFieldFilterCreateResult {\n    field: Field;\n    path: string;\n    fieldPathId: string;\n    filter: ValueFilterRegistry.Filter;\n    negate: boolean;\n    compareValue: any;\n    transformValue: <I = any, O = any>(value: I) => O;\n}\n\nexport interface IFieldFilterCreateParams<T = any> {\n    key: string;\n    value: T;\n    field: Field;\n    fields: Record<string, Field>;\n    operation: string;\n    valueFilterRegistry: ValueFilterRegistry.Interface;\n    transformRegistry: FieldFilterValueTransformRegistry.Interface;\n    getHandler: (fieldType: string) => IFieldFilterCreateHandler;\n    negate: boolean;\n    compareValue: any;\n    transformValue: <I = any, O = any>(value: I) => O;\n}\n\nexport interface IFieldFilterCreateHandler {\n    create(\n        params: IFieldFilterCreateParams\n    ): null | IFieldFilterCreateResult | IFieldFilterCreateResult[];\n}\n\nexport interface IFieldFilterCreateRegistry {\n    register(fieldType: string, handler: IFieldFilterCreateHandler): void;\n    get(fieldType: string): IFieldFilterCreateHandler | undefined;\n    getDefault(): IFieldFilterCreateHandler;\n}\n\nexport const FieldFilterCreateRegistry = new Abstraction<IFieldFilterCreateRegistry>(\n    \"Cms/Storage/FieldFilterCreateRegistry\"\n);\n\nexport namespace FieldFilterCreateRegistry {\n    export type Interface = IFieldFilterCreateRegistry;\n    export type Handler = IFieldFilterCreateHandler;\n    export type Params = IFieldFilterCreateParams;\n    export type Result = IFieldFilterCreateResult;\n}\n"],"names":["FieldFilterCreateRegistry","Abstraction"],"mappings":";AAyCO,MAAMA,4BAA4B,IAAIC,YACzC"}

package/dist/features/fieldFilterPath/FieldFilterPathRegistry.d.ts

@@ -0,0 +1,6 @@
+import type { FieldFilterPathRegistry } from "./abstractions.js";
+export declare class FieldFilterPathRegistryImpl implements FieldFilterPathRegistry.Interface {
+    private readonly handlers;
+    register(fieldType: string, handler: FieldFilterPathRegistry.Handler): void;
+    get(fieldType: string): FieldFilterPathRegistry.Handler | undefined;
+}

package/dist/features/fieldFilterPath/FieldFilterPathRegistry.js

@@ -0,0 +1,14 @@
+class FieldFilterPathRegistryImpl {
+    register(fieldType, handler) {
+        this.handlers.set(fieldType, handler);
+    }
+    get(fieldType) {
+        return this.handlers.get(fieldType);
+    }
+    constructor(){
+        this.handlers = new Map();
+    }
+}
+export { FieldFilterPathRegistryImpl };
+
+//# sourceMappingURL=FieldFilterPathRegistry.js.map

package/dist/features/fieldFilterPath/FieldFilterPathRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/fieldFilterPath/FieldFilterPathRegistry.js","sources":["../../../src/features/fieldFilterPath/FieldFilterPathRegistry.ts"],"sourcesContent":["import type { FieldFilterPathRegistry } from \"./abstractions.js\";\n\nexport class FieldFilterPathRegistryImpl implements FieldFilterPathRegistry.Interface {\n    private readonly handlers = new Map<string, FieldFilterPathRegistry.Handler>();\n\n    public register(fieldType: string, handler: FieldFilterPathRegistry.Handler): void {\n        this.handlers.set(fieldType, handler);\n    }\n\n    public get(fieldType: string): FieldFilterPathRegistry.Handler | undefined {\n        return this.handlers.get(fieldType);\n    }\n}\n"],"names":["FieldFilterPathRegistryImpl","fieldType","handler","Map"],"mappings":"AAEO,MAAMA;IAGF,SAASC,SAAiB,EAAEC,OAAwC,EAAQ;QAC/E,IAAI,CAAC,QAAQ,CAAC,GAAG,CAACD,WAAWC;IACjC;IAEO,IAAID,SAAiB,EAA+C;QACvE,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAACA;IAC7B;;aARiB,QAAQ,GAAG,IAAIE;;AASpC"}

package/dist/features/fieldFilterPath/abstractions.d.ts

@@ -0,0 +1,16 @@
+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 declare const FieldFilterPathRegistry: Abstraction<IFieldFilterPathRegistry>;
+export declare namespace FieldFilterPathRegistry {
+    type Interface = IFieldFilterPathRegistry;
+    type Handler = IFieldFilterPathHandler;
+}

package/dist/features/fieldFilterPath/abstractions.js

@@ -0,0 +1,5 @@
+import { Abstraction } from "@webiny/di";
+const FieldFilterPathRegistry = new Abstraction("Cms/Storage/FieldFilterPathRegistry");
+export { FieldFilterPathRegistry };
+
+//# sourceMappingURL=abstractions.js.map

package/dist/features/fieldFilterPath/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/fieldFilterPath/abstractions.js","sources":["../../../src/features/fieldFilterPath/abstractions.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\nimport type { CmsModelField } from \"@webiny/api-headless-cms/types/index.js\";\nimport type { CreatePathCallableParams } from \"../../plugins/CmsEntryFieldFilterPathPlugin.js\";\n\nexport interface IFieldFilterPathHandler {\n    canUse(field: Pick<CmsModelField, \"fieldId\" | \"type\">, parents: string[]): boolean;\n    createPath(params: CreatePathCallableParams): string;\n}\n\nexport interface IFieldFilterPathRegistry {\n    register(fieldType: string, handler: IFieldFilterPathHandler): void;\n    get(fieldType: string): IFieldFilterPathHandler | undefined;\n}\n\nexport const FieldFilterPathRegistry = new Abstraction<IFieldFilterPathRegistry>(\n    \"Cms/Storage/FieldFilterPathRegistry\"\n);\n\nexport namespace FieldFilterPathRegistry {\n    export type Interface = IFieldFilterPathRegistry;\n    export type Handler = IFieldFilterPathHandler;\n}\n"],"names":["FieldFilterPathRegistry","Abstraction"],"mappings":";AAcO,MAAMA,0BAA0B,IAAIC,YACvC"}

package/dist/features/fieldFilterValueTransform/FieldFilterValueTransformRegistry.d.ts

@@ -0,0 +1,6 @@
+import type { FieldFilterValueTransformRegistry } from "./abstractions.js";
+export declare class FieldFilterValueTransformRegistryImpl implements FieldFilterValueTransformRegistry.Interface {
+    private readonly handlers;
+    register(fieldType: string, handler: FieldFilterValueTransformRegistry.Handler): void;
+    get(fieldType: string): FieldFilterValueTransformRegistry.Handler | undefined;
+}

package/dist/features/fieldFilterValueTransform/FieldFilterValueTransformRegistry.js

@@ -0,0 +1,14 @@
+class FieldFilterValueTransformRegistryImpl {
+    register(fieldType, handler) {
+        this.handlers.set(fieldType, handler);
+    }
+    get(fieldType) {
+        return this.handlers.get(fieldType);
+    }
+    constructor(){
+        this.handlers = new Map();
+    }
+}
+export { FieldFilterValueTransformRegistryImpl };
+
+//# sourceMappingURL=FieldFilterValueTransformRegistry.js.map

package/dist/features/fieldFilterValueTransform/FieldFilterValueTransformRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/fieldFilterValueTransform/FieldFilterValueTransformRegistry.js","sources":["../../../src/features/fieldFilterValueTransform/FieldFilterValueTransformRegistry.ts"],"sourcesContent":["import type { FieldFilterValueTransformRegistry } from \"./abstractions.js\";\n\nexport class FieldFilterValueTransformRegistryImpl\n    implements FieldFilterValueTransformRegistry.Interface\n{\n    private readonly handlers = new Map<string, FieldFilterValueTransformRegistry.Handler>();\n\n    public register(fieldType: string, handler: FieldFilterValueTransformRegistry.Handler): void {\n        this.handlers.set(fieldType, handler);\n    }\n\n    public get(fieldType: string): FieldFilterValueTransformRegistry.Handler | undefined {\n        return this.handlers.get(fieldType);\n    }\n}\n"],"names":["FieldFilterValueTransformRegistryImpl","fieldType","handler","Map"],"mappings":"AAEO,MAAMA;IAKF,SAASC,SAAiB,EAAEC,OAAkD,EAAQ;QACzF,IAAI,CAAC,QAAQ,CAAC,GAAG,CAACD,WAAWC;IACjC;IAEO,IAAID,SAAiB,EAAyD;QACjF,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAACA;IAC7B;;aARiB,QAAQ,GAAG,IAAIE;;AASpC"}

package/dist/features/fieldFilterValueTransform/abstractions.d.ts

@@ -0,0 +1,14 @@
+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 declare const FieldFilterValueTransformRegistry: Abstraction<IFieldFilterValueTransformRegistry>;
+export declare namespace FieldFilterValueTransformRegistry {
+    type Interface = IFieldFilterValueTransformRegistry;
+    type Handler = IFieldFilterValueTransformHandler;
+}

package/dist/features/fieldFilterValueTransform/abstractions.js

@@ -0,0 +1,5 @@
+import { Abstraction } from "@webiny/di";
+const FieldFilterValueTransformRegistry = new Abstraction("Cms/Storage/FieldFilterValueTransformRegistry");
+export { FieldFilterValueTransformRegistry };
+
+//# sourceMappingURL=abstractions.js.map

package/dist/features/fieldFilterValueTransform/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/fieldFilterValueTransform/abstractions.js","sources":["../../../src/features/fieldFilterValueTransform/abstractions.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\nimport type { CmsFieldFilterValueTransformParams } from \"../../plugins/CmsFieldFilterValueTransformPlugin.js\";\n\nexport interface IFieldFilterValueTransformHandler {\n    transform(params: CmsFieldFilterValueTransformParams): any;\n}\n\nexport interface IFieldFilterValueTransformRegistry {\n    register(fieldType: string, handler: IFieldFilterValueTransformHandler): void;\n    get(fieldType: string): IFieldFilterValueTransformHandler | undefined;\n}\n\nexport const FieldFilterValueTransformRegistry =\n    new Abstraction<IFieldFilterValueTransformRegistry>(\n        \"Cms/Storage/FieldFilterValueTransformRegistry\"\n    );\n\nexport namespace FieldFilterValueTransformRegistry {\n    export type Interface = IFieldFilterValueTransformRegistry;\n    export type Handler = IFieldFilterValueTransformHandler;\n}\n"],"names":["FieldFilterValueTransformRegistry","Abstraction"],"mappings":";AAYO,MAAMA,oCACT,IAAIC,YACA"}

package/dist/features/fieldSorting/FieldSortingRegistry.d.ts

@@ -0,0 +1,6 @@
+import type { FieldSortingRegistry } from "./abstractions.js";
+export declare class FieldSortingRegistryImpl implements FieldSortingRegistry.Interface {
+    private readonly handlers;
+    register(handler: FieldSortingRegistry.Handler): void;
+    find(params: FieldSortingRegistry.CanUseParams): FieldSortingRegistry.Handler | undefined;
+}

package/dist/features/fieldSorting/FieldSortingRegistry.js

@@ -0,0 +1,14 @@
+class FieldSortingRegistryImpl {
+    register(handler) {
+        this.handlers.push(handler);
+    }
+    find(params) {
+        for(let i = this.handlers.length - 1; i >= 0; i--)if (this.handlers[i].canUse(params)) return this.handlers[i];
+    }
+    constructor(){
+        this.handlers = [];
+    }
+}
+export { FieldSortingRegistryImpl };
+
+//# sourceMappingURL=FieldSortingRegistry.js.map

package/dist/features/fieldSorting/FieldSortingRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/fieldSorting/FieldSortingRegistry.js","sources":["../../../src/features/fieldSorting/FieldSortingRegistry.ts"],"sourcesContent":["import type { FieldSortingRegistry } from \"./abstractions.js\";\n\nexport class FieldSortingRegistryImpl implements FieldSortingRegistry.Interface {\n    private readonly handlers: FieldSortingRegistry.Handler[] = [];\n\n    public register(handler: FieldSortingRegistry.Handler): void {\n        this.handlers.push(handler);\n    }\n\n    public find(\n        params: FieldSortingRegistry.CanUseParams\n    ): FieldSortingRegistry.Handler | undefined {\n        for (let i = this.handlers.length - 1; i >= 0; i--) {\n            if (this.handlers[i].canUse(params)) {\n                return this.handlers[i];\n            }\n        }\n        return undefined;\n    }\n}\n"],"names":["FieldSortingRegistryImpl","handler","params","i"],"mappings":"AAEO,MAAMA;IAGF,SAASC,OAAqC,EAAQ;QACzD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAACA;IACvB;IAEO,KACHC,MAAyC,EACD;QACxC,IAAK,IAAIC,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,GAAGA,KAAK,GAAGA,IAC3C,IAAI,IAAI,CAAC,QAAQ,CAACA,EAAE,CAAC,MAAM,CAACD,SACxB,OAAO,IAAI,CAAC,QAAQ,CAACC,EAAE;IAInC;;aAfiB,QAAQ,GAAmC,EAAE;;AAgBlE"}