@webiny/api-opensearch 0.0.0-unstable.0156a4c312

package/features/OpenSearchIndex/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchIndex/feature.js","sources":["../../../src/features/OpenSearchIndex/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api/index.js\";\nimport { OpenSearchIndexRegistry } from \"./OpenSearchIndexRegistry.js\";\n\nexport const OpenSearchIndexFeature = createFeature({\n    name: \"opensearch.internal.index\",\n    register(container) {\n        // Container scoped: each request builds the registry from its own container, so indexes that\n        // extensions register per request are included. As a singleton it would be built once, from\n        // the root container's registrations only (@webiny/di builds a singleton from the container\n        // that registers it), and would never see indexes registered in a request container.\n        container.register(OpenSearchIndexRegistry).inContainerScope();\n    }\n});\n"],"names":["OpenSearchIndexFeature","createFeature","container","OpenSearchIndexRegistry"],"mappings":";;AAGO,MAAMA,yBAAyBC,cAAc;IAChD,MAAM;IACN,UAASC,SAAS;QAKdA,UAAU,QAAQ,CAACC,yBAAyB,gBAAgB;IAChE;AACJ"}

package/features/OpenSearchQueryBuilderOperator/OpenSearchQueryBuilderOperatorRegistry.d.ts

@@ -0,0 +1,12 @@
+import { OpenSearchQueryBuilderOperator } from "./abstractions/OpenSearchQueryBuilderOperator.js";
+import { OpenSearchQueryBuilderOperatorRegistry as Abstraction } from "./abstractions/OpenSearchQueryBuilderOperatorRegistry.js";
+declare class OpenSearchQueryBuilderOperatorRegistryImpl implements Abstraction.Interface {
+    private readonly operators;
+    constructor(operators: OpenSearchQueryBuilderOperator.Interface[]);
+    get(operator: string): OpenSearchQueryBuilderOperator.Interface | undefined;
+    getAll(): OpenSearchQueryBuilderOperator.Interface[];
+}
+export declare const OpenSearchQueryBuilderOperatorRegistry: typeof OpenSearchQueryBuilderOperatorRegistryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/OpenSearchQueryBuilderOperatorRegistry.js").IOpenSearchQueryBuilderOperatorRegistry>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/OpenSearchQueryBuilderOperatorRegistry.js

