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

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,9 @@
+/**
+ * The registries are mutable: extensions add their own handlers with `register()`. They are container
+ * scoped, so registering the feature once in the root still gives every request (child) container its
+ * own registries. A shared instance would collect every request's registrations.
+ */
+export declare const FilterRegistriesFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/FilterRegistriesFeature.js

@@ -0,0 +1,17 @@
+import { createFeature } from "@webiny/feature/api/index.js";
+import { DefaultFieldFilterPathRegistry } from "./fieldFilterPath/DefaultFieldFilterPathRegistry.js";
+import { DefaultFieldFilterValueTransformRegistry } from "./fieldFilterValueTransform/DefaultFieldFilterValueTransformRegistry.js";
+import { DefaultFieldFilterCreateRegistry } from "./fieldFilterCreate/DefaultFieldFilterCreateRegistry.js";
+import { DefaultFieldSortingRegistry } from "./fieldSorting/DefaultFieldSortingRegistry.js";
+const FilterRegistriesFeature = createFeature({
+    name: "cms.storage.filterRegistries",
+    register: (container)=>{
+        container.register(DefaultFieldFilterPathRegistry).inContainerScope();
+        container.register(DefaultFieldFilterValueTransformRegistry).inContainerScope();
+        container.register(DefaultFieldFilterCreateRegistry).inContainerScope();
+        container.register(DefaultFieldSortingRegistry).inContainerScope();
+    }
+});
+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 { DefaultFieldFilterPathRegistry } from \"./fieldFilterPath/DefaultFieldFilterPathRegistry.js\";\nimport { DefaultFieldFilterValueTransformRegistry } from \"./fieldFilterValueTransform/DefaultFieldFilterValueTransformRegistry.js\";\nimport { DefaultFieldFilterCreateRegistry } from \"./fieldFilterCreate/DefaultFieldFilterCreateRegistry.js\";\nimport { DefaultFieldSortingRegistry } from \"./fieldSorting/DefaultFieldSortingRegistry.js\";\n\n/**\n * The registries are mutable: extensions add their own handlers with `register()`. They are container\n * scoped, so registering the feature once in the root still gives every request (child) container its\n * own registries. A shared instance would collect every request's registrations.\n */\nexport const FilterRegistriesFeature = createFeature({\n    name: \"cms.storage.filterRegistries\",\n    register: container => {\n        container.register(DefaultFieldFilterPathRegistry).inContainerScope();\n        container.register(DefaultFieldFilterValueTransformRegistry).inContainerScope();\n        container.register(DefaultFieldFilterCreateRegistry).inContainerScope();\n        container.register(DefaultFieldSortingRegistry).inContainerScope();\n    }\n});\n"],"names":["FilterRegistriesFeature","createFeature","container","DefaultFieldFilterPathRegistry","DefaultFieldFilterValueTransformRegistry","DefaultFieldFilterCreateRegistry","DefaultFieldSortingRegistry"],"mappings":";;;;;AAWO,MAAMA,0BAA0BC,cAAc;IACjD,MAAM;IACN,UAAUC,CAAAA;QACNA,UAAU,QAAQ,CAACC,gCAAgC,gBAAgB;QACnED,UAAU,QAAQ,CAACE,0CAA0C,gBAAgB;QAC7EF,UAAU,QAAQ,CAACG,kCAAkC,gBAAgB;QACrEH,UAAU,QAAQ,CAACI,6BAA6B,gBAAgB;IACpE;AACJ"}

package/features/fieldFilterCreate/DefaultFieldFilterCreateRegistry.d.ts

@@ -0,0 +1,9 @@
+import { FieldFilterCreateRegistry } from "./abstractions.js";
+import { FieldFilterCreateRegistryImpl } from "./FieldFilterCreateRegistry.js";
+declare class DefaultFieldFilterCreateRegistryImpl extends FieldFilterCreateRegistryImpl implements FieldFilterCreateRegistry.Interface {
+    constructor();
+}
+export declare const DefaultFieldFilterCreateRegistry: typeof DefaultFieldFilterCreateRegistryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IFieldFilterCreateRegistry>;
+};
+export {};

package/features/fieldFilterCreate/DefaultFieldFilterCreateRegistry.js

