@webiny/api-headless-cms-storage 0.0.0-unstable.0d717d18dd

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @webiny/api-headless-cms-storage
+
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/cms/storageHelpers.d.ts

@@ -0,0 +1,9 @@
+import type { CmsEntry, CmsEntryUniqueValue, CmsEntryValues, CmsModel, StorageOperationsCmsModel } from "@webiny/api-headless-cms/types/index.js";
+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: (container: Container) => {
+    getModel: <T extends CmsEntryValues = CmsEntryValues>(model: CmsModel) => StorageOperationsCmsModel<T>;
+};
+export declare const createStorageTransformCallable: (storageTransformRegistry: StorageTransformRegistry.Interface, model: StorageOperationsCmsModel) => FilterItemFromStorage;
+export declare const aggregateUniqueFieldValues: <T extends CmsEntryValues = CmsEntryValues>(items: CmsEntry<T>[], fieldId: string) => CmsEntryUniqueValue[];

package/cms/storageHelpers.js

@@ -0,0 +1,45 @@
+import { CmsStorageModelProvider } from "@webiny/api-headless-cms/features/shared/abstractions.js";
+import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
+const createStorageModelAccessor = (container)=>{
+    let cached;
+    const getProvider = ()=>{
+        if (!cached) cached = container.resolve(CmsStorageModelProvider);
+        return cached;
+    };
+    const getModel = (model)=>getProvider().getModel(model);
+    return {
+        getModel
+    };
+};
+const createStorageTransformCallable = (storageTransformRegistry, model)=>async (field, value)=>{
+        const fieldType = getBaseFieldType(field);
+        const storageTransform = storageTransformRegistry.get(fieldType);
+        if (!storageTransform) return value;
+        const result = await storageTransform.fromStorage({
+            model,
+            field,
+            value,
+            getStorageTransform (ft) {
+                return storageTransformRegistry.get(ft) || storageTransformRegistry.get("*");
+            }
+        });
+        return result;
+    };
+const aggregateUniqueFieldValues = (items, fieldId)=>{
+    const result = {};
+    for (const item of items){
+        const fieldValue = item.values[fieldId];
+        if (null == fieldValue) continue;
+        const values = Array.isArray(fieldValue) ? fieldValue : [
+            fieldValue
+        ];
+        if (0 !== values.length) 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);
+};
+export { aggregateUniqueFieldValues, createStorageModelAccessor, createStorageTransformCallable };
+
+//# sourceMappingURL=storageHelpers.js.map

package/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/features/FilterRegistriesFeature.d.ts

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

package/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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"}

package/features/fieldSorting/abstractions.d.ts

@@ -0,0 +1,40 @@
+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 declare const FieldSortingRegistry: Abstraction<IFieldSortingRegistry>;
+export declare namespace FieldSortingRegistry {
+    type Interface = IFieldSortingRegistry;
+    type Handler = IFieldSortingHandler;
+    type CanUseParams = IFieldSortingCanUseParams;
+    type CreateParams = IFieldSortingCreateParams;
+    type Result = IFieldSortingResult;
+}

package/features/fieldSorting/abstractions.js

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