@@ -0,0 +1,28 @@
+import { OpenSearchQueryBuilderOperator } from "./abstractions/OpenSearchQueryBuilderOperator.js";
+import { OpenSearchQueryBuilderOperatorRegistry } from "./abstractions/OpenSearchQueryBuilderOperatorRegistry.js";
+class OpenSearchQueryBuilderOperatorRegistryImpl {
+    constructor(operators){
+        this.operators = new Map();
+        for (const operator of operators)this.operators.set(operator.getOperator(), operator);
+    }
+    get(operator) {
+        return this.operators.get(operator);
+    }
+    getAll() {
+        return Array.from(this.operators.values());
+    }
+}
+const OpenSearchQueryBuilderOperatorRegistry_OpenSearchQueryBuilderOperatorRegistry = OpenSearchQueryBuilderOperatorRegistry.createImplementation({
+    implementation: OpenSearchQueryBuilderOperatorRegistryImpl,
+    dependencies: [
+        [
+            OpenSearchQueryBuilderOperator,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { OpenSearchQueryBuilderOperatorRegistry_OpenSearchQueryBuilderOperatorRegistry as OpenSearchQueryBuilderOperatorRegistry };
+
+//# sourceMappingURL=OpenSearchQueryBuilderOperatorRegistry.js.map

package/features/OpenSearchQueryBuilderOperator/OpenSearchQueryBuilderOperatorRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/OpenSearchQueryBuilderOperatorRegistry.js","sources":["../../../src/features/OpenSearchQueryBuilderOperator/OpenSearchQueryBuilderOperatorRegistry.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"./abstractions/OpenSearchQueryBuilderOperator.js\";\nimport { OpenSearchQueryBuilderOperatorRegistry as Abstraction } from \"./abstractions/OpenSearchQueryBuilderOperatorRegistry.js\";\n\nclass OpenSearchQueryBuilderOperatorRegistryImpl implements Abstraction.Interface {\n    private readonly operators: Map<string, OpenSearchQueryBuilderOperator.Interface>;\n\n    public constructor(operators: OpenSearchQueryBuilderOperator.Interface[]) {\n        this.operators = new Map();\n        for (const operator of operators) {\n            this.operators.set(operator.getOperator(), operator);\n        }\n    }\n\n    public get(operator: string): OpenSearchQueryBuilderOperator.Interface | undefined {\n        return this.operators.get(operator);\n    }\n\n    public getAll(): OpenSearchQueryBuilderOperator.Interface[] {\n        return Array.from(this.operators.values());\n    }\n}\n\nexport const OpenSearchQueryBuilderOperatorRegistry = Abstraction.createImplementation({\n    implementation: OpenSearchQueryBuilderOperatorRegistryImpl,\n    dependencies: [[OpenSearchQueryBuilderOperator, { multiple: true }]]\n});\n"],"names":["OpenSearchQueryBuilderOperatorRegistryImpl","operators","Map","operator","Array","OpenSearchQueryBuilderOperatorRegistry","Abstraction","OpenSearchQueryBuilderOperator"],"mappings":";;AAGA,MAAMA;IAGF,YAAmBC,SAAqD,CAAE;QACtE,IAAI,CAAC,SAAS,GAAG,IAAIC;QACrB,KAAK,MAAMC,YAAYF,UACnB,IAAI,CAAC,SAAS,CAAC,GAAG,CAACE,SAAS,WAAW,IAAIA;IAEnD;IAEO,IAAIA,QAAgB,EAAwD;QAC/E,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAACA;IAC9B;IAEO,SAAqD;QACxD,OAAOC,MAAM,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM;IAC3C;AACJ;AAEO,MAAMC,gFAAyCC,uCAAAA,oBAAgC,CAAC;IACnF,gBAAgBN;IAChB,cAAc;QAAC;YAACO;YAAgC;gBAAE,UAAU;YAAK;SAAE;KAAC;AACxE"}

package/features/OpenSearchQueryBuilderOperator/abstractions/OpenSearchQueryBuilderOperator.d.ts

@@ -0,0 +1,11 @@
+import type { OpenSearchBoolQueryConfig, OpenSearchQueryBuilderArgsPlugin } from "../../../types.js";
+export interface IOpenSearchQueryBuilderOperator {
+    getOperator(): string;
+    apply(query: OpenSearchBoolQueryConfig, params: OpenSearchQueryBuilderArgsPlugin): void;
+}
+export declare const OpenSearchQueryBuilderOperator: import("@webiny/di").Abstraction<IOpenSearchQueryBuilderOperator>;
+export declare namespace OpenSearchQueryBuilderOperator {
+    type Interface = IOpenSearchQueryBuilderOperator;
+    type Query = OpenSearchBoolQueryConfig;
+    type Params = OpenSearchQueryBuilderArgsPlugin;
+}

package/features/OpenSearchQueryBuilderOperator/abstractions/OpenSearchQueryBuilderOperator.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/exports/api.js";
+const OpenSearchQueryBuilderOperator = createAbstraction("OpenSearch/QueryBuilder/Operator");
+export { OpenSearchQueryBuilderOperator };
+
+//# sourceMappingURL=OpenSearchQueryBuilderOperator.js.map

package/features/OpenSearchQueryBuilderOperator/abstractions/OpenSearchQueryBuilderOperator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/abstractions/OpenSearchQueryBuilderOperator.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/abstractions/OpenSearchQueryBuilderOperator.ts"],"sourcesContent":["import type { OpenSearchBoolQueryConfig, OpenSearchQueryBuilderArgsPlugin } from \"~/types.js\";\nimport { createAbstraction } from \"@webiny/feature/exports/api.js\";\n\nexport interface IOpenSearchQueryBuilderOperator {\n    getOperator(): string;\n    apply(query: OpenSearchBoolQueryConfig, params: OpenSearchQueryBuilderArgsPlugin): void;\n}\n\nexport const OpenSearchQueryBuilderOperator = createAbstraction<IOpenSearchQueryBuilderOperator>(\n    \"OpenSearch/QueryBuilder/Operator\"\n);\n\nexport namespace OpenSearchQueryBuilderOperator {\n    export type Interface = IOpenSearchQueryBuilderOperator;\n    export type Query = OpenSearchBoolQueryConfig;\n    export type Params = OpenSearchQueryBuilderArgsPlugin;\n}\n"],"names":["OpenSearchQueryBuilderOperator","createAbstraction"],"mappings":";AAQO,MAAMA,iCAAiCC,kBAC1C"}

package/features/OpenSearchQueryBuilderOperator/abstractions/OpenSearchQueryBuilderOperatorRegistry.d.ts

@@ -0,0 +1,10 @@
+import type { OpenSearchQueryBuilderOperator } from "./OpenSearchQueryBuilderOperator.js";
+export interface IOpenSearchQueryBuilderOperatorRegistry {
+    get(operator: string): OpenSearchQueryBuilderOperator.Interface | undefined;
+    getAll(): OpenSearchQueryBuilderOperator.Interface[];
+}
+export declare const OpenSearchQueryBuilderOperatorRegistry: import("@webiny/di").Abstraction<IOpenSearchQueryBuilderOperatorRegistry>;
+export declare namespace OpenSearchQueryBuilderOperatorRegistry {
+    type Interface = IOpenSearchQueryBuilderOperatorRegistry;
+    type Operator = OpenSearchQueryBuilderOperator.Interface;
+}

