@webiny/api-opensearch 6.4.5 → 6.6.0-alpha.0

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).inSingletonScope();
+    }
+});
+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.register(OpenSearchQueryBuilderOperatorRegistry).inSingletonScope();\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;QAClDf,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/{plugins/operator/andIn.js → features/OpenSearchQueryBuilderOperator/operators/AndIn.js}

@@ -1,5 +1,5 @@
-import { OpenSearchQueryBuilderOperatorPlugin } from "../definition/OpenSearchQueryBuilderOperatorPlugin.js";
-class OpenSearchQueryBuilderOperatorAndInPlugin extends OpenSearchQueryBuilderOperatorPlugin {
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class AndInImpl {
     getOperator() {
         return "and_in";
     }
@@ -18,10 +18,11 @@ class OpenSearchQueryBuilderOperatorAndInPlugin extends OpenSearchQueryBuilderOp
             }
         });
     }
-    constructor(...args){
-        super(...args), this.name = "opensearch.queryBuilder.operator.andIn.default";
-    }
 }
-export { OpenSearchQueryBuilderOperatorAndInPlugin };
+const AndIn = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: AndInImpl,
+    dependencies: []
+});
+export { AndIn };
 
-//# sourceMappingURL=andIn.js.map
+//# 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/{plugins/operator/between.js → features/OpenSearchQueryBuilderOperator/operators/Between.js}

@@ -1,5 +1,5 @@
-import { OpenSearchQueryBuilderOperatorPlugin } from "../definition/OpenSearchQueryBuilderOperatorPlugin.js";
-class OpenSearchQueryBuilderOperatorBetweenPlugin extends OpenSearchQueryBuilderOperatorPlugin {
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class BetweenImpl {
     getOperator() {
         return "between";
     }
@@ -17,10 +17,11 @@ class OpenSearchQueryBuilderOperatorBetweenPlugin extends OpenSearchQueryBuilder
             }
         });
     }
-    constructor(...args){
-        super(...args), this.name = "opensearch.queryBuilder.operator.between.default";
-    }
 }
-export { OpenSearchQueryBuilderOperatorBetweenPlugin };
+const Between = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: BetweenImpl,
+    dependencies: []
+});
+export { Between };
 
-//# sourceMappingURL=between.js.map
+//# 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;QAE7F,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/{plugins/operator/equal.js → features/OpenSearchQueryBuilderOperator/operators/Equal.js}

@@ -1,5 +1,5 @@
-import { OpenSearchQueryBuilderOperatorPlugin } from "../definition/OpenSearchQueryBuilderOperatorPlugin.js";
-class OpenSearchQueryBuilderOperatorEqualPlugin extends OpenSearchQueryBuilderOperatorPlugin {
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class EqualImpl {
     getOperator() {
         return "eq";
     }
@@ -24,10 +24,11 @@ class OpenSearchQueryBuilderOperatorEqualPlugin extends OpenSearchQueryBuilderOp
             }
         });
     }
-    constructor(...args){
-        super(...args), this.name = "opensearch.queryBuilder.operator.equal.default";
-    }
 }
-export { OpenSearchQueryBuilderOperatorEqualPlugin };
+const Equal = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: EqualImpl,
+    dependencies: []
+});
+export { Equal };
 
-//# sourceMappingURL=equal.js.map
+//# 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/{plugins/operator/in.js → features/OpenSearchQueryBuilderOperator/operators/In.js}

@@ -1,5 +1,5 @@
-import { OpenSearchQueryBuilderOperatorPlugin } from "../definition/OpenSearchQueryBuilderOperatorPlugin.js";
-class OpenSearchQueryBuilderOperatorInPlugin extends OpenSearchQueryBuilderOperatorPlugin {
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class InImpl {
     getOperator() {
         return "in";
     }
@@ -14,10 +14,11 @@ class OpenSearchQueryBuilderOperatorInPlugin extends OpenSearchQueryBuilderOpera
             }
         });
     }
-    constructor(...args){
-        super(...args), this.name = "opensearch.queryBuilder.operator.in.default";
-    }
 }