@@ -0,0 +1,26 @@
+import { FieldFilterCreateRegistry } from "./abstractions.js";
+import { FieldFilterCreateRegistryImpl } from "./FieldFilterCreateRegistry.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";
+class DefaultFieldFilterCreateRegistryImpl extends FieldFilterCreateRegistryImpl {
+    constructor(){
+        super();
+        const defaultHandler = createDefaultFilterCreateHandler();
+        const refHandler = createRefFilterCreateHandler();
+        const objectHandler = createObjectFilterCreateHandler();
+        const searchableJsonHandler = createSearchableJsonFilterCreateHandler();
+        this.register("*", defaultHandler);
+        this.register("ref", refHandler);
+        this.register("object", objectHandler);
+        this.register("searchable-json", searchableJsonHandler);
+    }
+}
+const DefaultFieldFilterCreateRegistry = FieldFilterCreateRegistry.createImplementation({
+    implementation: DefaultFieldFilterCreateRegistryImpl,
+    dependencies: []
+});
+export { DefaultFieldFilterCreateRegistry };
+
+//# sourceMappingURL=DefaultFieldFilterCreateRegistry.js.map

package/features/fieldFilterCreate/DefaultFieldFilterCreateRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/fieldFilterCreate/DefaultFieldFilterCreateRegistry.js","sources":["../../../src/features/fieldFilterCreate/DefaultFieldFilterCreateRegistry.ts"],"sourcesContent":["import { FieldFilterCreateRegistry } from \"./abstractions.js\";\nimport { FieldFilterCreateRegistryImpl } from \"./FieldFilterCreateRegistry.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\nclass DefaultFieldFilterCreateRegistryImpl\n    extends FieldFilterCreateRegistryImpl\n    implements FieldFilterCreateRegistry.Interface\n{\n    public constructor() {\n        super();\n        const defaultHandler = createDefaultFilterCreateHandler();\n        const refHandler = createRefFilterCreateHandler();\n        const objectHandler = createObjectFilterCreateHandler();\n        const searchableJsonHandler = createSearchableJsonFilterCreateHandler();\n\n        this.register(\"*\", defaultHandler);\n        this.register(\"ref\", refHandler);\n        this.register(\"object\", objectHandler);\n        this.register(\"searchable-json\", searchableJsonHandler);\n    }\n}\n\nexport const DefaultFieldFilterCreateRegistry = FieldFilterCreateRegistry.createImplementation({\n    implementation: DefaultFieldFilterCreateRegistryImpl,\n    dependencies: []\n});\n"],"names":["DefaultFieldFilterCreateRegistryImpl","FieldFilterCreateRegistryImpl","defaultHandler","createDefaultFilterCreateHandler","refHandler","createRefFilterCreateHandler","objectHandler","createObjectFilterCreateHandler","searchableJsonHandler","createSearchableJsonFilterCreateHandler","DefaultFieldFilterCreateRegistry","FieldFilterCreateRegistry"],"mappings":";;;;;;AAOA,MAAMA,6CACMC;IAGR,aAAqB;QACjB,KAAK;QACL,MAAMC,iBAAiBC;QACvB,MAAMC,aAAaC;QACnB,MAAMC,gBAAgBC;QACtB,MAAMC,wBAAwBC;QAE9B,IAAI,CAAC,QAAQ,CAAC,KAAKP;QACnB,IAAI,CAAC,QAAQ,CAAC,OAAOE;QACrB,IAAI,CAAC,QAAQ,CAAC,UAAUE;QACxB,IAAI,CAAC,QAAQ,CAAC,mBAAmBE;IACrC;AACJ;AAEO,MAAME,mCAAmCC,0BAA0B,oBAAoB,CAAC;IAC3F,gBAAgBX;IAChB,cAAc,EAAE;AACpB"}

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/DefaultFieldFilterPathRegistry.d.ts

@@ -0,0 +1,9 @@
+import { FieldFilterPathRegistry } from "./abstractions.js";
+import { FieldFilterPathRegistryImpl } from "./FieldFilterPathRegistry.js";
+declare class DefaultFieldFilterPathRegistryImpl extends FieldFilterPathRegistryImpl implements FieldFilterPathRegistry.Interface {
+    constructor();
+}
+export declare const DefaultFieldFilterPathRegistry: typeof DefaultFieldFilterPathRegistryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IFieldFilterPathRegistry>;
+};
+export {};

package/features/fieldFilterPath/DefaultFieldFilterPathRegistry.js

