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

package/LICENSE

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

package/README.md

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

package/client.d.ts

@@ -0,0 +1,8 @@
+import { Client } from "@opensearch-project/opensearch";
+import type { ClientOptions } from "@opensearch-project/opensearch";
+export interface OpenSearchClientOptions extends ClientOptions {
+    endpoint?: string;
+}
+export { Client };
+export type { OpenSearchClientOptions as ClientOptions };
+export declare const createOpenSearchClient: (options: OpenSearchClientOptions) => Client;

package/client.js

@@ -0,0 +1,37 @@
+import crypto_0 from "crypto";
+import error from "@webiny/error";
+import { Client } from "@opensearch-project/opensearch";
+const clients = new Map();
+const createClientKey = (options)=>{
+    const key = JSON.stringify(options);
+    const hash = crypto_0.createHash("sha256");
+    hash.update(key);
+    return hash.digest("hex");
+};
+const createOpenSearchClient = (options)=>{
+    const key = createClientKey(options);
+    const existing = clients.get(key);
+    if (existing) return existing;
+    const { endpoint, node, ...rest } = options;
+    const clientOptions = {
+        node: endpoint || node,
+        ...rest
+    };
+    try {
+        const client = new Client(clientOptions);
+        clients.set(key, client);
+        return client;
+    } catch (ex) {
+        const data = {
+            error: ex,
+            node: endpoint || node,
+            ...rest,
+            auth: void 0
+        };
+        console.error(data);
+        throw new error("Could not connect to OpenSearch.", "OPENSEARCH_CLIENT_ERROR", data);
+    }
+};
+export { Client, createOpenSearchClient };
+
+//# sourceMappingURL=client.js.map

package/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sources":["../src/client.ts"],"sourcesContent":["import crypto from \"crypto\";\nimport WebinyError from \"@webiny/error\";\nimport { Client } from \"@opensearch-project/opensearch\";\nimport type { ClientOptions } from \"@opensearch-project/opensearch\";\n\nexport interface OpenSearchClientOptions extends ClientOptions {\n    endpoint?: string;\n}\n\nexport { Client };\nexport type { OpenSearchClientOptions as ClientOptions };\n\nconst clients = new Map<string, Client>();\n\nconst createClientKey = (options: OpenSearchClientOptions): string => {\n    const key = JSON.stringify(options);\n    const hash = crypto.createHash(\"sha256\");\n    hash.update(key);\n    return hash.digest(\"hex\");\n};\n\nexport const createOpenSearchClient = (options: OpenSearchClientOptions): Client => {\n    const key = createClientKey(options);\n    const existing = clients.get(key);\n    if (existing) {\n        return existing;\n    }\n\n    const { endpoint, node, ...rest } = options;\n\n    const clientOptions: ClientOptions = {\n        node: endpoint || node,\n        ...rest\n    };\n\n    try {\n        const client = new Client(clientOptions);\n        clients.set(key, client);\n        return client;\n    } catch (ex) {\n        const data = {\n            error: ex,\n            node: endpoint || node,\n            ...rest,\n            auth: undefined\n        };\n        console.error(data);\n        throw new WebinyError(\"Could not connect to OpenSearch.\", \"OPENSEARCH_CLIENT_ERROR\", data);\n    }\n};\n"],"names":["clients","Map","createClientKey","options","key","JSON","hash","crypto","createOpenSearchClient","existing","endpoint","node","rest","clientOptions","client","Client","ex","data","undefined","console","WebinyError"],"mappings":";;;AAYA,MAAMA,UAAU,IAAIC;AAEpB,MAAMC,kBAAkB,CAACC;IACrB,MAAMC,MAAMC,KAAK,SAAS,CAACF;IAC3B,MAAMG,OAAOC,SAAAA,UAAiB,CAAC;IAC/BD,KAAK,MAAM,CAACF;IACZ,OAAOE,KAAK,MAAM,CAAC;AACvB;AAEO,MAAME,yBAAyB,CAACL;IACnC,MAAMC,MAAMF,gBAAgBC;IAC5B,MAAMM,WAAWT,QAAQ,GAAG,CAACI;IAC7B,IAAIK,UACA,OAAOA;IAGX,MAAM,EAAEC,QAAQ,EAAEC,IAAI,EAAE,GAAGC,MAAM,GAAGT;IAEpC,MAAMU,gBAA+B;QACjC,MAAMH,YAAYC;QAClB,GAAGC,IAAI;IACX;IAEA,IAAI;QACA,MAAME,SAAS,IAAIC,OAAOF;QAC1Bb,QAAQ,GAAG,CAACI,KAAKU;QACjB,OAAOA;IACX,EAAE,OAAOE,IAAI;QACT,MAAMC,OAAO;YACT,OAAOD;YACP,MAAMN,YAAYC;YAClB,GAAGC,IAAI;YACP,MAAMM;QACV;QACAC,QAAQ,KAAK,CAACF;QACd,MAAM,IAAIG,MAAY,oCAAoC,2BAA2BH;IACzF;AACJ"}

package/cursors.d.ts

@@ -0,0 +1,10 @@
+import type { PrimitiveValue } from "./types.js";
+/**
+ * Encode a received cursor value into something that can be passed on to the user.
+ */
+export declare const encodeCursor: (input?: PrimitiveValue[]) => string | undefined;
+/**
+ * Decode a received value into an OpenSearch cursor.
+ * If no value is received or is not decodable, return undefined.
+ */
+export declare const decodeCursor: (cursor?: string | null) => PrimitiveValue[] | undefined;

package/cursors.js