package/features/fieldSorting/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/fieldSorting/abstractions.js","sources":["../../../src/features/fieldSorting/abstractions.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\nimport type { Field } from \"../../filtering/fields/types.js\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\n\nexport interface IFieldSortingCanUseParams {\n    model: CmsModel;\n    field?: Field;\n    fieldId: string;\n    order: \"ASC\" | \"DESC\";\n    sortBy: string;\n}\n\nexport interface IFieldSortingCreateParams {\n    model: CmsModel;\n    fieldId: string;\n    order: \"ASC\" | \"DESC\";\n    sortBy: string;\n    fields: Record<string, Field>;\n    field?: Field;\n}\n\nexport interface IFieldSortingResult {\n    valuePath: string;\n    reverse: boolean;\n    fieldId: string;\n    field: Field;\n}\n\nexport interface IFieldSortingHandler {\n    canUse(params: IFieldSortingCanUseParams): boolean;\n    createSort(params: IFieldSortingCreateParams): IFieldSortingResult;\n}\n\nexport interface IFieldSortingRegistry {\n    register(handler: IFieldSortingHandler): void;\n    find(params: IFieldSortingCanUseParams): IFieldSortingHandler | undefined;\n}\n\nexport const FieldSortingRegistry = new Abstraction<IFieldSortingRegistry>(\n    \"Cms/Storage/FieldSortingRegistry\"\n);\n\nexport namespace FieldSortingRegistry {\n    export type Interface = IFieldSortingRegistry;\n    export type Handler = IFieldSortingHandler;\n    export type CanUseParams = IFieldSortingCanUseParams;\n    export type CreateParams = IFieldSortingCreateParams;\n    export type Result = IFieldSortingResult;\n}\n"],"names":["FieldSortingRegistry","Abstraction"],"mappings":";AAsCO,MAAMA,uBAAuB,IAAIC,YACpC"}

package/filtering/expressions/createExpressions.d.ts

@@ -0,0 +1,29 @@
+import type { CmsEntryListWhere } from "@webiny/api-headless-cms/types/index.js";
+import type { Field } from "../fields/types.js";
+import { ValueFilter, ValueFilterRegistry } from "@webiny/db-utils";
+import type { FieldFilterCreateRegistry } from "../../features/fieldFilterCreate/abstractions.js";
+import type { FieldFilterValueTransformRegistry } from "../../features/fieldFilterValueTransform/abstractions.js";
+interface ICreateExpressionsParams {
+    filterCreateRegistry: FieldFilterCreateRegistry.Interface;
+    transformRegistry: FieldFilterValueTransformRegistry.Interface;
+    valueFilterRegistry: ValueFilterRegistry.Interface;
+    where: Partial<CmsEntryListWhere>;
+    fields: Record<string, Field>;
+}
+export type ExpressionCondition = "AND" | "OR";
+export interface Expression {
+    expressions: Expression[];
+    filters: Filter[];
+    condition: ExpressionCondition;
+}
+export interface Filter {
+    field: Field;
+    path: string;
+    fieldPathId: string;
+    filter: ValueFilter.Interface;
+    negate: boolean;
+    compareValue: any;
+    transformValue: <I = any, O = any>(value: I) => O;
+}
+export declare const createExpressions: (params: ICreateExpressionsParams) => Expression;
+export {};

package/filtering/expressions/createExpressions.js

