@webiny/api-search-index-tasks 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-search-index-tasks
+
+> [!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/abstractions/IndexManager.d.ts

@@ -0,0 +1,22 @@
+import type { GenericRecord } from "@webiny/api/types.js";
+export interface IIndexSettings {
+    numberOfReplicas: number;
+    refreshInterval: string;
+}
+export interface IIndexSettingsMap {
+    [index: string]: IIndexSettings;
+}
+export interface IIndexManager {
+    list(): Promise<string[]>;
+    indexExists(index: string): Promise<boolean>;
+    createIndex(index: string, settings?: GenericRecord): Promise<void>;
+    disableIndexing(index: string): Promise<IIndexSettings>;
+    enableIndexing(index?: string): Promise<void>;
+    settings: IIndexSettingsMap;
+}
+export declare const IndexManager: import("@webiny/di").Abstraction<IIndexManager>;
+export declare namespace IndexManager {
+    type Interface = IIndexManager;
+    type Settings = IIndexSettings;
+    type SettingsMap = IIndexSettingsMap;
+}

package/abstractions/IndexManager.js

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

package/abstractions/IndexManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractions/IndexManager.js","sources":["../../src/abstractions/IndexManager.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\nexport interface IIndexSettings {\n    numberOfReplicas: number;\n    refreshInterval: string;\n}\n\nexport interface IIndexSettingsMap {\n    [index: string]: IIndexSettings;\n}\n\nexport interface IIndexManager {\n    list(): Promise<string[]>;\n    indexExists(index: string): Promise<boolean>;\n    createIndex(index: string, settings?: GenericRecord): Promise<void>;\n    disableIndexing(index: string): Promise<IIndexSettings>;\n    enableIndexing(index?: string): Promise<void>;\n    settings: IIndexSettingsMap;\n}\n\nexport const IndexManager = createAbstraction<IIndexManager>(\"SearchIndexTasks/IndexManager\");\n\nexport namespace IndexManager {\n    export type Interface = IIndexManager;\n    export type Settings = IIndexSettings;\n    export type SettingsMap = IIndexSettingsMap;\n}\n"],"names":["IndexManager","createAbstraction"],"mappings":";AAqBO,MAAMA,eAAeC,kBAAiC"}

package/abstractions/IndexManagerFactory.d.ts

@@ -0,0 +1,13 @@
+import type { IIndexManager, IIndexSettings, IIndexSettingsMap } from "./IndexManager.js";
+export interface IIndexManagerFactoryParams {
+    settings: IIndexSettingsMap;
+    defaults?: Partial<IIndexSettings>;
+}
+export interface IIndexManagerFactory {
+    createIndexManager(params: IIndexManagerFactoryParams): IIndexManager;
+}
+export declare const IndexManagerFactory: import("@webiny/di").Abstraction<IIndexManagerFactory>;
+export declare namespace IndexManagerFactory {
+    type Interface = IIndexManagerFactory;
+    type Params = IIndexManagerFactoryParams;
+}

package/abstractions/IndexManagerFactory.js

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

package/abstractions/IndexManagerFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractions/IndexManagerFactory.js","sources":["../../src/abstractions/IndexManagerFactory.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IIndexManager, IIndexSettings, IIndexSettingsMap } from \"./IndexManager.js\";\n\nexport interface IIndexManagerFactoryParams {\n    settings: IIndexSettingsMap;\n    defaults?: Partial<IIndexSettings>;\n}\n\nexport interface IIndexManagerFactory {\n    createIndexManager(params: IIndexManagerFactoryParams): IIndexManager;\n}\n\nexport const IndexManagerFactory = createAbstraction<IIndexManagerFactory>(\n    \"SearchIndexTasks/IndexManagerFactory\"\n);\n\nexport namespace IndexManagerFactory {\n    export type Interface = IIndexManagerFactory;\n    export type Params = IIndexManagerFactoryParams;\n}\n"],"names":["IndexManagerFactory","createAbstraction"],"mappings":";AAYO,MAAMA,sBAAsBC,kBAC/B"}

package/abstractions/IndexSettingsManager.d.ts

@@ -0,0 +1,10 @@
+import type { IIndexSettings } from "./IndexManager.js";
+export interface IIndexSettingsManager {
+    getSettings(index: string): Promise<IIndexSettings>;
+    setSettings(index: string, settings: IIndexSettings): Promise<void>;
+}
+export declare const IndexSettingsManager: import("@webiny/di").Abstraction<IIndexSettingsManager>;
+export declare namespace IndexSettingsManager {
+    type Interface = IIndexSettingsManager;
+    type Settings = IIndexSettings;
+}

package/abstractions/IndexSettingsManager.js

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