@@ -0,0 +1,25 @@
+const encodeCursor = (input)=>{
+    if (!input) return;
+    const cursor = Array.isArray(input) ? input.filter((item)=>null != item).map((item)=>encodeURIComponent(item)) : encodeURIComponent(input);
+    try {
+        return Buffer.from(JSON.stringify(cursor)).toString("base64");
+    } catch (ex) {
+        console.error(ex.message);
+    }
+};
+const decodeCursor = (cursor)=>{
+    if (!cursor) return;
+    try {
+        const value = JSON.parse(Buffer.from(cursor, "base64").toString("ascii"));
+        if (Array.isArray(value)) return value.filter((item)=>null !== item).map(decodeURIComponent);
+        const decoded = decodeURIComponent(value);
+        return decoded ? [
+            decoded
+        ] : void 0;
+    } catch (ex) {
+        console.error(ex.message);
+    }
+};
+export { decodeCursor, encodeCursor };
+
+//# sourceMappingURL=cursors.js.map

package/cursors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursors.js","sources":["../src/cursors.ts"],"sourcesContent":["import type { PrimitiveValue } from \"~/types.js\";\n\n/**\n * Encode a received cursor value into something that can be passed on to the user.\n */\nexport const encodeCursor = (input?: PrimitiveValue[]): string | undefined => {\n    if (!input) {\n        return undefined;\n    }\n\n    const cursor = Array.isArray(input)\n        ? input\n              .filter((item: PrimitiveValue): item is string | number | boolean => item != null)\n              .map(item => encodeURIComponent(item))\n        : encodeURIComponent(input);\n\n    try {\n        return Buffer.from(JSON.stringify(cursor)).toString(\"base64\");\n    } catch (ex) {\n        console.error(ex.message);\n    }\n    return undefined;\n};\n/**\n * Decode a received value into an OpenSearch cursor.\n * If no value is received or is not decodable, return undefined.\n */\nexport const decodeCursor = (cursor?: string | null): PrimitiveValue[] | undefined => {\n    if (!cursor) {\n        return undefined;\n    }\n    try {\n        const value = JSON.parse(Buffer.from(cursor, \"base64\").toString(\"ascii\"));\n        if (Array.isArray(value)) {\n            return value.filter(item => item !== null).map(decodeURIComponent);\n        }\n        const decoded = decodeURIComponent(value);\n        return decoded ? [decoded] : undefined;\n    } catch (ex) {\n        console.error(ex.message);\n    }\n    return undefined;\n};\n"],"names":["encodeCursor","input","cursor","Array","item","encodeURIComponent","Buffer","JSON","ex","console","decodeCursor","value","decodeURIComponent","decoded","undefined"],"mappings":"AAKO,MAAMA,eAAe,CAACC;IACzB,IAAI,CAACA,OACD;IAGJ,MAAMC,SAASC,MAAM,OAAO,CAACF,SACvBA,MACK,MAAM,CAAC,CAACG,OAA4DA,AAAQ,QAARA,MACpE,GAAG,CAACA,CAAAA,OAAQC,mBAAmBD,SACpCC,mBAAmBJ;IAEzB,IAAI;QACA,OAAOK,OAAO,IAAI,CAACC,KAAK,SAAS,CAACL,SAAS,QAAQ,CAAC;IACxD,EAAE,OAAOM,IAAI;QACTC,QAAQ,KAAK,CAACD,GAAG,OAAO;IAC5B;AAEJ;AAKO,MAAME,eAAe,CAACR;IACzB,IAAI,CAACA,QACD;IAEJ,IAAI;QACA,MAAMS,QAAQJ,KAAK,KAAK,CAACD,OAAO,IAAI,CAACJ,QAAQ,UAAU,QAAQ,CAAC;QAChE,IAAIC,MAAM,OAAO,CAACQ,QACd,OAAOA,MAAM,MAAM,CAACP,CAAAA,OAAQA,AAAS,SAATA,MAAe,GAAG,CAACQ;QAEnD,MAAMC,UAAUD,mBAAmBD;QACnC,OAAOE,UAAU;YAACA;SAAQ,GAAGC;IACjC,EAAE,OAAON,IAAI;QACTC,QAAQ,KAAK,CAACD,GAAG,OAAO;IAC5B;AAEJ"}

package/exports/api/opensearch.d.ts

@@ -0,0 +1,9 @@
+export { createOpenSearchClient } from "../../client.js";
+export { OpenSearchClient } from "../../features/OpenSearchClient/abstraction.js";
+export { OpenSearchClientFactory } from "../../features/OpenSearchClientFactory/abstraction.js";
+export { OpenSearchQueryBuilderOperator } from "../../features/OpenSearchQueryBuilderOperator/abstractions/OpenSearchQueryBuilderOperator.js";
+export { OpenSearchQueryBuilderOperatorRegistry } from "../../features/OpenSearchQueryBuilderOperator/abstractions/OpenSearchQueryBuilderOperatorRegistry.js";
+export { OpenSearchField, OpenSearchFieldAll } from "../../features/OpenSearchField/abstractions/OpenSearchField.js";
+export { OpenSearchFieldFactory } from "../../features/OpenSearchField/abstractions/OpenSearchFieldFactory.js";
+export { OpenSearchIndex } from "../../features/OpenSearchIndex/abstractions/OpenSearchIndex.js";
+export { OpenSearchIndexRegistry } from "../../features/OpenSearchIndex/abstractions/OpenSearchIndexRegistry.js";

package/exports/api/opensearch.js

