@webiny/api-search-index-tasks 6.6.0-alpha.0

package/tasks/createIndexes/CreateIndexesRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks/createIndexes/CreateIndexesRunner.js","sources":["../../../src/tasks/createIndexes/CreateIndexesRunner.ts"],"sourcesContent":["import type { IIndexManager } from \"~/abstractions/IndexManager.js\";\nimport type { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { TaskController } from \"@webiny/api-core/features/task/TaskController/index.js\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { TenantIndexFactory } from \"~/abstractions/TenantIndexFactory.js\";\nimport { ListTenantsUseCase } from \"@webiny/api-core/features/tenancy/ListTenants/index.js\";\nimport { listIndexes } from \"./listIndexes.js\";\nimport { createIndexFactory } from \"./createIndexFactory.js\";\nimport { CreateIndexesRunner as Abstraction } from \"./abstractions/CreateIndexesRunner.js\";\n\nclass CreateIndexesRunnerImpl implements Abstraction.Interface {\n    constructor(\n        private readonly controller: TaskController.Interface,\n        private readonly tenantContext: TenantContext.Interface,\n        private readonly listTenantsUseCase: ListTenantsUseCase.Interface,\n        private readonly indexFactories: TenantIndexFactory.Interface[]\n    ) {}\n\n    public async execute(\n        matching: string | undefined,\n        done: string[],\n        indexManager: IIndexManager\n    ): Promise<TaskDefinition.Result> {\n        if (this.indexFactories.length === 0) {\n            return this.controller.response.done(\"No index plugins found.\");\n        }\n\n        const tenantsResult = await this.listTenantsUseCase.execute();\n        const tenants = tenantsResult.value;\n\n        const indexes = await listIndexes(this.tenantContext, tenants, this.indexFactories);\n\n        if (indexes.length === 0) {\n            return this.controller.response.done(\"No indexes found.\");\n        }\n\n        const isIndexAllowed = (index: string): boolean => {\n            if (typeof matching !== \"string\" || !matching) {\n                return true;\n            }\n            return index.includes(matching);\n        };\n\n        const factory = createIndexFactory(indexManager);\n\n        for (const { index, settings } of indexes) {\n            if (this.controller.runtime.isAborted()) {\n                return this.controller.response.aborted();\n            } else if (this.controller.runtime.isCloseToTimeout()) {\n                return this.controller.response.continue({\n                    done\n                });\n            }\n            try {\n                if (done.includes(index)) {\n                    continue;\n                } else if (isIndexAllowed(index) === false) {\n                    continue;\n                }\n                const exists = await indexManager.indexExists(index);\n                if (exists) {\n                    continue;\n                }\n                done.push(index);\n                await factory.create(index, settings);\n                await this.controller.logger.info({\n                    message: `Index \"${index}\" created.`,\n                    data: { index }\n                });\n            } catch (ex) {\n                await this.controller.logger.error({\n                    message: `Failed to create index \"${index}\".`,\n                    error: ex\n                });\n            }\n        }\n\n        return this.controller.response.done(\"Indexes created.\", {\n            done\n        });\n    }\n}\n\nexport const CreateIndexesRunner = Abstraction.createImplementation({\n    implementation: CreateIndexesRunnerImpl,\n    dependencies: [\n        TaskController,\n        TenantContext,\n        ListTenantsUseCase,\n        [TenantIndexFactory, { multiple: true }]\n    ]\n});\n"],"names":["CreateIndexesRunnerImpl","controller","tenantContext","listTenantsUseCase","indexFactories","matching","done","indexManager","tenantsResult","tenants","indexes","listIndexes","isIndexAllowed","index","factory","createIndexFactory","settings","exists","ex","CreateIndexesRunner","Abstraction","TaskController","TenantContext","ListTenantsUseCase","TenantIndexFactory"],"mappings":";;;;;;;AAUA,MAAMA;IACF,YACqBC,UAAoC,EACpCC,aAAsC,EACtCC,kBAAgD,EAChDC,cAA8C,CACjE;aAJmBH,UAAU,GAAVA;aACAC,aAAa,GAAbA;aACAC,kBAAkB,GAAlBA;aACAC,cAAc,GAAdA;IAClB;IAEH,MAAa,QACTC,QAA4B,EAC5BC,IAAc,EACdC,YAA2B,EACG;QAC9B,IAAI,AAA+B,MAA/B,IAAI,CAAC,cAAc,CAAC,MAAM,EAC1B,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC;QAGzC,MAAMC,gBAAgB,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO;QAC3D,MAAMC,UAAUD,cAAc,KAAK;QAEnC,MAAME,UAAU,MAAMC,YAAY,IAAI,CAAC,aAAa,EAAEF,SAAS,IAAI,CAAC,cAAc;QAElF,IAAIC,AAAmB,MAAnBA,QAAQ,MAAM,EACd,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC;QAGzC,MAAME,iBAAiB,CAACC;YACpB,IAAI,AAAoB,YAApB,OAAOR,YAAyB,CAACA,UACjC,OAAO;YAEX,OAAOQ,MAAM,QAAQ,CAACR;QAC1B;QAEA,MAAMS,UAAUC,mBAAmBR;QAEnC,KAAK,MAAM,EAAEM,KAAK,EAAEG,QAAQ,EAAE,IAAIN,QAAS;YACvC,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,SAAS,IACjC,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,OAAO;YACpC,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,gBAAgB,IAC/C,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC;gBACrCJ;YACJ;YAEJ,IAAI;gBACA,IAAIA,KAAK,QAAQ,CAACO,QACd;gBACG,IAAID,AAA0B,UAA1BA,eAAeC,QACtB;gBAEJ,MAAMI,SAAS,MAAMV,aAAa,WAAW,CAACM;gBAC9C,IAAII,QACA;gBAEJX,KAAK,IAAI,CAACO;gBACV,MAAMC,QAAQ,MAAM,CAACD,OAAOG;gBAC5B,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC;oBAC9B,SAAS,CAAC,OAAO,EAAEH,MAAM,UAAU,CAAC;oBACpC,MAAM;wBAAEA;oBAAM;gBAClB;YACJ,EAAE,OAAOK,IAAI;gBACT,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC;oBAC/B,SAAS,CAAC,wBAAwB,EAAEL,MAAM,EAAE,CAAC;oBAC7C,OAAOK;gBACX;YACJ;QACJ;QAEA,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,oBAAoB;YACrDZ;QACJ;IACJ;AACJ;AAEO,MAAMa,0CAAsBC,oBAAAA,oBAAgC,CAAC;IAChE,gBAAgBpB;IAChB,cAAc;QACVqB;QACAC;QACAC;QACA;YAACC;YAAoB;gBAAE,UAAU;YAAK;SAAE;KAC3C;AACL"}

package/tasks/createIndexes/CreateIndexesTask.d.ts