package/abstractions/IndexSettingsManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractions/IndexSettingsManager.js","sources":["../../src/abstractions/IndexSettingsManager.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IIndexSettings } from \"./IndexManager.js\";\n\nexport interface IIndexSettingsManager {\n    getSettings(index: string): Promise<IIndexSettings>;\n    setSettings(index: string, settings: IIndexSettings): Promise<void>;\n}\n\nexport const IndexSettingsManager = createAbstraction<IIndexSettingsManager>(\n    \"SearchIndexTasks/IndexSettingsManager\"\n);\n\nexport namespace IndexSettingsManager {\n    export type Interface = IIndexSettingsManager;\n    export type Settings = IIndexSettings;\n}\n"],"names":["IndexSettingsManager","createAbstraction"],"mappings":";AAQO,MAAMA,uBAAuBC,kBAChC"}

package/abstractions/StorageScanner.d.ts

@@ -0,0 +1,20 @@
+import type { GenericRecord } from "@webiny/api/types.js";
+export interface IStorageScannerRecord {
+    index: string;
+    entity: string;
+    data: GenericRecord;
+    modified: string;
+}
+export interface IStorageScannerResult {
+    items: IStorageScannerRecord[];
+    cursor?: string;
+}
+export interface IStorageScanner {
+    scan(cursor: string | undefined, limit: number): Promise<IStorageScannerResult>;
+}
+export declare const StorageScanner: import("@webiny/di").Abstraction<IStorageScanner>;
+export declare namespace StorageScanner {
+    type Interface = IStorageScanner;
+    type Record = IStorageScannerRecord;
+    type Result = IStorageScannerResult;
+}

package/abstractions/StorageScanner.js

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

package/abstractions/StorageScanner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractions/StorageScanner.js","sources":["../../src/abstractions/StorageScanner.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\nexport interface IStorageScannerRecord {\n    index: string;\n    entity: string;\n    data: GenericRecord;\n    modified: string;\n}\n\nexport interface IStorageScannerResult {\n    items: IStorageScannerRecord[];\n    cursor?: string;\n}\n\nexport interface IStorageScanner {\n    scan(cursor: string | undefined, limit: number): Promise<IStorageScannerResult>;\n}\n\nexport const StorageScanner = createAbstraction<IStorageScanner>(\"SearchIndexTasks/StorageScanner\");\n\nexport namespace StorageScanner {\n    export type Interface = IStorageScanner;\n    export type Record = IStorageScannerRecord;\n    export type Result = IStorageScannerResult;\n}\n"],"names":["StorageScanner","createAbstraction"],"mappings":";AAmBO,MAAMA,iBAAiBC,kBAAmC"}

package/abstractions/StorageWriter.d.ts

@@ -0,0 +1,14 @@
+import type { GenericRecord } from "@webiny/api/types.js";
+export interface IStorageWriterRecord {
+    entity: string;
+    data: GenericRecord;
+}
+export interface IStorageWriter {
+    put(record: IStorageWriterRecord): void;
+    execute(): Promise<void>;
+}
+export declare const StorageWriter: import("@webiny/di").Abstraction<IStorageWriter>;
+export declare namespace StorageWriter {
+    type Interface = IStorageWriter;
+    type Record = IStorageWriterRecord;
+}

package/abstractions/StorageWriter.js

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

package/abstractions/StorageWriter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractions/StorageWriter.js","sources":["../../src/abstractions/StorageWriter.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\nexport interface IStorageWriterRecord {\n    entity: string;\n    data: GenericRecord;\n}\n\nexport interface IStorageWriter {\n    put(record: IStorageWriterRecord): void;\n    execute(): Promise<void>;\n}\n\nexport const StorageWriter = createAbstraction<IStorageWriter>(\"SearchIndexTasks/StorageWriter\");\n\nexport namespace StorageWriter {\n    export type Interface = IStorageWriter;\n    export type Record = IStorageWriterRecord;\n}\n"],"names":["StorageWriter","createAbstraction"],"mappings":";AAaO,MAAMA,gBAAgBC,kBAAkC"}

package/abstractions/TenantIndexFactory.d.ts

@@ -0,0 +1,16 @@
+import type { GenericRecord } from "@webiny/api/types.js";
+import type { Tenant as BaseTenant } from "@webiny/api-core/types/tenancy.js";
+export interface ITenantIndexConfig {
+    index: string;
+    settings?: GenericRecord;
+}
+export type ITenant = Pick<BaseTenant, "id">;
+export interface ITenantIndexFactory {
+    getIndexList(tenant: ITenant): Promise<ITenantIndexConfig[]>;
+}
+export declare const TenantIndexFactory: import("@webiny/di").Abstraction<ITenantIndexFactory>;
+export declare namespace TenantIndexFactory {
+    type Interface = ITenantIndexFactory;
+    type IndexConfig = ITenantIndexConfig;
+    type Tenant = ITenant;
+}