package/features/OpenSearchQueryBuilderOperator/abstractions/OpenSearchQueryBuilderOperatorRegistry.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/exports/api.js";
+const OpenSearchQueryBuilderOperatorRegistry = createAbstraction("OpenSearch/QueryBuilder/OperatorRegistry");
+export { OpenSearchQueryBuilderOperatorRegistry };
+
+//# sourceMappingURL=OpenSearchQueryBuilderOperatorRegistry.js.map

package/features/OpenSearchQueryBuilderOperator/abstractions/OpenSearchQueryBuilderOperatorRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/abstractions/OpenSearchQueryBuilderOperatorRegistry.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/abstractions/OpenSearchQueryBuilderOperatorRegistry.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/exports/api.js\";\nimport type { OpenSearchQueryBuilderOperator } from \"./OpenSearchQueryBuilderOperator.js\";\n\nexport interface IOpenSearchQueryBuilderOperatorRegistry {\n    get(operator: string): OpenSearchQueryBuilderOperator.Interface | undefined;\n    getAll(): OpenSearchQueryBuilderOperator.Interface[];\n}\n\nexport const OpenSearchQueryBuilderOperatorRegistry =\n    createAbstraction<IOpenSearchQueryBuilderOperatorRegistry>(\n        \"OpenSearch/QueryBuilder/OperatorRegistry\"\n    );\n\nexport namespace OpenSearchQueryBuilderOperatorRegistry {\n    export type Interface = IOpenSearchQueryBuilderOperatorRegistry;\n    export type Operator = OpenSearchQueryBuilderOperator.Interface;\n}\n"],"names":["OpenSearchQueryBuilderOperatorRegistry","createAbstraction"],"mappings":";AAQO,MAAMA,yCACTC,kBACI"}

package/features/OpenSearchQueryBuilderOperator/feature.d.ts

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

package/features/OpenSearchQueryBuilderOperator/feature.js