@@ -0,0 +1,19 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { CreateIndexesRunner } from "./abstractions/CreateIndexesRunner.js";
+import { OnBeforeTrigger } from "./abstractions/OnBeforeTrigger.js";
+import { IndexManagerFactory } from "../../abstractions/IndexManagerFactory.js";
+declare class CreateIndexesTaskImpl implements TaskDefinition.Interface<CreateIndexesRunner.Input> {
+    private readonly indexManagerFactory;
+    private readonly runner;
+    private readonly onBeforeTriggerRunner;
+    readonly id = "elasticsearchCreateIndexes";
+    readonly title = "Create Missing Search Indexes";
+    readonly maxIterations = 2;
+    constructor(indexManagerFactory: IndexManagerFactory.Interface, runner: CreateIndexesRunner.Interface, onBeforeTriggerRunner: OnBeforeTrigger.Interface);
+    run({ input, controller }: TaskDefinition.RunParams<CreateIndexesRunner.Input>): Promise<TaskDefinition.Result<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>>;
+    onBeforeTrigger(): Promise<void>;
+}
+export declare const CreateIndexesTask: typeof CreateIndexesTaskImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskDefinition<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>>;
+};
+export {};

package/tasks/createIndexes/CreateIndexesTask.js

@@ -0,0 +1,40 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { CreateIndexesRunner } from "./abstractions/CreateIndexesRunner.js";
+import { OnBeforeTrigger } from "./abstractions/OnBeforeTrigger.js";
+import { IndexManagerFactory } from "../../abstractions/IndexManagerFactory.js";
+class CreateIndexesTaskImpl {
+    constructor(indexManagerFactory, runner, onBeforeTriggerRunner){
+        this.indexManagerFactory = indexManagerFactory;
+        this.runner = runner;
+        this.onBeforeTriggerRunner = onBeforeTriggerRunner;
+        this.id = "elasticsearchCreateIndexes";
+        this.title = "Create Missing Search Indexes";
+        this.maxIterations = 2;
+    }
+    async run({ input, controller }) {
+        if (controller.runtime.isAborted()) return controller.response.aborted();
+        const indexManager = this.indexManagerFactory.createIndexManager({
+            settings: {}
+        });
+        return this.runner.execute(input.matching, Array.from(input.done || []), indexManager);
+    }
+    async onBeforeTrigger() {
+        const indexManager = this.indexManagerFactory.createIndexManager({
+            settings: {}
+        });
+        await this.onBeforeTriggerRunner.run([
+            "wbytask"
+        ], indexManager);
+    }
+}
+const CreateIndexesTask = TaskDefinition.createImplementation({
+    implementation: CreateIndexesTaskImpl,
+    dependencies: [
+        IndexManagerFactory,
+        CreateIndexesRunner,
+        OnBeforeTrigger
+    ]
+});
+export { CreateIndexesTask };
+
+//# sourceMappingURL=CreateIndexesTask.js.map

package/tasks/createIndexes/CreateIndexesTask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks/createIndexes/CreateIndexesTask.js","sources":["../../../src/tasks/createIndexes/CreateIndexesTask.ts"],"sourcesContent":["import { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { CreateIndexesRunner } from \"./abstractions/CreateIndexesRunner.js\";\nimport { OnBeforeTrigger } from \"./abstractions/OnBeforeTrigger.js\";\nimport { IndexManagerFactory } from \"~/abstractions/IndexManagerFactory.js\";\n\nclass CreateIndexesTaskImpl implements TaskDefinition.Interface<CreateIndexesRunner.Input> {\n    public readonly id = \"elasticsearchCreateIndexes\";\n    public readonly title = \"Create Missing Search Indexes\";\n    public readonly maxIterations = 2;\n\n    constructor(\n        private readonly indexManagerFactory: IndexManagerFactory.Interface,\n        private readonly runner: CreateIndexesRunner.Interface,\n        private readonly onBeforeTriggerRunner: OnBeforeTrigger.Interface\n    ) {}\n\n    async run({ input, controller }: TaskDefinition.RunParams<CreateIndexesRunner.Input>) {\n        if (controller.runtime.isAborted()) {\n            return controller.response.aborted();\n        }\n\n        const indexManager = this.indexManagerFactory.createIndexManager({\n            settings: {}\n        });\n\n        return this.runner.execute(input.matching, Array.from(input.done || []), indexManager);\n    }\n\n    async onBeforeTrigger() {\n        const indexManager = this.indexManagerFactory.createIndexManager({\n            settings: {}\n        });\n\n        await this.onBeforeTriggerRunner.run([\"wbytask\"], indexManager);\n    }\n}\n\nexport const CreateIndexesTask = TaskDefinition.createImplementation({\n    implementation: CreateIndexesTaskImpl,\n    dependencies: [IndexManagerFactory, CreateIndexesRunner, OnBeforeTrigger]\n});\n"],"names":["CreateIndexesTaskImpl","indexManagerFactory","runner","onBeforeTriggerRunner","input","controller","indexManager","Array","CreateIndexesTask","TaskDefinition","IndexManagerFactory","CreateIndexesRunner","OnBeforeTrigger"],"mappings":";;;;AAKA,MAAMA;IAKF,YACqBC,mBAAkD,EAClDC,MAAqC,EACrCC,qBAAgD,CACnE;aAHmBF,mBAAmB,GAAnBA;aACAC,MAAM,GAANA;aACAC,qBAAqB,GAArBA;aAPL,EAAE,GAAG;aACL,KAAK,GAAG;aACR,aAAa,GAAG;IAM7B;IAEH,MAAM,IAAI,EAAEC,KAAK,EAAEC,UAAU,EAAuD,EAAE;QAClF,IAAIA,WAAW,OAAO,CAAC,SAAS,IAC5B,OAAOA,WAAW,QAAQ,CAAC,OAAO;QAGtC,MAAMC,eAAe,IAAI,CAAC,mBAAmB,CAAC,kBAAkB,CAAC;YAC7D,UAAU,CAAC;QACf;QAEA,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAACF,MAAM,QAAQ,EAAEG,MAAM,IAAI,CAACH,MAAM,IAAI,IAAI,EAAE,GAAGE;IAC7E;IAEA,MAAM,kBAAkB;QACpB,MAAMA,eAAe,IAAI,CAAC,mBAAmB,CAAC,kBAAkB,CAAC;YAC7D,UAAU,CAAC;QACf;QAEA,MAAM,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC;YAAC;SAAU,EAAEA;IACtD;AACJ;AAEO,MAAME,oBAAoBC,eAAe,oBAAoB,CAAC;IACjE,gBAAgBT;IAChB,cAAc;QAACU;QAAqBC;QAAqBC;KAAgB;AAC7E"}

package/tasks/createIndexes/OnBeforeTrigger.d.ts