@@ -0,0 +1,9 @@
+export { createOpenSearchClient } from "../../client.js";
+export { OpenSearchClient } from "../../features/OpenSearchClient/abstraction.js";
+export { OpenSearchClientFactory } from "../../features/OpenSearchClientFactory/abstraction.js";
+export { OpenSearchQueryBuilderOperator } from "../../features/OpenSearchQueryBuilderOperator/abstractions/OpenSearchQueryBuilderOperator.js";
+export { OpenSearchQueryBuilderOperatorRegistry } from "../../features/OpenSearchQueryBuilderOperator/abstractions/OpenSearchQueryBuilderOperatorRegistry.js";
+export { OpenSearchField, OpenSearchFieldAll } from "../../features/OpenSearchField/abstractions/OpenSearchField.js";
+export { OpenSearchFieldFactory } from "../../features/OpenSearchField/abstractions/OpenSearchFieldFactory.js";
+export { OpenSearchIndex } from "../../features/OpenSearchIndex/abstractions/OpenSearchIndex.js";
+export { OpenSearchIndexRegistry } from "../../features/OpenSearchIndex/abstractions/OpenSearchIndexRegistry.js";

package/features/OpenSearchClient/abstraction.d.ts

@@ -0,0 +1,9 @@
+import type { Client as IClient } from "../../client.js";
+export interface IOpenSearchClient {
+    use(): IClient;
+}
+export declare const OpenSearchClient: import("@webiny/di").Abstraction<IOpenSearchClient>;
+export declare namespace OpenSearchClient {
+    type Interface = IOpenSearchClient;
+    type Client = IClient;
+}

package/features/OpenSearchClient/abstraction.js

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

package/features/OpenSearchClient/abstraction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchClient/abstraction.js","sources":["../../../src/features/OpenSearchClient/abstraction.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Client as IClient } from \"~/client.js\";\n\nexport interface IOpenSearchClient {\n    use(): IClient;\n}\n\nexport const OpenSearchClient = createAbstraction<IOpenSearchClient>(\"OpenSearch/Client\");\n\nexport namespace OpenSearchClient {\n    export type Interface = IOpenSearchClient;\n    export type Client = IClient;\n}\n"],"names":["OpenSearchClient","createAbstraction"],"mappings":";AAOO,MAAMA,mBAAmBC,kBAAqC"}

package/features/OpenSearchClient/feature.d.ts

@@ -0,0 +1,5 @@
+import type { Client } from "../../client.js";
+export declare const OpenSearchClientFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container, context: Client): void;
+};

package/features/OpenSearchClient/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api/index.js";
+import { OpenSearchClient } from "./abstraction.js";
+const OpenSearchClientFeature = createFeature({
+    name: "opensearch.internal.client",
+    register (container, client) {
+        container.registerInstance(OpenSearchClient, {
+            use: ()=>client
+        });
+    }
+});
+export { OpenSearchClientFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/OpenSearchClient/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchClient/feature.js","sources":["../../../src/features/OpenSearchClient/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api/index.js\";\nimport type { Client } from \"~/client.js\";\nimport { OpenSearchClient } from \"./abstraction.js\";\n\nexport const OpenSearchClientFeature = createFeature<Client>({\n    name: \"opensearch.internal.client\",\n    register(container, client) {\n        container.registerInstance(OpenSearchClient, {\n            use: () => {\n                return client;\n            }\n        });\n    }\n});\n"],"names":["OpenSearchClientFeature","createFeature","container","client","OpenSearchClient"],"mappings":";;AAIO,MAAMA,0BAA0BC,cAAsB;IACzD,MAAM;IACN,UAASC,SAAS,EAAEC,MAAM;QACtBD,UAAU,gBAAgB,CAACE,kBAAkB;YACzC,KAAK,IACMD;QAEf;IACJ;AACJ"}

package/features/OpenSearchClientFactory/OpenSearchClientFactory.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchClientFactory as OpenSearchClientFactoryAbstraction } from "./abstraction.js";
+import { Client, type OpenSearchClientOptions } from "../../client.js";
+declare class OpenSearchClientFactoryImpl implements OpenSearchClientFactoryAbstraction.Interface {
+    getClient(params: OpenSearchClientOptions): Client;
+}
+export declare const OpenSearchClientFactory: typeof OpenSearchClientFactoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstraction.js").IOpenSearchClientFactory>;
+};
+export {};

package/features/OpenSearchClientFactory/OpenSearchClientFactory.js

@@ -0,0 +1,15 @@
+import { OpenSearchClientFactory } from "./abstraction.js";
+import { createOpenSearchClient } from "../../client.js";
+class OpenSearchClientFactoryImpl {
+    getClient(params) {
+        if (!params.endpoint && !params.node && !params.nodes) throw new Error("OpenSearch client requires an endpoint, nodes or node to be specified.");
+        return createOpenSearchClient(params);
+    }
+}
+const OpenSearchClientFactory_OpenSearchClientFactory = OpenSearchClientFactory.createImplementation({
+    implementation: OpenSearchClientFactoryImpl,
+    dependencies: []
+});
+export { OpenSearchClientFactory_OpenSearchClientFactory as OpenSearchClientFactory };
+
+//# sourceMappingURL=OpenSearchClientFactory.js.map

package/features/OpenSearchClientFactory/OpenSearchClientFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchClientFactory/OpenSearchClientFactory.js","sources":["../../../src/features/OpenSearchClientFactory/OpenSearchClientFactory.ts"],"sourcesContent":["import { OpenSearchClientFactory as OpenSearchClientFactoryAbstraction } from \"./abstraction.js\";\nimport { Client, type OpenSearchClientOptions, createOpenSearchClient } from \"~/client.js\";\n\nclass OpenSearchClientFactoryImpl implements OpenSearchClientFactoryAbstraction.Interface {\n    public getClient(params: OpenSearchClientOptions): Client {\n        if (!params.endpoint && !params.node && !params.nodes) {\n            throw new Error(\n                \"OpenSearch client requires an endpoint, nodes or node to be specified.\"\n            );\n        }\n        return createOpenSearchClient(params);\n    }\n}\n\nexport const OpenSearchClientFactory = OpenSearchClientFactoryAbstraction.createImplementation({\n    implementation: OpenSearchClientFactoryImpl,\n    dependencies: []\n});\n"],"names":["OpenSearchClientFactoryImpl","params","Error","createOpenSearchClient","OpenSearchClientFactory","OpenSearchClientFactoryAbstraction"],"mappings":";;AAGA,MAAMA;IACK,UAAUC,MAA+B,EAAU;QACtD,IAAI,CAACA,OAAO,QAAQ,IAAI,CAACA,OAAO,IAAI,IAAI,CAACA,OAAO,KAAK,EACjD,MAAM,IAAIC,MACN;QAGR,OAAOC,uBAAuBF;IAClC;AACJ;AAEO,MAAMG,kDAA0BC,wBAAAA,oBAAuD,CAAC;IAC3F,gBAAgBL;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchClientFactory/abstraction.d.ts