@@ -0,0 +1,41 @@
+import { createFeature } from "@webiny/feature/api/index.js";
+import { OpenSearchQueryBuilderOperatorRegistry } from "./OpenSearchQueryBuilderOperatorRegistry.js";
+import { Equal } from "./operators/Equal.js";
+import { Not } from "./operators/Not.js";
+import { Contains } from "./operators/Contains.js";
+import { NotContains } from "./operators/NotContains.js";
+import { Between } from "./operators/Between.js";
+import { NotBetween } from "./operators/NotBetween.js";
+import { GreaterThan } from "./operators/GreaterThan.js";
+import { GreaterThanOrEqual } from "./operators/GreaterThanOrEqual.js";
+import { LesserThan } from "./operators/LesserThan.js";
+import { LesserThanOrEqual } from "./operators/LesserThanOrEqual.js";
+import { In } from "./operators/In.js";
+import { AndIn } from "./operators/AndIn.js";
+import { NotIn } from "./operators/NotIn.js";
+import { StartsWith } from "./operators/StartsWith.js";
+import { NotStartsWith } from "./operators/NotStartsWith.js";
+const OpenSearchQueryBuilderOperatorFeature = createFeature({
+    name: "opensearch.internal.queryBuilderOperator",
+    register (container) {
+        container.register(Equal).inSingletonScope();
+        container.register(Not).inSingletonScope();
+        container.register(Contains).inSingletonScope();
+        container.register(NotContains).inSingletonScope();
+        container.register(Between).inSingletonScope();
+        container.register(NotBetween).inSingletonScope();
+        container.register(GreaterThan).inSingletonScope();
+        container.register(GreaterThanOrEqual).inSingletonScope();
+        container.register(LesserThan).inSingletonScope();
+        container.register(LesserThanOrEqual).inSingletonScope();
+        container.register(In).inSingletonScope();
+        container.register(AndIn).inSingletonScope();
+        container.register(NotIn).inSingletonScope();
+        container.register(StartsWith).inSingletonScope();
+        container.register(NotStartsWith).inSingletonScope();
+        container.register(OpenSearchQueryBuilderOperatorRegistry).inContainerScope();
+    }
+});
+export { OpenSearchQueryBuilderOperatorFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/OpenSearchQueryBuilderOperator/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/feature.js","sources":["../../../src/features/OpenSearchQueryBuilderOperator/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api/index.js\";\nimport { OpenSearchQueryBuilderOperatorRegistry } from \"./OpenSearchQueryBuilderOperatorRegistry.js\";\nimport { Equal } from \"./operators/Equal.js\";\nimport { Not } from \"./operators/Not.js\";\nimport { Contains } from \"./operators/Contains.js\";\nimport { NotContains } from \"./operators/NotContains.js\";\nimport { Between } from \"./operators/Between.js\";\nimport { NotBetween } from \"./operators/NotBetween.js\";\nimport { GreaterThan } from \"./operators/GreaterThan.js\";\nimport { GreaterThanOrEqual } from \"./operators/GreaterThanOrEqual.js\";\nimport { LesserThan } from \"./operators/LesserThan.js\";\nimport { LesserThanOrEqual } from \"./operators/LesserThanOrEqual.js\";\nimport { In } from \"./operators/In.js\";\nimport { AndIn } from \"./operators/AndIn.js\";\nimport { NotIn } from \"./operators/NotIn.js\";\nimport { StartsWith } from \"./operators/StartsWith.js\";\nimport { NotStartsWith } from \"./operators/NotStartsWith.js\";\n\nexport const OpenSearchQueryBuilderOperatorFeature = createFeature({\n    name: \"opensearch.internal.queryBuilderOperator\",\n    register(container) {\n        container.register(Equal).inSingletonScope();\n        container.register(Not).inSingletonScope();\n        container.register(Contains).inSingletonScope();\n        container.register(NotContains).inSingletonScope();\n        container.register(Between).inSingletonScope();\n        container.register(NotBetween).inSingletonScope();\n        container.register(GreaterThan).inSingletonScope();\n        container.register(GreaterThanOrEqual).inSingletonScope();\n        container.register(LesserThan).inSingletonScope();\n        container.register(LesserThanOrEqual).inSingletonScope();\n        container.register(In).inSingletonScope();\n        container.register(AndIn).inSingletonScope();\n        container.register(NotIn).inSingletonScope();\n        container.register(StartsWith).inSingletonScope();\n        container.register(NotStartsWith).inSingletonScope();\n        // Container scoped: each request builds the registry from its own container, so operators that\n        // extensions register per request are included. As a singleton it would be built once, from\n        // the root container's registrations only (@webiny/di builds a singleton from the container\n        // that registers it), and would never see operators registered in a request container.\n        container.register(OpenSearchQueryBuilderOperatorRegistry).inContainerScope();\n    }\n});\n"],"names":["OpenSearchQueryBuilderOperatorFeature","createFeature","container","Equal","Not","Contains","NotContains","Between","NotBetween","GreaterThan","GreaterThanOrEqual","LesserThan","LesserThanOrEqual","In","AndIn","NotIn","StartsWith","NotStartsWith","OpenSearchQueryBuilderOperatorRegistry"],"mappings":";;;;;;;;;;;;;;;;;AAkBO,MAAMA,wCAAwCC,cAAc;IAC/D,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,OAAO,gBAAgB;QAC1CD,UAAU,QAAQ,CAACE,KAAK,gBAAgB;QACxCF,UAAU,QAAQ,CAACG,UAAU,gBAAgB;QAC7CH,UAAU,QAAQ,CAACI,aAAa,gBAAgB;QAChDJ,UAAU,QAAQ,CAACK,SAAS,gBAAgB;QAC5CL,UAAU,QAAQ,CAACM,YAAY,gBAAgB;QAC/CN,UAAU,QAAQ,CAACO,aAAa,gBAAgB;QAChDP,UAAU,QAAQ,CAACQ,oBAAoB,gBAAgB;QACvDR,UAAU,QAAQ,CAACS,YAAY,gBAAgB;QAC/CT,UAAU,QAAQ,CAACU,mBAAmB,gBAAgB;QACtDV,UAAU,QAAQ,CAACW,IAAI,gBAAgB;QACvCX,UAAU,QAAQ,CAACY,OAAO,gBAAgB;QAC1CZ,UAAU,QAAQ,CAACa,OAAO,gBAAgB;QAC1Cb,UAAU,QAAQ,CAACc,YAAY,gBAAgB;QAC/Cd,UAAU,QAAQ,CAACe,eAAe,gBAAgB;QAKlDf,UAAU,QAAQ,CAACgB,wCAAwC,gBAAgB;IAC/E;AACJ"}

package/features/OpenSearchQueryBuilderOperator/operators/AndIn.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class AndInImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const AndIn: typeof AndInImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/AndIn.js

@@ -0,0 +1,28 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class AndInImpl {
+    getOperator() {
+        return "and_in";
+    }
+    apply(query, params) {
+        const { value: values, path, basePath } = params;
+        const isArray = Array.isArray(values);
+        if (false === isArray || 0 === values.length) throw new Error(`You cannot filter field "${path}" with "in" operator and not send an array of values.`);
+        let useBasePath = false;
+        for (const value of values)if ("string" != typeof value) {
+            useBasePath = true;
+            break;
+        }
+        for (const value of values)query.filter.push({
+            term: {
+                [useBasePath ? basePath : path]: value
+            }
+        });
+    }
+}
+const AndIn = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: AndInImpl,
+    dependencies: []
+});
+export { AndIn };
+
+//# sourceMappingURL=AndIn.js.map