@@ -0,0 +1,14 @@
+import type { IIndexManager } from "../../abstractions/IndexManager.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { TenantIndexFactory } from "../../abstractions/TenantIndexFactory.js";
+import { OnBeforeTrigger as Abstraction } from "./abstractions/OnBeforeTrigger.js";
+declare class OnBeforeTriggerImpl implements Abstraction.Interface {
+    private readonly tenantContext;
+    private readonly indexFactories;
+    constructor(tenantContext: TenantContext.Interface, indexFactories: TenantIndexFactory.Interface[]);
+    run(targets: string[] | undefined, indexManager: IIndexManager): Promise<void>;
+}
+export declare const OnBeforeTrigger: typeof OnBeforeTriggerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/OnBeforeTrigger.js").IOnBeforeTrigger>;
+};
+export {};

package/tasks/createIndexes/OnBeforeTrigger.js

@@ -0,0 +1,52 @@
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { TenantIndexFactory } from "../../abstractions/TenantIndexFactory.js";
+import { listIndexes } from "./listIndexes.js";
+import { createIndexFactory } from "./createIndexFactory.js";
+import { OnBeforeTrigger } from "./abstractions/OnBeforeTrigger.js";
+class OnBeforeTriggerImpl {
+    constructor(tenantContext, indexFactories){
+        this.tenantContext = tenantContext;
+        this.indexFactories = indexFactories;
+    }
+    async run(targets, indexManager) {
+        const tenant = this.tenantContext.getTenant();
+        if (!tenant) throw new Error("Something went wrong, tenant not found when triggering a task.");
+        try {
+            const allIndexes = await listIndexes(this.tenantContext, [
+                tenant
+            ], this.indexFactories);
+            const indexes = allIndexes.filter((index)=>{
+                if (!targets?.length) return true;
+                for (const t of targets)if (index.index.includes(t)) return true;
+                return false;
+            });
+            if (0 === indexes.length) return void console.warn("There are no indexes to create before triggering the Create indexes task.", {
+                targets
+            });
+            const factory = createIndexFactory(indexManager);
+            for (const { index, settings } of indexes)try {
+                console.log("Creating index", index);
+                await factory.createIfNotExists(index, settings);
+            } catch (ex) {
+                console.error(`Failed to create index "${index}".`, ex);
+            }
+        } catch (ex) {
+            console.error(ex);
+        }
+    }
+}
+const OnBeforeTrigger_OnBeforeTrigger = OnBeforeTrigger.createImplementation({
+    implementation: OnBeforeTriggerImpl,
+    dependencies: [
+        TenantContext,
+        [
+            TenantIndexFactory,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { OnBeforeTrigger_OnBeforeTrigger as OnBeforeTrigger };
+
+//# sourceMappingURL=OnBeforeTrigger.js.map

package/tasks/createIndexes/OnBeforeTrigger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks/createIndexes/OnBeforeTrigger.js","sources":["../../../src/tasks/createIndexes/OnBeforeTrigger.ts"],"sourcesContent":["import type { IIndexManager } from \"~/abstractions/IndexManager.js\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { TenantIndexFactory } from \"~/abstractions/TenantIndexFactory.js\";\nimport { listIndexes } from \"./listIndexes.js\";\nimport { createIndexFactory } from \"./createIndexFactory.js\";\nimport { OnBeforeTrigger as Abstraction } from \"./abstractions/OnBeforeTrigger.js\";\n\nclass OnBeforeTriggerImpl implements Abstraction.Interface {\n    constructor(\n        private readonly tenantContext: TenantContext.Interface,\n        private readonly indexFactories: TenantIndexFactory.Interface[]\n    ) {}\n\n    public async run(targets: string[] | undefined, indexManager: IIndexManager): Promise<void> {\n        const tenant = this.tenantContext.getTenant();\n        if (!tenant) {\n            throw new Error(\"Something went wrong, tenant not found when triggering a task.\");\n        }\n\n        try {\n            const allIndexes = await listIndexes(this.tenantContext, [tenant], this.indexFactories);\n\n            const indexes = allIndexes.filter(index => {\n                if (!targets?.length) {\n                    return true;\n                }\n                for (const t of targets) {\n                    if (index.index.includes(t)) {\n                        return true;\n                    }\n                }\n                return false;\n            });\n            if (indexes.length === 0) {\n                console.warn(\n                    \"There are no indexes to create before triggering the Create indexes task.\",\n                    {\n                        targets\n                    }\n                );\n                return;\n            }\n\n            const factory = createIndexFactory(indexManager);\n\n            for (const { index, settings } of indexes) {\n                try {\n                    console.log(\"Creating index\", index);\n                    await factory.createIfNotExists(index, settings);\n                } catch (ex) {\n                    console.error(`Failed to create index \"${index}\".`, ex);\n                }\n            }\n        } catch (ex) {\n            console.error(ex);\n        }\n    }\n}\n\nexport const OnBeforeTrigger = Abstraction.createImplementation({\n    implementation: OnBeforeTriggerImpl,\n    dependencies: [TenantContext, [TenantIndexFactory, { multiple: true }]]\n});\n"],"names":["OnBeforeTriggerImpl","tenantContext","indexFactories","targets","indexManager","tenant","Error","allIndexes","listIndexes","indexes","index","t","console","factory","createIndexFactory","settings","ex","OnBeforeTrigger","Abstraction","TenantContext","TenantIndexFactory"],"mappings":";;;;;AAOA,MAAMA;IACF,YACqBC,aAAsC,EACtCC,cAA8C,CACjE;aAFmBD,aAAa,GAAbA;aACAC,cAAc,GAAdA;IAClB;IAEH,MAAa,IAAIC,OAA6B,EAAEC,YAA2B,EAAiB;QACxF,MAAMC,SAAS,IAAI,CAAC,aAAa,CAAC,SAAS;QAC3C,IAAI,CAACA,QACD,MAAM,IAAIC,MAAM;QAGpB,IAAI;YACA,MAAMC,aAAa,MAAMC,YAAY,IAAI,CAAC,aAAa,EAAE;gBAACH;aAAO,EAAE,IAAI,CAAC,cAAc;YAEtF,MAAMI,UAAUF,WAAW,MAAM,CAACG,CAAAA;gBAC9B,IAAI,CAACP,SAAS,QACV,OAAO;gBAEX,KAAK,MAAMQ,KAAKR,QACZ,IAAIO,MAAM,KAAK,CAAC,QAAQ,CAACC,IACrB,OAAO;gBAGf,OAAO;YACX;YACA,IAAIF,AAAmB,MAAnBA,QAAQ,MAAM,EAAQ,YACtBG,QAAQ,IAAI,CACR,6EACA;gBACIT;YACJ;YAKR,MAAMU,UAAUC,mBAAmBV;YAEnC,KAAK,MAAM,EAAEM,KAAK,EAAEK,QAAQ,EAAE,IAAIN,QAC9B,IAAI;gBACAG,QAAQ,GAAG,CAAC,kBAAkBF;gBAC9B,MAAMG,QAAQ,iBAAiB,CAACH,OAAOK;YAC3C,EAAE,OAAOC,IAAI;gBACTJ,QAAQ,KAAK,CAAC,CAAC,wBAAwB,EAAEF,MAAM,EAAE,CAAC,EAAEM;YACxD;QAER,EAAE,OAAOA,IAAI;YACTJ,QAAQ,KAAK,CAACI;QAClB;IACJ;AACJ;AAEO,MAAMC,kCAAkBC,gBAAAA,oBAAgC,CAAC;IAC5D,gBAAgBlB;IAChB,cAAc;QAACmB;QAAe;YAACC;YAAoB;gBAAE,UAAU;YAAK;SAAE;KAAC;AAC3E"}

package/tasks/createIndexes/abstractions/CreateIndexesRunner.d.ts

@@ -0,0 +1,14 @@
+import type { IIndexManager } from "../../../abstractions/IndexManager.js";
+import type { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+export interface ICreateIndexesInput {
+    matching?: string;
+    done?: string[];
+}
+export interface ICreateIndexesRunner {
+    execute(matching: string | undefined, done: string[], indexManager: IIndexManager): Promise<TaskDefinition.Result>;
+}
+export declare const CreateIndexesRunner: import("@webiny/di").Abstraction<ICreateIndexesRunner>;
+export declare namespace CreateIndexesRunner {
+    type Interface = ICreateIndexesRunner;
+    type Input = ICreateIndexesInput;
+}

package/tasks/createIndexes/abstractions/CreateIndexesRunner.js

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

package/tasks/createIndexes/abstractions/CreateIndexesRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks/createIndexes/abstractions/CreateIndexesRunner.js","sources":["../../../../src/tasks/createIndexes/abstractions/CreateIndexesRunner.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IIndexManager } from \"~/abstractions/IndexManager.js\";\nimport type { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\n\nexport interface ICreateIndexesInput {\n    matching?: string;\n    done?: string[];\n}\n\nexport interface ICreateIndexesRunner {\n    execute(\n        matching: string | undefined,\n        done: string[],\n        indexManager: IIndexManager\n    ): Promise<TaskDefinition.Result>;\n}\n\nexport const CreateIndexesRunner = createAbstraction<ICreateIndexesRunner>(\n    \"SearchIndexTasks/CreateIndexesRunner\"\n);\n\nexport namespace CreateIndexesRunner {\n    export type Interface = ICreateIndexesRunner;\n    export type Input = ICreateIndexesInput;\n}\n"],"names":["CreateIndexesRunner","createAbstraction"],"mappings":";AAiBO,MAAMA,sBAAsBC,kBAC/B"}