@@ -0,0 +1,10 @@
+import type { Client, OpenSearchClientOptions } from "../../client.js";
+export interface IOpenSearchClientFactory {
+    getClient(params: OpenSearchClientOptions): Client;
+}
+export declare const OpenSearchClientFactory: import("@webiny/di").Abstraction<IOpenSearchClientFactory>;
+export declare namespace OpenSearchClientFactory {
+    type Interface = IOpenSearchClientFactory;
+    type Params = OpenSearchClientOptions;
+    type Return = Client;
+}

package/features/OpenSearchClientFactory/abstraction.js

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

package/features/OpenSearchClientFactory/abstraction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchClientFactory/abstraction.js","sources":["../../../src/features/OpenSearchClientFactory/abstraction.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Client, OpenSearchClientOptions } from \"~/client.js\";\n\nexport interface IOpenSearchClientFactory {\n    getClient(params: OpenSearchClientOptions): Client;\n}\n\nexport const OpenSearchClientFactory = createAbstraction<IOpenSearchClientFactory>(\n    \"OpenSearch/ClientFactory\"\n);\n\nexport namespace OpenSearchClientFactory {\n    export type Interface = IOpenSearchClientFactory;\n    export type Params = OpenSearchClientOptions;\n    export type Return = Client;\n}\n"],"names":["OpenSearchClientFactory","createAbstraction"],"mappings":";AAOO,MAAMA,0BAA0BC,kBACnC"}

package/features/OpenSearchClientFactory/feature.d.ts

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

package/features/OpenSearchClientFactory/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api/index.js";
+import { OpenSearchClientFactory } from "./OpenSearchClientFactory.js";
+const OpenSearchClientFactoryFeature = createFeature({
+    name: "opensearch.internal.clientFactory",
+    register (container) {
+        container.register(OpenSearchClientFactory).inSingletonScope();
+    }
+});
+export { OpenSearchClientFactoryFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/OpenSearchClientFactory/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchClientFactory/feature.js","sources":["../../../src/features/OpenSearchClientFactory/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api/index.js\";\nimport { OpenSearchClientFactory } from \"./OpenSearchClientFactory.js\";\n\nexport const OpenSearchClientFactoryFeature = createFeature({\n    name: \"opensearch.internal.clientFactory\",\n    register(container) {\n        container.register(OpenSearchClientFactory).inSingletonScope();\n    }\n});\n"],"names":["OpenSearchClientFactoryFeature","createFeature","container","OpenSearchClientFactory"],"mappings":";;AAGO,MAAMA,iCAAiCC,cAAc;IACxD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,yBAAyB,gBAAgB;IAChE;AACJ"}

package/features/OpenSearchField/OpenSearchField.d.ts

@@ -0,0 +1,18 @@
+import type { FieldSortOptions } from "../../types.js";
+import type { SortOrder } from "../../types.js";
+import type { OpenSearchField as OpenSearchFieldAbstraction } from "./abstractions/OpenSearchField.js";
+export declare class OpenSearchField implements OpenSearchFieldAbstraction.Interface {
+    readonly field: string;
+    readonly path: string;
+    readonly keyword: boolean;
+    readonly unmappedType?: string;
+    readonly sortable: boolean;
+    readonly searchable: boolean;
+    private readonly searchValueFn?;
+    static create(params: OpenSearchFieldAbstraction.Params): OpenSearchField;
+    private constructor();
+    getSortOptions(order: SortOrder): FieldSortOptions;
+    getPath(field: string): string;
+    getBasePath(field: string): string;
+    toSearchValue(params: OpenSearchFieldAbstraction.SearchValueParams): any;
+}

package/features/OpenSearchField/OpenSearchField.js

@@ -0,0 +1,49 @@
+const keywordLessUnmappedType = [
+    "date",
+    "long"
+];
+const unmappedTypeHasKeyword = (type)=>{
+    if (type) {
+        if (keywordLessUnmappedType.includes(type)) return false;
+    }
+    return true;
+};
+class OpenSearchField {
+    static create(params) {
+        return new OpenSearchField(params);
+    }
+    constructor(params){
+        this.field = params.field;
+        this.path = params.path || params.field;
+        this.unmappedType = params.unmappedType;
+        const keyword = void 0 === params.keyword ? true : params.keyword;
+        this.keyword = unmappedTypeHasKeyword(params.unmappedType) ? keyword : false;
+        this.sortable = void 0 === params.sortable ? true : params.sortable;
+        this.searchable = void 0 === params.searchable ? true : params.searchable;
+        this.searchValueFn = params.toSearchValue;
+    }
+    getSortOptions(order) {
+        const options = {
+            order
+        };
+        if (!this.unmappedType) return options;
+        return {
+            ...options,
+            unmapped_type: this.unmappedType
+        };
+    }
+    getPath(field) {
+        return `${this.getBasePath(field)}${this.keyword ? ".keyword" : ""}`;
+    }
+    getBasePath(field) {
+        if ("*" === this.path) return field;
+        return this.path;
+    }
+    toSearchValue(params) {
+        if (this.searchValueFn) return this.searchValueFn(params);
+        return params.value;
+    }
+}
+export { OpenSearchField };
+
+//# sourceMappingURL=OpenSearchField.js.map