package/features/OpenSearchQueryBuilderOperator/operators/AndIn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/AndIn.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/AndIn.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass AndInImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"and_in\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value: values, path, basePath } = params;\n        const isArray = Array.isArray(values);\n        if (isArray === false || values.length === 0) {\n            throw new Error(\n                `You cannot filter field \"${path}\" with \"in\" operator and not send an array of values.`\n            );\n        }\n\n        let useBasePath = false;\n        for (const value of values) {\n            if (typeof value !== \"string\") {\n                useBasePath = true;\n                break;\n            }\n        }\n\n        for (const value of values) {\n            query.filter.push({\n                term: {\n                    [useBasePath ? basePath : path]: value\n                }\n            });\n        }\n    }\n}\n\nexport const AndIn = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: AndInImpl,\n    dependencies: []\n});\n"],"names":["AndInImpl","query","params","values","path","basePath","isArray","Array","Error","useBasePath","value","AndIn","OpenSearchQueryBuilderOperator"],"mappings":";AAEA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAE,OAAOC,MAAM,EAAEC,IAAI,EAAEC,QAAQ,EAAE,GAAGH;QAC1C,MAAMI,UAAUC,MAAM,OAAO,CAACJ;QAC9B,IAAIG,AAAY,UAAZA,WAAqBH,AAAkB,MAAlBA,OAAO,MAAM,EAClC,MAAM,IAAIK,MACN,CAAC,yBAAyB,EAAEJ,KAAK,qDAAqD,CAAC;QAI/F,IAAIK,cAAc;QAClB,KAAK,MAAMC,SAASP,OAChB,IAAI,AAAiB,YAAjB,OAAOO,OAAoB;YAC3BD,cAAc;YACd;QACJ;QAGJ,KAAK,MAAMC,SAASP,OAChBF,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,MAAM;gBACF,CAACQ,cAAcJ,WAAWD,KAAK,EAAEM;YACrC;QACJ;IAER;AACJ;AAEO,MAAMC,QAAQC,+BAA+B,oBAAoB,CAAC;IACrE,gBAAgBZ;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchQueryBuilderOperator/operators/Between.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class BetweenImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const Between: typeof BetweenImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/Between.js

@@ -0,0 +1,27 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class BetweenImpl {
+    getOperator() {
+        return "between";
+    }
+    apply(query, params) {
+        const { value, basePath, name } = params;
+        if (false === Array.isArray(value)) throw new Error(`You cannot filter field path "${name}" with between query and not send an array of values.`);
+        else if (2 !== value.length) throw new Error(`You must pass 2 values in the array for field path "${name}" filtering.`);
+        const [gte, lte] = value;
+        query.filter.push({
+            range: {
+                [basePath]: {
+                    lte,
+                    gte
+                }
+            }
+        });
+    }
+}
+const Between = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: BetweenImpl,
+    dependencies: []
+});
+export { Between };
+
+//# sourceMappingURL=Between.js.map

package/features/OpenSearchQueryBuilderOperator/operators/Between.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/Between.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/Between.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass BetweenImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"between\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value, basePath, name } = params;\n        if (Array.isArray(value) === false) {\n            throw new Error(\n                `You cannot filter field path \"${name}\" with between query and not send an array of values.`\n            );\n        } else if (value.length !== 2) {\n            throw new Error(\n                `You must pass 2 values in the array for field path \"${name}\" filtering.`\n            );\n        }\n        const [gte, lte] = value;\n        query.filter.push({\n            range: {\n                [basePath]: {\n                    lte,\n                    gte\n                }\n            }\n        });\n    }\n}\n\nexport const Between = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: BetweenImpl,\n    dependencies: []\n});\n"],"names":["BetweenImpl","query","params","value","basePath","name","Array","Error","gte","lte","Between","OpenSearchQueryBuilderOperator"],"mappings":";AAEA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAEC,IAAI,EAAE,GAAGH;QAClC,IAAII,AAAyB,UAAzBA,MAAM,OAAO,CAACH,QACd,MAAM,IAAII,MACN,CAAC,8BAA8B,EAAEF,KAAK,qDAAqD,CAAC;aAE7F,IAAIF,AAAiB,MAAjBA,MAAM,MAAM,EACnB,MAAM,IAAII,MACN,CAAC,oDAAoD,EAAEF,KAAK,YAAY,CAAC;QAGjF,MAAM,CAACG,KAAKC,IAAI,GAAGN;QACnBF,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,OAAO;gBACH,CAACG,SAAS,EAAE;oBACRK;oBACAD;gBACJ;YACJ;QACJ;IACJ;AACJ;AAEO,MAAME,UAAUC,+BAA+B,oBAAoB,CAAC;IACvE,gBAAgBX;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchQueryBuilderOperator/operators/Contains.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class ContainsImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const Contains: typeof ContainsImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/Contains.js

@@ -0,0 +1,27 @@
+import { normalizeValueWithAsterisk } from "../../../normalize.js";
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class ContainsImpl {
+    getOperator() {
+        return "contains";
+    }
+    apply(query, params) {
+        const { value, basePath } = params;
+        query.must.push({
+            query_string: {
+                allow_leading_wildcard: true,
+                fields: [
+                    basePath
+                ],
+                query: normalizeValueWithAsterisk(value),
+                default_operator: "and"
+            }
+        });
+    }
+}
+const Contains = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: ContainsImpl,
+    dependencies: []
+});
+export { Contains };
+
+//# sourceMappingURL=Contains.js.map

