@webiny/db-dynamodb 0.0.0-unstable.6f45466a1d → 0.0.0-unstable.7be00a75a9

package/feature/FilterUtil/createFilters.js

@@ -0,0 +1,92 @@
+import { WebinyError } from "@webiny/error";
+import { extractWhereArgs } from "./extractWhereArgs.js";
+import * as __rspack_external_dot_prop_de53db47 from "dot-prop";
+const findFilter = (registry, operation)=>{
+    const filter = registry.get(operation);
+    if (filter) return filter;
+    throw new WebinyError("Missing filter plugin definition.", "FILTER_PLUGIN_ERROR", {
+        operation
+    });
+};
+const multiSearchFieldOperations = [
+    "contains",
+    "fuzzy"
+];
+const createFilters = (params)=>{
+    const { where, fields, filterRegistry } = params;
+    const keys = Object.keys(where);
+    if (0 === keys.length) return [];
+    return keys.reduce((filters, key)=>{
+        const compareValue = where[key];
+        if (void 0 === compareValue) return filters;
+        if (true === multiSearchFieldOperations.includes(key)) {
+            const data = compareValue;
+            let transformValue;
+            const paths = data.fields.map((field)=>{
+                const fieldPlugin = fields.find((plugin)=>plugin.getField() === field);
+                if (fieldPlugin) {
+                    transformValue = (value)=>fieldPlugin.transformValue(value);
+                    return fieldPlugin.getPath();
+                }
+                return field;
+            });
+            const filter = findFilter(filterRegistry, key);
+            filters.push({
+                operation: filter.operation,
+                compareValue: data.value,
+                filter,
+                transformValue,
+                paths,
+                negate: false
+            });
+            return filters;
+        }
+        const { field, operation, negate } = extractWhereArgs(key);
+        const filter = findFilter(filterRegistry, operation);
+        const fieldPlugin = fields.find((plugin)=>plugin.getField() === field);
+        let path = field;
+        let transformValue;
+        if (fieldPlugin) {
+            transformValue = (value)=>fieldPlugin.transformValue(value);
+            path = fieldPlugin.getPath();
+        }
+        filters.push({
+            operation: filter.operation,
+            compareValue,
+            filter,
+            transformValue,
+            paths: [
+                path
+            ],
+            negate
+        });
+        return filters;
+    }, []);
+};
+const transform = (value, transformValue)=>{
+    if (!transformValue) return value;
+    if (Array.isArray(value)) return value.map((v)=>transformValue(v));
+    return transformValue(value);
+};
+const createFilterCallable = (params)=>{
+    const filters = createFilters(params);
+    if (0 === filters.length) return null;
+    return (item)=>{
+        for (const filter of filters){
+            const result = filter.paths.some((path)=>{
+                const value = transform(__rspack_external_dot_prop_de53db47.getProperty(item, path), filter.transformValue);
+                const compareValue = transform(filter.compareValue, filter.transformValue);
+                const matched = filter.filter.matches({
+                    value,
+                    compareValue
+                });
+                return filter.negate ? !matched : matched;
+            });
+            if (false === result) return false;
+        }
+        return true;
+    };
+};
+export { createFilterCallable, createFilters };
+
+//# sourceMappingURL=createFilters.js.map