package/tasks/createIndexes/abstractions/OnBeforeTrigger.d.ts

@@ -0,0 +1,8 @@
+import type { IIndexManager } from "../../../abstractions/IndexManager.js";
+export interface IOnBeforeTrigger {
+    run(targets: string[] | undefined, indexManager: IIndexManager): Promise<void>;
+}
+export declare const OnBeforeTrigger: import("@webiny/di").Abstraction<IOnBeforeTrigger>;
+export declare namespace OnBeforeTrigger {
+    type Interface = IOnBeforeTrigger;
+}

package/tasks/createIndexes/abstractions/OnBeforeTrigger.js

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

package/tasks/createIndexes/abstractions/OnBeforeTrigger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks/createIndexes/abstractions/OnBeforeTrigger.js","sources":["../../../../src/tasks/createIndexes/abstractions/OnBeforeTrigger.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IIndexManager } from \"~/abstractions/IndexManager.js\";\n\nexport interface IOnBeforeTrigger {\n    run(targets: string[] | undefined, indexManager: IIndexManager): Promise<void>;\n}\n\nexport const OnBeforeTrigger = createAbstraction<IOnBeforeTrigger>(\n    \"SearchIndexTasks/OnBeforeTrigger\"\n);\n\nexport namespace OnBeforeTrigger {\n    export type Interface = IOnBeforeTrigger;\n}\n"],"names":["OnBeforeTrigger","createAbstraction"],"mappings":";AAOO,MAAMA,kBAAkBC,kBAC3B"}

package/tasks/createIndexes/createIndexFactory.d.ts

@@ -0,0 +1,6 @@
+import type { IIndexManager } from "../../abstractions/IndexManager.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+export declare const createIndexFactory: (manager: IIndexManager) => {
+    create: (index: string, settings?: GenericRecord) => Promise<void>;
+    createIfNotExists: (index: string, settings?: GenericRecord) => Promise<void>;
+};

package/tasks/createIndexes/createIndexFactory.js

@@ -0,0 +1,15 @@
+const createIndexFactory = (manager)=>({
+        create: async (index, settings)=>manager.createIndex(index, settings),
+        createIfNotExists: async (index, settings)=>{
+            try {
+                const exists = await manager.indexExists(index);
+                if (exists) return;
+            } catch  {
+                return;
+            }
+            return await manager.createIndex(index, settings);
+        }
+    });
+export { createIndexFactory };
+
+//# sourceMappingURL=createIndexFactory.js.map

package/tasks/createIndexes/createIndexFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks/createIndexes/createIndexFactory.js","sources":["../../../src/tasks/createIndexes/createIndexFactory.ts"],"sourcesContent":["import type { IIndexManager } from \"~/abstractions/IndexManager.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\nexport const createIndexFactory = (manager: IIndexManager) => {\n    return {\n        create: async (index: string, settings?: GenericRecord): Promise<void> => {\n            return manager.createIndex(index, settings);\n        },\n        createIfNotExists: async (index: string, settings?: GenericRecord): Promise<void> => {\n            try {\n                const exists = await manager.indexExists(index);\n                if (exists) {\n                    return;\n                }\n            } catch {\n                return;\n            }\n\n            return await manager.createIndex(index, settings);\n        }\n    };\n};\n"],"names":["createIndexFactory","manager","index","settings","exists"],"mappings":"AAGO,MAAMA,qBAAqB,CAACC,UACxB;QACH,QAAQ,OAAOC,OAAeC,WACnBF,QAAQ,WAAW,CAACC,OAAOC;QAEtC,mBAAmB,OAAOD,OAAeC;YACrC,IAAI;gBACA,MAAMC,SAAS,MAAMH,QAAQ,WAAW,CAACC;gBACzC,IAAIE,QACA;YAER,EAAE,OAAM;gBACJ;YACJ;YAEA,OAAO,MAAMH,QAAQ,WAAW,CAACC,OAAOC;QAC5C;IACJ"}

package/tasks/createIndexes/listIndexes.d.ts