@@ -0,0 +1,109 @@
+import error from "@webiny/error";
+import { extractWhereParams } from "../where.js";
+import { transformValue } from "../transform.js";
+import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
+import { getWhereValues } from "../values.js";
+const createExpressions = (params)=>{
+    const { where, filterCreateRegistry, transformRegistry, fields, valueFilterRegistry } = params;
+    const getHandler = (type)=>{
+        const fieldType = getBaseFieldType({
+            type
+        });
+        const handler = filterCreateRegistry.get(fieldType) || filterCreateRegistry.getDefault();
+        if (handler) return handler;
+        throw new error(`There is no filter create handler for the field type "${fieldType}".`, "MISSING_FILTER_CREATE_HANDLER", {
+            fieldType
+        });
+    };
+    const createExpression = ({ where, condition })=>{
+        const expression = {
+            filters: [],
+            expressions: [],
+            condition
+        };
+        for(const key in where){
+            const value = where[key];
+            if (void 0 === value) continue;
+            if ("AND" === key) {
+                const childWhereList = getWhereValues(value, key);
+                const childExpression = {
+                    condition: "AND",
+                    filters: [],
+                    expressions: []
+                };
+                for (const childWhere of childWhereList){
+                    const result = createExpression({
+                        where: childWhere,
+                        condition: "AND"
+                    });
+                    childExpression.expressions.push(result);
+                }
+                expression.expressions.push(childExpression);
+                continue;
+            }
+            if ("OR" === key) {
+                const childWhereList = getWhereValues(value, key);
+                const childExpression = {
+                    condition: "OR",
+                    filters: [],
+                    expressions: []
+                };
+                for (const childWhere of childWhereList){
+                    const result = createExpression({
+                        where: childWhere,
+                        condition: "AND"
+                    });
+                    childExpression.expressions.push(result);
+                }
+                expression.expressions.push(childExpression);
+                continue;
+            }
+            const whereParams = extractWhereParams(key);
+            if (!whereParams) continue;
+            const { fieldId, operation, negate } = whereParams;
+            const field = fields[fieldId];
+            if (!field) throw new error(`There is no field with the fieldId "${fieldId}".`, "FIELD_ERROR", {
+                fieldId
+            });
+            const handler = getHandler(field.type);
+            const fieldType = getBaseFieldType(field);
+            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 || Array.isArray(result) && 0 === result.length)) expression.filters.push(...Array.isArray(result) ? result : [
+                result
+            ]);
+        }
+        return expression;
+    };
+    const expression = createExpression({
+        where,
+        condition: "AND"
+    });
+    if (expression.filters.length > 0 || 1 !== expression.expressions.length) return expression;
+    return expression.expressions[0];
+};
+export { createExpressions };
+
+//# sourceMappingURL=createExpressions.js.map

