@webiny/api-aco 0.0.0-unstable.aa00eecd97 → 0.0.0-unstable.ac6ebf63c6

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

@@ -0,0 +1,16 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { type IDeleteFlpTaskInput } from "../../types.js";
+import { DeleteFlpUseCase } from "../../features/flp/DeleteFlp/index.js";
+declare class DeleteFlpTaskImpl implements TaskDefinition.Interface<IDeleteFlpTaskInput> {
+    private deleteFlp;
+    id: string;
+    title: string;
+    description: string;
+    databaseLogs: boolean;
+    constructor(deleteFlp: DeleteFlpUseCase.Interface);
+    run({ input, controller }: TaskDefinition.RunParams<IDeleteFlpTaskInput>): Promise<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultError | import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultAborted | TaskDefinition.ResultDone<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput> | TaskDefinition.ResultContinue<IDeleteFlpTaskInput>>;
+}
+export declare const DeleteFlpTask: typeof DeleteFlpTaskImpl & {
+    __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/deleteFlp.task.js

@@ -0,0 +1,35 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { DELETE_FLP_TASK_ID } from "./index.js";
+import { DeleteFlpUseCase } from "../../features/flp/DeleteFlp/index.js";
+class DeleteFlpTaskImpl {
+  id = DELETE_FLP_TASK_ID;
+  title = "ACO - Delete FLP record";
+  description = "Synchronizes the FLP catalog by deleting the FLP record based on the provided folder.";
+  databaseLogs = false;
+  constructor(deleteFlp) {
+    this.deleteFlp = deleteFlp;
+  }
+  async run({
+    input,
+    controller
+  }) {
+    try {
+      if (controller.runtime.isAborted()) {
+        return controller.response.aborted();
+      }
+      if (controller.runtime.isCloseToTimeout()) {
+        return controller.response.continue(input);
+      }
+      await this.deleteFlp.execute(input.folder);
+      return controller.response.done("Task done: FLP record deleted.");
+    } catch (error) {
+      return controller.response.error(error);
+    }
+  }
+}
+export const DeleteFlpTask = TaskDefinition.createImplementation({
+  implementation: DeleteFlpTaskImpl,
+  dependencies: [DeleteFlpUseCase]
+});
+
+//# sourceMappingURL=deleteFlp.task.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["TaskDefinition","DELETE_FLP_TASK_ID","DeleteFlpUseCase","DeleteFlpTaskImpl","id","title","description","databaseLogs","constructor","deleteFlp","run","input","controller","runtime","isAborted","response","aborted","isCloseToTimeout","continue","execute","folder","done","error","DeleteFlpTask","createImplementation","implementation","dependencies"],"sources":["deleteFlp.task.ts"],"sourcesContent":["import { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { DELETE_FLP_TASK_ID } from \"~/flp/tasks/index.js\";\nimport { type IDeleteFlpTaskInput } from \"~/types.js\";\nimport { DeleteFlpUseCase } from \"~/features/flp/DeleteFlp/index.js\";\n\nclass DeleteFlpTaskImpl implements TaskDefinition.Interface<IDeleteFlpTaskInput> {\n    id = DELETE_FLP_TASK_ID;\n    title = \"ACO - Delete FLP record\";\n    description =\n        \"Synchronizes the FLP catalog by deleting the FLP record based on the provided folder.\";\n    databaseLogs = false;\n\n    constructor(private deleteFlp: DeleteFlpUseCase.Interface) {}\n\n    async run({ input, controller }: TaskDefinition.RunParams<IDeleteFlpTaskInput>) {\n        try {\n            if (controller.runtime.isAborted()) {\n                return controller.response.aborted();\n            }\n\n            if (controller.runtime.isCloseToTimeout()) {\n                return controller.response.continue(input);\n            }\n\n            await this.deleteFlp.execute(input.folder);\n\n            return controller.response.done(\"Task done: FLP record deleted.\");\n        } catch (error) {\n            return controller.response.error(error);\n        }\n    }\n}\n\nexport const DeleteFlpTask = TaskDefinition.createImplementation({\n    implementation: DeleteFlpTaskImpl,\n    dependencies: [DeleteFlpUseCase]\n});\n"],"mappings":"AAAA,SAASA,cAAc,QAAQ,wDAAwD;AACvF,SAASC,kBAAkB;AAE3B,SAASC,gBAAgB;AAEzB,MAAMC,iBAAiB,CAA0D;EAC7EC,EAAE,GAAGH,kBAAkB;EACvBI,KAAK,GAAG,yBAAyB;EACjCC,WAAW,GACP,uFAAuF;EAC3FC,YAAY,GAAG,KAAK;EAEpBC,WAAWA,CAASC,SAAqC,EAAE;IAAA,KAAvCA,SAAqC,GAArCA,SAAqC;EAAG;EAE5D,MAAMC,GAAGA,CAAC;IAAEC,KAAK;IAAEC;EAA0D,CAAC,EAAE;IAC5E,IAAI;MACA,IAAIA,UAAU,CAACC,OAAO,CAACC,SAAS,CAAC,CAAC,EAAE;QAChC,OAAOF,UAAU,CAACG,QAAQ,CAACC,OAAO,CAAC,CAAC;MACxC;MAEA,IAAIJ,UAAU,CAACC,OAAO,CAACI,gBAAgB,CAAC,CAAC,EAAE;QACvC,OAAOL,UAAU,CAACG,QAAQ,CAACG,QAAQ,CAACP,KAAK,CAAC;MAC9C;MAEA,MAAM,IAAI,CAACF,SAAS,CAACU,OAAO,CAACR,KAAK,CAACS,MAAM,CAAC;MAE1C,OAAOR,UAAU,CAACG,QAAQ,CAACM,IAAI,CAAC,gCAAgC,CAAC;IACrE,CAAC,CAAC,OAAOC,KAAK,EAAE;MACZ,OAAOV,UAAU,CAACG,QAAQ,CAACO,KAAK,CAACA,KAAK,CAAC;IAC3C;EACJ;AACJ;AAEA,OAAO,MAAMC,aAAa,GAAGvB,cAAc,CAACwB,oBAAoB,CAAC;EAC7DC,cAAc,EAAEtB,iBAAiB;EACjCuB,YAAY,EAAE,CAACxB,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

package/flp/tasks/index.d.ts

@@ -0,0 +1,5 @@
+export declare const CREATE_FLP_TASK_ID = "acoCreateFlp";
+export declare const DELETE_FLP_TASK_ID = "acoDeleteFlp";
+export declare const UPDATE_FLP_TASK_ID = "acoUpdateFlp";
+export declare const SYNC_FLP_TASK_ID = "acoSyncFlp";
+export declare const flpTasks: () => import("@webiny/api").ContextPlugin<import("@webiny/api/types.js").Context>[];

package/flp/tasks/index.js

@@ -0,0 +1,19 @@
+import { CreateFlpTask } from "./createFlp.task.js";
+import { UpdateFlpTask } from "./updateFlp.task.js";
+import { DeleteFlpTask } from "./deleteFlp.task.js";
+import { SyncFlpTask } from "./syncFlp.task.js";
+import { createContextPlugin } from "@webiny/api";
+export const CREATE_FLP_TASK_ID = "acoCreateFlp";
+export const DELETE_FLP_TASK_ID = "acoDeleteFlp";
+export const UPDATE_FLP_TASK_ID = "acoUpdateFlp";
+export const SYNC_FLP_TASK_ID = "acoSyncFlp";
+export const flpTasks = () => {
+  return [createContextPlugin(context => {
+    context.container.register(CreateFlpTask);
+    context.container.register(UpdateFlpTask);
+    context.container.register(DeleteFlpTask);
+    context.container.register(SyncFlpTask);
+  })];
+};
+
+//# sourceMappingURL=index.js.map

package/flp/tasks/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CreateFlpTask","UpdateFlpTask","DeleteFlpTask","SyncFlpTask","createContextPlugin","CREATE_FLP_TASK_ID","DELETE_FLP_TASK_ID","UPDATE_FLP_TASK_ID","SYNC_FLP_TASK_ID","flpTasks","context","container","register"],"sources":["index.ts"],"sourcesContent":["import { CreateFlpTask } from \"./createFlp.task.js\";\nimport { UpdateFlpTask } from \"./updateFlp.task.js\";\nimport { DeleteFlpTask } from \"./deleteFlp.task.js\";\nimport { SyncFlpTask } from \"./syncFlp.task.js\";\nimport { createContextPlugin } from \"@webiny/api\";\n\nexport const CREATE_FLP_TASK_ID = \"acoCreateFlp\";\nexport const DELETE_FLP_TASK_ID = \"acoDeleteFlp\";\nexport const UPDATE_FLP_TASK_ID = \"acoUpdateFlp\";\nexport const SYNC_FLP_TASK_ID = \"acoSyncFlp\";\n\nexport const flpTasks = () => {\n    return [\n        createContextPlugin(context => {\n            context.container.register(CreateFlpTask);\n            context.container.register(UpdateFlpTask);\n            context.container.register(DeleteFlpTask);\n            context.container.register(SyncFlpTask);\n        })\n    ];\n};\n"],"mappings":"AAAA,SAASA,aAAa;AACtB,SAASC,aAAa;AACtB,SAASC,aAAa;AACtB,SAASC,WAAW;AACpB,SAASC,mBAAmB,QAAQ,aAAa;AAEjD,OAAO,MAAMC,kBAAkB,GAAG,cAAc;AAChD,OAAO,MAAMC,kBAAkB,GAAG,cAAc;AAChD,OAAO,MAAMC,kBAAkB,GAAG,cAAc;AAChD,OAAO,MAAMC,gBAAgB,GAAG,YAAY;AAE5C,OAAO,MAAMC,QAAQ,GAAGA,CAAA,KAAM;EAC1B,OAAO,CACHL,mBAAmB,CAACM,OAAO,IAAI;IAC3BA,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACZ,aAAa,CAAC;IACzCU,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACX,aAAa,CAAC;IACzCS,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACV,aAAa,CAAC;IACzCQ,OAAO,CAACC,SAAS,CAACC,QAAQ,CAACT,WAAW,CAAC;EAC3C,CAAC,CAAC,CACL;AACL,CAAC","ignoreList":[]}

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