package/feature/FilterUtil/createFilters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature/FilterUtil/createFilters.js","sources":["../../../src/feature/FilterUtil/createFilters.ts"],"sourcesContent":["import * as dotProp from \"dot-prop\";\nimport { WebinyError } from \"@webiny/error\";\nimport type { FieldPlugin } from \"~/plugins/definitions/FieldPlugin.js\";\nimport type { DynamoDbContainsFilter } from \"~/types.js\";\nimport type { ValueFilter, ValueFilterRegistry } from \"~/feature/ValueFilter/index.js\";\nimport { extractWhereArgs } from \"./extractWhereArgs.js\";\n\ntype TransformValue = (value: any) => any;\n\ninterface Filter {\n    operation: string;\n    compareValue: any;\n    filter: ValueFilter.Interface;\n    transformValue?: TransformValue;\n    paths: string[];\n    negate: boolean;\n}\n\ninterface CreateFiltersParams {\n    filterRegistry: ValueFilterRegistry.Interface;\n    where: Record<string, any>;\n    fields: FieldPlugin[];\n}\n\nconst findFilter = (\n    registry: ValueFilterRegistry.Interface,\n    operation: string\n): ValueFilter.Interface => {\n    const filter = registry.get(operation);\n    if (filter) {\n        return filter;\n    }\n    throw new WebinyError(`Missing filter plugin definition.`, \"FILTER_PLUGIN_ERROR\", {\n        operation\n    });\n};\n\nconst multiSearchFieldOperations = [\"contains\", \"fuzzy\"];\n\nexport const createFilters = (params: CreateFiltersParams): Filter[] => {\n    const { where, fields, filterRegistry } = params;\n\n    const keys = Object.keys(where);\n    /**\n     * Skip everything if there are no conditions to be applied.\n     */\n    if (keys.length === 0) {\n        return [];\n    }\n\n    return keys.reduce((filters, key) => {\n        const compareValue = where[key];\n        if (compareValue === undefined) {\n            return filters;\n        }\n        /**\n         * @see DynamoDbContainsFilter\n         */\n        if (multiSearchFieldOperations.includes(key) === true) {\n            const data: DynamoDbContainsFilter = compareValue;\n            let transformValue: TransformValue | undefined = undefined;\n            const paths = data.fields.map(field => {\n                const fieldPlugin = fields.find(plugin => plugin.getField() === field);\n                if (fieldPlugin) {\n                    transformValue = (value: any) => {\n                        return fieldPlugin.transformValue(value);\n                    };\n                    return fieldPlugin.getPath();\n                }\n                return field;\n            });\n\n            const filter = findFilter(filterRegistry, key);\n            filters.push({\n                operation: filter.operation,\n                compareValue: data.value,\n                filter,\n                transformValue,\n                paths,\n                negate: false\n            });\n            return filters;\n        }\n\n        const { field, operation, negate } = extractWhereArgs(key);\n\n        const filter = findFilter(filterRegistry, operation);\n\n        const fieldPlugin = fields.find(plugin => plugin.getField() === field);\n        let path: string = field;\n        let transformValue: TransformValue | undefined = undefined;\n        if (fieldPlugin) {\n            transformValue = (value: any) => {\n                return fieldPlugin.transformValue(value);\n            };\n            path = fieldPlugin.getPath();\n        }\n\n        filters.push({\n            operation: filter.operation,\n            compareValue,\n            filter,\n            transformValue,\n            paths: [path],\n            negate\n        });\n\n        return filters;\n    }, [] as Filter[]);\n};\n\n/**\n * Transforms the value with given transformer callable.\n */\nconst transform = (value: any, transformValue?: TransformValue): any => {\n    if (!transformValue) {\n        return value;\n    }\n    if (Array.isArray(value)) {\n        return value.map(v => transformValue(v));\n    }\n    return transformValue(value);\n};\n\n/**\n * Creates a filter callable that we can send to the .filter() method of the array.\n */\nexport const createFilterCallable = (\n    params: CreateFiltersParams\n): ((item: any) => boolean) | null => {\n    const filters = createFilters(params);\n    /**\n     * Just return null so there are no filters to be applied.\n     * Later in the code we check for null so we do not loop through the items.\n     */\n    if (filters.length === 0) {\n        return null;\n    }\n\n    return (item: any) => {\n        for (const filter of filters) {\n            const result = filter.paths.some(path => {\n                const value = transform(dotProp.getProperty(item, path), filter.transformValue);\n                const compareValue = transform(filter.compareValue, filter.transformValue);\n                const matched = filter.filter.matches({\n                    value,\n                    compareValue\n                });\n\n                return filter.negate ? !matched : matched;\n            });\n            if (result === false) {\n                return false;\n            }\n        }\n        return true;\n    };\n};\n"],"names":["findFilter","registry","operation","filter","WebinyError","multiSearchFieldOperations","createFilters","params","where","fields","filterRegistry","keys","Object","filters","key","compareValue","undefined","data","transformValue","paths","field","fieldPlugin","plugin","value","negate","extractWhereArgs","path","transform","Array","v","createFilterCallable","item","result","dotProp","matched"],"mappings":";;;AAwBA,MAAMA,aAAa,CACfC,UACAC;IAEA,MAAMC,SAASF,SAAS,GAAG,CAACC;IAC5B,IAAIC,QACA,OAAOA;IAEX,MAAM,IAAIC,YAAY,qCAAqC,uBAAuB;QAC9EF;IACJ;AACJ;AAEA,MAAMG,6BAA6B;IAAC;IAAY;CAAQ;AAEjD,MAAMC,gBAAgB,CAACC;IAC1B,MAAM,EAAEC,KAAK,EAAEC,MAAM,EAAEC,cAAc,EAAE,GAAGH;IAE1C,MAAMI,OAAOC,OAAO,IAAI,CAACJ;IAIzB,IAAIG,AAAgB,MAAhBA,KAAK,MAAM,EACX,OAAO,EAAE;IAGb,OAAOA,KAAK,MAAM,CAAC,CAACE,SAASC;QACzB,MAAMC,eAAeP,KAAK,CAACM,IAAI;QAC/B,IAAIC,AAAiBC,WAAjBD,cACA,OAAOF;QAKX,IAAIR,AAA6C,SAA7CA,2BAA2B,QAAQ,CAACS,MAAe;YACnD,MAAMG,OAA+BF;YACrC,IAAIG;YACJ,MAAMC,QAAQF,KAAK,MAAM,CAAC,GAAG,CAACG,CAAAA;gBAC1B,MAAMC,cAAcZ,OAAO,IAAI,CAACa,CAAAA,SAAUA,OAAO,QAAQ,OAAOF;gBAChE,IAAIC,aAAa;oBACbH,iBAAiB,CAACK,QACPF,YAAY,cAAc,CAACE;oBAEtC,OAAOF,YAAY,OAAO;gBAC9B;gBACA,OAAOD;YACX;YAEA,MAAMjB,SAASH,WAAWU,gBAAgBI;YAC1CD,QAAQ,IAAI,CAAC;gBACT,WAAWV,OAAO,SAAS;gBAC3B,cAAcc,KAAK,KAAK;gBACxBd;gBACAe;gBACAC;gBACA,QAAQ;YACZ;YACA,OAAON;QACX;QAEA,MAAM,EAAEO,KAAK,EAAElB,SAAS,EAAEsB,MAAM,EAAE,GAAGC,iBAAiBX;QAEtD,MAAMX,SAASH,WAAWU,gBAAgBR;QAE1C,MAAMmB,cAAcZ,OAAO,IAAI,CAACa,CAAAA,SAAUA,OAAO,QAAQ,OAAOF;QAChE,IAAIM,OAAeN;QACnB,IAAIF;QACJ,IAAIG,aAAa;YACbH,iBAAiB,CAACK,QACPF,YAAY,cAAc,CAACE;YAEtCG,OAAOL,YAAY,OAAO;QAC9B;QAEAR,QAAQ,IAAI,CAAC;YACT,WAAWV,OAAO,SAAS;YAC3BY;YACAZ;YACAe;YACA,OAAO;gBAACQ;aAAK;YACbF;QACJ;QAEA,OAAOX;IACX,GAAG,EAAE;AACT;AAKA,MAAMc,YAAY,CAACJ,OAAYL;IAC3B,IAAI,CAACA,gBACD,OAAOK;IAEX,IAAIK,MAAM,OAAO,CAACL,QACd,OAAOA,MAAM,GAAG,CAACM,CAAAA,IAAKX,eAAeW;IAEzC,OAAOX,eAAeK;AAC1B;AAKO,MAAMO,uBAAuB,CAChCvB;IAEA,MAAMM,UAAUP,cAAcC;IAK9B,IAAIM,AAAmB,MAAnBA,QAAQ,MAAM,EACd,OAAO;IAGX,OAAO,CAACkB;QACJ,KAAK,MAAM5B,UAAUU,QAAS;YAC1B,MAAMmB,SAAS7B,OAAO,KAAK,CAAC,IAAI,CAACuB,CAAAA;gBAC7B,MAAMH,QAAQI,UAAUM,oCAAAA,WAAmB,CAACF,MAAML,OAAOvB,OAAO,cAAc;gBAC9E,MAAMY,eAAeY,UAAUxB,OAAO,YAAY,EAAEA,OAAO,cAAc;gBACzE,MAAM+B,UAAU/B,OAAO,MAAM,CAAC,OAAO,CAAC;oBAClCoB;oBACAR;gBACJ;gBAEA,OAAOZ,OAAO,MAAM,GAAG,CAAC+B,UAAUA;YACtC;YACA,IAAIF,AAAW,UAAXA,QACA,OAAO;QAEf;QACA,OAAO;IACX;AACJ"}

package/feature/FilterUtil/extractWhereArgs.d.ts

@@ -0,0 +1,7 @@
+interface ExtractWhereArgsResult {
+    field: string;
+    operation: string;
+    negate: boolean;
+}
+export declare const extractWhereArgs: (key: string) => ExtractWhereArgsResult;
+export {};

package/feature/FilterUtil/extractWhereArgs.js

@@ -0,0 +1,20 @@
+const extractWhereArgs = (key)=>{
+    const result = key.split("_");
+    const field = result.shift();
+    const rawOp = 0 === result.length ? "eq" : result.join("_");
+    if ("not" === rawOp) return {
+        field,
+        operation: "eq",
+        negate: true
+    };
+    const negate = null !== rawOp.match("not_");
+    const operation = rawOp.replace("not_", "");
+    return {
+        field,
+        operation,
+        negate
+    };
+};
+export { extractWhereArgs };
+
+//# sourceMappingURL=extractWhereArgs.js.map