package/features/OpenSearchField/OpenSearchField.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchField/OpenSearchField.js","sources":["../../../src/features/OpenSearchField/OpenSearchField.ts"],"sourcesContent":["import type { FieldSortOptions } from \"~/types.js\";\nimport type { SortOrder } from \"~/types.js\";\nimport type { OpenSearchField as OpenSearchFieldAbstraction } from \"./abstractions/OpenSearchField.js\";\n\nconst keywordLessUnmappedType = [\"date\", \"long\"];\n\nconst unmappedTypeHasKeyword = (type?: string): boolean => {\n    if (!type) {\n        return true;\n    } else if (keywordLessUnmappedType.includes(type)) {\n        return false;\n    }\n    return true;\n};\n\nexport class OpenSearchField implements OpenSearchFieldAbstraction.Interface {\n    public readonly field: string;\n    public readonly path: string;\n    public readonly keyword: boolean;\n    public readonly unmappedType?: string;\n    public readonly sortable: boolean;\n    public readonly searchable: boolean;\n    private readonly searchValueFn?: (params: OpenSearchFieldAbstraction.SearchValueParams) => any;\n\n    public static create(params: OpenSearchFieldAbstraction.Params) {\n        return new OpenSearchField(params);\n    }\n\n    private constructor(params: OpenSearchFieldAbstraction.Params) {\n        this.field = params.field;\n        this.path = params.path || params.field;\n        this.unmappedType = params.unmappedType;\n        const keyword = params.keyword === undefined ? true : params.keyword;\n        this.keyword = unmappedTypeHasKeyword(params.unmappedType) ? keyword : false;\n        this.sortable = params.sortable === undefined ? true : params.sortable;\n        this.searchable = params.searchable === undefined ? true : params.searchable;\n        this.searchValueFn = params.toSearchValue;\n    }\n\n    public getSortOptions(order: SortOrder): FieldSortOptions {\n        const options = {\n            order\n        };\n        if (!this.unmappedType) {\n            return options;\n        }\n        return {\n            ...options,\n            unmapped_type: this.unmappedType as any\n        };\n    }\n\n    public getPath(field: string): string {\n        return `${this.getBasePath(field)}${this.keyword ? \".keyword\" : \"\"}`;\n    }\n\n    public getBasePath(field: string): string {\n        if (this.path === \"*\") {\n            return field;\n        }\n        return this.path;\n    }\n\n    public toSearchValue(params: OpenSearchFieldAbstraction.SearchValueParams): any {\n        if (this.searchValueFn) {\n            return this.searchValueFn(params);\n        }\n        return params.value;\n    }\n}\n"],"names":["keywordLessUnmappedType","unmappedTypeHasKeyword","type","OpenSearchField","params","keyword","undefined","order","options","field"],"mappings":"AAIA,MAAMA,0BAA0B;IAAC;IAAQ;CAAO;AAEhD,MAAMC,yBAAyB,CAACC;IAC5B,IAAKA,MAEE;QAAA,IAAIF,wBAAwB,QAAQ,CAACE,OACxC,OAAO;IACX;IACA,OAAO;AACX;AAEO,MAAMC;IAST,OAAc,OAAOC,MAAyC,EAAE;QAC5D,OAAO,IAAID,gBAAgBC;IAC/B;IAEA,YAAoBA,MAAyC,CAAE;QAC3D,IAAI,CAAC,KAAK,GAAGA,OAAO,KAAK;QACzB,IAAI,CAAC,IAAI,GAAGA,OAAO,IAAI,IAAIA,OAAO,KAAK;QACvC,IAAI,CAAC,YAAY,GAAGA,OAAO,YAAY;QACvC,MAAMC,UAAUD,AAAmBE,WAAnBF,OAAO,OAAO,GAAiB,OAAOA,OAAO,OAAO;QACpE,IAAI,CAAC,OAAO,GAAGH,uBAAuBG,OAAO,YAAY,IAAIC,UAAU;QACvE,IAAI,CAAC,QAAQ,GAAGD,AAAoBE,WAApBF,OAAO,QAAQ,GAAiB,OAAOA,OAAO,QAAQ;QACtE,IAAI,CAAC,UAAU,GAAGA,AAAsBE,WAAtBF,OAAO,UAAU,GAAiB,OAAOA,OAAO,UAAU;QAC5E,IAAI,CAAC,aAAa,GAAGA,OAAO,aAAa;IAC7C;IAEO,eAAeG,KAAgB,EAAoB;QACtD,MAAMC,UAAU;YACZD;QACJ;QACA,IAAI,CAAC,IAAI,CAAC,YAAY,EAClB,OAAOC;QAEX,OAAO;YACH,GAAGA,OAAO;YACV,eAAe,IAAI,CAAC,YAAY;QACpC;IACJ;IAEO,QAAQC,KAAa,EAAU;QAClC,OAAO,GAAG,IAAI,CAAC,WAAW,CAACA,SAAS,IAAI,CAAC,OAAO,GAAG,aAAa,IAAI;IACxE;IAEO,YAAYA,KAAa,EAAU;QACtC,IAAI,AAAc,QAAd,IAAI,CAAC,IAAI,EACT,OAAOA;QAEX,OAAO,IAAI,CAAC,IAAI;IACpB;IAEO,cAAcL,MAAoD,EAAO;QAC5E,IAAI,IAAI,CAAC,aAAa,EAClB,OAAO,IAAI,CAAC,aAAa,CAACA;QAE9B,OAAOA,OAAO,KAAK;IACvB;AACJ"}

package/features/OpenSearchField/OpenSearchFieldFactory.d.ts