@@ -0,0 +1,20 @@
+import { FieldFilterPathRegistry } from "./abstractions.js";
+import { FieldFilterPathRegistryImpl } from "./FieldFilterPathRegistry.js";
+import { createPlainObjectPathHandler } from "../../handlers/plainObjectPathHandler.js";
+import { createLocationFolderIdPathHandler } from "../../handlers/locationFolderIdPathHandler.js";
+class DefaultFieldFilterPathRegistryImpl extends FieldFilterPathRegistryImpl {
+    constructor(){
+        super();
+        const plainObjectHandler = createPlainObjectPathHandler();
+        const locationFolderIdHandler = createLocationFolderIdPathHandler();
+        this.register("plainObject", plainObjectHandler);
+        this.register("text", locationFolderIdHandler);
+    }
+}
+const DefaultFieldFilterPathRegistry = FieldFilterPathRegistry.createImplementation({
+    implementation: DefaultFieldFilterPathRegistryImpl,
+    dependencies: []
+});
+export { DefaultFieldFilterPathRegistry };
+
+//# sourceMappingURL=DefaultFieldFilterPathRegistry.js.map

package/features/fieldFilterPath/DefaultFieldFilterPathRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/fieldFilterPath/DefaultFieldFilterPathRegistry.js","sources":["../../../src/features/fieldFilterPath/DefaultFieldFilterPathRegistry.ts"],"sourcesContent":["import { FieldFilterPathRegistry } from \"./abstractions.js\";\nimport { FieldFilterPathRegistryImpl } from \"./FieldFilterPathRegistry.js\";\nimport { createPlainObjectPathHandler } from \"~/handlers/plainObjectPathHandler.js\";\nimport { createLocationFolderIdPathHandler } from \"~/handlers/locationFolderIdPathHandler.js\";\n\nclass DefaultFieldFilterPathRegistryImpl\n    extends FieldFilterPathRegistryImpl\n    implements FieldFilterPathRegistry.Interface\n{\n    public constructor() {\n        super();\n        const plainObjectHandler = createPlainObjectPathHandler();\n        const locationFolderIdHandler = createLocationFolderIdPathHandler();\n\n        this.register(\"plainObject\", plainObjectHandler);\n        this.register(\"text\", locationFolderIdHandler);\n    }\n}\n\nexport const DefaultFieldFilterPathRegistry = FieldFilterPathRegistry.createImplementation({\n    implementation: DefaultFieldFilterPathRegistryImpl,\n    dependencies: []\n});\n"],"names":["DefaultFieldFilterPathRegistryImpl","FieldFilterPathRegistryImpl","plainObjectHandler","createPlainObjectPathHandler","locationFolderIdHandler","createLocationFolderIdPathHandler","DefaultFieldFilterPathRegistry","FieldFilterPathRegistry"],"mappings":";;;;AAKA,MAAMA,2CACMC;IAGR,aAAqB;QACjB,KAAK;QACL,MAAMC,qBAAqBC;QAC3B,MAAMC,0BAA0BC;QAEhC,IAAI,CAAC,QAAQ,CAAC,eAAeH;QAC7B,IAAI,CAAC,QAAQ,CAAC,QAAQE;IAC1B;AACJ;AAEO,MAAME,iCAAiCC,wBAAwB,oBAAoB,CAAC;IACvF,gBAAgBP;IAChB,cAAc,EAAE;AACpB"}

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/DefaultFieldFilterValueTransformRegistry.d.ts

@@ -0,0 +1,9 @@
+import { FieldFilterValueTransformRegistry } from "./abstractions.js";
+import { FieldFilterValueTransformRegistryImpl } from "./FieldFilterValueTransformRegistry.js";
+declare class DefaultFieldFilterValueTransformRegistryImpl extends FieldFilterValueTransformRegistryImpl implements FieldFilterValueTransformRegistry.Interface {
+    constructor();
+}
+export declare const DefaultFieldFilterValueTransformRegistry: typeof DefaultFieldFilterValueTransformRegistryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IFieldFilterValueTransformRegistry>;
+};
+export {};

package/features/fieldFilterValueTransform/DefaultFieldFilterValueTransformRegistry.js

@@ -0,0 +1,17 @@
+import { FieldFilterValueTransformRegistry } from "./abstractions.js";
+import { FieldFilterValueTransformRegistryImpl } from "./FieldFilterValueTransformRegistry.js";
+import { createDatetimeTransformHandler } from "../../handlers/datetimeTransformHandler.js";
+class DefaultFieldFilterValueTransformRegistryImpl extends FieldFilterValueTransformRegistryImpl {
+    constructor(){
+        super();
+        const datetimeHandler = createDatetimeTransformHandler();
+        this.register("datetime", datetimeHandler);
+    }
+}
+const DefaultFieldFilterValueTransformRegistry = FieldFilterValueTransformRegistry.createImplementation({
+    implementation: DefaultFieldFilterValueTransformRegistryImpl,
+    dependencies: []
+});
+export { DefaultFieldFilterValueTransformRegistry };
+
+//# sourceMappingURL=DefaultFieldFilterValueTransformRegistry.js.map