@@ -0,0 +1,4 @@
+import type { TenantIndexFactory } from "../../abstractions/TenantIndexFactory.js";
+import type { Tenant } from "@webiny/api-core/types/tenancy.js";
+import type { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+export declare const listIndexes: (tenantContext: TenantContext.Interface, tenants: Tenant[], indexFactories: TenantIndexFactory.Interface[]) => Promise<TenantIndexFactory.IndexConfig[]>;

package/tasks/createIndexes/listIndexes.js

@@ -0,0 +1,14 @@
+const listIndexes = async (tenantContext, tenants, indexFactories)=>{
+    if (0 === indexFactories.length) return [];
+    const indexes = [];
+    await tenantContext.withEachTenant(tenants, async (tenant)=>{
+        for (const factory of indexFactories){
+            const results = await factory.getIndexList(tenant);
+            for (const result of results)if (!indexes.some((i)=>i.index === result.index)) indexes.push(result);
+        }
+    });
+    return indexes;
+};
+export { listIndexes };
+
+//# sourceMappingURL=listIndexes.js.map

package/tasks/createIndexes/listIndexes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks/createIndexes/listIndexes.js","sources":["../../../src/tasks/createIndexes/listIndexes.ts"],"sourcesContent":["import type { TenantIndexFactory } from \"~/abstractions/TenantIndexFactory.js\";\nimport type { Tenant } from \"@webiny/api-core/types/tenancy.js\";\nimport type { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\n\nexport const listIndexes = async (\n    tenantContext: TenantContext.Interface,\n    tenants: Tenant[],\n    indexFactories: TenantIndexFactory.Interface[]\n): Promise<TenantIndexFactory.IndexConfig[]> => {\n    if (indexFactories.length === 0) {\n        return [];\n    }\n\n    const indexes: TenantIndexFactory.IndexConfig[] = [];\n    await tenantContext.withEachTenant(tenants, async tenant => {\n        for (const factory of indexFactories) {\n            const results = await factory.getIndexList(tenant);\n            for (const result of results) {\n                if (indexes.some(i => i.index === result.index)) {\n                    continue;\n                }\n                indexes.push(result);\n            }\n        }\n    });\n\n    return indexes;\n};\n"],"names":["listIndexes","tenantContext","tenants","indexFactories","indexes","tenant","factory","results","result","i"],"mappings":"AAIO,MAAMA,cAAc,OACvBC,eACAC,SACAC;IAEA,IAAIA,AAA0B,MAA1BA,eAAe,MAAM,EACrB,OAAO,EAAE;IAGb,MAAMC,UAA4C,EAAE;IACpD,MAAMH,cAAc,cAAc,CAACC,SAAS,OAAMG;QAC9C,KAAK,MAAMC,WAAWH,eAAgB;YAClC,MAAMI,UAAU,MAAMD,QAAQ,YAAY,CAACD;YAC3C,KAAK,MAAMG,UAAUD,QACjB,KAAIH,QAAQ,IAAI,CAACK,CAAAA,IAAKA,EAAE,KAAK,KAAKD,OAAO,KAAK,GAG9CJ,QAAQ,IAAI,CAACI;QAErB;IACJ;IAEA,OAAOJ;AACX"}

package/tasks/enableIndexing/EnableIndexingRunner.d.ts

@@ -0,0 +1,13 @@
+import type { IIndexManager } from "../../abstractions/IndexManager.js";
+import type { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { TaskController } from "@webiny/api-core/features/task/TaskController/index.js";
+import { EnableIndexingRunner as Abstraction } from "./abstractions/EnableIndexingRunner.js";
+declare class EnableIndexingRunnerImpl implements Abstraction.Interface {
+    private readonly controller;
+    constructor(controller: TaskController.Interface);
+    execute(matching: string | undefined, indexManager: IIndexManager): Promise<TaskDefinition.Result<Abstraction.Input>>;
+}
+export declare const EnableIndexingRunner: typeof EnableIndexingRunnerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/EnableIndexingRunner.js").IEnableIndexingRunner>;
+};
+export {};

package/tasks/enableIndexing/EnableIndexingRunner.js

@@ -0,0 +1,40 @@
+import { TaskController } from "@webiny/api-core/features/task/TaskController/index.js";
+import { EnableIndexingRunner } from "./abstractions/EnableIndexingRunner.js";
+class EnableIndexingRunnerImpl {
+    constructor(controller){
+        this.controller = controller;
+    }
+    async execute(matching, indexManager) {
+        if (this.controller.runtime.isAborted()) return this.controller.response.aborted();
+        const isIndexAllowed = (index)=>{
+            if ("string" != typeof matching || !matching) return true;
+            return index.includes(matching);
+        };
+        const indexes = await indexManager.list();
+        const enabled = [];
+        const failed = [];
+        for (const index of indexes)if (isIndexAllowed(index)) try {
+            await indexManager.enableIndexing(index);
+            enabled.push(index);
+        } catch (ex) {
+            failed.push(index);
+            await this.controller.logger.error({
+                message: `Failed to enable indexing on index "${index}".`,
+                error: ex
+            });
+        }
+        return this.controller.response.done("Task done.", {
+            enabled,
+            failed
+        });
+    }
+}
+const EnableIndexingRunner_EnableIndexingRunner = EnableIndexingRunner.createImplementation({
+    implementation: EnableIndexingRunnerImpl,
+    dependencies: [
+        TaskController
+    ]
+});
+export { EnableIndexingRunner_EnableIndexingRunner as EnableIndexingRunner };
+
+//# sourceMappingURL=EnableIndexingRunner.js.map

package/tasks/enableIndexing/EnableIndexingRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks/enableIndexing/EnableIndexingRunner.js","sources":["../../../src/tasks/enableIndexing/EnableIndexingRunner.ts"],"sourcesContent":["import type { IIndexManager } from \"~/abstractions/IndexManager.js\";\nimport type { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { TaskController } from \"@webiny/api-core/features/task/TaskController/index.js\";\nimport { EnableIndexingRunner as Abstraction } from \"./abstractions/EnableIndexingRunner.js\";\n\nclass EnableIndexingRunnerImpl implements Abstraction.Interface {\n    constructor(private readonly controller: TaskController.Interface) {}\n\n    public async execute(\n        matching: string | undefined,\n        indexManager: IIndexManager\n    ): Promise<TaskDefinition.Result<Abstraction.Input>> {\n        if (this.controller.runtime.isAborted()) {\n            return this.controller.response.aborted();\n        }\n\n        const isIndexAllowed = (index: string): boolean => {\n            if (typeof matching !== \"string\" || !matching) {\n                return true;\n            }\n            return index.includes(matching);\n        };\n\n        const indexes = await indexManager.list();\n        const enabled: string[] = [];\n        const failed: string[] = [];\n        for (const index of indexes) {\n            if (!isIndexAllowed(index)) {\n                continue;\n            }\n            try {\n                await indexManager.enableIndexing(index);\n                enabled.push(index);\n            } catch (ex) {\n                failed.push(index);\n                await this.controller.logger.error({\n                    message: `Failed to enable indexing on index \"${index}\".`,\n                    error: ex\n                });\n            }\n        }\n        return this.controller.response.done(\"Task done.\", {\n            enabled,\n            failed\n        });\n    }\n}\n\nexport const EnableIndexingRunner = Abstraction.createImplementation({\n    implementation: EnableIndexingRunnerImpl,\n    dependencies: [TaskController]\n});\n"],"names":["EnableIndexingRunnerImpl","controller","matching","indexManager","isIndexAllowed","index","indexes","enabled","failed","ex","EnableIndexingRunner","Abstraction","TaskController"],"mappings":";;AAKA,MAAMA;IACF,YAA6BC,UAAoC,CAAE;aAAtCA,UAAU,GAAVA;IAAuC;IAEpE,MAAa,QACTC,QAA4B,EAC5BC,YAA2B,EACsB;QACjD,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,SAAS,IACjC,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,OAAO;QAG3C,MAAMC,iBAAiB,CAACC;YACpB,IAAI,AAAoB,YAApB,OAAOH,YAAyB,CAACA,UACjC,OAAO;YAEX,OAAOG,MAAM,QAAQ,CAACH;QAC1B;QAEA,MAAMI,UAAU,MAAMH,aAAa,IAAI;QACvC,MAAMI,UAAoB,EAAE;QAC5B,MAAMC,SAAmB,EAAE;QAC3B,KAAK,MAAMH,SAASC,QAChB,IAAKF,eAAeC,QAGpB,IAAI;YACA,MAAMF,aAAa,cAAc,CAACE;YAClCE,QAAQ,IAAI,CAACF;QACjB,EAAE,OAAOI,IAAI;YACTD,OAAO,IAAI,CAACH;YACZ,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC;gBAC/B,SAAS,CAAC,oCAAoC,EAAEA,MAAM,EAAE,CAAC;gBACzD,OAAOI;YACX;QACJ;QAEJ,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,cAAc;YAC/CF;YACAC;QACJ;IACJ;AACJ;AAEO,MAAME,4CAAuBC,qBAAAA,oBAAgC,CAAC;IACjE,gBAAgBX;IAChB,cAAc;QAACY;KAAe;AAClC"}