@@ -0,0 +1,9 @@
+import { OpenSearchFieldFactory as Abstraction } from "./abstractions/OpenSearchFieldFactory.js";
+import type { OpenSearchField as OpenSearchFieldAbstraction } from "./abstractions/OpenSearchField.js";
+declare class OpenSearchFieldFactoryImpl implements Abstraction.Interface {
+    create(params: OpenSearchFieldAbstraction.Params): OpenSearchFieldAbstraction.Interface;
+}
+export declare const OpenSearchFieldFactory: typeof OpenSearchFieldFactoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/OpenSearchFieldFactory.js").IOpenSearchFieldFactory>;
+};
+export {};

package/features/OpenSearchField/OpenSearchFieldFactory.js

@@ -0,0 +1,14 @@
+import { OpenSearchFieldFactory } from "./abstractions/OpenSearchFieldFactory.js";
+import { OpenSearchField } from "./OpenSearchField.js";
+class OpenSearchFieldFactoryImpl {
+    create(params) {
+        return OpenSearchField.create(params);
+    }
+}
+const OpenSearchFieldFactory_OpenSearchFieldFactory = OpenSearchFieldFactory.createImplementation({
+    implementation: OpenSearchFieldFactoryImpl,
+    dependencies: []
+});
+export { OpenSearchFieldFactory_OpenSearchFieldFactory as OpenSearchFieldFactory };
+
+//# sourceMappingURL=OpenSearchFieldFactory.js.map

package/features/OpenSearchField/OpenSearchFieldFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchField/OpenSearchFieldFactory.js","sources":["../../../src/features/OpenSearchField/OpenSearchFieldFactory.ts"],"sourcesContent":["import { OpenSearchFieldFactory as Abstraction } from \"./abstractions/OpenSearchFieldFactory.js\";\nimport type { OpenSearchField as OpenSearchFieldAbstraction } from \"./abstractions/OpenSearchField.js\";\nimport { OpenSearchField } from \"./OpenSearchField.js\";\n\nclass OpenSearchFieldFactoryImpl implements Abstraction.Interface {\n    public create(params: OpenSearchFieldAbstraction.Params): OpenSearchFieldAbstraction.Interface {\n        return OpenSearchField.create(params);\n    }\n}\n\nexport const OpenSearchFieldFactory = Abstraction.createImplementation({\n    implementation: OpenSearchFieldFactoryImpl,\n    dependencies: []\n});\n"],"names":["OpenSearchFieldFactoryImpl","params","OpenSearchField","OpenSearchFieldFactory","Abstraction"],"mappings":";;AAIA,MAAMA;IACK,OAAOC,MAAyC,EAAwC;QAC3F,OAAOC,gBAAgB,MAAM,CAACD;IAClC;AACJ;AAEO,MAAME,gDAAyBC,uBAAAA,oBAAgC,CAAC;IACnE,gBAAgBJ;IAChB,cAAc,EAAE;AACpB"}

package/features/OpenSearchField/abstractions/OpenSearchField.d.ts

@@ -0,0 +1,35 @@
+import type { FieldSortOptions } from "../../../types.js";
+import type { SortOrder } from "../../../types.js";
+export interface ToSearchValueParams {
+    value: any;
+    path: string;
+    basePath: string;
+}
+export interface OpenSearchFieldParams {
+    field: string;
+    path?: string;
+    keyword?: boolean;
+    unmappedType?: string;
+    sortable?: boolean;
+    searchable?: boolean;
+    toSearchValue?: (params: ToSearchValueParams) => any;
+}
+export interface IOpenSearchField {
+    readonly field: string;
+    readonly path: string;
+    readonly keyword: boolean;
+    readonly unmappedType?: string;
+    readonly sortable: boolean;
+    readonly searchable: boolean;
+    getPath(field: string): string;
+    getBasePath(field: string): string;
+    getSortOptions(order: SortOrder): FieldSortOptions;
+    toSearchValue(params: ToSearchValueParams): any;
+}
+export declare const OpenSearchField: import("@webiny/di").Abstraction<IOpenSearchField>;
+export declare namespace OpenSearchField {
+    type Interface = IOpenSearchField;
+    type Params = OpenSearchFieldParams;
+    type SearchValueParams = ToSearchValueParams;
+}
+export declare const OpenSearchFieldAll: "*";

package/features/OpenSearchField/abstractions/OpenSearchField.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/exports/api.js";
+const OpenSearchField = createAbstraction("OpenSearch/Field");
+const OpenSearchFieldAll = "*";
+export { OpenSearchField, OpenSearchFieldAll };
+
+//# sourceMappingURL=OpenSearchField.js.map

package/features/OpenSearchField/abstractions/OpenSearchField.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchField/abstractions/OpenSearchField.js","sources":["../../../../src/features/OpenSearchField/abstractions/OpenSearchField.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/exports/api.js\";\nimport type { FieldSortOptions } from \"~/types.js\";\nimport type { SortOrder } from \"~/types.js\";\n\nexport interface ToSearchValueParams {\n    value: any;\n    path: string;\n    basePath: string;\n}\n\nexport interface OpenSearchFieldParams {\n    field: string;\n    path?: string;\n    keyword?: boolean;\n    unmappedType?: string;\n    sortable?: boolean;\n    searchable?: boolean;\n    toSearchValue?: (params: ToSearchValueParams) => any;\n}\n\nexport interface IOpenSearchField {\n    readonly field: string;\n    readonly path: string;\n    readonly keyword: boolean;\n    readonly unmappedType?: string;\n    readonly sortable: boolean;\n    readonly searchable: boolean;\n    getPath(field: string): string;\n    getBasePath(field: string): string;\n    getSortOptions(order: SortOrder): FieldSortOptions;\n    toSearchValue(params: ToSearchValueParams): any;\n}\n\nexport const OpenSearchField = createAbstraction<IOpenSearchField>(\"OpenSearch/Field\");\n\nexport namespace OpenSearchField {\n    export type Interface = IOpenSearchField;\n    export type Params = OpenSearchFieldParams;\n    export type SearchValueParams = ToSearchValueParams;\n}\n\n/* The wildcard sentinel value used to match any field path. */\nexport const OpenSearchFieldAll = \"*\" as const;\n"],"names":["OpenSearchField","createAbstraction","OpenSearchFieldAll"],"mappings":";AAiCO,MAAMA,kBAAkBC,kBAAoC;AAS5D,MAAMC,qBAAqB"}