package/features/OpenSearchQueryBuilderOperator/operators/Contains.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/Contains.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/Contains.ts"],"sourcesContent":["import { normalizeValueWithAsterisk } from \"~/normalize.js\";\nimport { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass ContainsImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"contains\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value, basePath } = params;\n        query.must.push({\n            query_string: {\n                allow_leading_wildcard: true,\n                fields: [basePath],\n                query: normalizeValueWithAsterisk(value),\n                default_operator: \"and\"\n            }\n        });\n    }\n}\n\nexport const Contains = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: ContainsImpl,\n    dependencies: []\n});\n"],"names":["ContainsImpl","query","params","value","basePath","normalizeValueWithAsterisk","Contains","OpenSearchQueryBuilderOperator"],"mappings":";;AAGA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGF;QAC5BD,MAAM,IAAI,CAAC,IAAI,CAAC;YACZ,cAAc;gBACV,wBAAwB;gBACxB,QAAQ;oBAACG;iBAAS;gBAClB,OAAOC,2BAA2BF;gBAClC,kBAAkB;YACtB;QACJ;IACJ;AACJ;AAEO,MAAMG,WAAWC,+BAA+B,oBAAoB,CAAC;IACxE,gBAAgBP;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchQueryBuilderOperator/operators/Equal.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class EqualImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const Equal: typeof EqualImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/Equal.js

@@ -0,0 +1,34 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class EqualImpl {
+    getOperator() {
+        return "eq";
+    }
+    apply(query, params) {
+        const { value, path, basePath } = params;
+        if (null == value) return void query.must_not.push({
+            exists: {
+                field: path
+            }
+        });
+        const typeOf = typeof value;
+        if ("number" === typeOf || "boolean" === typeOf) return void query.filter.push({
+            term: {
+                [basePath]: value
+            }
+        });
+        const useBasePath = "string" !== typeOf;
+        const valuePath = useBasePath ? basePath : path;
+        query.filter.push({
+            term: {
+                [valuePath]: value
+            }
+        });
+    }
+}
+const Equal = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: EqualImpl,
+    dependencies: []
+});
+export { Equal };
+
+//# sourceMappingURL=Equal.js.map

package/features/OpenSearchQueryBuilderOperator/operators/Equal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/Equal.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/Equal.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass EqualImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"eq\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value, path, basePath } = params;\n\n        if (value === null || value === undefined) {\n            query.must_not.push({\n                exists: {\n                    field: path\n                }\n            });\n            return;\n        }\n        const typeOf = typeof value;\n        if (typeOf === \"number\" || typeOf === \"boolean\") {\n            query.filter.push({\n                term: {\n                    [basePath]: value\n                }\n            });\n            return;\n        }\n        const useBasePath = typeOf !== \"string\";\n        const valuePath = useBasePath ? basePath : path;\n        query.filter.push({\n            term: {\n                [valuePath]: value\n            }\n        });\n    }\n}\n\nexport const Equal = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: EqualImpl,\n    dependencies: []\n});\n"],"names":["EqualImpl","query","params","value","path","basePath","typeOf","useBasePath","valuePath","Equal","OpenSearchQueryBuilderOperator"],"mappings":";AAEA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAEC,KAAK,EAAEC,IAAI,EAAEC,QAAQ,EAAE,GAAGH;QAElC,IAAIC,QAAAA,OAAuC,YACvCF,MAAM,QAAQ,CAAC,IAAI,CAAC;YAChB,QAAQ;gBACJ,OAAOG;YACX;QACJ;QAGJ,MAAME,SAAS,OAAOH;QACtB,IAAIG,AAAW,aAAXA,UAAuBA,AAAW,cAAXA,QAAsB,YAC7CL,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,MAAM;gBACF,CAACI,SAAS,EAAEF;YAChB;QACJ;QAGJ,MAAMI,cAAcD,AAAW,aAAXA;QACpB,MAAME,YAAYD,cAAcF,WAAWD;QAC3CH,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,MAAM;gBACF,CAACO,UAAU,EAAEL;YACjB;QACJ;IACJ;AACJ;AAEO,MAAMM,QAAQC,+BAA+B,oBAAoB,CAAC;IACrE,gBAAgBV;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchQueryBuilderOperator/operators/GreaterThan.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class GreaterThanImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const GreaterThan: typeof GreaterThanImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/GreaterThan.js

@@ -0,0 +1,23 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class GreaterThanImpl {
+    getOperator() {
+        return "gt";
+    }
+    apply(query, params) {
+        const { value, basePath } = params;
+        query.filter.push({
+            range: {
+                [basePath]: {
+                    gt: value
+                }
+            }
+        });
+    }
+}
+const GreaterThan = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: GreaterThanImpl,
+    dependencies: []
+});
+export { GreaterThan };
+
+//# sourceMappingURL=GreaterThan.js.map