package/abstractions/TenantIndexFactory.js

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

package/abstractions/TenantIndexFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractions/TenantIndexFactory.js","sources":["../../src/abstractions/TenantIndexFactory.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\nimport type { Tenant as BaseTenant } from \"@webiny/api-core/types/tenancy.js\";\n\nexport interface ITenantIndexConfig {\n    index: string;\n    settings?: GenericRecord;\n}\n\nexport type ITenant = Pick<BaseTenant, \"id\">;\n\nexport interface ITenantIndexFactory {\n    getIndexList(tenant: ITenant): Promise<ITenantIndexConfig[]>;\n}\n\nexport const TenantIndexFactory = createAbstraction<ITenantIndexFactory>(\n    \"SearchIndexTenantIndexFactory\"\n);\n\nexport namespace TenantIndexFactory {\n    export type Interface = ITenantIndexFactory;\n    export type IndexConfig = ITenantIndexConfig;\n    export type Tenant = ITenant;\n}\n"],"names":["TenantIndexFactory","createAbstraction"],"mappings":";AAeO,MAAMA,qBAAqBC,kBAC9B"}

package/errors/IndexingDisableError.d.ts

@@ -0,0 +1,2 @@
+export declare class IndexingDisableError extends Error {
+}

package/errors/IndexingDisableError.js

@@ -0,0 +1,5 @@
+class IndexingDisableError extends Error {
+}
+export { IndexingDisableError };
+
+//# sourceMappingURL=IndexingDisableError.js.map

package/errors/IndexingDisableError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors/IndexingDisableError.js","sources":["../../src/errors/IndexingDisableError.ts"],"sourcesContent":["export class IndexingDisableError extends Error {}\n"],"names":["IndexingDisableError","Error"],"mappings":"AAAO,MAAMA,6BAA6BC;AAAO"}

package/errors/IndexingEnableError.d.ts

@@ -0,0 +1,2 @@
+export declare class IndexingEnableError extends Error {
+}

package/errors/IndexingEnableError.js

@@ -0,0 +1,5 @@
+class IndexingEnableError extends Error {
+}
+export { IndexingEnableError };
+
+//# sourceMappingURL=IndexingEnableError.js.map

package/errors/IndexingEnableError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors/IndexingEnableError.js","sources":["../../src/errors/IndexingEnableError.ts"],"sourcesContent":["export class IndexingEnableError extends Error {}\n"],"names":["IndexingEnableError","Error"],"mappings":"AAAO,MAAMA,4BAA4BC;AAAO"}

package/feature.d.ts

@@ -0,0 +1,5 @@
+import { type Container } from "@webiny/feature/api";
+export declare const SearchIndexTasksFeature: {
+    name: string;
+    register(container: Container): void;
+};

package/feature.js

@@ -0,0 +1,27 @@
+import { createFeature } from "@webiny/feature/api";
+import { DisableIndexing } from "./settings/DisableIndexing.js";
+import { EnableIndexing } from "./settings/EnableIndexing.js";
+import { ReindexRunner } from "./tasks/reindex/ReindexRunner.js";
+import { ReindexTask } from "./tasks/reindex/ReindexTask.js";
+import { EnableIndexingRunner } from "./tasks/enableIndexing/EnableIndexingRunner.js";
+import { EnableIndexingTask } from "./tasks/enableIndexing/EnableIndexingTask.js";
+import { CreateIndexesRunner } from "./tasks/createIndexes/CreateIndexesRunner.js";
+import { OnBeforeTrigger } from "./tasks/createIndexes/OnBeforeTrigger.js";
+import { CreateIndexesTask } from "./tasks/createIndexes/CreateIndexesTask.js";
+const SearchIndexTasksFeature = createFeature({
+    name: "SearchIndexTasks",
+    register (container) {
+        container.register(DisableIndexing);
+        container.register(EnableIndexing);
+        container.register(ReindexRunner);
+        container.register(ReindexTask);
+        container.register(EnableIndexingRunner);
+        container.register(EnableIndexingTask);
+        container.register(CreateIndexesRunner);
+        container.register(OnBeforeTrigger);
+        container.register(CreateIndexesTask);
+    }
+});
+export { SearchIndexTasksFeature };
+
+//# sourceMappingURL=feature.js.map

