@webiny/api-aco 0.0.0-unstable.eb196ccd2f → 0.0.0-unstable.eb81deee7e

package/flp/tasks/syncFlp.task.js

@@ -1,126 +1,121 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.syncFlpTask = void 0;
-var _tasks = require("@webiny/tasks");
-var _ = require("./");
-var _constants = require("../../constants");
-class SyncFlpTask {
-  init = () => {
-    return (0, _tasks.createTaskDefinition)({
-      id: _.SYNC_FLP_TASK_ID,
-      title: "ACO - Sync FLP record",
-      description: "Synchronizes the FLP catalog by updating the FLP record and its descendants.",
-      disableDatabaseLogs: true,
-      run: async params => {
-        const {
-          response,
-          isAborted,
-          input,
-          context,
-          store
-        } = params;
+import { TaskDefinition, TaskHandler } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { ListModelsUseCase } from "@webiny/api-headless-cms/features/contentModel/ListModels/index.js";
+import { SYNC_FLP_TASK_ID, UPDATE_FLP_TASK_ID } from "./index.js";
+import { FM_FILE_TYPE } from "../../constants.js";
+import { GetFolderUseCase } from "../../features/folder/GetFolder/index.js";
+import { ListFoldersUseCase } from "../../features/folder/ListFolders/index.js";
+class SyncFlpTaskHandlerImpl {
+    constructor(getFolder, listFolders, listModels){
+        this.getFolder = getFolder;
+        this.listFolders = listFolders;
+        this.listModels = listModels;
+    }
+    async run({ input, controller }) {
         try {
-          if (isAborted()) {
-            return response.aborted();
-          }
-
-          /**
-           * `folderId` provided in the task input. We need to:
-           *
-           * - update the FLP records for the found folder and all its descendants.
-           */
-          if (input.folderId) {
-            const folder = await context.aco.folder.get(input.folderId, true);
-            await context.tasks.trigger({
-              definition: _.UPDATE_FLP_TASK_ID,
-              input: {
-                folder
-              }
-            });
-            return response.done(`Task completed successfully: all FLP records for folderId "${input.folderId}" and its children have been queued to be synchronized.`);
-          }
-
-          /**
-           *  Full update required. We need to:
-           *
-           *  - list cms models to collect their types, together with the default ones [PB_PAGE_TYPE, FM_FILE_TYPE]
-           *  - list all root folders
-           *  - update the FLP records for the found folders and all its descendants.
-           */
-          if (input.type && input.type === "*") {
-            // Some folder types are fixed: pages and files.
-            const folderTypes = [_constants.PB_PAGE_TYPE, _constants.FM_FILE_TYPE];
-
-            // List all non-private models for the current locale.
-            const models = await context.security.withoutAuthorization(async () => await context.cms.listModels());
-            for (const model of models) {
-              folderTypes.push(`cms:${model.modelId}`);
-            }
-            for (const folderType of folderTypes) {
-              const [folders] = await context.aco.folder.list({
-                where: {
-                  type: folderType,
-                  parentId: null
-                },
-                disablePermissions: true
-              });
-              for (const folder of folders) {
-                await context.tasks.trigger({
-                  definition: _.UPDATE_FLP_TASK_ID,
-                  input: {
-                    folder
-                  }
+            if (controller.runtime.isAborted()) return controller.response.aborted();
+            if (input.folderId) {
+                const result = await this.getFolder.execute(input.folderId);
+                if (result.isFail()) return controller.response.error(result.error);
+                const folder = result.value;
+                await controller.task.trigger({
+                    definition: UPDATE_FLP_TASK_ID,
+                    input: {
+                        folder
+                    }
                 });
-              }
-              await store.addInfoLog({
-                message: `FLP Update task triggered for type ${folderType}`,
-                data: {
-                  type: folderType
-                }
-              });
+                return controller.response.done(`Task completed successfully: all FLP records for folderId "${input.folderId}" and its children have been queued to be synchronized.`);
             }
-            return response.done(`Task completed successfully: all FLP records have been queued to be synchronized.`);
-          }
-
-          /**
-           * `type` provided in the task input. We need to:
-           *
-           * - list all root folders for the provided type
-           * - update the FLP records for the found folders and all its descendants.
-           */
-          if (input.type) {
-            const [folders] = await context.aco.folder.list({
-              where: {
-                type: input.type,
-                parentId: null
-              },
-              disablePermissions: true
-            });
-            for (const folder of folders) {
-              await context.tasks.trigger({
-                definition: _.UPDATE_FLP_TASK_ID,
-                input: {
-                  folder
+            if (input.type && "*" === input.type) {
+                const folderTypes = [
+                    FM_FILE_TYPE
+                ];
+                const modelsResult = await this.listModels.execute();
+                if (modelsResult.isOk()) {
+                    const models = modelsResult.value;
+                    for (const model of models)folderTypes.push(`cms:${model.modelId}`);
                 }
-              });
+                for (const folderType of folderTypes){
+                    const result = await this.listFolders.execute({
+                        where: {
+                            type: folderType,
+                            parentId: null
+                        }
+                    });
+                    if (result.isFail()) {
+                        await controller.logger.error({
+                            message: `Failed to list root folders for type ${folderType}`,
+                            data: {
+                                type: folderType,
+                                error: result.error
+                            }
+                        });
+                        continue;
+                    }
+                    const { folders } = result.value;
+                    for (const folder of folders)await controller.task.trigger({
+                        definition: UPDATE_FLP_TASK_ID,
+                        input: {
+                            folder
+                        }
+                    });
+                    await controller.logger.info({
+                        message: `FLP Update task triggered for type ${folderType}`,
+                        data: {
+                            type: folderType
+                        }
+                    });
+                }
+                return controller.response.done("Task completed successfully: all FLP records have been queued to be synchronized.");
+            }
+            if (input.type) {
+                const result = await this.listFolders.execute({
+                    where: {
+                        type: input.type,
+                        parentId: null
+                    }
+                });
+                if (result.isFail()) return controller.response.error(result.error);
+                const { folders } = result.value;
+                for (const folder of folders)await controller.task.trigger({
+                    definition: UPDATE_FLP_TASK_ID,
+                    input: {
+                        folder
+                    }
+                });
+                return controller.response.done(`Task completed successfully: all FLP records for type "${input.type}" have been queued to be synchronized.`);
             }
-            return response.done(`Task completed successfully: all FLP records for type "${input.type}" have been queued to be synchronized.`);
-          }
-          return response.error("Invalid input: please provide either `type` or `folderId`.");
+            return controller.response.error("Invalid input: please provide either `type` or `folderId`.");
         } catch (error) {
-          return response.error(error);
+            return controller.response.error(error);
         }
-      }
-    });
-  };
+    }
 }
-const syncFlpTask = () => {
-  const task = new SyncFlpTask();
-  return task.init();
-};
-exports.syncFlpTask = syncFlpTask;
+const SyncFlpTaskHandler = TaskHandler.createImplementation({
+    implementation: SyncFlpTaskHandlerImpl,
+    dependencies: [
+        GetFolderUseCase,
+        ListFoldersUseCase,
+        ListModelsUseCase
+    ]
+});
+class SyncFlpTaskImpl {
+    constructor(){
+        this.id = SYNC_FLP_TASK_ID;
+        this.title = "ACO - Sync FLP record";
+        this.description = "Synchronizes the FLP catalog by updating the FLP record and its descendants.";
+        this.databaseLogs = false;
+        this.isPrivate = true;
+        this.selfCleanup = [
+            "onSuccess",
+            "onAbort"
+        ];
+        this.handler = SyncFlpTaskHandler;
+    }
+}
+const SyncFlpTask = TaskDefinition.createImplementation({
+    implementation: SyncFlpTaskImpl,
+    dependencies: []
+});
+export { SyncFlpTask };
 
 //# sourceMappingURL=syncFlp.task.js.map

package/flp/tasks/syncFlp.task.js.map

@@ -1 +1 @@
-{"version":3,"names":["_tasks","require","_","_constants","SyncFlpTask","init","createTaskDefinition","id","SYNC_FLP_TASK_ID","title","description","disableDatabaseLogs","run","params","response","isAborted","input","context","store","aborted","folderId","folder","aco","get","tasks","trigger","definition","UPDATE_FLP_TASK_ID","done","type","folderTypes","PB_PAGE_TYPE","FM_FILE_TYPE","models","security","withoutAuthorization","cms","listModels","model","push","modelId","folderType","folders","list","where","parentId","disablePermissions","addInfoLog","message","data","error","syncFlpTask","task","exports"],"sources":["syncFlp.task.ts"],"sourcesContent":["import { createTaskDefinition } from \"@webiny/tasks\";\nimport { SYNC_FLP_TASK_ID, UPDATE_FLP_TASK_ID } from \"~/flp/tasks\";\nimport {\n    type AcoContext,\n    type ISyncFlpTaskInput,\n    type ISyncFlpTaskParams,\n    type IUpdateFlpTaskInput\n} from \"~/types\";\nimport { PB_PAGE_TYPE, FM_FILE_TYPE } from \"~/constants\";\n\nclass SyncFlpTask {\n    public init = () => {\n        return createTaskDefinition<AcoContext, ISyncFlpTaskInput>({\n            id: SYNC_FLP_TASK_ID,\n            title: \"ACO - Sync FLP record\",\n            description:\n                \"Synchronizes the FLP catalog by updating the FLP record and its descendants.\",\n            disableDatabaseLogs: true,\n            run: async (params: ISyncFlpTaskParams) => {\n                const { response, isAborted, input, context, store } = params;\n                try {\n                    if (isAborted()) {\n                        return response.aborted();\n                    }\n\n                    /**\n                     * `folderId` provided in the task input. We need to:\n                     *\n                     * - update the FLP records for the found folder and all its descendants.\n                     */\n                    if (input.folderId) {\n                        const folder = await context.aco.folder.get(input.folderId, true);\n                        await context.tasks.trigger<IUpdateFlpTaskInput>({\n                            definition: UPDATE_FLP_TASK_ID,\n                            input: {\n                                folder\n                            }\n                        });\n\n                        return response.done(\n                            `Task completed successfully: all FLP records for folderId \"${input.folderId}\" and its children have been queued to be synchronized.`\n                        );\n                    }\n\n                    /**\n                     *  Full update required. We need to:\n                     *\n                     *  - list cms models to collect their types, together with the default ones [PB_PAGE_TYPE, FM_FILE_TYPE]\n                     *  - list all root folders\n                     *  - update the FLP records for the found folders and all its descendants.\n                     */\n                    if (input.type && input.type === \"*\") {\n                        // Some folder types are fixed: pages and files.\n                        const folderTypes = [PB_PAGE_TYPE, FM_FILE_TYPE];\n\n                        // List all non-private models for the current locale.\n                        const models = await context.security.withoutAuthorization(\n                            async () => await context.cms.listModels()\n                        );\n\n                        for (const model of models) {\n                            folderTypes.push(`cms:${model.modelId}`);\n                        }\n\n                        for (const folderType of folderTypes) {\n                            const [folders] = await context.aco.folder.list({\n                                where: {\n                                    type: folderType,\n                                    parentId: null\n                                },\n                                disablePermissions: true\n                            });\n\n                            for (const folder of folders) {\n                                await context.tasks.trigger<IUpdateFlpTaskInput>({\n                                    definition: UPDATE_FLP_TASK_ID,\n                                    input: {\n                                        folder\n                                    }\n                                });\n                            }\n\n                            await store.addInfoLog({\n                                message: `FLP Update task triggered for type ${folderType}`,\n                                data: {\n                                    type: folderType\n                                }\n                            });\n                        }\n\n                        return response.done(\n                            `Task completed successfully: all FLP records have been queued to be synchronized.`\n                        );\n                    }\n\n                    /**\n                     * `type` provided in the task input. We need to:\n                     *\n                     * - list all root folders for the provided type\n                     * - update the FLP records for the found folders and all its descendants.\n                     */\n                    if (input.type) {\n                        const [folders] = await context.aco.folder.list({\n                            where: {\n                                type: input.type,\n                                parentId: null\n                            },\n                            disablePermissions: true\n                        });\n\n                        for (const folder of folders) {\n                            await context.tasks.trigger<IUpdateFlpTaskInput>({\n                                definition: UPDATE_FLP_TASK_ID,\n                                input: {\n                                    folder\n                                }\n                            });\n                        }\n\n                        return response.done(\n                            `Task completed successfully: all FLP records for type \"${input.type}\" have been queued to be synchronized.`\n                        );\n                    }\n\n                    return response.error(\n                        \"Invalid input: please provide either `type` or `folderId`.\"\n                    );\n                } catch (error) {\n                    return response.error(error);\n                }\n            }\n        });\n    };\n}\n\nexport const syncFlpTask = () => {\n    const task = new SyncFlpTask();\n    return task.init();\n};\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"flp/tasks/syncFlp.task.js","sources":["../../../src/flp/tasks/syncFlp.task.ts"],"sourcesContent":["import {\n    TaskDefinition,\n    TaskHandler\n} from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { ListModelsUseCase } from \"@webiny/api-headless-cms/features/contentModel/ListModels/index.js\";\nimport { SYNC_FLP_TASK_ID, UPDATE_FLP_TASK_ID } from \"~/flp/tasks/index.js\";\nimport { type ISyncFlpTaskInput, type IUpdateFlpTaskInput } from \"~/types.js\";\nimport { FM_FILE_TYPE } from \"~/constants.js\";\nimport { GetFolderUseCase } from \"~/features/folder/GetFolder/index.js\";\nimport { ListFoldersUseCase } from \"~/features/folder/ListFolders/index.js\";\n\nclass SyncFlpTaskHandlerImpl implements TaskHandler.Interface<ISyncFlpTaskInput> {\n    public constructor(\n        private getFolder: GetFolderUseCase.Interface,\n        private listFolders: ListFoldersUseCase.Interface,\n        private listModels: ListModelsUseCase.Interface\n    ) {}\n\n    async run({ input, controller }: TaskHandler.RunParams<ISyncFlpTaskInput>) {\n        try {\n            if (controller.runtime.isAborted()) {\n                return controller.response.aborted();\n            }\n\n            /**\n             * `folderId` provided in the task input. We need to:\n             *\n             * - update the FLP records for the found folder and all its descendants.\n             */\n            if (input.folderId) {\n                const result = await this.getFolder.execute(input.folderId);\n                if (result.isFail()) {\n                    return controller.response.error(result.error);\n                }\n                const folder = result.value;\n\n                await controller.task.trigger<IUpdateFlpTaskInput>({\n                    definition: UPDATE_FLP_TASK_ID,\n                    input: {\n                        folder\n                    }\n                });\n\n                return controller.response.done(\n                    `Task completed successfully: all FLP records for folderId \"${input.folderId}\" and its children have been queued to be synchronized.`\n                );\n            }\n\n            /**\n             *  Full update required. We need to:\n             *\n             *  - list cms models to collect their types, together with the default ones [FM_FILE_TYPE]\n             *  - list all root folders\n             *  - update the FLP records for the found folders and all its descendants.\n             */\n            if (input.type && input.type === \"*\") {\n                // Some folder types are fixed: pages and files.\n                const folderTypes = [FM_FILE_TYPE];\n\n                // List all non-private models\n                const modelsResult = await this.listModels.execute();\n                if (modelsResult.isOk()) {\n                    const models = modelsResult.value;\n                    for (const model of models) {\n                        folderTypes.push(`cms:${model.modelId}`);\n                    }\n                }\n\n                for (const folderType of folderTypes) {\n                    const result = await this.listFolders.execute({\n                        where: {\n                            type: folderType,\n                            parentId: null\n                        }\n                    });\n                    if (result.isFail()) {\n                        await controller.logger.error({\n                            message: `Failed to list root folders for type ${folderType}`,\n                            data: {\n                                type: folderType,\n                                error: result.error\n                            }\n                        });\n                        continue;\n                    }\n\n                    const { folders } = result.value;\n\n                    for (const folder of folders) {\n                        await controller.task.trigger<IUpdateFlpTaskInput>({\n                            definition: UPDATE_FLP_TASK_ID,\n                            input: {\n                                folder\n                            }\n                        });\n                    }\n\n                    await controller.logger.info({\n                        message: `FLP Update task triggered for type ${folderType}`,\n                        data: {\n                            type: folderType\n                        }\n                    });\n                }\n\n                return controller.response.done(\n                    `Task completed successfully: all FLP records have been queued to be synchronized.`\n                );\n            }\n\n            /**\n             * `type` provided in the task input. We need to:\n             *\n             * - list all root folders for the provided type\n             * - update the FLP records for the found folders and all its descendants.\n             */\n            if (input.type) {\n                const result = await this.listFolders.execute({\n                    where: {\n                        type: input.type!,\n                        parentId: null\n                    }\n                });\n                if (result.isFail()) {\n                    return controller.response.error(result.error);\n                }\n\n                const { folders } = result.value;\n\n                for (const folder of folders) {\n                    await controller.task.trigger<IUpdateFlpTaskInput>({\n                        definition: UPDATE_FLP_TASK_ID,\n                        input: {\n                            folder\n                        }\n                    });\n                }\n\n                return controller.response.done(\n                    `Task completed successfully: all FLP records for type \"${input.type}\" have been queued to be synchronized.`\n                );\n            }\n\n            return controller.response.error(\n                \"Invalid input: please provide either `type` or `folderId`.\"\n            );\n        } catch (error) {\n            return controller.response.error(error);\n        }\n    }\n}\n\nconst SyncFlpTaskHandler = TaskHandler.createImplementation({\n    implementation: SyncFlpTaskHandlerImpl,\n    dependencies: [GetFolderUseCase, ListFoldersUseCase, ListModelsUseCase]\n});\n\nclass SyncFlpTaskImpl implements TaskDefinition.Interface {\n    public readonly id = SYNC_FLP_TASK_ID;\n    public readonly title = \"ACO - Sync FLP record\";\n    public readonly description =\n        \"Synchronizes the FLP catalog by updating the FLP record and its descendants.\";\n    public readonly databaseLogs = false;\n    public readonly isPrivate = true;\n    public readonly selfCleanup = [\"onSuccess\" as const, \"onAbort\" as const];\n\n    handler = SyncFlpTaskHandler;\n}\n\nexport const SyncFlpTask = TaskDefinition.createImplementation({\n    implementation: SyncFlpTaskImpl,\n    dependencies: []\n});\n"],"names":["SyncFlpTaskHandlerImpl","getFolder","listFolders","listModels","input","controller","result","folder","UPDATE_FLP_TASK_ID","folderTypes","FM_FILE_TYPE","modelsResult","models","model","folderType","folders","error","SyncFlpTaskHandler","TaskHandler","GetFolderUseCase","ListFoldersUseCase","ListModelsUseCase","SyncFlpTaskImpl","SYNC_FLP_TASK_ID","SyncFlpTask","TaskDefinition"],"mappings":"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"}

package/flp/tasks/updateFlp.task.d.ts

@@ -1,2 +1,23 @@
-import { type AcoContext, type IUpdateFlpTaskInput } from "../../types";
-export declare const updateFlpTask: () => import("@webiny/tasks").TaskDefinitionPlugin<AcoContext, IUpdateFlpTaskInput, import("@webiny/tasks").ITaskResponseDoneResultOutput>;
+import { TaskDefinition, TaskHandler } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { type IUpdateFlpTaskInput } from "../../types.js";
+import { UpdateFlpUseCase } from "../../features/flp/UpdateFlp/index.js";
+declare class UpdateFlpTaskHandlerImpl implements TaskHandler.Interface<IUpdateFlpTaskInput> {
+    private updateFlp;
+    constructor(updateFlp: UpdateFlpUseCase.Interface);
+    run({ input, controller }: TaskHandler.RunParams<IUpdateFlpTaskInput>): Promise<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultAborted | import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultError | TaskDefinition.ResultContinue<IUpdateFlpTaskInput> | TaskDefinition.ResultDone<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+}
+declare class UpdateFlpTaskImpl implements TaskDefinition.Interface {
+    readonly id = "acoUpdateFlp";
+    readonly title = "ACO - Update FLP record";
+    readonly description = "Synchronizes the FLP catalog by updating the FLP record and its descendants based on the provided folder.";
+    readonly databaseLogs = false;
+    readonly isPrivate = true;
+    readonly selfCleanup: ("onAbort" | "onSuccess")[];
+    handler: typeof UpdateFlpTaskHandlerImpl & {
+        __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskHandler<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+    };
+}
+export declare const UpdateFlpTask: typeof UpdateFlpTaskImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskDefinition<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+};
+export {};

package/flp/tasks/updateFlp.task.js

@@ -1,55 +1,56 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.updateFlpTask = void 0;
-var _tasks = require("@webiny/tasks");
-var _ = require("./");
-class UpdateFlpTask {
-  init = () => {
-    return (0, _tasks.createPrivateTaskDefinition)({
-      id: _.UPDATE_FLP_TASK_ID,
-      title: "ACO - Update FLP record",
-      description: "Synchronizes the FLP catalog by updating the FLP record and its descendants based on the provided folder.",
-      disableDatabaseLogs: true,
-      run: async params => {
-        const {
-          response,
-          isAborted,
-          input,
-          context,
-          isCloseToTimeout
-        } = params;
-        const {
-          UpdateFlp
-        } = await import(/* webpackChunkName: "UpdateFlp" */"../useCases/UpdateFlp");
-        const useCase = new UpdateFlp({
-          context,
-          queued: input.queued,
-          isCloseToTimeout: isCloseToTimeout,
-          handleTimeout: queued => response.continue({
-            ...input,
-            queued
-          })
-        });
+import { TaskDefinition, TaskHandler } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { UPDATE_FLP_TASK_ID } from "./index.js";
+import { UpdateFlpUseCase } from "../../features/flp/UpdateFlp/index.js";
+class UpdateFlpTaskHandlerImpl {
+    constructor(updateFlp){
+        this.updateFlp = updateFlp;
+    }
+    async run({ input, controller }) {
         try {
-          if (isAborted()) {
-            return response.aborted();
-          }
-          await useCase.execute(input.folder);
-          return response.done("Task done: FLP record updated.");
+            if (controller.runtime.isAborted()) return controller.response.aborted();
+            let continuation;
+            await this.updateFlp.execute({
+                folder: input.folder,
+                completed: input.completed,
+                isCloseToTimeout: controller.runtime.isCloseToTimeout,
+                handleTimeout: (completed)=>{
+                    continuation = controller.response.continue({
+                        ...input,
+                        completed
+                    });
+                }
+            });
+            if (continuation) return continuation;
+            return controller.response.done("Task done: FLP record updated.");
         } catch (error) {
-          return response.error(error);
+            return controller.response.error(error);
         }
-      }
-    });
-  };
+    }
 }
-const updateFlpTask = () => {
-  const task = new UpdateFlpTask();
-  return task.init();
-};
-exports.updateFlpTask = updateFlpTask;
+const UpdateFlpTaskHandler = TaskHandler.createImplementation({
+    implementation: UpdateFlpTaskHandlerImpl,
+    dependencies: [
+        UpdateFlpUseCase
+    ]
+});
+class UpdateFlpTaskImpl {
+    constructor(){
+        this.id = UPDATE_FLP_TASK_ID;
+        this.title = "ACO - Update FLP record";
+        this.description = "Synchronizes the FLP catalog by updating the FLP record and its descendants based on the provided folder.";
+        this.databaseLogs = false;
+        this.isPrivate = true;
+        this.selfCleanup = [
+            "onSuccess",
+            "onAbort"
+        ];
+        this.handler = UpdateFlpTaskHandler;
+    }
+}
+const UpdateFlpTask = TaskDefinition.createImplementation({
+    implementation: UpdateFlpTaskImpl,
+    dependencies: []
+});
+export { UpdateFlpTask };
 
 //# sourceMappingURL=updateFlp.task.js.map

package/flp/tasks/updateFlp.task.js.map

@@ -1 +1 @@
-{"version":3,"names":["_tasks","require","_","UpdateFlpTask","init","createPrivateTaskDefinition","id","UPDATE_FLP_TASK_ID","title","description","disableDatabaseLogs","run","params","response","isAborted","input","context","isCloseToTimeout","UpdateFlp","useCase","queued","handleTimeout","continue","aborted","execute","folder","done","error","updateFlpTask","task","exports"],"sources":["updateFlp.task.ts"],"sourcesContent":["import { createPrivateTaskDefinition } from \"@webiny/tasks\";\nimport { UPDATE_FLP_TASK_ID } from \"~/flp/tasks\";\nimport { type AcoContext, type IUpdateFlpTaskInput, type IUpdateFlpTaskParams } from \"~/types\";\n\nclass UpdateFlpTask {\n    public init = () => {\n        return createPrivateTaskDefinition<AcoContext, IUpdateFlpTaskInput>({\n            id: UPDATE_FLP_TASK_ID,\n            title: \"ACO - Update FLP record\",\n            description:\n                \"Synchronizes the FLP catalog by updating the FLP record and its descendants based on the provided folder.\",\n            disableDatabaseLogs: true,\n            run: async (params: IUpdateFlpTaskParams) => {\n                const { response, isAborted, input, context, isCloseToTimeout } = params;\n\n                const { UpdateFlp } = await import(\n                    /* webpackChunkName: \"UpdateFlp\" */ \"../useCases/UpdateFlp\"\n                );\n\n                const useCase = new UpdateFlp({\n                    context,\n                    queued: input.queued,\n                    isCloseToTimeout: isCloseToTimeout,\n                    handleTimeout: (queued: string[]) => response.continue({ ...input, queued })\n                });\n\n                try {\n                    if (isAborted()) {\n                        return response.aborted();\n                    }\n                    await useCase.execute(input.folder);\n                    return response.done(\"Task done: FLP record updated.\");\n                } catch (error) {\n                    return response.error(error);\n                }\n            }\n        });\n    };\n}\n\nexport const updateFlpTask = () => {\n    const task = new UpdateFlpTask();\n    return task.init();\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,CAAA,GAAAD,OAAA;AAGA,MAAME,aAAa,CAAC;EACTC,IAAI,GAAGA,CAAA,KAAM;IAChB,OAAO,IAAAC,kCAA2B,EAAkC;MAChEC,EAAE,EAAEC,oBAAkB;MACtBC,KAAK,EAAE,yBAAyB;MAChCC,WAAW,EACP,2GAA2G;MAC/GC,mBAAmB,EAAE,IAAI;MACzBC,GAAG,EAAE,MAAOC,MAA4B,IAAK;QACzC,MAAM;UAAEC,QAAQ;UAAEC,SAAS;UAAEC,KAAK;UAAEC,OAAO;UAAEC;QAAiB,CAAC,GAAGL,MAAM;QAExE,MAAM;UAAEM;QAAU,CAAC,GAAG,MAAM,MAAM,CAC9B,0DACJ,CAAC;QAED,MAAMC,OAAO,GAAG,IAAID,SAAS,CAAC;UAC1BF,OAAO;UACPI,MAAM,EAAEL,KAAK,CAACK,MAAM;UACpBH,gBAAgB,EAAEA,gBAAgB;UAClCI,aAAa,EAAGD,MAAgB,IAAKP,QAAQ,CAACS,QAAQ,CAAC;YAAE,GAAGP,KAAK;YAAEK;UAAO,CAAC;QAC/E,CAAC,CAAC;QAEF,IAAI;UACA,IAAIN,SAAS,CAAC,CAAC,EAAE;YACb,OAAOD,QAAQ,CAACU,OAAO,CAAC,CAAC;UAC7B;UACA,MAAMJ,OAAO,CAACK,OAAO,CAACT,KAAK,CAACU,MAAM,CAAC;UACnC,OAAOZ,QAAQ,CAACa,IAAI,CAAC,gCAAgC,CAAC;QAC1D,CAAC,CAAC,OAAOC,KAAK,EAAE;UACZ,OAAOd,QAAQ,CAACc,KAAK,CAACA,KAAK,CAAC;QAChC;MACJ;IACJ,CAAC,CAAC;EACN,CAAC;AACL;AAEO,MAAMC,aAAa,GAAGA,CAAA,KAAM;EAC/B,MAAMC,IAAI,GAAG,IAAI1B,aAAa,CAAC,CAAC;EAChC,OAAO0B,IAAI,CAACzB,IAAI,CAAC,CAAC;AACtB,CAAC;AAAC0B,OAAA,CAAAF,aAAA,GAAAA,aAAA","ignoreList":[]}
+{"version":3,"file":"flp/tasks/updateFlp.task.js","sources":["../../../src/flp/tasks/updateFlp.task.ts"],"sourcesContent":["import {\n    TaskDefinition,\n    TaskHandler\n} from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { UPDATE_FLP_TASK_ID } from \"~/flp/tasks/index.js\";\nimport { type IUpdateFlpTaskInput } from \"~/types.js\";\nimport { UpdateFlpUseCase } from \"~/features/flp/UpdateFlp/index.js\";\n\nclass UpdateFlpTaskHandlerImpl implements TaskHandler.Interface<IUpdateFlpTaskInput> {\n    public constructor(private updateFlp: UpdateFlpUseCase.Interface) {}\n\n    async run({ input, controller }: TaskHandler.RunParams<IUpdateFlpTaskInput>) {\n        try {\n            if (controller.runtime.isAborted()) {\n                return controller.response.aborted();\n            }\n\n            /*\n             * `response.continue()` only builds the result; it does nothing until the task returns\n             * it. Returning `done` regardless used to drop the continuation, leaving the rest of a\n             * large subtree with its old permissions.\n             */\n            let continuation: ReturnType<typeof controller.response.continue> | undefined;\n\n            await this.updateFlp.execute({\n                folder: input.folder,\n                completed: input.completed,\n                isCloseToTimeout: controller.runtime.isCloseToTimeout,\n                handleTimeout: completed => {\n                    continuation = controller.response.continue({ ...input, completed });\n                }\n            });\n\n            if (continuation) {\n                return continuation;\n            }\n\n            return controller.response.done(\"Task done: FLP record updated.\");\n        } catch (error) {\n            return controller.response.error(error);\n        }\n    }\n}\n\nconst UpdateFlpTaskHandler = TaskHandler.createImplementation({\n    implementation: UpdateFlpTaskHandlerImpl,\n    dependencies: [UpdateFlpUseCase]\n});\n\nclass UpdateFlpTaskImpl implements TaskDefinition.Interface {\n    public readonly id = UPDATE_FLP_TASK_ID;\n    public readonly title = \"ACO - Update FLP record\";\n    public readonly description =\n        \"Synchronizes the FLP catalog by updating the FLP record and its descendants based on the provided folder.\";\n    public readonly databaseLogs = false;\n    public readonly isPrivate = true;\n    public readonly selfCleanup = [\"onSuccess\" as const, \"onAbort\" as const];\n\n    handler = UpdateFlpTaskHandler;\n}\n\nexport const UpdateFlpTask = TaskDefinition.createImplementation({\n    implementation: UpdateFlpTaskImpl,\n    dependencies: []\n});\n"],"names":["UpdateFlpTaskHandlerImpl","updateFlp","input","controller","continuation","completed","error","UpdateFlpTaskHandler","TaskHandler","UpdateFlpUseCase","UpdateFlpTaskImpl","UPDATE_FLP_TASK_ID","UpdateFlpTask","TaskDefinition"],"mappings":";;;AAQA,MAAMA;IACF,YAA2BC,SAAqC,CAAE;aAAvCA,SAAS,GAATA;IAAwC;IAEnE,MAAM,IAAI,EAAEC,KAAK,EAAEC,UAAU,EAA8C,EAAE;QACzE,IAAI;YACA,IAAIA,WAAW,OAAO,CAAC,SAAS,IAC5B,OAAOA,WAAW,QAAQ,CAAC,OAAO;YAQtC,IAAIC;YAEJ,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;gBACzB,QAAQF,MAAM,MAAM;gBACpB,WAAWA,MAAM,SAAS;gBAC1B,kBAAkBC,WAAW,OAAO,CAAC,gBAAgB;gBACrD,eAAeE,CAAAA;oBACXD,eAAeD,WAAW,QAAQ,CAAC,QAAQ,CAAC;wBAAE,GAAGD,KAAK;wBAAEG;oBAAU;gBACtE;YACJ;YAEA,IAAID,cACA,OAAOA;YAGX,OAAOD,WAAW,QAAQ,CAAC,IAAI,CAAC;QACpC,EAAE,OAAOG,OAAO;YACZ,OAAOH,WAAW,QAAQ,CAAC,KAAK,CAACG;QACrC;IACJ;AACJ;AAEA,MAAMC,uBAAuBC,YAAY,oBAAoB,CAAC;IAC1D,gBAAgBR;IAChB,cAAc;QAACS;KAAiB;AACpC;AAEA,MAAMC;;aACc,EAAE,GAAGC;aACL,KAAK,GAAG;aACR,WAAW,GACvB;aACY,YAAY,GAAG;aACf,SAAS,GAAG;aACZ,WAAW,GAAG;YAAC;YAAsB;SAAmB;aAExE,OAAO,GAAGJ;;AACd;AAEO,MAAMK,gBAAgBC,eAAe,oBAAoB,CAAC;IAC7D,gBAAgBH;IAChB,cAAc,EAAE;AACpB"}

package/folder/createFolderModelModifier.d.ts

@@ -1,6 +1,6 @@
 import { Plugin } from "@webiny/plugins";
 import type { CmsPrivateModelFull } from "@webiny/api-headless-cms";
-import type { CmsModelField as BaseModelField } from "@webiny/api-headless-cms/types";
+import type { CmsModelField as BaseModelField } from "@webiny/api-headless-cms/types/index.js";
 export type CmsModelField = Omit<BaseModelField, "storageId"> & {
     modelIds?: string[];
 };

package/folder/createFolderModelModifier.js

@@ -1,70 +1,61 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createFolderModelModifier = exports.FolderModelFieldsModifier = exports.FolderCmsModelModifierPlugin = void 0;
-var _plugins = require("@webiny/plugins");
-var _apiHeadlessCms = require("@webiny/api-headless-cms");
-var _folder = require("./folder.model");
+import { Plugin } from "@webiny/plugins";
+import { createModelField } from "@webiny/api-headless-cms";
+import { FOLDER_MODEL_ID } from "../domain/folder/folder.model.js";
 class FolderModelFieldsModifier {
-  fields = [];
-  constructor(namespace) {
-    this.namespace = namespace;
-  }
-  setFields(fields) {
-    this.fields = fields;
-  }
-  addField(field) {
-    const {
-      tags,
-      ...rest
-    } = field;
-    this.fields.push({
-      ...rest,
-      storageId: `${field.type}@${this.namespace}_${field.id}`,
-      tags: (tags ?? []).concat([`$namespace:${this.namespace}`])
-    });
-  }
+    constructor(namespace){
+        this.fields = [];
+        this.namespace = namespace;
+    }
+    setFields(fields) {
+        this.fields = fields;
+    }
+    addField(field) {
+        const { tags, ...rest } = field;
+        this.fields.push({
+            ...rest,
+            storageId: `${field.type}@${this.namespace}_${field.id}`,
+            tags: (tags ?? []).concat([
+                `$namespace:${this.namespace}`
+            ])
+        });
+    }
 }
-exports.FolderModelFieldsModifier = FolderModelFieldsModifier;
-class FolderCmsModelModifierPlugin extends _plugins.Plugin {
-  static type = "aco.folder.cms-model-modifier";
-  constructor(params) {
-    super();
-    this.modifier = params.modifier;
-    this.callback = params.callback;
-  }
-  async modifyModel(model) {
-    if (model.modelId !== _folder.FOLDER_MODEL_ID) {
-      return;
+class FolderCmsModelModifierPlugin extends Plugin {
+    static{
+        this.type = "aco.folder.cms-model-modifier";
+    }
+    constructor(params){
+        super();
+        this.modifier = params.modifier;
+        this.callback = params.callback;
     }
-    let extensionsField = model.fields.find(field => field.fieldId === "extensions");
-    if (!extensionsField) {
-      extensionsField = (0, _apiHeadlessCms.createModelField)({
-        label: "Extensions",
-        type: "object",
-        settings: {
-          layout: [],
-          fields: []
+    async modifyModel(model) {
+        if (model.modelId !== FOLDER_MODEL_ID) return;
+        let extensionsField = model.fields.find((field)=>"extensions" === field.fieldId);
+        if (!extensionsField) {
+            extensionsField = createModelField({
+                label: "Extensions",
+                type: "object",
+                settings: {
+                    layout: [],
+                    fields: []
+                }
+            });
+            model.fields.push(extensionsField);
         }
-      });
-      model.fields.push(extensionsField);
+        this.modifier.setFields(extensionsField.settings.fields);
+        await this.callback({
+            modifier: this.modifier
+        });
     }
-    this.modifier.setFields(extensionsField.settings.fields);
-    await this.callback({
-      modifier: this.modifier
-    });
-  }
 }
-exports.FolderCmsModelModifierPlugin = FolderCmsModelModifierPlugin;
-const createFolderModelModifier = callback => {
-  const modifier = new FolderModelFieldsModifier("global");
-  return new FolderCmsModelModifierPlugin({
-    callback,
-    modifier
-  });
+const createFolderModelModifier = (callback)=>{
+    const modifier = new FolderModelFieldsModifier("global");
+    return new FolderCmsModelModifierPlugin({
+        callback,
+        modifier
+    });
 };
-exports.createFolderModelModifier = createFolderModelModifier;
+export { FolderCmsModelModifierPlugin, FolderModelFieldsModifier, createFolderModelModifier };
 
 //# sourceMappingURL=createFolderModelModifier.js.map