@@ -0,0 +1,20 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { ListModelsUseCase } from "@webiny/api-headless-cms/features/contentModel/ListModels/index.js";
+import { type ISyncFlpTaskInput } from "../../types.js";
+import { GetFolderUseCase } from "../../features/folder/GetFolder/index.js";
+import { ListFoldersUseCase } from "../../features/folder/ListFolders/index.js";
+declare class SyncFlpTaskImpl implements TaskDefinition.Interface<ISyncFlpTaskInput> {
+    private getFolder;
+    private listFolders;
+    private listModels;
+    id: string;
+    title: string;
+    description: string;
+    databaseLogs: boolean;
+    constructor(getFolder: GetFolderUseCase.Interface, listFolders: ListFoldersUseCase.Interface, listModels: ListModelsUseCase.Interface);
+    run({ input, controller }: TaskDefinition.RunParams<ISyncFlpTaskInput>): Promise<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultError | import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultAborted | TaskDefinition.ResultDone<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+}
+export declare const SyncFlpTask: typeof SyncFlpTaskImpl & {
+    __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/syncFlp.task.js

@@ -0,0 +1,127 @@
+import { TaskDefinition } 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 SyncFlpTaskImpl {
+  id = SYNC_FLP_TASK_ID;
+  title = "ACO - Sync FLP record";
+  description = "Synchronizes the FLP catalog by updating the FLP record and its descendants.";
+  databaseLogs = false;
+  constructor(getFolder, listFolders, listModels) {
+    this.getFolder = getFolder;
+    this.listFolders = listFolders;
+    this.listModels = listModels;
+  }
+  async run({
+    input,
+    controller
+  }) {
+    try {
+      if (controller.runtime.isAborted()) {
+        return controller.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 result = await this.getFolder.execute(input.folderId);
+        const folder = result.value;
+        await controller.task.trigger({
+          definition: UPDATE_FLP_TASK_ID,
+          input: {
+            folder
+          }
+        });
+        return controller.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 [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 = [FM_FILE_TYPE];
+
+        // List all non-private models
+        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
+            }
+          });
+          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.`);
+      }
+
+      /**
+       * `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 result = await this.listFolders.execute({
+          where: {
+            type: input.type,
+            parentId: null
+          }
+        });
+        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 controller.response.error("Invalid input: please provide either `type` or `folderId`.");
+    } catch (error) {
+      return controller.response.error(error);
+    }
+  }
+}
+export const SyncFlpTask = TaskDefinition.createImplementation({
+  implementation: SyncFlpTaskImpl,
+  dependencies: [GetFolderUseCase, ListFoldersUseCase, ListModelsUseCase]
+});
+
+//# sourceMappingURL=syncFlp.task.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["TaskDefinition","ListModelsUseCase","SYNC_FLP_TASK_ID","UPDATE_FLP_TASK_ID","FM_FILE_TYPE","GetFolderUseCase","ListFoldersUseCase","SyncFlpTaskImpl","id","title","description","databaseLogs","constructor","getFolder","listFolders","listModels","run","input","controller","runtime","isAborted","response","aborted","folderId","result","execute","folder","value","task","trigger","definition","done","type","folderTypes","modelsResult","isOk","models","model","push","modelId","folderType","where","parentId","folders","logger","info","message","data","error","SyncFlpTask","createImplementation","implementation","dependencies"],"sources":["syncFlp.task.ts"],"sourcesContent":["import { TaskDefinition } 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 SyncFlpTaskImpl implements TaskDefinition.Interface<ISyncFlpTaskInput> {\n    id = SYNC_FLP_TASK_ID;\n    title = \"ACO - Sync FLP record\";\n    description = \"Synchronizes the FLP catalog by updating the FLP record and its descendants.\";\n    databaseLogs = false;\n\n    constructor(\n        private getFolder: GetFolderUseCase.Interface,\n        private listFolders: ListFoldersUseCase.Interface,\n        private listModels: ListModelsUseCase.Interface\n    ) {}\n\n    async run({ input, controller }: TaskDefinition.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                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\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\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\nexport const SyncFlpTask = TaskDefinition.createImplementation({\n    implementation: SyncFlpTaskImpl,\n    dependencies: [GetFolderUseCase, ListFoldersUseCase, ListModelsUseCase]\n});\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,16 @@
+import { TaskDefinition } 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 UpdateFlpTaskImpl implements TaskDefinition.Interface<IUpdateFlpTaskInput> {
+    private updateFlp;
+    id: string;
+    title: string;
+    description: string;
+    databaseLogs: boolean;
+    constructor(updateFlp: UpdateFlpUseCase.Interface);
+    run({ input, controller }: TaskDefinition.RunParams<IUpdateFlpTaskInput>): Promise<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultError | import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultAborted | TaskDefinition.ResultDone<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

@@ -0,0 +1,40 @@
+import { TaskDefinition } 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 UpdateFlpTaskImpl {
+  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.";
+  databaseLogs = false;
+  constructor(updateFlp) {
+    this.updateFlp = updateFlp;
+  }
+  async run({
+    input,
+    controller
+  }) {
+    try {
+      if (controller.runtime.isAborted()) {
+        return controller.response.aborted();
+      }
+      await this.updateFlp.execute({
+        folder: input.folder,
+        queued: input.queued,
+        isCloseToTimeout: controller.runtime.isCloseToTimeout,
+        handleTimeout: queued => controller.response.continue({
+          ...input,
+          queued
+        })
+      });
+      return controller.response.done("Task done: FLP record updated.");
+    } catch (error) {
+      return controller.response.error(error);
+    }
+  }
+}
+export const UpdateFlpTask = TaskDefinition.createImplementation({
+  implementation: UpdateFlpTaskImpl,
+  dependencies: [UpdateFlpUseCase]
+});
+
+//# sourceMappingURL=updateFlp.task.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["TaskDefinition","UPDATE_FLP_TASK_ID","UpdateFlpUseCase","UpdateFlpTaskImpl","id","title","description","databaseLogs","constructor","updateFlp","run","input","controller","runtime","isAborted","response","aborted","execute","folder","queued","isCloseToTimeout","handleTimeout","continue","done","error","UpdateFlpTask","createImplementation","implementation","dependencies"],"sources":["updateFlp.task.ts"],"sourcesContent":["import { TaskDefinition } 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 UpdateFlpTaskImpl implements TaskDefinition.Interface<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    databaseLogs = false;\n\n    constructor(private updateFlp: UpdateFlpUseCase.Interface) {}\n\n    async run({ input, controller }: TaskDefinition.RunParams<IUpdateFlpTaskInput>) {\n        try {\n            if (controller.runtime.isAborted()) {\n                return controller.response.aborted();\n            }\n\n            await this.updateFlp.execute({\n                folder: input.folder,\n                queued: input.queued,\n                isCloseToTimeout: controller.runtime.isCloseToTimeout,\n                handleTimeout: queued => controller.response.continue({ ...input, queued })\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\nexport const UpdateFlpTask = TaskDefinition.createImplementation({\n    implementation: UpdateFlpTaskImpl,\n    dependencies: [UpdateFlpUseCase]\n});\n"],"mappings":"AAAA,SAASA,cAAc,QAAQ,wDAAwD;AACvF,SAASC,kBAAkB;AAE3B,SAASC,gBAAgB;AAEzB,MAAMC,iBAAiB,CAA0D;EAC7EC,EAAE,GAAGH,kBAAkB;EACvBI,KAAK,GAAG,yBAAyB;EACjCC,WAAW,GACP,2GAA2G;EAC/GC,YAAY,GAAG,KAAK;EAEpBC,WAAWA,CAASC,SAAqC,EAAE;IAAA,KAAvCA,SAAqC,GAArCA,SAAqC;EAAG;EAE5D,MAAMC,GAAGA,CAAC;IAAEC,KAAK;IAAEC;EAA0D,CAAC,EAAE;IAC5E,IAAI;MACA,IAAIA,UAAU,CAACC,OAAO,CAACC,SAAS,CAAC,CAAC,EAAE;QAChC,OAAOF,UAAU,CAACG,QAAQ,CAACC,OAAO,CAAC,CAAC;MACxC;MAEA,MAAM,IAAI,CAACP,SAAS,CAACQ,OAAO,CAAC;QACzBC,MAAM,EAAEP,KAAK,CAACO,MAAM;QACpBC,MAAM,EAAER,KAAK,CAACQ,MAAM;QACpBC,gBAAgB,EAAER,UAAU,CAACC,OAAO,CAACO,gBAAgB;QACrDC,aAAa,EAAEF,MAAM,IAAIP,UAAU,CAACG,QAAQ,CAACO,QAAQ,CAAC;UAAE,GAAGX,KAAK;UAAEQ;QAAO,CAAC;MAC9E,CAAC,CAAC;MAEF,OAAOP,UAAU,CAACG,QAAQ,CAACQ,IAAI,CAAC,gCAAgC,CAAC;IACrE,CAAC,CAAC,OAAOC,KAAK,EAAE;MACZ,OAAOZ,UAAU,CAACG,QAAQ,CAACS,KAAK,CAACA,KAAK,CAAC;IAC3C;EACJ;AACJ;AAEA,OAAO,MAAMC,aAAa,GAAGzB,cAAc,CAAC0B,oBAAoB,CAAC;EAC7DC,cAAc,EAAExB,iBAAiB;EACjCyB,YAAY,EAAE,CAAC1B,gBAAgB;AACnC,CAAC,CAAC","ignoreList":[]}

package/folder/createFolderModelModifier.d.ts

@@ -0,0 +1,36 @@
+import { Plugin } from "@webiny/plugins";
+import type { CmsPrivateModelFull } from "@webiny/api-headless-cms";
+import type { CmsModelField as BaseModelField } from "@webiny/api-headless-cms/types/index.js";
+export type CmsModelField = Omit<BaseModelField, "storageId"> & {
+    modelIds?: string[];
+};
+export interface IFolderModelFieldsModifier {
+    setFields: (fields: BaseModelField[]) => void;
+    addField: (field: CmsModelField) => void;
+}
+export declare class FolderModelFieldsModifier implements IFolderModelFieldsModifier {
+    private fields;
+    private readonly namespace;
+    constructor(namespace: string);
+    setFields(fields: BaseModelField[]): void;
+    addField(field: CmsModelField): void;
+}
+interface CmsModelModifierCallableParams {
+    modifier: IFolderModelFieldsModifier;
+}
+export interface CmsModelModifierCallable {
+    (params: CmsModelModifierCallableParams): Promise<void> | void;
+}
+interface FolderCmsModelModifierPluginParams {
+    modifier: IFolderModelFieldsModifier;
+    callback: CmsModelModifierCallable;
+}
+export declare class FolderCmsModelModifierPlugin extends Plugin {
+    static type: string;
+    private readonly modifier;
+    private readonly callback;
+    constructor(params: FolderCmsModelModifierPluginParams);
+    modifyModel(model: CmsPrivateModelFull): Promise<void>;
+}
+export declare const createFolderModelModifier: (callback: CmsModelModifierCallable) => FolderCmsModelModifierPlugin;
+export {};

package/folder/createFolderModelModifier.js

@@ -0,0 +1,61 @@
+import { Plugin } from "@webiny/plugins";
+import { createModelField } from "@webiny/api-headless-cms";
+import { FOLDER_MODEL_ID } from "../domain/folder/folder.model.js";
+export 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}`])
+    });
+  }
+}
+export class FolderCmsModelModifierPlugin extends 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_MODEL_ID) {
+      return;
+    }
+    let extensionsField = model.fields.find(field => field.fieldId === "extensions");
+    if (!extensionsField) {
+      extensionsField = createModelField({
+        label: "Extensions",
+        type: "object",
+        settings: {
+          layout: [],
+          fields: []
+        }
+      });
+      model.fields.push(extensionsField);
+    }
+    this.modifier.setFields(extensionsField.settings.fields);
+    await this.callback({
+      modifier: this.modifier
+    });
+  }
+}
+export const createFolderModelModifier = callback => {
+  const modifier = new FolderModelFieldsModifier("global");
+  return new FolderCmsModelModifierPlugin({
+    callback,
+    modifier
+  });
+};
+
+//# sourceMappingURL=createFolderModelModifier.js.map

package/folder/createFolderModelModifier.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Plugin","createModelField","FOLDER_MODEL_ID","FolderModelFieldsModifier","fields","constructor","namespace","setFields","addField","field","tags","rest","push","storageId","type","id","concat","FolderCmsModelModifierPlugin","params","modifier","callback","modifyModel","model","modelId","extensionsField","find","fieldId","label","settings","layout","createFolderModelModifier"],"sources":["createFolderModelModifier.ts"],"sourcesContent":["import { Plugin } from \"@webiny/plugins\";\nimport type { CmsPrivateModelFull } from \"@webiny/api-headless-cms\";\nimport { createModelField } from \"@webiny/api-headless-cms\";\nimport type { CmsModelField as BaseModelField } from \"@webiny/api-headless-cms/types/index.js\";\nimport { FOLDER_MODEL_ID } from \"~/domain/folder/folder.model.js\";\n\nexport type CmsModelField = Omit<BaseModelField, \"storageId\"> & { modelIds?: string[] };\n\nexport interface IFolderModelFieldsModifier {\n    setFields: (fields: BaseModelField[]) => void;\n    addField: (field: CmsModelField) => void;\n}\n\nexport class FolderModelFieldsModifier implements IFolderModelFieldsModifier {\n    private fields: BaseModelField[] = [];\n    private readonly namespace: string;\n\n    constructor(namespace: string) {\n        this.namespace = namespace;\n    }\n\n    setFields(fields: BaseModelField[]) {\n        this.fields = fields;\n    }\n\n    addField(field: CmsModelField) {\n        const { tags, ...rest } = field;\n\n        this.fields.push({\n            ...rest,\n            storageId: `${field.type}@${this.namespace}_${field.id}`,\n            tags: (tags ?? []).concat([`$namespace:${this.namespace}`])\n        });\n    }\n}\n\ninterface CmsModelModifierCallableParams {\n    modifier: IFolderModelFieldsModifier;\n}\n\nexport interface CmsModelModifierCallable {\n    (params: CmsModelModifierCallableParams): Promise<void> | void;\n}\n\ninterface FolderCmsModelModifierPluginParams {\n    modifier: IFolderModelFieldsModifier;\n    callback: CmsModelModifierCallable;\n}\n\nexport class FolderCmsModelModifierPlugin extends Plugin {\n    public static override type = \"aco.folder.cms-model-modifier\";\n    private readonly modifier: IFolderModelFieldsModifier;\n    private readonly callback: CmsModelModifierCallable;\n\n    constructor(params: FolderCmsModelModifierPluginParams) {\n        super();\n        this.modifier = params.modifier;\n        this.callback = params.callback;\n    }\n\n    async modifyModel(model: CmsPrivateModelFull): Promise<void> {\n        if (model.modelId !== FOLDER_MODEL_ID) {\n            return;\n        }\n\n        let extensionsField = model.fields.find(field => field.fieldId === \"extensions\");\n        if (!extensionsField) {\n            extensionsField = createModelField({\n                label: \"Extensions\",\n                type: \"object\",\n                settings: {\n                    layout: [],\n                    fields: []\n                }\n            });\n            model.fields.push(extensionsField);\n        }\n\n        this.modifier.setFields(extensionsField.settings!.fields!);\n\n        await this.callback({ modifier: this.modifier });\n    }\n}\n\nexport const createFolderModelModifier = (callback: CmsModelModifierCallable) => {\n    const modifier = new FolderModelFieldsModifier(\"global\");\n\n    return new FolderCmsModelModifierPlugin({\n        callback,\n        modifier\n    });\n};\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,iBAAiB;AAExC,SAASC,gBAAgB,QAAQ,0BAA0B;AAE3D,SAASC,eAAe;AASxB,OAAO,MAAMC,yBAAyB,CAAuC;EACjEC,MAAM,GAAqB,EAAE;EAGrCC,WAAWA,CAACC,SAAiB,EAAE;IAC3B,IAAI,CAACA,SAAS,GAAGA,SAAS;EAC9B;EAEAC,SAASA,CAACH,MAAwB,EAAE;IAChC,IAAI,CAACA,MAAM,GAAGA,MAAM;EACxB;EAEAI,QAAQA,CAACC,KAAoB,EAAE;IAC3B,MAAM;MAAEC,IAAI;MAAE,GAAGC;IAAK,CAAC,GAAGF,KAAK;IAE/B,IAAI,CAACL,MAAM,CAACQ,IAAI,CAAC;MACb,GAAGD,IAAI;MACPE,SAAS,EAAE,GAAGJ,KAAK,CAACK,IAAI,IAAI,IAAI,CAACR,SAAS,IAAIG,KAAK,CAACM,EAAE,EAAE;MACxDL,IAAI,EAAE,CAACA,IAAI,IAAI,EAAE,EAAEM,MAAM,CAAC,CAAC,cAAc,IAAI,CAACV,SAAS,EAAE,CAAC;IAC9D,CAAC,CAAC;EACN;AACJ;AAeA,OAAO,MAAMW,4BAA4B,SAASjB,MAAM,CAAC;EACrD,OAAuBc,IAAI,GAAG,+BAA+B;EAI7DT,WAAWA,CAACa,MAA0C,EAAE;IACpD,KAAK,CAAC,CAAC;IACP,IAAI,CAACC,QAAQ,GAAGD,MAAM,CAACC,QAAQ;IAC/B,IAAI,CAACC,QAAQ,GAAGF,MAAM,CAACE,QAAQ;EACnC;EAEA,MAAMC,WAAWA,CAACC,KAA0B,EAAiB;IACzD,IAAIA,KAAK,CAACC,OAAO,KAAKrB,eAAe,EAAE;MACnC;IACJ;IAEA,IAAIsB,eAAe,GAAGF,KAAK,CAAClB,MAAM,CAACqB,IAAI,CAAChB,KAAK,IAAIA,KAAK,CAACiB,OAAO,KAAK,YAAY,CAAC;IAChF,IAAI,CAACF,eAAe,EAAE;MAClBA,eAAe,GAAGvB,gBAAgB,CAAC;QAC/B0B,KAAK,EAAE,YAAY;QACnBb,IAAI,EAAE,QAAQ;QACdc,QAAQ,EAAE;UACNC,MAAM,EAAE,EAAE;UACVzB,MAAM,EAAE;QACZ;MACJ,CAAC,CAAC;MACFkB,KAAK,CAAClB,MAAM,CAACQ,IAAI,CAACY,eAAe,CAAC;IACtC;IAEA,IAAI,CAACL,QAAQ,CAACZ,SAAS,CAACiB,eAAe,CAACI,QAAQ,CAAExB,MAAO,CAAC;IAE1D,MAAM,IAAI,CAACgB,QAAQ,CAAC;MAAED,QAAQ,EAAE,IAAI,CAACA;IAAS,CAAC,CAAC;EACpD;AACJ;AAEA,OAAO,MAAMW,yBAAyB,GAAIV,QAAkC,IAAK;EAC7E,MAAMD,QAAQ,GAAG,IAAIhB,yBAAyB,CAAC,QAAQ,CAAC;EAExD,OAAO,IAAIc,4BAA4B,CAAC;IACpCG,QAAQ;IACRD;EACJ,CAAC,CAAC;AACN,CAAC","ignoreList":[]}

package/folder/createFolderTypeDefs.d.ts

@@ -0,0 +1,7 @@
+import type { CmsFieldTypePlugins, CmsModel } from "@webiny/api-headless-cms/types/index.js";
+export interface CreateFolderTypeDefsParams {
+    model: CmsModel;
+    models: CmsModel[];
+    plugins: CmsFieldTypePlugins;
+}
+export declare const createFolderTypeDefs: (params: CreateFolderTypeDefsParams) => string;

package/folder/createFolderTypeDefs.js

@@ -0,0 +1,186 @@
+import { renderFields } from "@webiny/api-headless-cms/utils/renderFields.js";
+import { renderInputFields } from "@webiny/api-headless-cms/utils/renderInputFields.js";
+const removeFieldRequiredValidation = field => {
+  if (field.validation) {
+    field.validation = field.validation.filter(validation => validation.name !== "required");
+  }
+  if (field.listValidation) {
+    field.listValidation = field.listValidation.filter(v => v.name !== "required");
+  }
+  return field;
+};
+const createUpdateFields = fields => {
+  return fields.reduce((collection, field) => {
+    collection.push(removeFieldRequiredValidation({
+      ...field
+    }));
+    return collection;
+  }, []);
+};
+export const createFolderTypeDefs = params => {
+  const {
+    model,
+    models,
+    plugins: fieldTypePlugins
+  } = params;
+  const {
+    fields
+  } = model;
+  const fieldTypes = renderFields({
+    models,
+    model,
+    fields,
+    type: "manage",
+    fieldTypePlugins
+  });
+  const inputCreateFields = renderInputFields({
+    models,
+    model,
+    fields,
+    fieldTypePlugins
+  });
+  const inputUpdateFields = renderInputFields({
+    models,
+    model,
+    fields: createUpdateFields(fields),
+    fieldTypePlugins
+  });
+  return /* GraphQL */`
+        ${fieldTypes.map(f => f.typeDefs).join("\n")}
+       
+        type Folder {
+            id: ID!
+            # Tells us if the current user can manage folder structure.
+            canManageStructure: Boolean
+
+            # Tells us if the current user can manage folder permissions.
+            canManagePermissions: Boolean
+
+            # Tells us if the current user can manage folder content.
+            canManageContent: Boolean
+
+            # Tells us if the folder contains non-inherited permissions.
+            hasNonInheritedPermissions: Boolean
+
+            createdOn: DateTime
+            modifiedOn: DateTime
+            savedOn: DateTime
+            createdBy: AcoUser
+            modifiedBy: AcoUser
+            savedBy: AcoUser
+            
+            ${fieldTypes.map(f => f.fields).join("\n")}
+        }
+
+        ${inputCreateFields.map(f => f.typeDefs).join("\n")}
+        
+        input FolderCreateInput {
+             # Pass an ID if you want to create a folder with a specific ID.
+             id: ID  
+             
+             ${inputCreateFields.map(f => f.fields).join("\n")}
+        }
+                
+         input FolderUpdateInput {
+            ${inputUpdateFields.map(f => f.fields).join("\n")}
+        }
+        
+        input FoldersListWhereInput {
+            type: String!
+            parentId: ID
+            parentId_in: [ID]
+            slug: String
+            slug_not: String
+            slug_contains: String
+            slug_not_contains: String
+            slug_in: [String]
+            slug_not_in: [String]
+            slug_startsWith: String
+            slug_not_startsWith: String
+            path: String
+            path_not: String
+            path_contains: String
+            path_not_contains: String
+            path_in: [String]
+            path_not_in: [String]
+            path_startsWith: String
+            path_not_startsWith: String
+            createdBy: ID
+        }
+        
+        type FolderResponse {
+            data: Folder
+            error: AcoError
+        }
+
+        type FoldersListResponse {
+            data: [Folder]
+            error: AcoError
+            meta: AcoMeta
+        }
+
+        type FoldersHierarchyData {
+            parents: [Folder]
+            siblings: [Folder]
+        }
+
+        type FoldersHierarchyResponse {
+            data: FoldersHierarchyData
+            error: AcoError
+        }
+
+        type FolderLevelPermissionsTarget {
+            id: ID!
+            type: String!
+            target: ID!
+            name: String!
+            meta: JSON
+        }
+
+        type FolderLevelPermissionsTargetsListMeta {
+            totalCount: Int!
+        }
+
+        type FolderLevelPermissionsTargetsListResponse {
+            data: [FolderLevelPermissionsTarget]
+            meta: FolderLevelPermissionsTargetsListMeta
+            error: AcoError
+        }
+        
+         type FolderModelResponse {
+            data: JSON
+            error: AcoError
+        }
+
+        extend type AcoQuery {
+            getFolderModel: FolderModelResponse!
+            getFolder(id: ID!): FolderResponse
+            listFolders(
+                where: FoldersListWhereInput!
+                limit: Int
+                after: String
+                sort: AcoSort
+            ): FoldersListResponse
+            getFolderHierarchy(type: String!, id: ID!): FoldersHierarchyResponse
+            listFolderLevelPermissionsTargets: FolderLevelPermissionsTargetsListResponse
+        }
+
+        extend type AcoMutation {
+            createFolder(data: FolderCreateInput!): FolderResponse
+            updateFolder(id: ID!, data: FolderUpdateInput!): FolderResponse
+            deleteFolder(id: ID!): AcoBooleanResponse
+        }
+        
+        # The base type is dynamically generated from a Folder model
+        
+        extend type AcoFolder_Permissions {
+             inheritedFrom: ID
+        }
+        
+         extend input AcoFolder_PermissionsInput {
+             inheritedFrom: ID
+        }
+    `;
+};
+
+//# sourceMappingURL=createFolderTypeDefs.js.map