package/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.js","sources":["../src/feature.ts"],"sourcesContent":["import { type Container, createFeature } from \"@webiny/feature/api\";\nimport { DisableIndexing } from \"~/settings/DisableIndexing.js\";\nimport { EnableIndexing } from \"~/settings/EnableIndexing.js\";\nimport { ReindexRunner } from \"~/tasks/reindex/ReindexRunner.js\";\nimport { ReindexTask } from \"~/tasks/reindex/ReindexTask.js\";\nimport { EnableIndexingRunner } from \"~/tasks/enableIndexing/EnableIndexingRunner.js\";\nimport { EnableIndexingTask } from \"~/tasks/enableIndexing/EnableIndexingTask.js\";\nimport { CreateIndexesRunner } from \"~/tasks/createIndexes/CreateIndexesRunner.js\";\nimport { OnBeforeTrigger } from \"~/tasks/createIndexes/OnBeforeTrigger.js\";\nimport { CreateIndexesTask } from \"~/tasks/createIndexes/CreateIndexesTask.js\";\n\nexport const SearchIndexTasksFeature = createFeature({\n    name: \"SearchIndexTasks\",\n    register(container: Container) {\n        container.register(DisableIndexing);\n        container.register(EnableIndexing);\n        container.register(ReindexRunner);\n        container.register(ReindexTask);\n        container.register(EnableIndexingRunner);\n        container.register(EnableIndexingTask);\n        container.register(CreateIndexesRunner);\n        container.register(OnBeforeTrigger);\n        container.register(CreateIndexesTask);\n    }\n});\n"],"names":["SearchIndexTasksFeature","createFeature","container","DisableIndexing","EnableIndexing","ReindexRunner","ReindexTask","EnableIndexingRunner","EnableIndexingTask","CreateIndexesRunner","OnBeforeTrigger","CreateIndexesTask"],"mappings":";;;;;;;;;;AAWO,MAAMA,0BAA0BC,cAAc;IACjD,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QACnBL,UAAU,QAAQ,CAACM;QACnBN,UAAU,QAAQ,CAACO;QACnBP,UAAU,QAAQ,CAACQ;QACnBR,UAAU,QAAQ,CAACS;IACvB;AACJ"}

package/index.d.ts

@@ -0,0 +1,23 @@
+import "@webiny/background-tasks/api/features/TaskController/index.js";
+export { StorageScanner } from "./abstractions/StorageScanner.js";
+export { IndexManager } from "./abstractions/IndexManager.js";
+export { StorageWriter } from "./abstractions/StorageWriter.js";
+export { IndexManagerFactory } from "./abstractions/IndexManagerFactory.js";
+export { IndexSettingsManager } from "./abstractions/IndexSettingsManager.js";
+export { DisableIndexing } from "./settings/abstractions/DisableIndexing.js";
+export { EnableIndexing } from "./settings/abstractions/EnableIndexing.js";
+export { DisableIndexing as DisableIndexingImpl } from "./settings/DisableIndexing.js";
+export { EnableIndexing as EnableIndexingImpl } from "./settings/EnableIndexing.js";
+export { EnableIndexingRunner } from "./tasks/enableIndexing/abstractions/EnableIndexingRunner.js";
+export { EnableIndexingRunner as EnableIndexingRunnerImpl } from "./tasks/enableIndexing/EnableIndexingRunner.js";
+export { EnableIndexingTask } from "./tasks/enableIndexing/EnableIndexingTask.js";
+export { TenantIndexFactory } from "./abstractions/TenantIndexFactory.js";
+export { CreateIndexesRunner } from "./tasks/createIndexes/abstractions/CreateIndexesRunner.js";
+export { OnBeforeTrigger } from "./tasks/createIndexes/abstractions/OnBeforeTrigger.js";
+export { CreateIndexesRunner as CreateIndexesRunnerImpl } from "./tasks/createIndexes/CreateIndexesRunner.js";
+export { OnBeforeTrigger as OnBeforeTriggerImpl } from "./tasks/createIndexes/OnBeforeTrigger.js";
+export { CreateIndexesTask } from "./tasks/createIndexes/CreateIndexesTask.js";
+export { ReindexRunner } from "./tasks/reindex/abstractions/ReindexRunner.js";
+export { ReindexRunner as ReindexRunnerImpl } from "./tasks/reindex/ReindexRunner.js";
+export { ReindexTask } from "./tasks/reindex/ReindexTask.js";
+export { SearchIndexTasksFeature } from "./feature.js";

package/index.js