package/tasks/enableIndexing/EnableIndexingTask.d.ts

@@ -0,0 +1,16 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { EnableIndexingRunner } from "./abstractions/EnableIndexingRunner.js";
+import { IndexManagerFactory } from "../../abstractions/IndexManagerFactory.js";
+declare class EnableIndexingTaskImpl implements TaskDefinition.Interface<EnableIndexingRunner.Input> {
+    private readonly indexManagerFactory;
+    private readonly runner;
+    readonly id = "elasticsearchEnableIndexing";
+    readonly title = "Enable Search Indexing";
+    readonly maxIterations = 2;
+    constructor(indexManagerFactory: IndexManagerFactory.Interface, runner: EnableIndexingRunner.Interface);
+    run({ input, controller }: TaskDefinition.RunParams<EnableIndexingRunner.Input>): Promise<TaskDefinition.Result<import("./abstractions/EnableIndexingRunner.js").IEnableIndexingInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>>;
+}
+export declare const EnableIndexingTask: typeof EnableIndexingTaskImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskDefinition<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>>;
+};
+export {};

package/tasks/enableIndexing/EnableIndexingTask.js

@@ -0,0 +1,33 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { EnableIndexingRunner } from "./abstractions/EnableIndexingRunner.js";
+import { IndexManagerFactory } from "../../abstractions/IndexManagerFactory.js";
+class EnableIndexingTaskImpl {
+    constructor(indexManagerFactory, runner){
+        this.indexManagerFactory = indexManagerFactory;
+        this.runner = runner;
+        this.id = "elasticsearchEnableIndexing";
+        this.title = "Enable Search Indexing";
+        this.maxIterations = 2;
+    }
+    async run({ input, controller }) {
+        if (controller.runtime.isAborted()) return controller.response.aborted();
+        const indexManager = this.indexManagerFactory.createIndexManager({
+            settings: {},
+            defaults: {
+                refreshInterval: input.refreshInterval,
+                numberOfReplicas: input.numberOfReplicas
+            }
+        });
+        return this.runner.execute(input.matching, indexManager);
+    }
+}
+const EnableIndexingTask = TaskDefinition.createImplementation({
+    implementation: EnableIndexingTaskImpl,
+    dependencies: [
+        IndexManagerFactory,
+        EnableIndexingRunner
+    ]
+});
+export { EnableIndexingTask };
+
+//# sourceMappingURL=EnableIndexingTask.js.map

package/tasks/enableIndexing/EnableIndexingTask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks/enableIndexing/EnableIndexingTask.js","sources":["../../../src/tasks/enableIndexing/EnableIndexingTask.ts"],"sourcesContent":["import { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { EnableIndexingRunner } from \"./abstractions/EnableIndexingRunner.js\";\nimport { IndexManagerFactory } from \"~/abstractions/IndexManagerFactory.js\";\n\nclass EnableIndexingTaskImpl implements TaskDefinition.Interface<EnableIndexingRunner.Input> {\n    public readonly id = \"elasticsearchEnableIndexing\";\n    public readonly title = \"Enable Search Indexing\";\n    public readonly maxIterations = 2;\n\n    constructor(\n        private readonly indexManagerFactory: IndexManagerFactory.Interface,\n        private readonly runner: EnableIndexingRunner.Interface\n    ) {}\n\n    async run({ input, controller }: TaskDefinition.RunParams<EnableIndexingRunner.Input>) {\n        if (controller.runtime.isAborted()) {\n            return controller.response.aborted();\n        }\n\n        const indexManager = this.indexManagerFactory.createIndexManager({\n            settings: {},\n            defaults: {\n                refreshInterval: input.refreshInterval,\n                numberOfReplicas: input.numberOfReplicas\n            }\n        });\n\n        return this.runner.execute(input.matching, indexManager);\n    }\n}\n\nexport const EnableIndexingTask = TaskDefinition.createImplementation({\n    implementation: EnableIndexingTaskImpl,\n    dependencies: [IndexManagerFactory, EnableIndexingRunner]\n});\n"],"names":["EnableIndexingTaskImpl","indexManagerFactory","runner","input","controller","indexManager","EnableIndexingTask","TaskDefinition","IndexManagerFactory","EnableIndexingRunner"],"mappings":";;;AAIA,MAAMA;IAKF,YACqBC,mBAAkD,EAClDC,MAAsC,CACzD;aAFmBD,mBAAmB,GAAnBA;aACAC,MAAM,GAANA;aANL,EAAE,GAAG;aACL,KAAK,GAAG;aACR,aAAa,GAAG;IAK7B;IAEH,MAAM,IAAI,EAAEC,KAAK,EAAEC,UAAU,EAAwD,EAAE;QACnF,IAAIA,WAAW,OAAO,CAAC,SAAS,IAC5B,OAAOA,WAAW,QAAQ,CAAC,OAAO;QAGtC,MAAMC,eAAe,IAAI,CAAC,mBAAmB,CAAC,kBAAkB,CAAC;YAC7D,UAAU,CAAC;YACX,UAAU;gBACN,iBAAiBF,MAAM,eAAe;gBACtC,kBAAkBA,MAAM,gBAAgB;YAC5C;QACJ;QAEA,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAACA,MAAM,QAAQ,EAAEE;IAC/C;AACJ;AAEO,MAAMC,qBAAqBC,eAAe,oBAAoB,CAAC;IAClE,gBAAgBP;IAChB,cAAc;QAACQ;QAAqBC;KAAqB;AAC7D"}