package/feature/FilterUtil/extractWhereArgs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature/FilterUtil/extractWhereArgs.js","sources":["../../../src/feature/FilterUtil/extractWhereArgs.ts"],"sourcesContent":["interface ExtractWhereArgsResult {\n    field: string;\n    operation: string;\n    negate: boolean;\n}\n\nexport const extractWhereArgs = (key: string): ExtractWhereArgsResult => {\n    const result = key.split(\"_\");\n    const field = result.shift() as string;\n    const rawOp = result.length === 0 ? \"eq\" : result.join(\"_\");\n    /**\n     * When rawOp is not, it means it is equal negated so just return that.\n     */\n    if (rawOp === \"not\") {\n        return {\n            field,\n            operation: \"eq\",\n            negate: true\n        };\n    }\n    const negate = rawOp.match(\"not_\") !== null;\n    const operation = rawOp.replace(\"not_\", \"\");\n    return {\n        field,\n        operation,\n        negate\n    };\n};\n"],"names":["extractWhereArgs","key","result","field","rawOp","negate","operation"],"mappings":"AAMO,MAAMA,mBAAmB,CAACC;IAC7B,MAAMC,SAASD,IAAI,KAAK,CAAC;IACzB,MAAME,QAAQD,OAAO,KAAK;IAC1B,MAAME,QAAQF,AAAkB,MAAlBA,OAAO,MAAM,GAAS,OAAOA,OAAO,IAAI,CAAC;IAIvD,IAAIE,AAAU,UAAVA,OACA,OAAO;QACHD;QACA,WAAW;QACX,QAAQ;IACZ;IAEJ,MAAME,SAASD,AAAwB,SAAxBA,MAAM,KAAK,CAAC;IAC3B,MAAME,YAAYF,MAAM,OAAO,CAAC,QAAQ;IACxC,OAAO;QACHD;QACAG;QACAD;IACJ;AACJ"}

package/feature/FilterUtil/feature.d.ts

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

package/feature/FilterUtil/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { FilterUtil } from "./FilterUtil.js";
+const FilterUtilFeature = createFeature({
+    name: "Db/DynamoDB/FilterUtilFeature",
+    register: (container)=>{
+        container.register(FilterUtil);
+    }
+});
+export { FilterUtilFeature };
+
+//# sourceMappingURL=feature.js.map

package/feature/FilterUtil/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature/FilterUtil/feature.js","sources":["../../../src/feature/FilterUtil/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { FilterUtil } from \"./FilterUtil.js\";\n\nexport const FilterUtilFeature = createFeature({\n    name: \"Db/DynamoDB/FilterUtilFeature\",\n    register: container => {\n        container.register(FilterUtil);\n    }\n});\n"],"names":["FilterUtilFeature","createFeature","container","FilterUtil"],"mappings":";;AAGO,MAAMA,oBAAoBC,cAAc;IAC3C,MAAM;IACN,UAAUC,CAAAA;QACNA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/feature/FilterUtil/index.d.ts

@@ -0,0 +1,2 @@
+export { FilterUtil } from "./abstractions/FilterUtil.js";
+export { FilterUtilFeature } from "./feature.js";

package/feature/FilterUtil/index.js

@@ -0,0 +1,2 @@
+export { FilterUtil } from "./abstractions/FilterUtil.js";
+export { FilterUtilFeature } from "./feature.js";

package/feature/ValueFilter/ValueFilterRegistry.d.ts

@@ -0,0 +1,12 @@
+import { ValueFilterRegistry as Abstraction } from "./abstractions/ValueFilterRegistry.js";
+import { ValueFilter } from "./abstractions/ValueFilter.js";
+declare class ValueFilterRegistryImpl implements Abstraction.Interface {
+    private readonly filters;
+    constructor(filters: ValueFilter.Interface[]);
+    get(operation: string): ValueFilter.Interface | undefined;
+    getAll(): ValueFilter.Interface[];
+}
+export declare const ValueFilterRegistry: typeof ValueFilterRegistryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/ValueFilterRegistry.js").IValueFilterRegistry>;
+};
+export {};

package/feature/ValueFilter/ValueFilterRegistry.js