-export { OpenSearchQueryBuilderOperatorInPlugin };
+const In = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: InImpl,
+    dependencies: []
+});
+export { In };
 
-//# sourceMappingURL=in.js.map
+//# 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/{plugins/operator/not.js → features/OpenSearchQueryBuilderOperator/operators/Not.js}

@@ -1,5 +1,5 @@
-import { OpenSearchQueryBuilderOperatorPlugin } from "../definition/OpenSearchQueryBuilderOperatorPlugin.js";
-class OpenSearchQueryBuilderOperatorNotPlugin extends OpenSearchQueryBuilderOperatorPlugin {
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class NotImpl {
     getOperator() {
         return "not";
     }
@@ -28,10 +28,11 @@ class OpenSearchQueryBuilderOperatorNotPlugin extends OpenSearchQueryBuilderOper
             }
         });
     }
-    constructor(...args){
-        super(...args), this.name = "opensearch.queryBuilder.operator.not.default";
-    }
 }
-export { OpenSearchQueryBuilderOperatorNotPlugin };
+const Not = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: NotImpl,
+    dependencies: []
+});
+export { Not };
 
-//# sourceMappingURL=not.js.map
+//# sourceMappingURL=Not.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/Not.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/Not.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass NotImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"not\";\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.filter.push({\n                exists: {\n                    field: path\n                }\n            });\n            return;\n        }\n\n        const typeOf = typeof value;\n\n        if (typeOf === \"boolean\") {\n            query.filter.push({\n                bool: {\n                    must_not: {\n                        term: {\n                            [path]: value\n                        }\n                    }\n                }\n            });\n            return;\n        }\n\n        const useBasePath = typeOf !== \"string\";\n        const valuePath = useBasePath ? basePath : path;\n        query.must_not.push({\n            term: {\n                [valuePath]: value\n            }\n        });\n    }\n}\n\nexport const Not = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: NotImpl,\n    dependencies: []\n});\n"],"names":["NotImpl","query","params","value","path","basePath","typeOf","useBasePath","valuePath","Not","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,MAAM,CAAC,IAAI,CAAC;YACd,QAAQ;gBACJ,OAAOG;YACX;QACJ;QAIJ,MAAME,SAAS,OAAOH;QAEtB,IAAIG,AAAW,cAAXA,QAAsB,YACtBL,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,MAAM;gBACF,UAAU;oBACN,MAAM;wBACF,CAACG,KAAK,EAAED;oBACZ;gBACJ;YACJ;QACJ;QAIJ,MAAMI,cAAcD,AAAW,aAAXA;QACpB,MAAME,YAAYD,cAAcF,WAAWD;QAC3CH,MAAM,QAAQ,CAAC,IAAI,CAAC;YAChB,MAAM;gBACF,CAACO,UAAU,EAAEL;YACjB;QACJ;IACJ;AACJ;AAEO,MAAMM,MAAMC,+BAA+B,oBAAoB,CAAC;IACnE,gBAAgBV;IAChB,cAAc,EAAE;AACpB"}

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

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

package/{plugins/operator/notBetween.js → features/OpenSearchQueryBuilderOperator/operators/NotBetween.js}

@@ -1,5 +1,5 @@
-import { OpenSearchQueryBuilderOperatorPlugin } from "../definition/OpenSearchQueryBuilderOperatorPlugin.js";
-class OpenSearchQueryBuilderOperatorNotBetweenPlugin extends OpenSearchQueryBuilderOperatorPlugin {
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class NotBetweenImpl {
     getOperator() {
         return "not_between";
     }
@@ -17,10 +17,11 @@ class OpenSearchQueryBuilderOperatorNotBetweenPlugin extends OpenSearchQueryBuil
             }
         });
     }
-    constructor(...args){
-        super(...args), this.name = "opensearch.queryBuilder.operator.notBetween.default";
-    }
 }
-export { OpenSearchQueryBuilderOperatorNotBetweenPlugin };
+const NotBetween = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: NotBetweenImpl,
+    dependencies: []
+});
+export { NotBetween };
 