@@ -0,0 +1,23 @@
+import "@webiny/background-tasks/api/features/TaskController/index.js";
+export { StorageScanner } from "./abstractions/StorageScanner.js";
+export { IndexManager } from "./abstractions/IndexManager.js";
+export { StorageWriter } from "./abstractions/StorageWriter.js";
+export { IndexManagerFactory } from "./abstractions/IndexManagerFactory.js";
+export { IndexSettingsManager } from "./abstractions/IndexSettingsManager.js";
+export { DisableIndexing } from "./settings/abstractions/DisableIndexing.js";
+export { EnableIndexing } from "./settings/abstractions/EnableIndexing.js";
+export { DisableIndexing as DisableIndexingImpl } from "./settings/DisableIndexing.js";
+export { EnableIndexing as EnableIndexingImpl } from "./settings/EnableIndexing.js";
+export { EnableIndexingRunner } from "./tasks/enableIndexing/abstractions/EnableIndexingRunner.js";
+export { EnableIndexingRunner as EnableIndexingRunnerImpl } from "./tasks/enableIndexing/EnableIndexingRunner.js";
+export { EnableIndexingTask } from "./tasks/enableIndexing/EnableIndexingTask.js";
+export { TenantIndexFactory } from "./abstractions/TenantIndexFactory.js";
+export { CreateIndexesRunner } from "./tasks/createIndexes/abstractions/CreateIndexesRunner.js";
+export { OnBeforeTrigger } from "./tasks/createIndexes/abstractions/OnBeforeTrigger.js";
+export { CreateIndexesRunner as CreateIndexesRunnerImpl } from "./tasks/createIndexes/CreateIndexesRunner.js";
+export { OnBeforeTrigger as OnBeforeTriggerImpl } from "./tasks/createIndexes/OnBeforeTrigger.js";
+export { CreateIndexesTask } from "./tasks/createIndexes/CreateIndexesTask.js";
+export { ReindexRunner } from "./tasks/reindex/abstractions/ReindexRunner.js";
+export { ReindexRunner as ReindexRunnerImpl } from "./tasks/reindex/ReindexRunner.js";
+export { ReindexTask } from "./tasks/reindex/ReindexTask.js";
+export { SearchIndexTasksFeature } from "./feature.js";

package/package.json

@@ -0,0 +1,39 @@
+{
+	"name": "@webiny/api-search-index-tasks",
+	"version": "0.0.0-unstable.0156a4c312",
+	"type": "module",
+	"exports": {
+		".": "./index.js",
+		"./*": "./*"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/api-search-index-tasks"
+	},
+	"description": "Platform-agnostic search index background tasks.",
+	"license": "MIT",
+	"author": "Webiny Ltd.",
+	"dependencies": {
+		"@webiny/api": "0.0.0-unstable.0156a4c312",
+		"@webiny/api-core": "0.0.0-unstable.0156a4c312",
+		"@webiny/background-tasks": "0.0.0-unstable.0156a4c312",
+		"@webiny/feature": "0.0.0-unstable.0156a4c312"
+	},
+	"devDependencies": {
+		"@webiny/build-tools": "0.0.0-unstable.0156a4c312",
+		"typescript": "7.0.2",
+		"vitest": "5.0.5"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"adio": {
+		"ignoreDirs": [
+			"__tests__"
+		]
+	},
+	"webiny": {
+		"publishFrom": "dist"
+	}
+}

package/settings/DisableIndexing.d.ts

@@ -0,0 +1,11 @@
+import { IndexSettingsManager } from "../abstractions/IndexSettingsManager.js";
+import { DisableIndexing as Abstraction } from "./abstractions/DisableIndexing.js";
+declare class DisableIndexingImpl implements Abstraction.Interface {
+    private readonly settings;
+    constructor(settings: IndexSettingsManager.Interface);
+    execute(index: string): Promise<Abstraction.Settings>;
+}
+export declare const DisableIndexing: typeof DisableIndexingImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/DisableIndexing.js").IDisableIndexing>;
+};
+export {};

package/settings/DisableIndexing.js

@@ -0,0 +1,29 @@
+import { IndexingDisableError } from "../errors/IndexingDisableError.js";
+import { IndexSettingsManager } from "../abstractions/IndexSettingsManager.js";
+import { DisableIndexing } from "./abstractions/DisableIndexing.js";
+class DisableIndexingImpl {
+    constructor(settings){
+        this.settings = settings;
+    }
+    async execute(index) {
+        const settings = await this.settings.getSettings(index);
+        try {
+            await this.settings.setSettings(index, {
+                numberOfReplicas: 0,
+                refreshInterval: "-1"
+            });
+        } catch (ex) {
+            throw new IndexingDisableError(ex instanceof Error ? ex.message : String(ex));
+        }
+        return settings;
+    }
+}
+const DisableIndexing_DisableIndexing = DisableIndexing.createImplementation({
+    implementation: DisableIndexingImpl,
+    dependencies: [
+        IndexSettingsManager
+    ]
+});
+export { DisableIndexing_DisableIndexing as DisableIndexing };
+
+//# sourceMappingURL=DisableIndexing.js.map