package/tasks/enableIndexing/abstractions/EnableIndexingRunner.d.ts

@@ -0,0 +1,15 @@
+import type { IIndexManager } from "../../../abstractions/IndexManager.js";
+import type { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+export interface IEnableIndexingInput {
+    matching?: string;
+    numberOfReplicas?: number;
+    refreshInterval?: string;
+}
+export interface IEnableIndexingRunner {
+    execute(matching: string | undefined, indexManager: IIndexManager): Promise<TaskDefinition.Result<IEnableIndexingInput>>;
+}
+export declare const EnableIndexingRunner: import("@webiny/di").Abstraction<IEnableIndexingRunner>;
+export declare namespace EnableIndexingRunner {
+    type Interface = IEnableIndexingRunner;
+    type Input = IEnableIndexingInput;
+}

package/tasks/enableIndexing/abstractions/EnableIndexingRunner.js

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

package/tasks/enableIndexing/abstractions/EnableIndexingRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks/enableIndexing/abstractions/EnableIndexingRunner.js","sources":["../../../../src/tasks/enableIndexing/abstractions/EnableIndexingRunner.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IIndexManager } from \"~/abstractions/IndexManager.js\";\nimport type { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\n\nexport interface IEnableIndexingInput {\n    matching?: string;\n    numberOfReplicas?: number;\n    refreshInterval?: string;\n}\n\nexport interface IEnableIndexingRunner {\n    execute(\n        matching: string | undefined,\n        indexManager: IIndexManager\n    ): Promise<TaskDefinition.Result<IEnableIndexingInput>>;\n}\n\nexport const EnableIndexingRunner = createAbstraction<IEnableIndexingRunner>(\n    \"SearchIndexTasks/EnableIndexingRunner\"\n);\n\nexport namespace EnableIndexingRunner {\n    export type Interface = IEnableIndexingRunner;\n    export type Input = IEnableIndexingInput;\n}\n"],"names":["EnableIndexingRunner","createAbstraction"],"mappings":";AAiBO,MAAMA,uBAAuBC,kBAChC"}

package/tasks/reindex/ReindexRunner.d.ts

@@ -0,0 +1,24 @@
+import type { IIndexManager } from "../../abstractions/IndexManager.js";
+import type { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { TaskController } from "@webiny/api-core/features/task/TaskController/index.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { ListTenantsUseCase } from "@webiny/api-core/features/tenancy/ListTenants/index.js";
+import { StorageScanner } from "../../abstractions/StorageScanner.js";
+import { StorageWriter } from "../../abstractions/StorageWriter.js";
+import { TenantIndexFactory } from "../../abstractions/TenantIndexFactory.js";
+import { ReindexRunner as Abstraction } from "./abstractions/ReindexRunner.js";
+declare class ReindexRunnerImpl implements Abstraction.Interface {
+    private readonly controller;
+    private readonly scanner;
+    private readonly writer;
+    private readonly tenantContext;
+    private readonly listTenantsUseCase;
+    private readonly indexFactories;
+    constructor(controller: TaskController.Interface, scanner: StorageScanner.Interface, writer: StorageWriter.Interface, tenantContext: TenantContext.Interface, listTenantsUseCase: ListTenantsUseCase.Interface, indexFactories: TenantIndexFactory.Interface[]);
+    execute(cursor: string | undefined, limit: number, indexManager: IIndexManager): Promise<TaskDefinition.Result<Abstraction.Input>>;
+    private buildIndexConfigs;
+}
+export declare const ReindexRunner: typeof ReindexRunnerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/ReindexRunner.js").IReindexRunner>;
+};
+export {};

package/tasks/reindex/ReindexRunner.js