package/filtering/expressions/createExpressions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filtering/expressions/createExpressions.js","sources":["../../../src/filtering/expressions/createExpressions.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { CmsEntryListWhere } from \"@webiny/api-headless-cms/types/index.js\";\nimport type { Field } from \"../fields/types.js\";\nimport { extractWhereParams } from \"../where.js\";\nimport { transformValue } from \"../transform.js\";\nimport { getBaseFieldType } from \"@webiny/api-headless-cms/utils/getBaseFieldType.js\";\nimport { ValueFilter, ValueFilterRegistry } from \"@webiny/db-utils\";\nimport type { FieldFilterCreateRegistry } from \"../../features/fieldFilterCreate/abstractions.js\";\nimport type { FieldFilterValueTransformRegistry } from \"../../features/fieldFilterValueTransform/abstractions.js\";\nimport { getWhereValues } from \"../values.js\";\n\ninterface CreateExpressionParams {\n    where: Partial<CmsEntryListWhere>;\n    condition: ExpressionCondition;\n}\n\ninterface ICreateExpressionsParams {\n    filterCreateRegistry: FieldFilterCreateRegistry.Interface;\n    transformRegistry: FieldFilterValueTransformRegistry.Interface;\n    valueFilterRegistry: ValueFilterRegistry.Interface;\n    where: Partial<CmsEntryListWhere>;\n    fields: Record<string, Field>;\n}\n\nexport type ExpressionCondition = \"AND\" | \"OR\";\n\nexport interface Expression {\n    expressions: Expression[];\n    filters: Filter[];\n    condition: ExpressionCondition;\n}\n\nexport interface Filter {\n    field: Field;\n    path: string;\n    fieldPathId: string;\n    filter: ValueFilter.Interface;\n    negate: boolean;\n    compareValue: any;\n    transformValue: <I = any, O = any>(value: I) => O;\n}\n\nexport const createExpressions = (params: ICreateExpressionsParams): Expression => {\n    const { where, filterCreateRegistry, transformRegistry, fields, valueFilterRegistry } = params;\n\n    const getHandler = (type: string) => {\n        const fieldType = getBaseFieldType({ type });\n        const handler = filterCreateRegistry.get(fieldType) || filterCreateRegistry.getDefault();\n        if (handler) {\n            return handler;\n        }\n        throw new WebinyError(\n            `There is no filter create handler for the field type \"${fieldType}\".`,\n            \"MISSING_FILTER_CREATE_HANDLER\",\n            { fieldType }\n        );\n    };\n\n    const createExpression = ({ where, condition }: CreateExpressionParams): Expression => {\n        const expression: Expression = {\n            filters: [],\n            expressions: [],\n            condition\n        };\n\n        for (const key in where) {\n            const value = where[key as keyof typeof where];\n            if (value === undefined) {\n                continue;\n            }\n\n            if (key === \"AND\") {\n                const childWhereList = getWhereValues(value, key);\n                const childExpression: Expression = {\n                    condition: \"AND\",\n                    filters: [],\n                    expressions: []\n                };\n                for (const childWhere of childWhereList) {\n                    const result = createExpression({\n                        where: childWhere,\n                        condition: \"AND\"\n                    });\n                    childExpression.expressions.push(result);\n                }\n                expression.expressions.push(childExpression);\n                continue;\n            }\n            if (key === \"OR\") {\n                const childWhereList = getWhereValues(value, key);\n                const childExpression: Expression = {\n                    condition: \"OR\",\n                    filters: [],\n                    expressions: []\n                };\n                for (const childWhere of childWhereList) {\n                    const result = createExpression({\n                        where: childWhere,\n                        condition: \"AND\"\n                    });\n                    childExpression.expressions.push(result);\n                }\n                expression.expressions.push(childExpression);\n                continue;\n            }\n\n            const whereParams = extractWhereParams(key);\n            if (!whereParams) {\n                continue;\n            }\n\n            const { fieldId, operation, negate } = whereParams;\n\n            const field = fields[fieldId];\n            if (!field) {\n                throw new WebinyError(\n                    `There is no field with the fieldId \"${fieldId}\".`,\n                    \"FIELD_ERROR\",\n                    { fieldId }\n                );\n            }\n\n            const handler = getHandler(field.type);\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 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\n            if (!result || (Array.isArray(result) && result.length === 0)) {\n                continue;\n            }\n\n            expression.filters.push(...(Array.isArray(result) ? result : [result]));\n        }\n\n        return expression;\n    };\n\n    const expression = createExpression({\n        where,\n        condition: \"AND\"\n    });\n\n    if (expression.filters.length > 0 || expression.expressions.length !== 1) {\n        return expression;\n    }\n    return expression.expressions[0];\n};\n"],"names":["createExpressions","params","where","filterCreateRegistry","transformRegistry","fields","valueFilterRegistry","getHandler","type","fieldType","getBaseFieldType","handler","WebinyError","createExpression","condition","expression","key","value","undefined","childWhereList","getWhereValues","childExpression","childWhere","result","whereParams","extractWhereParams","fieldId","operation","negate","field","transformHandler","transformValueCallable","transformValue","Array"],"mappings":";;;;;AA0CO,MAAMA,oBAAoB,CAACC;IAC9B,MAAM,EAAEC,KAAK,EAAEC,oBAAoB,EAAEC,iBAAiB,EAAEC,MAAM,EAAEC,mBAAmB,EAAE,GAAGL;IAExF,MAAMM,aAAa,CAACC;QAChB,MAAMC,YAAYC,iBAAiB;YAAEF;QAAK;QAC1C,MAAMG,UAAUR,qBAAqB,GAAG,CAACM,cAAcN,qBAAqB,UAAU;QACtF,IAAIQ,SACA,OAAOA;QAEX,MAAM,IAAIC,MACN,CAAC,sDAAsD,EAAEH,UAAU,EAAE,CAAC,EACtE,iCACA;YAAEA;QAAU;IAEpB;IAEA,MAAMI,mBAAmB,CAAC,EAAEX,KAAK,EAAEY,SAAS,EAA0B;QAClE,MAAMC,aAAyB;YAC3B,SAAS,EAAE;YACX,aAAa,EAAE;YACfD;QACJ;QAEA,IAAK,MAAME,OAAOd,MAAO;YACrB,MAAMe,QAAQf,KAAK,CAACc,IAA0B;YAC9C,IAAIC,AAAUC,WAAVD,OACA;YAGJ,IAAID,AAAQ,UAARA,KAAe;gBACf,MAAMG,iBAAiBC,eAAeH,OAAOD;gBAC7C,MAAMK,kBAA8B;oBAChC,WAAW;oBACX,SAAS,EAAE;oBACX,aAAa,EAAE;gBACnB;gBACA,KAAK,MAAMC,cAAcH,eAAgB;oBACrC,MAAMI,SAASV,iBAAiB;wBAC5B,OAAOS;wBACP,WAAW;oBACf;oBACAD,gBAAgB,WAAW,CAAC,IAAI,CAACE;gBACrC;gBACAR,WAAW,WAAW,CAAC,IAAI,CAACM;gBAC5B;YACJ;YACA,IAAIL,AAAQ,SAARA,KAAc;gBACd,MAAMG,iBAAiBC,eAAeH,OAAOD;gBAC7C,MAAMK,kBAA8B;oBAChC,WAAW;oBACX,SAAS,EAAE;oBACX,aAAa,EAAE;gBACnB;gBACA,KAAK,MAAMC,cAAcH,eAAgB;oBACrC,MAAMI,SAASV,iBAAiB;wBAC5B,OAAOS;wBACP,WAAW;oBACf;oBACAD,gBAAgB,WAAW,CAAC,IAAI,CAACE;gBACrC;gBACAR,WAAW,WAAW,CAAC,IAAI,CAACM;gBAC5B;YACJ;YAEA,MAAMG,cAAcC,mBAAmBT;YACvC,IAAI,CAACQ,aACD;YAGJ,MAAM,EAAEE,OAAO,EAAEC,SAAS,EAAEC,MAAM,EAAE,GAAGJ;YAEvC,MAAMK,QAAQxB,MAAM,CAACqB,QAAQ;YAC7B,IAAI,CAACG,OACD,MAAM,IAAIjB,MACN,CAAC,oCAAoC,EAAEc,QAAQ,EAAE,CAAC,EAClD,eACA;gBAAEA;YAAQ;YAIlB,MAAMf,UAAUJ,WAAWsB,MAAM,IAAI;YACrC,MAAMpB,YAAYC,iBAAiBmB;YACnC,MAAMC,mBAAmB1B,kBAAkB,GAAG,CAACK;YAE/C,MAAMsB,yBAAyB,CAACd;gBAC5B,IAAI,CAACa,kBACD,OAAOb;gBAEX,OAAOa,iBAAiB,SAAS,CAAC;oBAAED;oBAAOZ;gBAAM;YACrD;YAEA,MAAMM,SAASZ,QAAQ,MAAM,CAAC;gBAC1BK;gBACAC;gBACAX;gBACAF;gBACAG;gBACAoB;gBACAC;gBACAC;gBACAxB;gBACA,cAAc2B,eAAe;oBACzBf;oBACA,WAAWc;gBACf;gBACA,gBAAgBA;YACpB;YAEA,KAAI,EAACR,UAAWU,MAAM,OAAO,CAACV,WAAWA,AAAkB,MAAlBA,OAAO,MAAM,AAAK,GAI3DR,WAAW,OAAO,CAAC,IAAI,IAAKkB,MAAM,OAAO,CAACV,UAAUA,SAAS;gBAACA;aAAO;QACzE;QAEA,OAAOR;IACX;IAEA,MAAMA,aAAaF,iBAAiB;QAChCX;QACA,WAAW;IACf;IAEA,IAAIa,WAAW,OAAO,CAAC,MAAM,GAAG,KAAKA,AAAkC,MAAlCA,WAAW,WAAW,CAAC,MAAM,EAC9D,OAAOA;IAEX,OAAOA,WAAW,WAAW,CAAC,EAAE;AACpC"}