@@ -0,0 +1,27 @@
+import { ValueFilterRegistry } from "./abstractions/ValueFilterRegistry.js";
+import { ValueFilter } from "./abstractions/ValueFilter.js";
+class ValueFilterRegistryImpl {
+    constructor(filters){
+        this.filters = filters;
+    }
+    get(operation) {
+        return this.filters.find((filter)=>filter.is(operation));
+    }
+    getAll() {
+        return this.filters;
+    }
+}
+const ValueFilterRegistry_ValueFilterRegistry = ValueFilterRegistry.createImplementation({
+    implementation: ValueFilterRegistryImpl,
+    dependencies: [
+        [
+            ValueFilter,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { ValueFilterRegistry_ValueFilterRegistry as ValueFilterRegistry };
+
+//# sourceMappingURL=ValueFilterRegistry.js.map

package/feature/ValueFilter/ValueFilterRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature/ValueFilter/ValueFilterRegistry.js","sources":["../../../src/feature/ValueFilter/ValueFilterRegistry.ts"],"sourcesContent":["import { ValueFilterRegistry as Abstraction } from \"./abstractions/ValueFilterRegistry.js\";\nimport { ValueFilter } from \"./abstractions/ValueFilter.js\";\n\nclass ValueFilterRegistryImpl implements Abstraction.Interface {\n    public constructor(private readonly filters: ValueFilter.Interface[]) {}\n\n    public get(operation: string): ValueFilter.Interface | undefined {\n        return this.filters.find(filter => {\n            return filter.is(operation);\n        });\n    }\n\n    public getAll(): ValueFilter.Interface[] {\n        return this.filters;\n    }\n}\n\nexport const ValueFilterRegistry = Abstraction.createImplementation({\n    implementation: ValueFilterRegistryImpl,\n    dependencies: [[ValueFilter, { multiple: true }]]\n});\n"],"names":["ValueFilterRegistryImpl","filters","operation","filter","ValueFilterRegistry","Abstraction","ValueFilter"],"mappings":";;AAGA,MAAMA;IACF,YAAoCC,OAAgC,CAAE;aAAlCA,OAAO,GAAPA;IAAmC;IAEhE,IAAIC,SAAiB,EAAqC;QAC7D,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAACC,CAAAA,SACdA,OAAO,EAAE,CAACD;IAEzB;IAEO,SAAkC;QACrC,OAAO,IAAI,CAAC,OAAO;IACvB;AACJ;AAEO,MAAME,0CAAsBC,oBAAAA,oBAAgC,CAAC;IAChE,gBAAgBL;IAChB,cAAc;QAAC;YAACM;YAAa;gBAAE,UAAU;YAAK;SAAE;KAAC;AACrD"}

package/feature/ValueFilter/abstractions/ValueFilter.d.ts

@@ -0,0 +1,22 @@
+export interface IValueFilterCanUseParams<TValue = any, TCompareValue = any> {
+    value: TValue;
+    compareValue: TCompareValue;
+}
+export interface IValueFilterMatchesParams<TValue = any, TCompareValue = any> {
+    value: TValue;
+    compareValue: TCompareValue;
+}
+export type IValueFilterMatchesResult = boolean;
+export interface IValueFilter<TValue = any, TCompareValue = any> {
+    readonly operation: string;
+    is(operation: string): boolean;
+    canUse(params: IValueFilterCanUseParams): boolean;
+    matches(params: IValueFilterMatchesParams<TValue, TCompareValue>): IValueFilterMatchesResult;
+}
+export declare const ValueFilter: import("@webiny/di").Abstraction<IValueFilter<any, any>>;
+export declare namespace ValueFilter {
+    type Interface<TValue = any, TCompareValue = any> = IValueFilter<TValue, TCompareValue>;
+    type CanUseParams = IValueFilterCanUseParams;
+    type MatchesParams = IValueFilterMatchesParams;
+    type Result = IValueFilterMatchesResult;
+}

package/feature/ValueFilter/abstractions/ValueFilter.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ValueFilter = createAbstraction("Db/DynamoDB/ValueFilter");
+export { ValueFilter };
+
+//# sourceMappingURL=ValueFilter.js.map

package/feature/ValueFilter/abstractions/ValueFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature/ValueFilter/abstractions/ValueFilter.js","sources":["../../../../src/feature/ValueFilter/abstractions/ValueFilter.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface IValueFilterCanUseParams<TValue = any, TCompareValue = any> {\n    value: TValue;\n    compareValue: TCompareValue;\n}\n\nexport interface IValueFilterMatchesParams<TValue = any, TCompareValue = any> {\n    value: TValue;\n    compareValue: TCompareValue;\n}\n\nexport type IValueFilterMatchesResult = boolean;\n\nexport interface IValueFilter<TValue = any, TCompareValue = any> {\n    readonly operation: string;\n    is(operation: string): boolean;\n    canUse(params: IValueFilterCanUseParams): boolean;\n    matches(params: IValueFilterMatchesParams<TValue, TCompareValue>): IValueFilterMatchesResult;\n}\n\nexport const ValueFilter = createAbstraction<IValueFilter>(\"Db/DynamoDB/ValueFilter\");\n\nexport namespace ValueFilter {\n    export type Interface<TValue = any, TCompareValue = any> = IValueFilter<TValue, TCompareValue>;\n    export type CanUseParams = IValueFilterCanUseParams;\n    export type MatchesParams = IValueFilterMatchesParams;\n    export type Result = IValueFilterMatchesResult;\n}\n"],"names":["ValueFilter","createAbstraction"],"mappings":";AAqBO,MAAMA,cAAcC,kBAAgC"}

package/feature/ValueFilter/abstractions/ValueFilterRegistry.d.ts

@@ -0,0 +1,10 @@
+import type { ValueFilter } from "./ValueFilter.js";
+export interface IValueFilterRegistry {
+    get(operation: string): ValueFilter.Interface | undefined;
+    getAll(): ValueFilter.Interface[];
+}
+export declare const ValueFilterRegistry: import("@webiny/di").Abstraction<IValueFilterRegistry>;
+export declare namespace ValueFilterRegistry {
+    type Interface = IValueFilterRegistry;
+    type Filter = ValueFilter.Interface;
+}

package/feature/ValueFilter/abstractions/ValueFilterRegistry.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ValueFilterRegistry = createAbstraction("Db/DynamoDB/ValueFilterRegistry");
+export { ValueFilterRegistry };
+
+//# sourceMappingURL=ValueFilterRegistry.js.map

package/feature/ValueFilter/abstractions/ValueFilterRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature/ValueFilter/abstractions/ValueFilterRegistry.js","sources":["../../../../src/feature/ValueFilter/abstractions/ValueFilterRegistry.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { ValueFilter } from \"./ValueFilter.js\";\n\nexport interface IValueFilterRegistry {\n    get(operation: string): ValueFilter.Interface | undefined;\n    getAll(): ValueFilter.Interface[];\n}\n\nexport const ValueFilterRegistry = createAbstraction<IValueFilterRegistry>(\n    \"Db/DynamoDB/ValueFilterRegistry\"\n);\n\nexport namespace ValueFilterRegistry {\n    export type Interface = IValueFilterRegistry;\n    export type Filter = ValueFilter.Interface;\n}\n"],"names":["ValueFilterRegistry","createAbstraction"],"mappings":";AAQO,MAAMA,sBAAsBC,kBAC/B"}

package/feature/ValueFilter/feature.d.ts

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

package/feature/ValueFilter/feature.js

@@ -0,0 +1,33 @@
+import { createFeature } from "@webiny/feature/api";
+import { EqFilter } from "./filters/EqFilter.js";
+import { GtFilter } from "./filters/GtFilter.js";
+import { GteFilter } from "./filters/GteFilter.js";
+import { LtFilter } from "./filters/LtFilter.js";
+import { LteFilter } from "./filters/LteFilter.js";
+import { BetweenFilter } from "./filters/BetweenFilter.js";
+import { InFilter } from "./filters/InFilter.js";
+import { AndInFilter } from "./filters/AndInFilter.js";
+import { ContainsFilter } from "./filters/ContainsFilter.js";
+import { FuzzyFilter } from "./filters/FuzzyFilter.js";
+import { StartsWithFilter } from "./filters/StartsWithFilter.js";
+import { ValueFilterRegistry } from "./ValueFilterRegistry.js";
+const ValueFilterFeature = createFeature({
+    name: "Db/DynamoDB/ValueFilterFeature",
+    register: (container)=>{
+        container.register(EqFilter);
+        container.register(GtFilter);
+        container.register(GteFilter);
+        container.register(LtFilter);
+        container.register(LteFilter);
+        container.register(BetweenFilter);
+        container.register(InFilter);
+        container.register(AndInFilter);
+        container.register(ContainsFilter);
+        container.register(FuzzyFilter);
+        container.register(StartsWithFilter);
+        container.register(ValueFilterRegistry);
+    }
+});
+export { ValueFilterFeature };
+
+//# sourceMappingURL=feature.js.map