package/features/OpenSearchQueryBuilderOperator/operators/GreaterThan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/GreaterThan.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/GreaterThan.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass GreaterThanImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"gt\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value, basePath } = params;\n        query.filter.push({\n            range: {\n                [basePath]: {\n                    gt: value\n                }\n            }\n        });\n    }\n}\n\nexport const GreaterThan = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: GreaterThanImpl,\n    dependencies: []\n});\n"],"names":["GreaterThanImpl","query","params","value","basePath","GreaterThan","OpenSearchQueryBuilderOperator"],"mappings":";AAEA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGF;QAC5BD,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,OAAO;gBACH,CAACG,SAAS,EAAE;oBACR,IAAID;gBACR;YACJ;QACJ;IACJ;AACJ;AAEO,MAAME,cAAcC,+BAA+B,oBAAoB,CAAC;IAC3E,gBAAgBN;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchQueryBuilderOperator/operators/GreaterThanOrEqual.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class GreaterThanOrEqualImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const GreaterThanOrEqual: typeof GreaterThanOrEqualImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/GreaterThanOrEqual.js

@@ -0,0 +1,23 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class GreaterThanOrEqualImpl {
+    getOperator() {
+        return "gte";
+    }
+    apply(query, params) {
+        const { value, basePath } = params;
+        query.filter.push({
+            range: {
+                [basePath]: {
+                    gte: value
+                }
+            }
+        });
+    }
+}
+const GreaterThanOrEqual = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: GreaterThanOrEqualImpl,
+    dependencies: []
+});
+export { GreaterThanOrEqual };
+
+//# sourceMappingURL=GreaterThanOrEqual.js.map

package/features/OpenSearchQueryBuilderOperator/operators/GreaterThanOrEqual.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/GreaterThanOrEqual.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/GreaterThanOrEqual.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass GreaterThanOrEqualImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"gte\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value, basePath } = params;\n        query.filter.push({\n            range: {\n                [basePath]: {\n                    gte: value\n                }\n            }\n        });\n    }\n}\n\nexport const GreaterThanOrEqual = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: GreaterThanOrEqualImpl,\n    dependencies: []\n});\n"],"names":["GreaterThanOrEqualImpl","query","params","value","basePath","GreaterThanOrEqual","OpenSearchQueryBuilderOperator"],"mappings":";AAEA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGF;QAC5BD,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,OAAO;gBACH,CAACG,SAAS,EAAE;oBACR,KAAKD;gBACT;YACJ;QACJ;IACJ;AACJ;AAEO,MAAME,qBAAqBC,+BAA+B,oBAAoB,CAAC;IAClF,gBAAgBN;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchQueryBuilderOperator/operators/In.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class InImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const In: typeof InImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/In.js

@@ -0,0 +1,24 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class InImpl {
+    getOperator() {
+        return "in";
+    }
+    apply(query, params) {
+        const { value: values, path, basePath, name } = params;
+        const isArray = Array.isArray(values);
+        if (false === isArray || 0 === values.length) throw new Error(`You cannot filter field "${name}" with "in" operator and not send an array of values.`);
+        const useBasePath = values.some((value)=>"string" != typeof value);
+        query.filter.push({
+            terms: {
+                [useBasePath ? basePath : path]: values
+            }
+        });
+    }
+}
+const In = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: InImpl,
+    dependencies: []
+});
+export { In };
+
+//# sourceMappingURL=In.js.map

package/features/OpenSearchQueryBuilderOperator/operators/In.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/In.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/In.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass InImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"in\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value: values, path, basePath, name } = params;\n        const isArray = Array.isArray(values);\n        if (isArray === false || values.length === 0) {\n            throw new Error(\n                `You cannot filter field \"${name}\" with \"in\" operator and not send an array of values.`\n            );\n        }\n\n        const useBasePath = values.some(\n            (value: string | number | boolean | null | undefined) => typeof value !== \"string\"\n        );\n\n        query.filter.push({\n            terms: {\n                [useBasePath ? basePath : path]: values\n            }\n        });\n    }\n}\n\nexport const In = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: InImpl,\n    dependencies: []\n});\n"],"names":["InImpl","query","params","values","path","basePath","name","isArray","Array","Error","useBasePath","value","In","OpenSearchQueryBuilderOperator"],"mappings":";AAEA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAE,OAAOC,MAAM,EAAEC,IAAI,EAAEC,QAAQ,EAAEC,IAAI,EAAE,GAAGJ;QAChD,MAAMK,UAAUC,MAAM,OAAO,CAACL;QAC9B,IAAII,AAAY,UAAZA,WAAqBJ,AAAkB,MAAlBA,OAAO,MAAM,EAClC,MAAM,IAAIM,MACN,CAAC,yBAAyB,EAAEH,KAAK,qDAAqD,CAAC;QAI/F,MAAMI,cAAcP,OAAO,IAAI,CAC3B,CAACQ,QAAwD,AAAiB,YAAjB,OAAOA;QAGpEV,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,OAAO;gBACH,CAACS,cAAcL,WAAWD,KAAK,EAAED;YACrC;QACJ;IACJ;AACJ;AAEO,MAAMS,KAAKC,+BAA+B,oBAAoB,CAAC;IAClE,gBAAgBb;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchQueryBuilderOperator/operators/LesserThan.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class LesserThanImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const LesserThan: typeof LesserThanImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/LesserThan.js