package/settings/DisableIndexing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings/DisableIndexing.js","sources":["../../src/settings/DisableIndexing.ts"],"sourcesContent":["import { IndexingDisableError } from \"~/errors/IndexingDisableError.js\";\nimport { IndexSettingsManager } from \"~/abstractions/IndexSettingsManager.js\";\nimport { DisableIndexing as Abstraction } from \"./abstractions/DisableIndexing.js\";\n\nclass DisableIndexingImpl implements Abstraction.Interface {\n    constructor(private readonly settings: IndexSettingsManager.Interface) {}\n\n    public async execute(index: string): Promise<Abstraction.Settings> {\n        const settings = await this.settings.getSettings(index);\n\n        try {\n            await this.settings.setSettings(index, {\n                numberOfReplicas: 0,\n                refreshInterval: \"-1\"\n            });\n        } catch (ex) {\n            throw new IndexingDisableError(ex instanceof Error ? ex.message : String(ex));\n        }\n\n        return settings;\n    }\n}\n\nexport const DisableIndexing = Abstraction.createImplementation({\n    implementation: DisableIndexingImpl,\n    dependencies: [IndexSettingsManager]\n});\n"],"names":["DisableIndexingImpl","settings","index","ex","IndexingDisableError","Error","String","DisableIndexing","Abstraction","IndexSettingsManager"],"mappings":";;;AAIA,MAAMA;IACF,YAA6BC,QAAwC,CAAE;aAA1CA,QAAQ,GAARA;IAA2C;IAExE,MAAa,QAAQC,KAAa,EAAiC;QAC/D,MAAMD,WAAW,MAAM,IAAI,CAAC,QAAQ,CAAC,WAAW,CAACC;QAEjD,IAAI;YACA,MAAM,IAAI,CAAC,QAAQ,CAAC,WAAW,CAACA,OAAO;gBACnC,kBAAkB;gBAClB,iBAAiB;YACrB;QACJ,EAAE,OAAOC,IAAI;YACT,MAAM,IAAIC,qBAAqBD,cAAcE,QAAQF,GAAG,OAAO,GAAGG,OAAOH;QAC7E;QAEA,OAAOF;IACX;AACJ;AAEO,MAAMM,kCAAkBC,gBAAAA,oBAAgC,CAAC;IAC5D,gBAAgBR;IAChB,cAAc;QAACS;KAAqB;AACxC"}

package/settings/EnableIndexing.d.ts

@@ -0,0 +1,11 @@
+import { IndexSettingsManager } from "../abstractions/IndexSettingsManager.js";
+import { EnableIndexing as Abstraction } from "./abstractions/EnableIndexing.js";
+declare class EnableIndexingImpl implements Abstraction.Interface {
+    private readonly settings;
+    constructor(settings: IndexSettingsManager.Interface);
+    execute(index: string, settings: Abstraction.Settings): Promise<void>;
+}
+export declare const EnableIndexing: typeof EnableIndexingImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/EnableIndexing.js").IEnableIndexing>;
+};
+export {};

package/settings/EnableIndexing.js

@@ -0,0 +1,29 @@
+import { IndexingEnableError } from "../errors/IndexingEnableError.js";
+import { IndexSettingsManager } from "../abstractions/IndexSettingsManager.js";
+import { EnableIndexing } from "./abstractions/EnableIndexing.js";
+class EnableIndexingImpl {
+    constructor(settings){
+        this.settings = settings;
+    }
+    async execute(index, settings) {
+        try {
+            const refreshInterval = parseInt(settings.refreshInterval || "", 10) || 0;
+            await this.settings.setSettings(index, {
+                ...settings,
+                numberOfReplicas: settings.numberOfReplicas < 1 ? 1 : settings.numberOfReplicas,
+                refreshInterval: refreshInterval <= 0 ? "1s" : settings.refreshInterval
+            });
+        } catch (ex) {
+            throw new IndexingEnableError(ex instanceof Error ? ex.message : String(ex));
+        }
+    }
+}
+const EnableIndexing_EnableIndexing = EnableIndexing.createImplementation({
+    implementation: EnableIndexingImpl,
+    dependencies: [
+        IndexSettingsManager
+    ]
+});
+export { EnableIndexing_EnableIndexing as EnableIndexing };
+
+//# sourceMappingURL=EnableIndexing.js.map