package/features/fieldFilterValueTransform/DefaultFieldFilterValueTransformRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/fieldFilterValueTransform/DefaultFieldFilterValueTransformRegistry.js","sources":["../../../src/features/fieldFilterValueTransform/DefaultFieldFilterValueTransformRegistry.ts"],"sourcesContent":["import { FieldFilterValueTransformRegistry } from \"./abstractions.js\";\nimport { FieldFilterValueTransformRegistryImpl } from \"./FieldFilterValueTransformRegistry.js\";\nimport { createDatetimeTransformHandler } from \"~/handlers/datetimeTransformHandler.js\";\n\nclass DefaultFieldFilterValueTransformRegistryImpl\n    extends FieldFilterValueTransformRegistryImpl\n    implements FieldFilterValueTransformRegistry.Interface\n{\n    public constructor() {\n        super();\n        const datetimeHandler = createDatetimeTransformHandler();\n\n        this.register(\"datetime\", datetimeHandler);\n    }\n}\n\nexport const DefaultFieldFilterValueTransformRegistry =\n    FieldFilterValueTransformRegistry.createImplementation({\n        implementation: DefaultFieldFilterValueTransformRegistryImpl,\n        dependencies: []\n    });\n"],"names":["DefaultFieldFilterValueTransformRegistryImpl","FieldFilterValueTransformRegistryImpl","datetimeHandler","createDatetimeTransformHandler","DefaultFieldFilterValueTransformRegistry","FieldFilterValueTransformRegistry"],"mappings":";;;AAIA,MAAMA,qDACMC;IAGR,aAAqB;QACjB,KAAK;QACL,MAAMC,kBAAkBC;QAExB,IAAI,CAAC,QAAQ,CAAC,YAAYD;IAC9B;AACJ;AAEO,MAAME,2CACTC,kCAAkC,oBAAoB,CAAC;IACnD,gBAAgBL;IAChB,cAAc,EAAE;AACpB"}

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/DefaultFieldSortingRegistry.d.ts

@@ -0,0 +1,8 @@
+import { FieldSortingRegistry } from "./abstractions.js";
+import { FieldSortingRegistryImpl } from "./FieldSortingRegistry.js";
+declare class DefaultFieldSortingRegistryImpl extends FieldSortingRegistryImpl implements FieldSortingRegistry.Interface {
+}
+export declare const DefaultFieldSortingRegistry: typeof DefaultFieldSortingRegistryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IFieldSortingRegistry>;
+};
+export {};

package/features/fieldSorting/DefaultFieldSortingRegistry.js

@@ -0,0 +1,11 @@
+import { FieldSortingRegistry } from "./abstractions.js";
+import { FieldSortingRegistryImpl } from "./FieldSortingRegistry.js";
+class DefaultFieldSortingRegistryImpl extends FieldSortingRegistryImpl {
+}
+const DefaultFieldSortingRegistry = FieldSortingRegistry.createImplementation({
+    implementation: DefaultFieldSortingRegistryImpl,
+    dependencies: []
+});
+export { DefaultFieldSortingRegistry };
+
+//# sourceMappingURL=DefaultFieldSortingRegistry.js.map

package/features/fieldSorting/DefaultFieldSortingRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/fieldSorting/DefaultFieldSortingRegistry.js","sources":["../../../src/features/fieldSorting/DefaultFieldSortingRegistry.ts"],"sourcesContent":["import { FieldSortingRegistry } from \"./abstractions.js\";\nimport { FieldSortingRegistryImpl } from \"./FieldSortingRegistry.js\";\n\nclass DefaultFieldSortingRegistryImpl\n    extends FieldSortingRegistryImpl\n    implements FieldSortingRegistry.Interface {}\n\nexport const DefaultFieldSortingRegistry = FieldSortingRegistry.createImplementation({\n    implementation: DefaultFieldSortingRegistryImpl,\n    dependencies: []\n});\n"],"names":["DefaultFieldSortingRegistryImpl","FieldSortingRegistryImpl","DefaultFieldSortingRegistry","FieldSortingRegistry"],"mappings":";;AAGA,MAAMA,wCACMC;AACmC;AAExC,MAAMC,8BAA8BC,qBAAqB,oBAAoB,CAAC;IACjF,gBAAgBH;IAChB,cAAc,EAAE;AACpB"}

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 {};