package/feature/ValueFilter/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature/ValueFilter/feature.js","sources":["../../../src/feature/ValueFilter/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { EqFilter } from \"./filters/EqFilter.js\";\nimport { GtFilter } from \"./filters/GtFilter.js\";\nimport { GteFilter } from \"./filters/GteFilter.js\";\nimport { LtFilter } from \"./filters/LtFilter.js\";\nimport { LteFilter } from \"./filters/LteFilter.js\";\nimport { BetweenFilter } from \"./filters/BetweenFilter.js\";\nimport { InFilter } from \"./filters/InFilter.js\";\nimport { AndInFilter } from \"./filters/AndInFilter.js\";\nimport { ContainsFilter } from \"./filters/ContainsFilter.js\";\nimport { FuzzyFilter } from \"./filters/FuzzyFilter.js\";\nimport { StartsWithFilter } from \"./filters/StartsWithFilter.js\";\nimport { ValueFilterRegistry } from \"./ValueFilterRegistry.js\";\n\nexport const ValueFilterFeature = createFeature({\n    name: \"Db/DynamoDB/ValueFilterFeature\",\n    register: container => {\n        container.register(EqFilter);\n        container.register(GtFilter);\n        container.register(GteFilter);\n        container.register(LtFilter);\n        container.register(LteFilter);\n        container.register(BetweenFilter);\n        container.register(InFilter);\n        container.register(AndInFilter);\n        container.register(ContainsFilter);\n        container.register(FuzzyFilter);\n        container.register(StartsWithFilter);\n        container.register(ValueFilterRegistry);\n    }\n});\n"],"names":["ValueFilterFeature","createFeature","container","EqFilter","GtFilter","GteFilter","LtFilter","LteFilter","BetweenFilter","InFilter","AndInFilter","ContainsFilter","FuzzyFilter","StartsWithFilter","ValueFilterRegistry"],"mappings":";;;;;;;;;;;;;AAcO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAAUC,CAAAA;QACNA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QACnBL,UAAU,QAAQ,CAACM;QACnBN,UAAU,QAAQ,CAACO;QACnBP,UAAU,QAAQ,CAACQ;QACnBR,UAAU,QAAQ,CAACS;QACnBT,UAAU,QAAQ,CAACU;QACnBV,UAAU,QAAQ,CAACW;QACnBX,UAAU,QAAQ,CAACY;IACvB;AACJ"}

package/feature/ValueFilter/filters/AndInFilter.d.ts

@@ -0,0 +1,11 @@
+import { ValueFilter } from "../abstractions/ValueFilter.js";
+declare class AndInFilterImpl implements ValueFilter.Interface {
+    readonly operation = "and_in";
+    is(operation: string): boolean;
+    canUse(): boolean;
+    matches({ value, compareValue }: ValueFilter.MatchesParams): ValueFilter.Result;
+}
+export declare const AndInFilter: typeof AndInFilterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/ValueFilter.js").IValueFilter<any, any>>;
+};
+export {};

package/feature/ValueFilter/filters/AndInFilter.js

@@ -0,0 +1,28 @@
+import { WebinyError } from "@webiny/error";
+import { ValueFilter } from "../abstractions/ValueFilter.js";
+class AndInFilterImpl {
+    is(operation) {
+        return this.operation === operation;
+    }
+    canUse() {
+        return true;
+    }
+    matches({ value, compareValue }) {
+        if (!compareValue || false === Array.isArray(compareValue)) throw new WebinyError('The value given as "compareValue" must be an array!', "COMPARE_VALUE_ERROR", {
+            value,
+            compareValue
+        });
+        if (true === Array.isArray(value)) return compareValue.every((c)=>value.includes(c));
+        return compareValue.includes(value);
+    }
+    constructor(){
+        this.operation = "and_in";
+    }
+}
+const AndInFilter = ValueFilter.createImplementation({
+    implementation: AndInFilterImpl,
+    dependencies: []
+});
+export { AndInFilter };
+
+//# sourceMappingURL=AndInFilter.js.map

package/feature/ValueFilter/filters/AndInFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature/ValueFilter/filters/AndInFilter.js","sources":["../../../../src/feature/ValueFilter/filters/AndInFilter.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { ValueFilter } from \"../abstractions/ValueFilter.js\";\n\nclass AndInFilterImpl implements ValueFilter.Interface {\n    public readonly operation = \"and_in\";\n\n    public is(operation: string): boolean {\n        return this.operation === operation;\n    }\n\n    public canUse(): boolean {\n        return true;\n    }\n\n    public matches({ value, compareValue }: ValueFilter.MatchesParams): ValueFilter.Result {\n        if (!compareValue || Array.isArray(compareValue) === false) {\n            throw new WebinyError(\n                `The value given as \"compareValue\" must be an array!`,\n                \"COMPARE_VALUE_ERROR\",\n                {\n                    value,\n                    compareValue\n                }\n            );\n        }\n        if (Array.isArray(value) === true) {\n            return compareValue.every((c: any) => value.includes(c));\n        }\n        return compareValue.includes(value);\n    }\n}\n\nexport const AndInFilter = ValueFilter.createImplementation({\n    implementation: AndInFilterImpl,\n    dependencies: []\n});\n"],"names":["AndInFilterImpl","operation","value","compareValue","Array","WebinyError","c","AndInFilter","ValueFilter"],"mappings":";;AAGA,MAAMA;IAGK,GAAGC,SAAiB,EAAW;QAClC,OAAO,IAAI,CAAC,SAAS,KAAKA;IAC9B;IAEO,SAAkB;QACrB,OAAO;IACX;IAEO,QAAQ,EAAEC,KAAK,EAAEC,YAAY,EAA6B,EAAsB;QACnF,IAAI,CAACA,gBAAgBC,AAAgC,UAAhCA,MAAM,OAAO,CAACD,eAC/B,MAAM,IAAIE,YACN,uDACA,uBACA;YACIH;YACAC;QACJ;QAGR,IAAIC,AAAyB,SAAzBA,MAAM,OAAO,CAACF,QACd,OAAOC,aAAa,KAAK,CAAC,CAACG,IAAWJ,MAAM,QAAQ,CAACI;QAEzD,OAAOH,aAAa,QAAQ,CAACD;IACjC;;aAzBgB,SAAS,GAAG;;AA0BhC;AAEO,MAAMK,cAAcC,YAAY,oBAAoB,CAAC;IACxD,gBAAgBR;IAChB,cAAc,EAAE;AACpB"}

package/feature/ValueFilter/filters/BetweenFilter.d.ts

@@ -0,0 +1,11 @@
+import { ValueFilter } from "../abstractions/ValueFilter.js";
+declare class BetweenFilterImpl implements ValueFilter.Interface {
+    readonly operation = "between";
+    is(operation: string): boolean;
+    canUse(): boolean;
+    matches({ value, compareValue }: ValueFilter.MatchesParams): ValueFilter.Result;
+}
+export declare const BetweenFilter: typeof BetweenFilterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/ValueFilter.js").IValueFilter<any, any>>;
+};
+export {};

package/feature/ValueFilter/filters/BetweenFilter.js

@@ -0,0 +1,31 @@
+import { WebinyError } from "@webiny/error";
+import { ValueFilter } from "../abstractions/ValueFilter.js";
+class BetweenFilterImpl {
+    is(operation) {
+        return this.operation === operation;
+    }
+    canUse() {
+        return true;
+    }
+    matches({ value, compareValue }) {
+        if (Array.isArray(compareValue)) {
+            if (2 !== compareValue.length) throw new WebinyError("When comparing between and you give an array, there must be two items in it.", "FILTER_ERROR", {
+                value,
+                compareValue
+            });
+            const [from, to] = compareValue;
+            return value >= from && value <= to;
+        }
+        return value >= compareValue && value <= compareValue;
+    }
+    constructor(){
+        this.operation = "between";
+    }
+}
+const BetweenFilter = ValueFilter.createImplementation({
+    implementation: BetweenFilterImpl,
+    dependencies: []
+});
+export { BetweenFilter };
+
+//# sourceMappingURL=BetweenFilter.js.map