package/settings/EnableIndexing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings/EnableIndexing.js","sources":["../../src/settings/EnableIndexing.ts"],"sourcesContent":["import { IndexingEnableError } from \"~/errors/IndexingEnableError.js\";\nimport { IndexSettingsManager } from \"~/abstractions/IndexSettingsManager.js\";\nimport { EnableIndexing as Abstraction } from \"./abstractions/EnableIndexing.js\";\n\nclass EnableIndexingImpl implements Abstraction.Interface {\n    constructor(private readonly settings: IndexSettingsManager.Interface) {}\n\n    public async execute(index: string, settings: Abstraction.Settings): Promise<void> {\n        try {\n            const refreshInterval = parseInt(settings.refreshInterval || \"\", 10) || 0;\n            await this.settings.setSettings(index, {\n                ...settings,\n                numberOfReplicas: settings.numberOfReplicas < 1 ? 1 : settings.numberOfReplicas,\n                refreshInterval: refreshInterval <= 0 ? \"1s\" : settings.refreshInterval\n            });\n        } catch (ex) {\n            throw new IndexingEnableError(ex instanceof Error ? ex.message : String(ex));\n        }\n    }\n}\n\nexport const EnableIndexing = Abstraction.createImplementation({\n    implementation: EnableIndexingImpl,\n    dependencies: [IndexSettingsManager]\n});\n"],"names":["EnableIndexingImpl","settings","index","refreshInterval","parseInt","ex","IndexingEnableError","Error","String","EnableIndexing","Abstraction","IndexSettingsManager"],"mappings":";;;AAIA,MAAMA;IACF,YAA6BC,QAAwC,CAAE;aAA1CA,QAAQ,GAARA;IAA2C;IAExE,MAAa,QAAQC,KAAa,EAAED,QAA8B,EAAiB;QAC/E,IAAI;YACA,MAAME,kBAAkBC,SAASH,SAAS,eAAe,IAAI,IAAI,OAAO;YACxE,MAAM,IAAI,CAAC,QAAQ,CAAC,WAAW,CAACC,OAAO;gBACnC,GAAGD,QAAQ;gBACX,kBAAkBA,SAAS,gBAAgB,GAAG,IAAI,IAAIA,SAAS,gBAAgB;gBAC/E,iBAAiBE,mBAAmB,IAAI,OAAOF,SAAS,eAAe;YAC3E;QACJ,EAAE,OAAOI,IAAI;YACT,MAAM,IAAIC,oBAAoBD,cAAcE,QAAQF,GAAG,OAAO,GAAGG,OAAOH;QAC5E;IACJ;AACJ;AAEO,MAAMI,gCAAiBC,eAAAA,oBAAgC,CAAC;IAC3D,gBAAgBV;IAChB,cAAc;QAACW;KAAqB;AACxC"}

package/settings/abstractions/DisableIndexing.d.ts

@@ -0,0 +1,9 @@
+import type { IIndexSettings } from "../../abstractions/IndexManager.js";
+export interface IDisableIndexing {
+    execute(index: string): Promise<IIndexSettings>;
+}
+export declare const DisableIndexing: import("@webiny/di").Abstraction<IDisableIndexing>;
+export declare namespace DisableIndexing {
+    type Interface = IDisableIndexing;
+    type Settings = IIndexSettings;
+}

package/settings/abstractions/DisableIndexing.js

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

package/settings/abstractions/DisableIndexing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings/abstractions/DisableIndexing.js","sources":["../../../src/settings/abstractions/DisableIndexing.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IIndexSettings } from \"~/abstractions/IndexManager.js\";\n\nexport interface IDisableIndexing {\n    execute(index: string): Promise<IIndexSettings>;\n}\n\nexport const DisableIndexing = createAbstraction<IDisableIndexing>(\n    \"SearchIndexTasks/DisableIndexing\"\n);\n\nexport namespace DisableIndexing {\n    export type Interface = IDisableIndexing;\n    export type Settings = IIndexSettings;\n}\n"],"names":["DisableIndexing","createAbstraction"],"mappings":";AAOO,MAAMA,kBAAkBC,kBAC3B"}

package/settings/abstractions/EnableIndexing.d.ts

@@ -0,0 +1,9 @@
+import type { IIndexSettings } from "../../abstractions/IndexManager.js";
+export interface IEnableIndexing {
+    execute(index: string, settings: IIndexSettings): Promise<void>;
+}
+export declare const EnableIndexing: import("@webiny/di").Abstraction<IEnableIndexing>;
+export declare namespace EnableIndexing {
+    type Interface = IEnableIndexing;
+    type Settings = IIndexSettings;
+}

package/settings/abstractions/EnableIndexing.js

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