package/features/OpenSearchField/abstractions/OpenSearchFieldFactory.d.ts

@@ -0,0 +1,8 @@
+import type { OpenSearchField } from "./OpenSearchField.js";
+export interface IOpenSearchFieldFactory {
+    create(params: OpenSearchField.Params): OpenSearchField.Interface;
+}
+export declare const OpenSearchFieldFactory: import("@webiny/di").Abstraction<IOpenSearchFieldFactory>;
+export declare namespace OpenSearchFieldFactory {
+    type Interface = IOpenSearchFieldFactory;
+}

package/features/OpenSearchField/abstractions/OpenSearchFieldFactory.js

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

package/features/OpenSearchField/abstractions/OpenSearchFieldFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchField/abstractions/OpenSearchFieldFactory.js","sources":["../../../../src/features/OpenSearchField/abstractions/OpenSearchFieldFactory.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/exports/api.js\";\nimport type { OpenSearchField } from \"./OpenSearchField.js\";\n\nexport interface IOpenSearchFieldFactory {\n    create(params: OpenSearchField.Params): OpenSearchField.Interface;\n}\n\nexport const OpenSearchFieldFactory =\n    createAbstraction<IOpenSearchFieldFactory>(\"OpenSearch/FieldFactory\");\n\nexport namespace OpenSearchFieldFactory {\n    export type Interface = IOpenSearchFieldFactory;\n}\n"],"names":["OpenSearchFieldFactory","createAbstraction"],"mappings":";AAOO,MAAMA,yBACTC,kBAA2C"}

package/features/OpenSearchField/feature.d.ts

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

package/features/OpenSearchField/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api/index.js";
+import { OpenSearchFieldFactory } from "./OpenSearchFieldFactory.js";
+const OpenSearchFieldFeature = createFeature({
+    name: "opensearch.internal.field",
+    register (container) {
+        container.register(OpenSearchFieldFactory).inSingletonScope();
+    }
+});
+export { OpenSearchFieldFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/OpenSearchField/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchField/feature.js","sources":["../../../src/features/OpenSearchField/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api/index.js\";\nimport { OpenSearchFieldFactory } from \"./OpenSearchFieldFactory.js\";\n\nexport const OpenSearchFieldFeature = createFeature({\n    name: \"opensearch.internal.field\",\n    register(container) {\n        container.register(OpenSearchFieldFactory).inSingletonScope();\n    }\n});\n"],"names":["OpenSearchFieldFeature","createFeature","container","OpenSearchFieldFactory"],"mappings":";;AAGO,MAAMA,yBAAyBC,cAAc;IAChD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,wBAAwB,gBAAgB;IAC/D;AACJ"}

package/features/OpenSearchIndex/OpenSearchIndexRegistry.d.ts

@@ -0,0 +1,12 @@
+import { OpenSearchIndex } from "./abstractions/OpenSearchIndex.js";
+import { OpenSearchIndexRegistry as Abstraction } from "./abstractions/OpenSearchIndexRegistry.js";
+declare class OpenSearchIndexRegistryImpl implements Abstraction.Interface {
+    private readonly indices;
+    constructor(indices: OpenSearchIndex.Interface[]);
+    getLastAdded(): OpenSearchIndex.Interface;
+    getAll(): OpenSearchIndex.Interface[];
+}
+export declare const OpenSearchIndexRegistry: typeof OpenSearchIndexRegistryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/OpenSearchIndexRegistry.js").IOpenSearchIndexRegistry>;
+};
+export {};

package/features/OpenSearchIndex/OpenSearchIndexRegistry.js