package/feature/ValueFilter/filters/BetweenFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature/ValueFilter/filters/BetweenFilter.js","sources":["../../../../src/feature/ValueFilter/filters/BetweenFilter.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { ValueFilter } from \"../abstractions/ValueFilter.js\";\n\nclass BetweenFilterImpl implements ValueFilter.Interface {\n    public readonly operation = \"between\";\n\n    public is(operation: string): boolean {\n        return this.operation === operation;\n    }\n\n    public canUse(): boolean {\n        return true;\n    }\n\n    public matches({ value, compareValue }: ValueFilter.MatchesParams): ValueFilter.Result {\n        if (Array.isArray(compareValue)) {\n            if (compareValue.length !== 2) {\n                throw new WebinyError(\n                    \"When comparing between and you give an array, there must be two items in it.\",\n                    \"FILTER_ERROR\",\n                    {\n                        value,\n                        compareValue\n                    }\n                );\n            }\n            const [from, to] = compareValue;\n            return value >= from && value <= to;\n        }\n        return value >= compareValue && value <= compareValue;\n    }\n}\n\nexport const BetweenFilter = ValueFilter.createImplementation({\n    implementation: BetweenFilterImpl,\n    dependencies: []\n});\n"],"names":["BetweenFilterImpl","operation","value","compareValue","Array","WebinyError","from","to","BetweenFilter","ValueFilter"],"mappings":";;AAGA,MAAMA;IAGK,GAAGC,SAAiB,EAAW;QAClC,OAAO,IAAI,CAAC,SAAS,KAAKA;IAC9B;IAEO,SAAkB;QACrB,OAAO;IACX;IAEO,QAAQ,EAAEC,KAAK,EAAEC,YAAY,EAA6B,EAAsB;QACnF,IAAIC,MAAM,OAAO,CAACD,eAAe;YAC7B,IAAIA,AAAwB,MAAxBA,aAAa,MAAM,EACnB,MAAM,IAAIE,YACN,gFACA,gBACA;gBACIH;gBACAC;YACJ;YAGR,MAAM,CAACG,MAAMC,GAAG,GAAGJ;YACnB,OAAOD,SAASI,QAAQJ,SAASK;QACrC;QACA,OAAOL,SAASC,gBAAgBD,SAASC;IAC7C;;aA1BgB,SAAS,GAAG;;AA2BhC;AAEO,MAAMK,gBAAgBC,YAAY,oBAAoB,CAAC;IAC1D,gBAAgBT;IAChB,cAAc,EAAE;AACpB"}

package/feature/ValueFilter/filters/ContainsFilter.d.ts

@@ -0,0 +1,11 @@
+import { ValueFilter } from "../abstractions/ValueFilter.js";
+declare class ContainsFilterImpl implements ValueFilter.Interface {
+    readonly operation = "contains";
+    is(operation: string): boolean;
+    canUse(): boolean;
+    matches({ value: initialValue, compareValue: initialCompareValue }: ValueFilter.MatchesParams): ValueFilter.Result;
+}
+export declare const ContainsFilter: typeof ContainsFilterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/ValueFilter.js").IValueFilter<any, any>>;
+};
+export {};

package/feature/ValueFilter/filters/ContainsFilter.js