package/settings/abstractions/EnableIndexing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings/abstractions/EnableIndexing.js","sources":["../../../src/settings/abstractions/EnableIndexing.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IIndexSettings } from \"~/abstractions/IndexManager.js\";\n\nexport interface IEnableIndexing {\n    execute(index: string, settings: IIndexSettings): Promise<void>;\n}\n\nexport const EnableIndexing = createAbstraction<IEnableIndexing>(\"SearchIndexTasks/EnableIndexing\");\n\nexport namespace EnableIndexing {\n    export type Interface = IEnableIndexing;\n    export type Settings = IIndexSettings;\n}\n"],"names":["EnableIndexing","createAbstraction"],"mappings":";AAOO,MAAMA,iBAAiBC,kBAAmC"}

package/tasks/createIndexes/CreateIndexesRunner.d.ts

@@ -0,0 +1,19 @@
+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 { TenantIndexFactory } from "../../abstractions/TenantIndexFactory.js";
+import { ListTenantsUseCase } from "@webiny/api-core/features/tenancy/ListTenants/index.js";
+import { CreateIndexesRunner as Abstraction } from "./abstractions/CreateIndexesRunner.js";
+declare class CreateIndexesRunnerImpl implements Abstraction.Interface {
+    private readonly controller;
+    private readonly tenantContext;
+    private readonly listTenantsUseCase;
+    private readonly indexFactories;
+    constructor(controller: TaskController.Interface, tenantContext: TenantContext.Interface, listTenantsUseCase: ListTenantsUseCase.Interface, indexFactories: TenantIndexFactory.Interface[]);
+    execute(matching: string | undefined, done: string[], indexManager: IIndexManager): Promise<TaskDefinition.Result>;
+}
+export declare const CreateIndexesRunner: typeof CreateIndexesRunnerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/CreateIndexesRunner.js").ICreateIndexesRunner>;
+};
+export {};

package/tasks/createIndexes/CreateIndexesRunner.js

@@ -0,0 +1,73 @@
+import { TaskController } from "@webiny/api-core/features/task/TaskController/index.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { TenantIndexFactory } from "../../abstractions/TenantIndexFactory.js";
+import { ListTenantsUseCase } from "@webiny/api-core/features/tenancy/ListTenants/index.js";
+import { listIndexes } from "./listIndexes.js";
+import { createIndexFactory } from "./createIndexFactory.js";
+import { CreateIndexesRunner } from "./abstractions/CreateIndexesRunner.js";
+class CreateIndexesRunnerImpl {
+    constructor(controller, tenantContext, listTenantsUseCase, indexFactories){
+        this.controller = controller;
+        this.tenantContext = tenantContext;
+        this.listTenantsUseCase = listTenantsUseCase;
+        this.indexFactories = indexFactories;
+    }
+    async execute(matching, done, indexManager) {
+        if (0 === this.indexFactories.length) return this.controller.response.done("No index plugins found.");
+        const tenantsResult = await this.listTenantsUseCase.execute();
+        if (tenantsResult.isFail()) return this.controller.response.error(tenantsResult.error);
+        const tenants = tenantsResult.value;
+        const indexes = await listIndexes(this.tenantContext, tenants, this.indexFactories);
+        if (0 === indexes.length) return this.controller.response.done("No indexes found.");
+        const isIndexAllowed = (index)=>{
+            if ("string" != typeof matching || !matching) return true;
+            return index.includes(matching);
+        };
+        const factory = createIndexFactory(indexManager);
+        for (const { index, settings } of indexes){
+            if (this.controller.runtime.isAborted()) return this.controller.response.aborted();
+            else if (this.controller.runtime.isCloseToTimeout()) return this.controller.response.continue({
+                done
+            });
+            try {
+                if (done.includes(index)) continue;
+                else if (false === isIndexAllowed(index)) continue;
+                const exists = await indexManager.indexExists(index);
+                if (exists) continue;
+                done.push(index);
+                await factory.create(index, settings);
+                await this.controller.logger.info({
+                    message: `Index "${index}" created.`,
+                    data: {
+                        index
+                    }
+                });
+            } catch (ex) {
+                await this.controller.logger.error({
+                    message: `Failed to create index "${index}".`,
+                    error: ex
+                });
+            }
+        }
+        return this.controller.response.done("Indexes created.", {
+            done
+        });
+    }
+}
+const CreateIndexesRunner_CreateIndexesRunner = CreateIndexesRunner.createImplementation({
+    implementation: CreateIndexesRunnerImpl,
+    dependencies: [
+        TaskController,
+        TenantContext,
+        ListTenantsUseCase,
+        [
+            TenantIndexFactory,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { CreateIndexesRunner_CreateIndexesRunner as CreateIndexesRunner };
+
+//# sourceMappingURL=CreateIndexesRunner.js.map