@@ -0,0 +1,30 @@
+import error from "@webiny/error";
+import { OpenSearchIndex } from "./abstractions/OpenSearchIndex.js";
+import { OpenSearchIndexRegistry } from "./abstractions/OpenSearchIndexRegistry.js";
+class OpenSearchIndexRegistryImpl {
+    constructor(indices){
+        this.indices = indices;
+    }
+    getLastAdded() {
+        const usable = this.indices.filter((index)=>index.canUse());
+        if (0 === usable.length) throw new error("Could not find a single OpenSearchIndex.", "OPENSEARCH_INDEX_TEMPLATE_ERROR");
+        return usable[usable.length - 1];
+    }
+    getAll() {
+        return this.indices.filter((index)=>index.canUse());
+    }
+}
+const OpenSearchIndexRegistry_OpenSearchIndexRegistry = OpenSearchIndexRegistry.createImplementation({
+    implementation: OpenSearchIndexRegistryImpl,
+    dependencies: [
+        [
+            OpenSearchIndex,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { OpenSearchIndexRegistry_OpenSearchIndexRegistry as OpenSearchIndexRegistry };
+
+//# sourceMappingURL=OpenSearchIndexRegistry.js.map

package/features/OpenSearchIndex/OpenSearchIndexRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchIndex/OpenSearchIndexRegistry.js","sources":["../../../src/features/OpenSearchIndex/OpenSearchIndexRegistry.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { OpenSearchIndex } from \"./abstractions/OpenSearchIndex.js\";\nimport { OpenSearchIndexRegistry as Abstraction } from \"./abstractions/OpenSearchIndexRegistry.js\";\n\nclass OpenSearchIndexRegistryImpl implements Abstraction.Interface {\n    private readonly indices: OpenSearchIndex.Interface[];\n\n    public constructor(indices: OpenSearchIndex.Interface[]) {\n        this.indices = indices;\n    }\n\n    public getLastAdded(): OpenSearchIndex.Interface {\n        const usable = this.indices.filter(index => index.canUse());\n        if (usable.length === 0) {\n            throw new WebinyError(\n                \"Could not find a single OpenSearchIndex.\",\n                \"OPENSEARCH_INDEX_TEMPLATE_ERROR\"\n            );\n        }\n        return usable[usable.length - 1];\n    }\n\n    public getAll(): OpenSearchIndex.Interface[] {\n        return this.indices.filter(index => index.canUse());\n    }\n}\n\nexport const OpenSearchIndexRegistry = Abstraction.createImplementation({\n    implementation: OpenSearchIndexRegistryImpl,\n    dependencies: [[OpenSearchIndex, { multiple: true }]]\n});\n"],"names":["OpenSearchIndexRegistryImpl","indices","usable","index","WebinyError","OpenSearchIndexRegistry","Abstraction","OpenSearchIndex"],"mappings":";;;AAIA,MAAMA;IAGF,YAAmBC,OAAoC,CAAE;QACrD,IAAI,CAAC,OAAO,GAAGA;IACnB;IAEO,eAA0C;QAC7C,MAAMC,SAAS,IAAI,CAAC,OAAO,CAAC,MAAM,CAACC,CAAAA,QAASA,MAAM,MAAM;QACxD,IAAID,AAAkB,MAAlBA,OAAO,MAAM,EACb,MAAM,IAAIE,MACN,4CACA;QAGR,OAAOF,MAAM,CAACA,OAAO,MAAM,GAAG,EAAE;IACpC;IAEO,SAAsC;QACzC,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAACC,CAAAA,QAASA,MAAM,MAAM;IACpD;AACJ;AAEO,MAAME,kDAA0BC,wBAAAA,oBAAgC,CAAC;IACpE,gBAAgBN;IAChB,cAAc;QAAC;YAACO;YAAiB;gBAAE,UAAU;YAAK;SAAE;KAAC;AACzD"}

package/features/OpenSearchIndex/abstractions/OpenSearchIndex.d.ts

@@ -0,0 +1,9 @@
+import type { OpenSearchIndexRequestBody } from "../../../types.js";
+export interface IOpenSearchIndex {
+    readonly body: OpenSearchIndexRequestBody;
+    canUse(): boolean;
+}
+export declare const OpenSearchIndex: import("@webiny/di").Abstraction<IOpenSearchIndex>;
+export declare namespace OpenSearchIndex {
+    type Interface = IOpenSearchIndex;
+}

package/features/OpenSearchIndex/abstractions/OpenSearchIndex.js

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

package/features/OpenSearchIndex/abstractions/OpenSearchIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchIndex/abstractions/OpenSearchIndex.js","sources":["../../../../src/features/OpenSearchIndex/abstractions/OpenSearchIndex.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/exports/api.js\";\nimport type { OpenSearchIndexRequestBody } from \"~/types.js\";\n\nexport interface IOpenSearchIndex {\n    readonly body: OpenSearchIndexRequestBody;\n    canUse(): boolean;\n}\n\nexport const OpenSearchIndex = createAbstraction<IOpenSearchIndex>(\"OpenSearch/Index\");\n\nexport namespace OpenSearchIndex {\n    export type Interface = IOpenSearchIndex;\n}\n"],"names":["OpenSearchIndex","createAbstraction"],"mappings":";AAQO,MAAMA,kBAAkBC,kBAAoC"}

package/features/OpenSearchIndex/abstractions/OpenSearchIndexRegistry.d.ts

@@ -0,0 +1,9 @@
+import type { OpenSearchIndex } from "./OpenSearchIndex.js";
+export interface IOpenSearchIndexRegistry {
+    getLastAdded(): OpenSearchIndex.Interface;
+    getAll(): OpenSearchIndex.Interface[];
+}
+export declare const OpenSearchIndexRegistry: import("@webiny/di").Abstraction<IOpenSearchIndexRegistry>;
+export declare namespace OpenSearchIndexRegistry {
+    type Interface = IOpenSearchIndexRegistry;
+}

package/features/OpenSearchIndex/abstractions/OpenSearchIndexRegistry.js

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

package/features/OpenSearchIndex/abstractions/OpenSearchIndexRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OpenSearchIndex/abstractions/OpenSearchIndexRegistry.js","sources":["../../../../src/features/OpenSearchIndex/abstractions/OpenSearchIndexRegistry.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/exports/api.js\";\nimport type { OpenSearchIndex } from \"./OpenSearchIndex.js\";\n\nexport interface IOpenSearchIndexRegistry {\n    getLastAdded(): OpenSearchIndex.Interface;\n    getAll(): OpenSearchIndex.Interface[];\n}\n\nexport const OpenSearchIndexRegistry = createAbstraction<IOpenSearchIndexRegistry>(\n    \"OpenSearch/IndexRegistry\"\n);\n\nexport namespace OpenSearchIndexRegistry {\n    export type Interface = IOpenSearchIndexRegistry;\n}\n"],"names":["OpenSearchIndexRegistry","createAbstraction"],"mappings":";AAQO,MAAMA,0BAA0BC,kBACnC"}

package/features/OpenSearchIndex/feature.d.ts

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

package/features/OpenSearchIndex/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api/index.js";
+import { OpenSearchIndexRegistry } from "./OpenSearchIndexRegistry.js";
+const OpenSearchIndexFeature = createFeature({
+    name: "opensearch.internal.index",
+    register (container) {
+        container.register(OpenSearchIndexRegistry).inContainerScope();
+    }
+});
+export { OpenSearchIndexFeature };
+
+//# sourceMappingURL=feature.js.map