@@ -0,0 +1,42 @@
+import { ValueFilter } from "../abstractions/ValueFilter.js";
+const createValues = (initialValue)=>{
+    if ("string" == typeof initialValue) return [
+        initialValue
+    ];
+    if (Array.isArray(initialValue)) return initialValue.flat().map((v)=>v.toString()).filter(Boolean);
+    const result = [];
+    const traverse = (node)=>{
+        if (null == node) return;
+        if ("string" == typeof node || "number" == typeof node) result.push(node.toString());
+        else if (Array.isArray(node)) node.forEach(traverse);
+        else if ("object" == typeof node) Object.values(node).forEach(traverse);
+    };
+    traverse(initialValue);
+    return result.filter(Boolean);
+};
+const createCompareValues = (value)=>value.replace(/\s+/g, " ").trim().replace(/\?/g, "\\?").replace(/\//g, "\\/").replace(/:/g, "").replace(/-/g, "\\-").split(" ").filter((val)=>val.length > 0);
+class ContainsFilterImpl {
+    is(operation) {
+        return this.operation === operation;
+    }
+    canUse() {
+        return true;
+    }
+    matches({ value: initialValue, compareValue: initialCompareValue }) {
+        if (!initialValue || Array.isArray(initialValue) && 0 === initialValue.length) return false;
+        if (null == initialCompareValue) return true;
+        const values = createValues(initialValue);
+        const compareValues = createCompareValues(initialCompareValue);
+        return values.some((target)=>compareValues.every((compareValue)=>null !== target.match(new RegExp(compareValue, "gi"))));
+    }
+    constructor(){
+        this.operation = "contains";
+    }
+}
+const ContainsFilter = ValueFilter.createImplementation({
+    implementation: ContainsFilterImpl,
+    dependencies: []
+});
+export { ContainsFilter };
+
+//# sourceMappingURL=ContainsFilter.js.map

package/feature/ValueFilter/filters/ContainsFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature/ValueFilter/filters/ContainsFilter.js","sources":["../../../../src/feature/ValueFilter/filters/ContainsFilter.ts"],"sourcesContent":["import { ValueFilter } from \"../abstractions/ValueFilter.js\";\n\nconst createValues = (initialValue: string | string[] | object): string[] => {\n    if (typeof initialValue === \"string\") {\n        return [initialValue];\n    }\n\n    if (Array.isArray(initialValue)) {\n        return initialValue\n            .flat()\n            .map(v => v.toString())\n            .filter(Boolean);\n    }\n\n    const result: string[] = [];\n\n    const traverse = (node: any): void => {\n        if (node == null) {\n            return;\n        }\n        if (typeof node === \"string\" || typeof node === \"number\") {\n            result.push(node.toString());\n        } else if (Array.isArray(node)) {\n            node.forEach(traverse);\n        } else if (typeof node === \"object\") {\n            Object.values(node).forEach(traverse);\n        }\n    };\n\n    traverse(initialValue);\n\n    return result.filter(Boolean);\n};\n\nconst createCompareValues = (value: string) => {\n    return value\n        .replace(/\\s+/g, \" \")\n        .trim()\n        .replace(/\\?/g, `\\\\?`)\n        .replace(/\\//g, `\\\\/`)\n        .replace(/:/g, ``)\n        .replace(/-/g, `\\\\-`)\n        .split(\" \")\n        .filter(val => {\n            return val.length > 0;\n        });\n};\n\nclass ContainsFilterImpl implements ValueFilter.Interface {\n    public readonly operation = \"contains\";\n\n    public is(operation: string): boolean {\n        return this.operation === operation;\n    }\n\n    public canUse(): boolean {\n        return true;\n    }\n\n    public matches({\n        value: initialValue,\n        compareValue: initialCompareValue\n    }: ValueFilter.MatchesParams): ValueFilter.Result {\n        if (!initialValue || (Array.isArray(initialValue) && initialValue.length === 0)) {\n            return false;\n        } else if (initialCompareValue === undefined || initialCompareValue === null) {\n            return true;\n        }\n        const values = createValues(initialValue);\n        const compareValues = createCompareValues(initialCompareValue);\n        return values.some(target => {\n            return compareValues.every(compareValue => {\n                return target.match(new RegExp(compareValue, \"gi\")) !== null;\n            });\n        });\n    }\n}\n\nexport const ContainsFilter = ValueFilter.createImplementation({\n    implementation: ContainsFilterImpl,\n    dependencies: []\n});\n"],"names":["createValues","initialValue","Array","v","Boolean","result","traverse","node","Object","createCompareValues","value","val","ContainsFilterImpl","operation","initialCompareValue","values","compareValues","target","compareValue","RegExp","ContainsFilter","ValueFilter"],"mappings":";AAEA,MAAMA,eAAe,CAACC;IAClB,IAAI,AAAwB,YAAxB,OAAOA,cACP,OAAO;QAACA;KAAa;IAGzB,IAAIC,MAAM,OAAO,CAACD,eACd,OAAOA,aACF,IAAI,GACJ,GAAG,CAACE,CAAAA,IAAKA,EAAE,QAAQ,IACnB,MAAM,CAACC;IAGhB,MAAMC,SAAmB,EAAE;IAE3B,MAAMC,WAAW,CAACC;QACd,IAAIA,AAAQ,QAARA,MACA;QAEJ,IAAI,AAAgB,YAAhB,OAAOA,QAAqB,AAAgB,YAAhB,OAAOA,MACnCF,OAAO,IAAI,CAACE,KAAK,QAAQ;aACtB,IAAIL,MAAM,OAAO,CAACK,OACrBA,KAAK,OAAO,CAACD;aACV,IAAI,AAAgB,YAAhB,OAAOC,MACdC,OAAO,MAAM,CAACD,MAAM,OAAO,CAACD;IAEpC;IAEAA,SAASL;IAET,OAAOI,OAAO,MAAM,CAACD;AACzB;AAEA,MAAMK,sBAAsB,CAACC,QAClBA,MACF,OAAO,CAAC,QAAQ,KAChB,IAAI,GACJ,OAAO,CAAC,OAAO,OACf,OAAO,CAAC,OAAO,OACf,OAAO,CAAC,MAAM,IACd,OAAO,CAAC,MAAM,OACd,KAAK,CAAC,KACN,MAAM,CAACC,CAAAA,MACGA,IAAI,MAAM,GAAG;AAIhC,MAAMC;IAGK,GAAGC,SAAiB,EAAW;QAClC,OAAO,IAAI,CAAC,SAAS,KAAKA;IAC9B;IAEO,SAAkB;QACrB,OAAO;IACX;IAEO,QAAQ,EACX,OAAOZ,YAAY,EACnB,cAAca,mBAAmB,EACT,EAAsB;QAC9C,IAAI,CAACb,gBAAiBC,MAAM,OAAO,CAACD,iBAAiBA,AAAwB,MAAxBA,aAAa,MAAM,EACpE,OAAO;QACJ,IAAIa,QAAAA,qBACP,OAAO;QAEX,MAAMC,SAASf,aAAaC;QAC5B,MAAMe,gBAAgBP,oBAAoBK;QAC1C,OAAOC,OAAO,IAAI,CAACE,CAAAA,SACRD,cAAc,KAAK,CAACE,CAAAA,eAChBD,AAAiD,SAAjDA,OAAO,KAAK,CAAC,IAAIE,OAAOD,cAAc;IAGzD;;aA1BgB,SAAS,GAAG;;AA2BhC;AAEO,MAAME,iBAAiBC,YAAY,oBAAoB,CAAC;IAC3D,gBAAgBT;IAChB,cAAc,EAAE;AACpB"}

package/feature/ValueFilter/filters/EqFilter.d.ts

@@ -0,0 +1,11 @@
+import { ValueFilter } from "../abstractions/ValueFilter.js";
+declare class EqFilterImpl implements ValueFilter.Interface {
+    readonly operation = "eq";
+    is(operation: string): boolean;
+    canUse(): boolean;
+    matches({ value, compareValue }: ValueFilter.MatchesParams): ValueFilter.Result;
+}
+export declare const EqFilter: typeof EqFilterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/ValueFilter.js").IValueFilter<any, any>>;
+};
+export {};

package/feature/ValueFilter/filters/EqFilter.js

@@ -0,0 +1,24 @@
+import { ValueFilter } from "../abstractions/ValueFilter.js";
+class EqFilterImpl {
+    is(operation) {
+        return this.operation === operation;
+    }
+    canUse() {
+        return true;
+    }
+    matches({ value, compareValue }) {
+        if (true === Array.isArray(value)) return value.some((v)=>Array.isArray(compareValue) ? compareValue.includes(v) : compareValue === v);
+        if (true === Array.isArray(compareValue)) return compareValue.every((v)=>value == v);
+        return value == compareValue;
+    }
+    constructor(){
+        this.operation = "eq";
+    }
+}
+const EqFilter = ValueFilter.createImplementation({
+    implementation: EqFilterImpl,
+    dependencies: []
+});
+export { EqFilter };
+
+//# sourceMappingURL=EqFilter.js.map