@@ -0,0 +1,23 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class LesserThanImpl {
+    getOperator() {
+        return "lt";
+    }
+    apply(query, params) {
+        const { value, basePath } = params;
+        query.filter.push({
+            range: {
+                [basePath]: {
+                    lt: value
+                }
+            }
+        });
+    }
+}
+const LesserThan = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: LesserThanImpl,
+    dependencies: []
+});
+export { LesserThan };
+
+//# sourceMappingURL=LesserThan.js.map

package/features/OpenSearchQueryBuilderOperator/operators/LesserThan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/LesserThan.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/LesserThan.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass LesserThanImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"lt\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value, basePath } = params;\n        query.filter.push({\n            range: {\n                [basePath]: {\n                    lt: value\n                }\n            }\n        });\n    }\n}\n\nexport const LesserThan = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: LesserThanImpl,\n    dependencies: []\n});\n"],"names":["LesserThanImpl","query","params","value","basePath","LesserThan","OpenSearchQueryBuilderOperator"],"mappings":";AAEA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGF;QAC5BD,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,OAAO;gBACH,CAACG,SAAS,EAAE;oBACR,IAAID;gBACR;YACJ;QACJ;IACJ;AACJ;AAEO,MAAME,aAAaC,+BAA+B,oBAAoB,CAAC;IAC1E,gBAAgBN;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchQueryBuilderOperator/operators/LesserThanOrEqual.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class LesserThanOrEqualImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const LesserThanOrEqual: typeof LesserThanOrEqualImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/LesserThanOrEqual.js

@@ -0,0 +1,23 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class LesserThanOrEqualImpl {
+    getOperator() {
+        return "lte";
+    }
+    apply(query, params) {
+        const { value, basePath } = params;
+        query.filter.push({
+            range: {
+                [basePath]: {
+                    lte: value
+                }
+            }
+        });
+    }
+}
+const LesserThanOrEqual = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: LesserThanOrEqualImpl,
+    dependencies: []
+});
+export { LesserThanOrEqual };
+
+//# sourceMappingURL=LesserThanOrEqual.js.map

package/features/OpenSearchQueryBuilderOperator/operators/LesserThanOrEqual.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/LesserThanOrEqual.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/LesserThanOrEqual.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass LesserThanOrEqualImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"lte\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value, basePath } = params;\n        query.filter.push({\n            range: {\n                [basePath]: {\n                    lte: value\n                }\n            }\n        });\n    }\n}\n\nexport const LesserThanOrEqual = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: LesserThanOrEqualImpl,\n    dependencies: []\n});\n"],"names":["LesserThanOrEqualImpl","query","params","value","basePath","LesserThanOrEqual","OpenSearchQueryBuilderOperator"],"mappings":";AAEA,MAAMA;IACK,cAAsB;QACzB,OAAO;IACX;IAEO,MACHC,KAA2C,EAC3CC,MAA6C,EACzC;QACJ,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGF;QAC5BD,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,OAAO;gBACH,CAACG,SAAS,EAAE;oBACR,KAAKD;gBACT;YACJ;QACJ;IACJ;AACJ;AAEO,MAAME,oBAAoBC,+BAA+B,oBAAoB,CAAC;IACjF,gBAAgBN;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchQueryBuilderOperator/operators/Not.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+declare class NotImpl implements OpenSearchQueryBuilderOperator.Interface {
+    getOperator(): string;
+    apply(query: OpenSearchQueryBuilderOperator.Query, params: OpenSearchQueryBuilderOperator.Params): void;
+}
+export declare const Not: typeof NotImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/OpenSearchQueryBuilderOperator.js").IOpenSearchQueryBuilderOperator>;
+};
+export {};

package/features/OpenSearchQueryBuilderOperator/operators/Not.js

@@ -0,0 +1,38 @@
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class NotImpl {
+    getOperator() {
+        return "not";
+    }
+    apply(query, params) {
+        const { value, path, basePath } = params;
+        if (null == value) return void query.filter.push({
+            exists: {
+                field: path
+            }
+        });
+        const typeOf = typeof value;
+        if ("boolean" === typeOf) return void query.filter.push({
+            bool: {
+                must_not: {
+                    term: {
+                        [path]: value
+                    }
+                }
+            }
+        });
+        const useBasePath = "string" !== typeOf;
+        const valuePath = useBasePath ? basePath : path;
+        query.must_not.push({
+            term: {
+                [valuePath]: value
+            }
+        });
+    }
+}
+const Not = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: NotImpl,
+    dependencies: []
+});
+export { Not };
+
+//# sourceMappingURL=Not.js.map