@@ -0,0 +1,114 @@
+import { TaskController } from "@webiny/api-core/features/task/TaskController/index.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { ListTenantsUseCase } from "@webiny/api-core/features/tenancy/ListTenants/index.js";
+import { StorageScanner } from "../../abstractions/StorageScanner.js";
+import { StorageWriter } from "../../abstractions/StorageWriter.js";
+import { TenantIndexFactory } from "../../abstractions/TenantIndexFactory.js";
+import { ReindexRunner } from "./abstractions/ReindexRunner.js";
+class ReindexRunnerImpl {
+    constructor(controller, scanner, writer, tenantContext, listTenantsUseCase, indexFactories){
+        this.controller = controller;
+        this.scanner = scanner;
+        this.writer = writer;
+        this.tenantContext = tenantContext;
+        this.listTenantsUseCase = listTenantsUseCase;
+        this.indexFactories = indexFactories;
+    }
+    async execute(cursor, limit, indexManager) {
+        const isIndexAllowed = (index)=>{
+            const input = this.controller.state.getInput();
+            if ("string" != typeof input.matching || !input.matching) return true;
+            return index.includes(input.matching);
+        };
+        const indexConfigs = await this.buildIndexConfigs();
+        try {
+            while(false === this.controller.runtime.isCloseToTimeout()){
+                if (this.controller.runtime.isAborted()) return this.controller.response.aborted();
+                const results = await this.scanner.scan(cursor, limit);
+                if (0 === results.items.length) {
+                    await indexManager.enableIndexing();
+                    return this.controller.response.done("No more items to process.");
+                }
+                for (const item of results.items){
+                    if (!item.index) continue;
+                    if (false === isIndexAllowed(item.index)) continue;
+                    if (!item.entity) continue;
+                    const exists = await indexManager.indexExists(item.index);
+                    if (!exists) {
+                        const config = indexConfigs[item.index];
+                        if (!config) {
+                            await this.controller.logger.info({
+                                message: `Index "${item.index}" does not exist and no configuration found. Skipping.`
+                            });
+                            continue;
+                        }
+                        await indexManager.createIndex(item.index, config.settings);
+                        await this.controller.logger.info({
+                            message: `Index "${item.index}" created.`
+                        });
+                    }
+                    await indexManager.disableIndexing(item.index);
+                    this.writer.put({
+                        entity: item.entity,
+                        data: {
+                            ...item.data,
+                            modified: new Date().toISOString()
+                        }
+                    });
+                }
+                await this.writer.execute();
+                cursor = results.cursor;
+                await this.controller.state.updateInput({
+                    settings: indexManager.settings,
+                    cursor
+                });
+                if (!cursor) {
+                    await indexManager.enableIndexing();
+                    return this.controller.response.done("No more items to process - no last evaluated keys.");
+                }
+            }
+            return this.controller.response.continue({
+                cursor
+            });
+        } catch (ex) {
+            try {
+                await indexManager.enableIndexing();
+            } catch (er) {
+                er.data = ex;
+                return this.controller.response.error(er);
+            }
+            return this.controller.response.error(ex);
+        }
+    }
+    async buildIndexConfigs() {
+        const configs = {};
+        const tenantsResult = await this.listTenantsUseCase.execute();
+        const tenants = tenantsResult.value;
+        await this.tenantContext.withEachTenant(tenants, async (tenant)=>{
+            for (const factory of this.indexFactories){
+                const results = await factory.getIndexList(tenant);
+                for (const result of results)if (!configs[result.index]) configs[result.index] = result;
+            }
+        });
+        return configs;
+    }
+}
+const ReindexRunner_ReindexRunner = ReindexRunner.createImplementation({
+    implementation: ReindexRunnerImpl,
+    dependencies: [
+        TaskController,
+        StorageScanner,
+        StorageWriter,
+        TenantContext,
+        ListTenantsUseCase,
+        [
+            TenantIndexFactory,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { ReindexRunner_ReindexRunner as ReindexRunner };
+
+//# sourceMappingURL=ReindexRunner.js.map

package/tasks/reindex/ReindexRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks/reindex/ReindexRunner.js","sources":["../../../src/tasks/reindex/ReindexRunner.ts"],"sourcesContent":["import type { IIndexManager } from \"~/abstractions/IndexManager.js\";\nimport type { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { TaskController } from \"@webiny/api-core/features/task/TaskController/index.js\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { ListTenantsUseCase } from \"@webiny/api-core/features/tenancy/ListTenants/index.js\";\nimport { StorageScanner } from \"~/abstractions/StorageScanner.js\";\nimport { StorageWriter } from \"~/abstractions/StorageWriter.js\";\nimport { TenantIndexFactory } from \"~/abstractions/TenantIndexFactory.js\";\nimport { ReindexRunner as Abstraction } from \"./abstractions/ReindexRunner.js\";\n\nclass ReindexRunnerImpl implements Abstraction.Interface {\n    constructor(\n        private readonly controller: TaskController.Interface,\n        private readonly scanner: StorageScanner.Interface,\n        private readonly writer: StorageWriter.Interface,\n        private readonly tenantContext: TenantContext.Interface,\n        private readonly listTenantsUseCase: ListTenantsUseCase.Interface,\n        private readonly indexFactories: TenantIndexFactory.Interface[]\n    ) {}\n\n    public async execute(\n        cursor: string | undefined,\n        limit: number,\n        indexManager: IIndexManager\n    ): Promise<TaskDefinition.Result<Abstraction.Input>> {\n        const isIndexAllowed = (index: string): boolean => {\n            const input = this.controller.state.getInput();\n            if (typeof input.matching !== \"string\" || !input.matching) {\n                return true;\n            }\n            return index.includes(input.matching);\n        };\n\n        const indexConfigs = await this.buildIndexConfigs();\n\n        try {\n            while (this.controller.runtime.isCloseToTimeout() === false) {\n                if (this.controller.runtime.isAborted()) {\n                    return this.controller.response.aborted();\n                }\n\n                const results = await this.scanner.scan(cursor, limit);\n                if (results.items.length === 0) {\n                    await indexManager.enableIndexing();\n                    return this.controller.response.done(\"No more items to process.\");\n                }\n\n                for (const item of results.items) {\n                    if (!item.index) {\n                        continue;\n                    }\n                    if (isIndexAllowed(item.index) === false) {\n                        continue;\n                    }\n                    if (!item.entity) {\n                        continue;\n                    }\n\n                    const exists = await indexManager.indexExists(item.index);\n                    if (!exists) {\n                        const config = indexConfigs[item.index];\n                        if (!config) {\n                            await this.controller.logger.info({\n                                message: `Index \"${item.index}\" does not exist and no configuration found. Skipping.`\n                            });\n                            continue;\n                        }\n                        await indexManager.createIndex(item.index, config.settings);\n                        await this.controller.logger.info({\n                            message: `Index \"${item.index}\" created.`\n                        });\n                    }\n\n                    await indexManager.disableIndexing(item.index);\n                    this.writer.put({\n                        entity: item.entity,\n                        data: {\n                            ...item.data,\n                            modified: new Date().toISOString()\n                        }\n                    });\n                }\n                await this.writer.execute();\n                cursor = results.cursor;\n                await this.controller.state.updateInput({\n                    settings: indexManager.settings,\n                    cursor\n                });\n                if (!cursor) {\n                    await indexManager.enableIndexing();\n                    return this.controller.response.done(\n                        \"No more items to process - no last evaluated keys.\"\n                    );\n                }\n            }\n            return this.controller.response.continue({\n                cursor\n            });\n        } catch (ex) {\n            try {\n                await indexManager.enableIndexing();\n            } catch (er) {\n                er.data = ex;\n                return this.controller.response.error(er);\n            }\n            return this.controller.response.error(ex);\n        }\n    }\n\n    private async buildIndexConfigs(): Promise<Abstraction.IndexConfigsMap> {\n        const configs: Abstraction.IndexConfigsMap = {};\n        const tenantsResult = await this.listTenantsUseCase.execute();\n        const tenants = tenantsResult.value;\n\n        await this.tenantContext.withEachTenant(tenants, async tenant => {\n            for (const factory of this.indexFactories) {\n                const results = await factory.getIndexList(tenant);\n                for (const result of results) {\n                    if (!configs[result.index]) {\n                        configs[result.index] = result;\n                    }\n                }\n            }\n        });\n\n        return configs;\n    }\n}\n\nexport const ReindexRunner = Abstraction.createImplementation({\n    implementation: ReindexRunnerImpl,\n    dependencies: [\n        TaskController,\n        StorageScanner,\n        StorageWriter,\n        TenantContext,\n        ListTenantsUseCase,\n        [TenantIndexFactory, { multiple: true }]\n    ]\n});\n"],"names":["ReindexRunnerImpl","controller","scanner","writer","tenantContext","listTenantsUseCase","indexFactories","cursor","limit","indexManager","isIndexAllowed","index","input","indexConfigs","results","item","exists","config","Date","ex","er","configs","tenantsResult","tenants","tenant","factory","result","ReindexRunner","Abstraction","TaskController","StorageScanner","StorageWriter","TenantContext","ListTenantsUseCase","TenantIndexFactory"],"mappings":"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"}

package/tasks/reindex/ReindexTask.d.ts

@@ -0,0 +1,16 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { ReindexRunner } from "./abstractions/ReindexRunner.js";
+import { IndexManagerFactory } from "../../abstractions/IndexManagerFactory.js";
+declare class ReindexTaskImpl implements TaskDefinition.Interface<ReindexRunner.Input> {
+    private readonly indexManagerFactory;
+    private readonly runner;
+    readonly id = "elasticsearchReindexing";
+    readonly title = "Reindex Search Index";
+    readonly maxIterations = 500;
+    constructor(indexManagerFactory: IndexManagerFactory.Interface, runner: ReindexRunner.Interface);
+    run({ input, controller }: TaskDefinition.RunParams<ReindexRunner.Input>): Promise<TaskDefinition.Result<import("./abstractions/ReindexRunner.js").IReindexInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>>;
+}
+export declare const ReindexTask: typeof ReindexTaskImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskDefinition<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>>;
+};
+export {};