package/feature/ValueFilter/filters/EqFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature/ValueFilter/filters/EqFilter.js","sources":["../../../../src/feature/ValueFilter/filters/EqFilter.ts"],"sourcesContent":["import { ValueFilter } from \"../abstractions/ValueFilter.js\";\n\nclass EqFilterImpl implements ValueFilter.Interface {\n    public readonly operation = \"eq\";\n\n    public is(operation: string): boolean {\n        return this.operation === operation;\n    }\n\n    public canUse(): boolean {\n        return true;\n    }\n\n    public matches({ value, compareValue }: ValueFilter.MatchesParams): ValueFilter.Result {\n        /**\n         * Possibility that either input value or one from the system is array.\n         */\n        if (Array.isArray(value) === true) {\n            return value.some((v: string) => {\n                return Array.isArray(compareValue) ? compareValue.includes(v) : compareValue === v;\n            });\n        } else if (Array.isArray(compareValue) === true) {\n            return compareValue.every((v: string) => {\n                return value == v;\n            });\n        }\n        return value == compareValue;\n    }\n}\n\nexport const EqFilter = ValueFilter.createImplementation({\n    implementation: EqFilterImpl,\n    dependencies: []\n});\n"],"names":["EqFilterImpl","operation","value","compareValue","Array","v","EqFilter","ValueFilter"],"mappings":";AAEA,MAAMA;IAGK,GAAGC,SAAiB,EAAW;QAClC,OAAO,IAAI,CAAC,SAAS,KAAKA;IAC9B;IAEO,SAAkB;QACrB,OAAO;IACX;IAEO,QAAQ,EAAEC,KAAK,EAAEC,YAAY,EAA6B,EAAsB;QAInF,IAAIC,AAAyB,SAAzBA,MAAM,OAAO,CAACF,QACd,OAAOA,MAAM,IAAI,CAAC,CAACG,IACRD,MAAM,OAAO,CAACD,gBAAgBA,aAAa,QAAQ,CAACE,KAAKF,iBAAiBE;QAElF,IAAID,AAAgC,SAAhCA,MAAM,OAAO,CAACD,eACrB,OAAOA,aAAa,KAAK,CAAC,CAACE,IAChBH,SAASG;QAGxB,OAAOH,SAASC;IACpB;;aAxBgB,SAAS,GAAG;;AAyBhC;AAEO,MAAMG,WAAWC,YAAY,oBAAoB,CAAC;IACrD,gBAAgBP;IAChB,cAAc,EAAE;AACpB"}

package/feature/ValueFilter/filters/FuzzyFilter.d.ts

@@ -0,0 +1,11 @@
+import { ValueFilter } from "../abstractions/ValueFilter.js";
+declare class FuzzyFilterImpl implements ValueFilter.Interface<string | null | undefined> {
+    readonly operation = "fuzzy";
+    is(operation: string): boolean;
+    canUse(): boolean;
+    matches({ value: initialValue, compareValue: initialCompareValue }: ValueFilter.MatchesParams): ValueFilter.Result;
+}
+export declare const FuzzyFilter: typeof FuzzyFilterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/ValueFilter.js").IValueFilter<any, any>>;
+};
+export {};

package/feature/ValueFilter/filters/FuzzyFilter.js

@@ -0,0 +1,37 @@
+import fuse from "fuse.js";
+import { ValueFilter } from "../abstractions/ValueFilter.js";
+class FuzzyFilterImpl {
+    is(operation) {
+        return this.operation === operation;
+    }
+    canUse() {
+        return true;
+    }
+    matches({ value: initialValue, compareValue: initialCompareValue }) {
+        if ("string" != typeof initialValue || "string" != typeof initialCompareValue) return false;
+        const value = initialValue.replaceAll("/", " ");
+        const compareValue = initialCompareValue.replaceAll("/", " ");
+        const f = new fuse([
+            value
+        ], {
+            includeScore: true,
+            minMatchCharLength: 3,
+            threshold: 0.5,
+            isCaseSensitive: false,
+            findAllMatches: true,
+            ignoreLocation: true
+        });
+        const result = f.search(compareValue);
+        return result.length > 0;
+    }
+    constructor(){
+        this.operation = "fuzzy";
+    }
+}
+const FuzzyFilter = ValueFilter.createImplementation({
+    implementation: FuzzyFilterImpl,
+    dependencies: []
+});
+export { FuzzyFilter };
+
+//# sourceMappingURL=FuzzyFilter.js.map

package/feature/ValueFilter/filters/FuzzyFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature/ValueFilter/filters/FuzzyFilter.js","sources":["../../../../src/feature/ValueFilter/filters/FuzzyFilter.ts"],"sourcesContent":["import Fuse from \"fuse.js\";\nimport { ValueFilter } from \"../abstractions/ValueFilter.js\";\n\nclass FuzzyFilterImpl implements ValueFilter.Interface<string | null | undefined> {\n    public readonly operation = \"fuzzy\";\n\n    public is(operation: string): boolean {\n        return this.operation === operation;\n    }\n\n    public canUse(): boolean {\n        return true;\n    }\n\n    public matches({\n        value: initialValue,\n        compareValue: initialCompareValue\n    }: ValueFilter.MatchesParams): ValueFilter.Result {\n        if (typeof initialValue !== \"string\" || typeof initialCompareValue !== \"string\") {\n            return false;\n        }\n        const value = initialValue.replaceAll(\"/\", \" \");\n        const compareValue = initialCompareValue.replaceAll(\"/\", \" \");\n\n        const f = new Fuse([value], {\n            includeScore: true,\n            minMatchCharLength: 3,\n            threshold: 0.5,\n            isCaseSensitive: false,\n            findAllMatches: true,\n            ignoreLocation: true\n        });\n        const result = f.search(compareValue);\n\n        return result.length > 0;\n    }\n}\n\nexport const FuzzyFilter = ValueFilter.createImplementation({\n    implementation: FuzzyFilterImpl,\n    dependencies: []\n});\n"],"names":["FuzzyFilterImpl","operation","initialValue","initialCompareValue","value","compareValue","f","Fuse","result","FuzzyFilter","ValueFilter"],"mappings":";;AAGA,MAAMA;IAGK,GAAGC,SAAiB,EAAW;QAClC,OAAO,IAAI,CAAC,SAAS,KAAKA;IAC9B;IAEO,SAAkB;QACrB,OAAO;IACX;IAEO,QAAQ,EACX,OAAOC,YAAY,EACnB,cAAcC,mBAAmB,EACT,EAAsB;QAC9C,IAAI,AAAwB,YAAxB,OAAOD,gBAA6B,AAA+B,YAA/B,OAAOC,qBAC3C,OAAO;QAEX,MAAMC,QAAQF,aAAa,UAAU,CAAC,KAAK;QAC3C,MAAMG,eAAeF,oBAAoB,UAAU,CAAC,KAAK;QAEzD,MAAMG,IAAI,IAAIC,KAAK;YAACH;SAAM,EAAE;YACxB,cAAc;YACd,oBAAoB;YACpB,WAAW;YACX,iBAAiB;YACjB,gBAAgB;YAChB,gBAAgB;QACpB;QACA,MAAMI,SAASF,EAAE,MAAM,CAACD;QAExB,OAAOG,OAAO,MAAM,GAAG;IAC3B;;aA/BgB,SAAS,GAAG;;AAgChC;AAEO,MAAMC,cAAcC,YAAY,oBAAoB,CAAC;IACxD,gBAAgBV;IAChB,cAAc,EAAE;AACpB"}

package/feature/ValueFilter/filters/GtFilter.d.ts

@@ -0,0 +1,11 @@
+import { ValueFilter } from "../abstractions/ValueFilter.js";
+declare class GtFilterImpl implements ValueFilter.Interface {
+    readonly operation = "gt";
+    is(operation: string): boolean;
+    canUse(): boolean;
+    matches({ value, compareValue }: ValueFilter.MatchesParams): ValueFilter.Result;
+}
+export declare const GtFilter: typeof GtFilterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/ValueFilter.js").IValueFilter<any, any>>;
+};
+export {};