-//# sourceMappingURL=notBetween.js.map
+//# sourceMappingURL=NotBetween.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/NotBetween.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/NotBetween.ts"],"sourcesContent":["import { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass NotBetweenImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"not_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 \"not_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.must_not.push({\n            range: {\n                [basePath]: {\n                    lte,\n                    gte\n                }\n            }\n        });\n    }\n}\n\nexport const NotBetween = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: NotBetweenImpl,\n    dependencies: []\n});\n"],"names":["NotBetweenImpl","query","params","value","basePath","name","Array","Error","gte","lte","NotBetween","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,2DAA2D,CAAC;QAEnG,IAAIF,AAAiB,MAAjBA,MAAM,MAAM,EACnB,MAAM,IAAII,MACN,CAAC,oDAAoD,EAAEF,KAAK,YAAY,CAAC;QAGjF,MAAM,CAACG,KAAKC,IAAI,GAAGN;QACnBF,MAAM,QAAQ,CAAC,IAAI,CAAC;YAChB,OAAO;gBACH,CAACG,SAAS,EAAE;oBACRK;oBACAD;gBACJ;YACJ;QACJ;IACJ;AACJ;AAEO,MAAME,aAAaC,+BAA+B,oBAAoB,CAAC;IAC1E,gBAAgBX;IAChB,cAAc,EAAE;AACpB"}

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

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

package/features/OpenSearchQueryBuilderOperator/operators/NotContains.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchQueryBuilderOperator/operators/NotContains.js","sources":["../../../../src/features/OpenSearchQueryBuilderOperator/operators/NotContains.ts"],"sourcesContent":["import { normalizeValueWithAsterisk } from \"~/normalize.js\";\nimport { OpenSearchQueryBuilderOperator } from \"../abstractions/OpenSearchQueryBuilderOperator.js\";\n\nclass NotContainsImpl implements OpenSearchQueryBuilderOperator.Interface {\n    public getOperator(): string {\n        return \"not_contains\";\n    }\n\n    public apply(\n        query: OpenSearchQueryBuilderOperator.Query,\n        params: OpenSearchQueryBuilderOperator.Params\n    ): void {\n        const { value, basePath } = params;\n        query.must_not.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 NotContains = OpenSearchQueryBuilderOperator.createImplementation({\n    implementation: NotContainsImpl,\n    dependencies: []\n});\n"],"names":["NotContainsImpl","query","params","value","basePath","normalizeValueWithAsterisk","NotContains","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,QAAQ,CAAC,IAAI,CAAC;YAChB,cAAc;gBACV,wBAAwB;gBACxB,QAAQ;oBAACG;iBAAS;gBAClB,OAAOC,2BAA2BF;gBAClC,kBAAkB;YACtB;QACJ;IACJ;AACJ;AAEO,MAAMG,cAAcC,+BAA+B,oBAAoB,CAAC;IAC3E,gBAAgBP;IAChB,cAAc,EAAE;AACpB"}

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

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

package/{plugins/operator/notIn.js → features/OpenSearchQueryBuilderOperator/operators/NotIn.js}

@@ -1,5 +1,5 @@
-import { OpenSearchQueryBuilderOperatorPlugin } from "../definition/OpenSearchQueryBuilderOperatorPlugin.js";
-class OpenSearchQueryBuilderOperatorNotInPlugin extends OpenSearchQueryBuilderOperatorPlugin {
+import { OpenSearchQueryBuilderOperator } from "../abstractions/OpenSearchQueryBuilderOperator.js";
+class NotInImpl {
     getOperator() {
         return "not_in";
     }
@@ -14,10 +14,11 @@ class OpenSearchQueryBuilderOperatorNotInPlugin extends OpenSearchQueryBuilderOp
             }
         });
     }
-    constructor(...args){
-        super(...args), this.name = "opensearch.queryBuilder.operator.notIn.default";
-    }
 }
-export { OpenSearchQueryBuilderOperatorNotInPlugin };
+const NotIn = OpenSearchQueryBuilderOperator.createImplementation({
+    implementation: NotInImpl,
+    dependencies: []
+});
+export { NotIn };
 
-//# sourceMappingURL=notIn.js.map
+//# sourceMappingURL=NotIn.js.map