@webiny/api-aco 6.0.0-beta.0 → 6.0.0-rc.0

package/features/flp/UpdateFlp/index.js

@@ -0,0 +1,4 @@
+export { UpdateFlpFeature } from "./feature.js";
+export { UpdateFlpUseCase } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

package/features/flp/UpdateFlp/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["UpdateFlpFeature","UpdateFlpUseCase"],"sources":["index.ts"],"sourcesContent":["export { UpdateFlpFeature } from \"./feature.js\";\nexport { UpdateFlpUseCase } from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,gBAAgB;AACzB,SAASC,gBAAgB","ignoreList":[]}

package/features/flp/UpdateFlpOnFolderUpdated/UpdateFlpOnFolderUpdatedHandler.d.ts

@@ -0,0 +1,14 @@
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { UpdateFlpUseCase } from "../UpdateFlp/abstractions.js";
+import type { FolderAfterUpdateEvent } from "../../../features/folder/UpdateFolder/events.js";
+import { FolderAfterUpdateHandler } from "../../../features/folder/UpdateFolder/index.js";
+declare class UpdateFlpOnFolderUpdatedHandlerImpl implements FolderAfterUpdateHandler.Interface {
+    private updateFlpUseCase;
+    private tasks?;
+    constructor(updateFlpUseCase: UpdateFlpUseCase.Interface, tasks?: TaskService.Interface | undefined);
+    handle(event: FolderAfterUpdateEvent): Promise<void>;
+}
+export declare const UpdateFlpOnFolderUpdatedHandler: typeof UpdateFlpOnFolderUpdatedHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-core/features/EventPublisher").DomainEvent<import("../../folder/UpdateFolder/abstractions.js").FolderAfterUpdatePayload>>>;
+};
+export {};

package/features/flp/UpdateFlpOnFolderUpdated/UpdateFlpOnFolderUpdatedHandler.js

@@ -0,0 +1,39 @@
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { UpdateFlpUseCase } from "../UpdateFlp/abstractions.js";
+import { UPDATE_FLP_TASK_ID } from "../../../flp/tasks/index.js";
+import { FolderAfterUpdateHandler } from "../../folder/UpdateFolder/index.js";
+class UpdateFlpOnFolderUpdatedHandlerImpl {
+  constructor(updateFlpUseCase, tasks) {
+    this.updateFlpUseCase = updateFlpUseCase;
+    this.tasks = tasks;
+  }
+  async handle(event) {
+    const {
+      folder
+    } = event.payload;
+    try {
+      if (this.tasks) {
+        await this.tasks.trigger({
+          definition: UPDATE_FLP_TASK_ID,
+          input: {
+            folder
+          }
+        });
+      } else {
+        await this.updateFlpUseCase.execute({
+          folder
+        });
+      }
+    } catch {
+      // Ignore errors
+    }
+  }
+}
+export const UpdateFlpOnFolderUpdatedHandler = FolderAfterUpdateHandler.createImplementation({
+  implementation: UpdateFlpOnFolderUpdatedHandlerImpl,
+  dependencies: [UpdateFlpUseCase, [TaskService, {
+    optional: true
+  }]]
+});
+
+//# sourceMappingURL=UpdateFlpOnFolderUpdatedHandler.js.map

package/features/flp/UpdateFlpOnFolderUpdated/UpdateFlpOnFolderUpdatedHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TaskService","UpdateFlpUseCase","UPDATE_FLP_TASK_ID","FolderAfterUpdateHandler","UpdateFlpOnFolderUpdatedHandlerImpl","constructor","updateFlpUseCase","tasks","handle","event","folder","payload","trigger","definition","input","execute","UpdateFlpOnFolderUpdatedHandler","createImplementation","implementation","dependencies","optional"],"sources":["UpdateFlpOnFolderUpdatedHandler.ts"],"sourcesContent":["import { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport { UpdateFlpUseCase } from \"../UpdateFlp/abstractions.js\";\nimport type { FolderAfterUpdateEvent } from \"~/features/folder/UpdateFolder/events.js\";\nimport type { IUpdateFlpTaskInput } from \"~/types.js\";\nimport { UPDATE_FLP_TASK_ID } from \"~/flp/tasks/index.js\";\nimport { FolderAfterUpdateHandler } from \"~/features/folder/UpdateFolder/index.js\";\n\nclass UpdateFlpOnFolderUpdatedHandlerImpl implements FolderAfterUpdateHandler.Interface {\n    constructor(\n        private updateFlpUseCase: UpdateFlpUseCase.Interface,\n        private tasks?: TaskService.Interface\n    ) {}\n\n    async handle(event: FolderAfterUpdateEvent): Promise<void> {\n        const { folder } = event.payload;\n\n        try {\n            if (this.tasks) {\n                await this.tasks.trigger<IUpdateFlpTaskInput>({\n                    definition: UPDATE_FLP_TASK_ID,\n                    input: { folder }\n                });\n            } else {\n                await this.updateFlpUseCase.execute({ folder });\n            }\n        } catch {\n            // Ignore errors\n        }\n    }\n}\n\nexport const UpdateFlpOnFolderUpdatedHandler = FolderAfterUpdateHandler.createImplementation({\n    implementation: UpdateFlpOnFolderUpdatedHandlerImpl,\n    dependencies: [UpdateFlpUseCase, [TaskService, { optional: true }]]\n});\n"],"mappings":"AAAA,SAASA,WAAW,QAAQ,qDAAqD;AACjF,SAASC,gBAAgB;AAGzB,SAASC,kBAAkB;AAC3B,SAASC,wBAAwB;AAEjC,MAAMC,mCAAmC,CAA+C;EACpFC,WAAWA,CACCC,gBAA4C,EAC5CC,KAA6B,EACvC;IAAA,KAFUD,gBAA4C,GAA5CA,gBAA4C;IAAA,KAC5CC,KAA6B,GAA7BA,KAA6B;EACtC;EAEH,MAAMC,MAAMA,CAACC,KAA6B,EAAiB;IACvD,MAAM;MAAEC;IAAO,CAAC,GAAGD,KAAK,CAACE,OAAO;IAEhC,IAAI;MACA,IAAI,IAAI,CAACJ,KAAK,EAAE;QACZ,MAAM,IAAI,CAACA,KAAK,CAACK,OAAO,CAAsB;UAC1CC,UAAU,EAAEX,kBAAkB;UAC9BY,KAAK,EAAE;YAAEJ;UAAO;QACpB,CAAC,CAAC;MACN,CAAC,MAAM;QACH,MAAM,IAAI,CAACJ,gBAAgB,CAACS,OAAO,CAAC;UAAEL;QAAO,CAAC,CAAC;MACnD;IACJ,CAAC,CAAC,MAAM;MACJ;IAAA;EAER;AACJ;AAEA,OAAO,MAAMM,+BAA+B,GAAGb,wBAAwB,CAACc,oBAAoB,CAAC;EACzFC,cAAc,EAAEd,mCAAmC;EACnDe,YAAY,EAAE,CAAClB,gBAAgB,EAAE,CAACD,WAAW,EAAE;IAAEoB,QAAQ,EAAE;EAAK,CAAC,CAAC;AACtE,CAAC,CAAC","ignoreList":[]}

package/features/flp/UpdateFlpOnFolderUpdated/feature.d.ts

@@ -0,0 +1 @@
+export declare const UpdateFlpOnFolderUpdatedFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/flp/UpdateFlpOnFolderUpdated/feature.js

@@ -0,0 +1,10 @@
+import { createFeature } from "@webiny/feature/api";
+import { UpdateFlpOnFolderUpdatedHandler } from "./UpdateFlpOnFolderUpdatedHandler.js";
+export const UpdateFlpOnFolderUpdatedFeature = createFeature({
+  name: "UpdateFlpOnFolderUpdated",
+  register(container) {
+    container.register(UpdateFlpOnFolderUpdatedHandler);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/flp/UpdateFlpOnFolderUpdated/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","UpdateFlpOnFolderUpdatedHandler","UpdateFlpOnFolderUpdatedFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UpdateFlpOnFolderUpdatedHandler } from \"./UpdateFlpOnFolderUpdatedHandler.js\";\n\nexport const UpdateFlpOnFolderUpdatedFeature = createFeature({\n    name: \"UpdateFlpOnFolderUpdated\",\n    register(container) {\n        container.register(UpdateFlpOnFolderUpdatedHandler);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,+BAA+B;AAExC,OAAO,MAAMC,+BAA+B,GAAGF,aAAa,CAAC;EACzDG,IAAI,EAAE,0BAA0B;EAChCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,+BAA+B,CAAC;EACvD;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/flp/UpdateFlpOnFolderUpdated/index.d.ts

@@ -0,0 +1 @@
+export { UpdateFlpOnFolderUpdatedFeature } from "./feature.js";

package/features/flp/UpdateFlpOnFolderUpdated/index.js

@@ -0,0 +1,3 @@
+export { UpdateFlpOnFolderUpdatedFeature } from "./feature.js";
+
+//# sourceMappingURL=index.js.map

package/features/flp/UpdateFlpOnFolderUpdated/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["UpdateFlpOnFolderUpdatedFeature"],"sources":["index.ts"],"sourcesContent":["export { UpdateFlpOnFolderUpdatedFeature } from \"./feature.js\";\n"],"mappings":"AAAA,SAASA,+BAA+B","ignoreList":[]}

package/features/folder/CreateFolder/CreateFolderRepository.d.ts

@@ -0,0 +1,21 @@
+import { Result } from "@webiny/feature/api";
+import { CreateFolderRepository as RepositoryAbstraction, type ICreateFolderRepository } from "./abstractions.js";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { FolderModel } from "../../../domain/folder/abstractions.js";
+import type { CreateFolderParams, Folder } from "../../../folder/folder.types.js";
+declare class CreateFolderRepositoryImpl implements ICreateFolderRepository {
+    private createEntry;
+    private listLatestEntries;
+    private getEntryById;
+    private folderModel;
+    constructor(createEntry: CreateEntryUseCase.Interface, listLatestEntries: ListLatestEntriesUseCase.Interface, getEntryById: GetEntryByIdUseCase.Interface, folderModel: FolderModel.Interface);
+    execute(data: CreateFolderParams): Promise<Result<Folder, RepositoryAbstraction.Error>>;
+    private checkExistingFolder;
+    private createFolderPath;
+}
+export declare const CreateFolderRepository: typeof CreateFolderRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<ICreateFolderRepository>;
+};
+export {};

package/features/folder/CreateFolder/CreateFolderRepository.js

@@ -0,0 +1,108 @@
+import { Result } from "@webiny/feature/api";
+import { CreateFolderRepository as RepositoryAbstraction } from "./abstractions.js";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { FolderModel } from "../../../domain/folder/abstractions.js";
+import { EntryToFolderMapper } from "../shared/EntryToFolderMapper.js";
+import { FolderPersistenceError, FolderValidationError } from "../../../domain/folder/errors.js";
+import { Path } from "../../../utils/Path.js";
+import { EntryId } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+class CreateFolderRepositoryImpl {
+  constructor(createEntry, listLatestEntries, getEntryById, folderModel) {
+    this.createEntry = createEntry;
+    this.listLatestEntries = listLatestEntries;
+    this.getEntryById = getEntryById;
+    this.folderModel = folderModel;
+  }
+  async execute(data) {
+    // Check if folder already exists
+    const checkResult = await this.checkExistingFolder({
+      type: data.type,
+      slug: data.slug,
+      parentId: data.parentId
+    });
+    if (checkResult.isFail()) {
+      return Result.fail(checkResult.error);
+    }
+
+    // Create folder path
+    const pathResult = await this.createFolderPath({
+      slug: data.slug,
+      parentId: data.parentId
+    });
+    if (pathResult.isFail()) {
+      return Result.fail(pathResult.error);
+    }
+
+    // Create the entry
+    const result = await this.createEntry.execute(this.folderModel, {
+      values: {
+        ...data,
+        parentId: data.parentId || null,
+        path: pathResult.value
+      }
+    });
+    if (result.isFail()) {
+      if (result.error.code === "Cms/Entry/ValidationError") {
+        return Result.fail(new FolderValidationError(result.error.message));
+      }
+      return Result.fail(new FolderPersistenceError(result.error));
+    }
+    const folder = EntryToFolderMapper.toFolder(result.value);
+    return Result.ok(folder);
+  }
+  async checkExistingFolder(params) {
+    const {
+      type,
+      slug,
+      parentId,
+      excludeId
+    } = params;
+    const result = await this.listLatestEntries.execute(this.folderModel, {
+      where: {
+        latest: true,
+        values: {
+          type,
+          slug,
+          parentId
+        },
+        ...(excludeId ? {
+          entryId_not: excludeId
+        } : {})
+      },
+      limit: 1
+    });
+    if (result.isFail()) {
+      return Result.fail(new FolderPersistenceError(result.error));
+    }
+    const {
+      entries
+    } = result.value;
+    if (entries.length > 0) {
+      return Result.fail(new FolderValidationError(`Folder with slug "${slug}" already exists at this level.`));
+    }
+    return Result.ok();
+  }
+  async createFolderPath(params) {
+    const {
+      slug,
+      parentId
+    } = params;
+    if (!parentId) {
+      return Result.ok(Path.create(slug));
+    }
+    const parentResult = await this.getEntryById.execute(this.folderModel, EntryId.from(parentId).toString());
+    if (parentResult.isFail()) {
+      return Result.fail(new FolderPersistenceError(new Error("Parent folder not found. Unable to create the folder path")));
+    }
+    const parentFolder = EntryToFolderMapper.toFolder(parentResult.value);
+    return Result.ok(Path.create(slug, parentFolder.path));
+  }
+}
+export const CreateFolderRepository = RepositoryAbstraction.createImplementation({
+  implementation: CreateFolderRepositoryImpl,
+  dependencies: [CreateEntryUseCase, ListLatestEntriesUseCase, GetEntryByIdUseCase, FolderModel]
+});
+
+//# sourceMappingURL=CreateFolderRepository.js.map

package/features/folder/CreateFolder/CreateFolderRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","CreateFolderRepository","RepositoryAbstraction","CreateEntryUseCase","ListLatestEntriesUseCase","GetEntryByIdUseCase","FolderModel","EntryToFolderMapper","FolderPersistenceError","FolderValidationError","Path","EntryId","CreateFolderRepositoryImpl","constructor","createEntry","listLatestEntries","getEntryById","folderModel","execute","data","checkResult","checkExistingFolder","type","slug","parentId","isFail","fail","error","pathResult","createFolderPath","result","values","path","value","code","message","folder","toFolder","ok","params","excludeId","where","latest","entryId_not","limit","entries","length","create","parentResult","from","toString","Error","parentFolder","createImplementation","implementation","dependencies"],"sources":["CreateFolderRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    CreateFolderRepository as RepositoryAbstraction,\n    type ICreateFolderRepository\n} from \"./abstractions.js\";\nimport { CreateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { FolderModel } from \"~/domain/folder/abstractions.js\";\nimport type { CmsEntryFolder, CreateFolderParams, Folder } from \"~/folder/folder.types.js\";\nimport { EntryToFolderMapper } from \"../shared/EntryToFolderMapper.js\";\nimport { FolderPersistenceError, FolderValidationError } from \"~/domain/folder/errors.js\";\nimport { Path } from \"~/utils/Path.js\";\nimport { EntryId } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\n\nclass CreateFolderRepositoryImpl implements ICreateFolderRepository {\n    constructor(\n        private createEntry: CreateEntryUseCase.Interface,\n        private listLatestEntries: ListLatestEntriesUseCase.Interface,\n        private getEntryById: GetEntryByIdUseCase.Interface,\n        private folderModel: FolderModel.Interface\n    ) {}\n\n    async execute(data: CreateFolderParams): Promise<Result<Folder, RepositoryAbstraction.Error>> {\n        // Check if folder already exists\n        const checkResult = await this.checkExistingFolder({\n            type: data.type,\n            slug: data.slug,\n            parentId: data.parentId\n        });\n\n        if (checkResult.isFail()) {\n            return Result.fail(checkResult.error);\n        }\n\n        // Create folder path\n        const pathResult = await this.createFolderPath({\n            slug: data.slug,\n            parentId: data.parentId\n        });\n\n        if (pathResult.isFail()) {\n            return Result.fail(pathResult.error);\n        }\n\n        // Create the entry\n        const result = await this.createEntry.execute<CmsEntryFolder>(this.folderModel, {\n            values: {\n                ...data,\n                parentId: data.parentId || null,\n                path: pathResult.value\n            }\n        });\n\n        if (result.isFail()) {\n            if (result.error.code === \"Cms/Entry/ValidationError\") {\n                return Result.fail(new FolderValidationError(result.error.message));\n            }\n            return Result.fail(new FolderPersistenceError(result.error));\n        }\n\n        const folder = EntryToFolderMapper.toFolder(result.value);\n        return Result.ok(folder);\n    }\n\n    private async checkExistingFolder(params: {\n        type: string;\n        slug: string;\n        parentId?: string | null;\n        excludeId?: string;\n    }): Promise<Result<void, RepositoryAbstraction.Error>> {\n        const { type, slug, parentId, excludeId } = params;\n\n        const result = await this.listLatestEntries.execute<CmsEntryFolder>(this.folderModel, {\n            where: {\n                latest: true,\n                values: {\n                    type,\n                    slug,\n                    parentId\n                },\n                ...(excludeId ? { entryId_not: excludeId } : {})\n            },\n            limit: 1\n        });\n\n        if (result.isFail()) {\n            return Result.fail(new FolderPersistenceError(result.error));\n        }\n\n        const { entries } = result.value;\n\n        if (entries.length > 0) {\n            return Result.fail(\n                new FolderValidationError(\n                    `Folder with slug \"${slug}\" already exists at this level.`\n                )\n            );\n        }\n\n        return Result.ok();\n    }\n\n    private async createFolderPath(params: {\n        slug: string;\n        parentId?: string | null;\n    }): Promise<Result<string, RepositoryAbstraction.Error>> {\n        const { slug, parentId } = params;\n\n        if (!parentId) {\n            return Result.ok(Path.create(slug));\n        }\n\n        const parentResult = await this.getEntryById.execute<CmsEntryFolder>(\n            this.folderModel,\n            EntryId.from(parentId).toString()\n        );\n\n        if (parentResult.isFail()) {\n            return Result.fail(\n                new FolderPersistenceError(\n                    new Error(\"Parent folder not found. Unable to create the folder path\")\n                )\n            );\n        }\n\n        const parentFolder = EntryToFolderMapper.toFolder(parentResult.value);\n        return Result.ok(Path.create(slug, parentFolder.path));\n    }\n}\n\nexport const CreateFolderRepository = RepositoryAbstraction.createImplementation({\n    implementation: CreateFolderRepositoryImpl,\n    dependencies: [CreateEntryUseCase, ListLatestEntriesUseCase, GetEntryByIdUseCase, FolderModel]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SACIC,sBAAsB,IAAIC,qBAAqB;AAGnD,SAASC,kBAAkB,QAAQ,4DAA4D;AAC/F,SAASC,wBAAwB,QAAQ,4DAA4D;AACrG,SAASC,mBAAmB,QAAQ,6DAA6D;AACjG,SAASC,WAAW;AAEpB,SAASC,mBAAmB;AAC5B,SAASC,sBAAsB,EAAEC,qBAAqB;AACtD,SAASC,IAAI;AACb,SAASC,OAAO,QAAQ,mDAAmD;AAE3E,MAAMC,0BAA0B,CAAoC;EAChEC,WAAWA,CACCC,WAAyC,EACzCC,iBAAqD,EACrDC,YAA2C,EAC3CC,WAAkC,EAC5C;IAAA,KAJUH,WAAyC,GAAzCA,WAAyC;IAAA,KACzCC,iBAAqD,GAArDA,iBAAqD;IAAA,KACrDC,YAA2C,GAA3CA,YAA2C;IAAA,KAC3CC,WAAkC,GAAlCA,WAAkC;EAC3C;EAEH,MAAMC,OAAOA,CAACC,IAAwB,EAAwD;IAC1F;IACA,MAAMC,WAAW,GAAG,MAAM,IAAI,CAACC,mBAAmB,CAAC;MAC/CC,IAAI,EAAEH,IAAI,CAACG,IAAI;MACfC,IAAI,EAAEJ,IAAI,CAACI,IAAI;MACfC,QAAQ,EAAEL,IAAI,CAACK;IACnB,CAAC,CAAC;IAEF,IAAIJ,WAAW,CAACK,MAAM,CAAC,CAAC,EAAE;MACtB,OAAOzB,MAAM,CAAC0B,IAAI,CAACN,WAAW,CAACO,KAAK,CAAC;IACzC;;IAEA;IACA,MAAMC,UAAU,GAAG,MAAM,IAAI,CAACC,gBAAgB,CAAC;MAC3CN,IAAI,EAAEJ,IAAI,CAACI,IAAI;MACfC,QAAQ,EAAEL,IAAI,CAACK;IACnB,CAAC,CAAC;IAEF,IAAII,UAAU,CAACH,MAAM,CAAC,CAAC,EAAE;MACrB,OAAOzB,MAAM,CAAC0B,IAAI,CAACE,UAAU,CAACD,KAAK,CAAC;IACxC;;IAEA;IACA,MAAMG,MAAM,GAAG,MAAM,IAAI,CAAChB,WAAW,CAACI,OAAO,CAAiB,IAAI,CAACD,WAAW,EAAE;MAC5Ec,MAAM,EAAE;QACJ,GAAGZ,IAAI;QACPK,QAAQ,EAAEL,IAAI,CAACK,QAAQ,IAAI,IAAI;QAC/BQ,IAAI,EAAEJ,UAAU,CAACK;MACrB;IACJ,CAAC,CAAC;IAEF,IAAIH,MAAM,CAACL,MAAM,CAAC,CAAC,EAAE;MACjB,IAAIK,MAAM,CAACH,KAAK,CAACO,IAAI,KAAK,2BAA2B,EAAE;QACnD,OAAOlC,MAAM,CAAC0B,IAAI,CAAC,IAAIjB,qBAAqB,CAACqB,MAAM,CAACH,KAAK,CAACQ,OAAO,CAAC,CAAC;MACvE;MACA,OAAOnC,MAAM,CAAC0B,IAAI,CAAC,IAAIlB,sBAAsB,CAACsB,MAAM,CAACH,KAAK,CAAC,CAAC;IAChE;IAEA,MAAMS,MAAM,GAAG7B,mBAAmB,CAAC8B,QAAQ,CAACP,MAAM,CAACG,KAAK,CAAC;IACzD,OAAOjC,MAAM,CAACsC,EAAE,CAACF,MAAM,CAAC;EAC5B;EAEA,MAAcf,mBAAmBA,CAACkB,MAKjC,EAAsD;IACnD,MAAM;MAAEjB,IAAI;MAAEC,IAAI;MAAEC,QAAQ;MAAEgB;IAAU,CAAC,GAAGD,MAAM;IAElD,MAAMT,MAAM,GAAG,MAAM,IAAI,CAACf,iBAAiB,CAACG,OAAO,CAAiB,IAAI,CAACD,WAAW,EAAE;MAClFwB,KAAK,EAAE;QACHC,MAAM,EAAE,IAAI;QACZX,MAAM,EAAE;UACJT,IAAI;UACJC,IAAI;UACJC;QACJ,CAAC;QACD,IAAIgB,SAAS,GAAG;UAAEG,WAAW,EAAEH;QAAU,CAAC,GAAG,CAAC,CAAC;MACnD,CAAC;MACDI,KAAK,EAAE;IACX,CAAC,CAAC;IAEF,IAAId,MAAM,CAACL,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOzB,MAAM,CAAC0B,IAAI,CAAC,IAAIlB,sBAAsB,CAACsB,MAAM,CAACH,KAAK,CAAC,CAAC;IAChE;IAEA,MAAM;MAAEkB;IAAQ,CAAC,GAAGf,MAAM,CAACG,KAAK;IAEhC,IAAIY,OAAO,CAACC,MAAM,GAAG,CAAC,EAAE;MACpB,OAAO9C,MAAM,CAAC0B,IAAI,CACd,IAAIjB,qBAAqB,CACrB,qBAAqBc,IAAI,iCAC7B,CACJ,CAAC;IACL;IAEA,OAAOvB,MAAM,CAACsC,EAAE,CAAC,CAAC;EACtB;EAEA,MAAcT,gBAAgBA,CAACU,MAG9B,EAAwD;IACrD,MAAM;MAAEhB,IAAI;MAAEC;IAAS,CAAC,GAAGe,MAAM;IAEjC,IAAI,CAACf,QAAQ,EAAE;MACX,OAAOxB,MAAM,CAACsC,EAAE,CAAC5B,IAAI,CAACqC,MAAM,CAACxB,IAAI,CAAC,CAAC;IACvC;IAEA,MAAMyB,YAAY,GAAG,MAAM,IAAI,CAAChC,YAAY,CAACE,OAAO,CAChD,IAAI,CAACD,WAAW,EAChBN,OAAO,CAACsC,IAAI,CAACzB,QAAQ,CAAC,CAAC0B,QAAQ,CAAC,CACpC,CAAC;IAED,IAAIF,YAAY,CAACvB,MAAM,CAAC,CAAC,EAAE;MACvB,OAAOzB,MAAM,CAAC0B,IAAI,CACd,IAAIlB,sBAAsB,CACtB,IAAI2C,KAAK,CAAC,2DAA2D,CACzE,CACJ,CAAC;IACL;IAEA,MAAMC,YAAY,GAAG7C,mBAAmB,CAAC8B,QAAQ,CAACW,YAAY,CAACf,KAAK,CAAC;IACrE,OAAOjC,MAAM,CAACsC,EAAE,CAAC5B,IAAI,CAACqC,MAAM,CAACxB,IAAI,EAAE6B,YAAY,CAACpB,IAAI,CAAC,CAAC;EAC1D;AACJ;AAEA,OAAO,MAAM/B,sBAAsB,GAAGC,qBAAqB,CAACmD,oBAAoB,CAAC;EAC7EC,cAAc,EAAE1C,0BAA0B;EAC1C2C,YAAY,EAAE,CAACpD,kBAAkB,EAAEC,wBAAwB,EAAEC,mBAAmB,EAAEC,WAAW;AACjG,CAAC,CAAC","ignoreList":[]}

package/features/folder/CreateFolder/CreateFolderUseCase.d.ts

@@ -0,0 +1,12 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher as EventPublisherAbstraction } from "@webiny/api-core/features/EventPublisher";
+import { CreateFolderUseCase as UseCaseAbstraction, CreateFolderRepository } from "./abstractions.js";
+import type { Folder, CreateFolderParams } from "../../../folder/folder.types.js";
+declare class CreateFolderUseCaseImpl implements UseCaseAbstraction.Interface {
+    private eventPublisher;
+    private repository;
+    constructor(eventPublisher: EventPublisherAbstraction.Interface, repository: CreateFolderRepository.Interface);
+    execute(params: CreateFolderParams): Promise<Result<Folder, UseCaseAbstraction.Error>>;
+}
+export declare const CreateFolderUseCase: import("@webiny/di").Implementation<typeof CreateFolderUseCaseImpl>;
+export {};

package/features/folder/CreateFolder/CreateFolderUseCase.js

@@ -0,0 +1,39 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import { createImplementation } from "@webiny/di";
+import { CreateFolderUseCase as UseCaseAbstraction, CreateFolderRepository } from "./abstractions.js";
+import { FolderBeforeCreateEvent, FolderAfterCreateEvent } from "./events.js";
+class CreateFolderUseCaseImpl {
+  constructor(eventPublisher, repository) {
+    this.eventPublisher = eventPublisher;
+    this.repository = repository;
+  }
+  async execute(params) {
+    // Publish before create event
+    const beforeCreateEvent = new FolderBeforeCreateEvent({
+      input: params
+    });
+    await this.eventPublisher.publish(beforeCreateEvent);
+
+    // Execute the create operation
+    const result = await this.repository.execute(params);
+    if (result.isFail()) {
+      return result;
+    }
+    const folder = result.value;
+
+    // Publish after create event
+    const afterCreateEvent = new FolderAfterCreateEvent({
+      folder
+    });
+    await this.eventPublisher.publish(afterCreateEvent);
+    return Result.ok(folder);
+  }
+}
+export const CreateFolderUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: CreateFolderUseCaseImpl,
+  dependencies: [EventPublisher, CreateFolderRepository]
+});
+
+//# sourceMappingURL=CreateFolderUseCase.js.map

package/features/folder/CreateFolder/CreateFolderUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","EventPublisher","createImplementation","CreateFolderUseCase","UseCaseAbstraction","CreateFolderRepository","FolderBeforeCreateEvent","FolderAfterCreateEvent","CreateFolderUseCaseImpl","constructor","eventPublisher","repository","execute","params","beforeCreateEvent","input","publish","result","isFail","folder","value","afterCreateEvent","ok","abstraction","implementation","dependencies"],"sources":["CreateFolderUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    EventPublisher,\n    EventPublisher as EventPublisherAbstraction\n} from \"@webiny/api-core/features/EventPublisher\";\nimport { createImplementation } from \"@webiny/di\";\nimport {\n    CreateFolderUseCase as UseCaseAbstraction,\n    CreateFolderRepository\n} from \"./abstractions.js\";\nimport { FolderBeforeCreateEvent, FolderAfterCreateEvent } from \"./events.js\";\nimport type { Folder, CreateFolderParams } from \"~/folder/folder.types.js\";\n\nclass CreateFolderUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private eventPublisher: EventPublisherAbstraction.Interface,\n        private repository: CreateFolderRepository.Interface\n    ) {}\n\n    async execute(params: CreateFolderParams): Promise<Result<Folder, UseCaseAbstraction.Error>> {\n        // Publish before create event\n        const beforeCreateEvent = new FolderBeforeCreateEvent({\n            input: params\n        });\n\n        await this.eventPublisher.publish(beforeCreateEvent);\n\n        // Execute the create operation\n        const result = await this.repository.execute(params);\n\n        if (result.isFail()) {\n            return result;\n        }\n\n        const folder = result.value;\n\n        // Publish after create event\n        const afterCreateEvent = new FolderAfterCreateEvent({\n            folder\n        });\n\n        await this.eventPublisher.publish(afterCreateEvent);\n\n        return Result.ok(folder);\n    }\n}\n\nexport const CreateFolderUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: CreateFolderUseCaseImpl,\n    dependencies: [EventPublisher, CreateFolderRepository]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SACIC,cAAc,QAEX,0CAA0C;AACjD,SAASC,oBAAoB,QAAQ,YAAY;AACjD,SACIC,mBAAmB,IAAIC,kBAAkB,EACzCC,sBAAsB;AAE1B,SAASC,uBAAuB,EAAEC,sBAAsB;AAGxD,MAAMC,uBAAuB,CAAyC;EAClEC,WAAWA,CACCC,cAAmD,EACnDC,UAA4C,EACtD;IAAA,KAFUD,cAAmD,GAAnDA,cAAmD;IAAA,KACnDC,UAA4C,GAA5CA,UAA4C;EACrD;EAEH,MAAMC,OAAOA,CAACC,MAA0B,EAAqD;IACzF;IACA,MAAMC,iBAAiB,GAAG,IAAIR,uBAAuB,CAAC;MAClDS,KAAK,EAAEF;IACX,CAAC,CAAC;IAEF,MAAM,IAAI,CAACH,cAAc,CAACM,OAAO,CAACF,iBAAiB,CAAC;;IAEpD;IACA,MAAMG,MAAM,GAAG,MAAM,IAAI,CAACN,UAAU,CAACC,OAAO,CAACC,MAAM,CAAC;IAEpD,IAAII,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOD,MAAM;IACjB;IAEA,MAAME,MAAM,GAAGF,MAAM,CAACG,KAAK;;IAE3B;IACA,MAAMC,gBAAgB,GAAG,IAAId,sBAAsB,CAAC;MAChDY;IACJ,CAAC,CAAC;IAEF,MAAM,IAAI,CAACT,cAAc,CAACM,OAAO,CAACK,gBAAgB,CAAC;IAEnD,OAAOrB,MAAM,CAACsB,EAAE,CAACH,MAAM,CAAC;EAC5B;AACJ;AAEA,OAAO,MAAMhB,mBAAmB,GAAGD,oBAAoB,CAAC;EACpDqB,WAAW,EAAEnB,kBAAkB;EAC/BoB,cAAc,EAAEhB,uBAAuB;EACvCiB,YAAY,EAAE,CAACxB,cAAc,EAAEI,sBAAsB;AACzD,CAAC,CAAC","ignoreList":[]}

package/features/folder/CreateFolder/abstractions.d.ts

@@ -0,0 +1,55 @@
+import type { Result } from "@webiny/feature/api";
+import type { DomainEvent, IEventHandler } from "@webiny/api-core/features/EventPublisher";
+import type { Folder, CreateFolderParams } from "../../../folder/folder.types.js";
+import type { FolderNotAuthorizedError, FolderPersistenceError, FolderValidationError } from "../../../domain/folder/errors.js";
+/**
+ * CreateFolder repository interface
+ */
+export interface ICreateFolderRepository {
+    execute(data: CreateFolderParams): Promise<Result<Folder, RepositoryError>>;
+}
+export interface ICreateFolderRepositoryErrors {
+    validation: FolderValidationError;
+    persistence: FolderPersistenceError;
+}
+type RepositoryError = ICreateFolderRepositoryErrors[keyof ICreateFolderRepositoryErrors];
+export declare const CreateFolderRepository: import("@webiny/di").Abstraction<ICreateFolderRepository>;
+export declare namespace CreateFolderRepository {
+    type Interface = ICreateFolderRepository;
+    type Error = RepositoryError;
+}
+/**
+ * CreateFolder use case interface
+ */
+export interface ICreateFolderUseCase {
+    execute(params: CreateFolderParams): Promise<Result<Folder, UseCaseError>>;
+}
+export interface ICreateFolderUseCaseErrors {
+    notAuthorized: FolderNotAuthorizedError;
+    persistence: FolderPersistenceError;
+    validation: FolderValidationError;
+}
+type UseCaseError = ICreateFolderUseCaseErrors[keyof ICreateFolderUseCaseErrors];
+export declare const CreateFolderUseCase: import("@webiny/di").Abstraction<ICreateFolderUseCase>;
+export declare namespace CreateFolderUseCase {
+    type Interface = ICreateFolderUseCase;
+    type Return = Promise<Result<Folder, UseCaseError>>;
+    type Error = UseCaseError;
+}
+export interface FolderBeforeCreatePayload {
+    input: CreateFolderParams;
+}
+export interface FolderAfterCreatePayload {
+    folder: Folder;
+}
+export declare const FolderBeforeCreateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<FolderBeforeCreatePayload>>>;
+export declare namespace FolderBeforeCreateHandler {
+    type Interface = IEventHandler<DomainEvent<FolderBeforeCreatePayload>>;
+    type Event = DomainEvent<FolderBeforeCreatePayload>;
+}
+export declare const FolderAfterCreateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<FolderAfterCreatePayload>>>;
+export declare namespace FolderAfterCreateHandler {
+    type Interface = IEventHandler<DomainEvent<FolderAfterCreatePayload>>;
+    type Event = DomainEvent<FolderAfterCreatePayload>;
+}
+export {};

package/features/folder/CreateFolder/abstractions.js

@@ -0,0 +1,21 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * CreateFolder repository interface
+ */
+
+export const CreateFolderRepository = createAbstraction("CreateFolderRepository");
+
+/**
+ * CreateFolder use case interface
+ */
+
+export const CreateFolderUseCase = createAbstraction("CreateFolderUseCase");
+
+// Event Payload Types
+
+// Event Handler Abstractions
+export const FolderBeforeCreateHandler = createAbstraction("FolderBeforeCreateHandler");
+export const FolderAfterCreateHandler = createAbstraction("FolderAfterCreateHandler");
+
+//# sourceMappingURL=abstractions.js.map

package/features/folder/CreateFolder/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","CreateFolderRepository","CreateFolderUseCase","FolderBeforeCreateHandler","FolderAfterCreateHandler"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { DomainEvent, IEventHandler } from \"@webiny/api-core/features/EventPublisher\";\nimport type { Folder, CreateFolderParams } from \"~/folder/folder.types.js\";\nimport type {\n    FolderNotAuthorizedError,\n    FolderPersistenceError,\n    FolderValidationError\n} from \"~/domain/folder/errors.js\";\n\n/**\n * CreateFolder repository interface\n */\nexport interface ICreateFolderRepository {\n    execute(data: CreateFolderParams): Promise<Result<Folder, RepositoryError>>;\n}\n\nexport interface ICreateFolderRepositoryErrors {\n    validation: FolderValidationError;\n    persistence: FolderPersistenceError;\n}\n\ntype RepositoryError = ICreateFolderRepositoryErrors[keyof ICreateFolderRepositoryErrors];\n\nexport const CreateFolderRepository =\n    createAbstraction<ICreateFolderRepository>(\"CreateFolderRepository\");\n\nexport namespace CreateFolderRepository {\n    export type Interface = ICreateFolderRepository;\n    export type Error = RepositoryError;\n}\n\n/**\n * CreateFolder use case interface\n */\nexport interface ICreateFolderUseCase {\n    execute(params: CreateFolderParams): Promise<Result<Folder, UseCaseError>>;\n}\n\nexport interface ICreateFolderUseCaseErrors {\n    notAuthorized: FolderNotAuthorizedError;\n    persistence: FolderPersistenceError;\n    validation: FolderValidationError;\n}\n\ntype UseCaseError = ICreateFolderUseCaseErrors[keyof ICreateFolderUseCaseErrors];\n\nexport const CreateFolderUseCase = createAbstraction<ICreateFolderUseCase>(\"CreateFolderUseCase\");\n\nexport namespace CreateFolderUseCase {\n    export type Interface = ICreateFolderUseCase;\n    export type Return = Promise<Result<Folder, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n\n// Event Payload Types\nexport interface FolderBeforeCreatePayload {\n    input: CreateFolderParams;\n}\n\nexport interface FolderAfterCreatePayload {\n    folder: Folder;\n}\n\n// Event Handler Abstractions\nexport const FolderBeforeCreateHandler = createAbstraction<\n    IEventHandler<DomainEvent<FolderBeforeCreatePayload>>\n>(\"FolderBeforeCreateHandler\");\n\nexport namespace FolderBeforeCreateHandler {\n    export type Interface = IEventHandler<DomainEvent<FolderBeforeCreatePayload>>;\n    export type Event = DomainEvent<FolderBeforeCreatePayload>;\n}\n\nexport const FolderAfterCreateHandler = createAbstraction<\n    IEventHandler<DomainEvent<FolderAfterCreatePayload>>\n>(\"FolderAfterCreateHandler\");\n\nexport namespace FolderAfterCreateHandler {\n    export type Interface = IEventHandler<DomainEvent<FolderAfterCreatePayload>>;\n    export type Event = DomainEvent<FolderAfterCreatePayload>;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAUvD;AACA;AACA;;AAYA,OAAO,MAAMC,sBAAsB,GAC/BD,iBAAiB,CAA0B,wBAAwB,CAAC;;AAOxE;AACA;AACA;;AAaA,OAAO,MAAME,mBAAmB,GAAGF,iBAAiB,CAAuB,qBAAqB,CAAC;;AAQjG;;AASA;AACA,OAAO,MAAMG,yBAAyB,GAAGH,iBAAiB,CAExD,2BAA2B,CAAC;AAO9B,OAAO,MAAMI,wBAAwB,GAAGJ,iBAAiB,CAEvD,0BAA0B,CAAC","ignoreList":[]}

package/features/folder/CreateFolder/decorators/CreateFolderWithFolderLevelPermissions.d.ts

@@ -0,0 +1,11 @@
+import { FolderLevelPermissions } from "../../../../features/flp/FolderLevelPermissions/index.js";
+import { CreateFolderUseCase } from "../abstractions.js";
+import type { CreateFolderParams } from "../../../../folder/folder.types.js";
+declare class CreateFolderWithFolderLevelPermissionsImpl implements CreateFolderUseCase.Interface {
+    private folderLevelPermissions;
+    private readonly decoretee;
+    constructor(folderLevelPermissions: FolderLevelPermissions.Interface, decoretee: CreateFolderUseCase.Interface);
+    execute(params: CreateFolderParams): CreateFolderUseCase.Return;
+}
+export declare const CreateFolderWithFolderLevelPermissions: typeof CreateFolderWithFolderLevelPermissionsImpl;
+export {};

package/features/folder/CreateFolder/decorators/CreateFolderWithFolderLevelPermissions.js

@@ -0,0 +1,44 @@
+import { FolderLevelPermissions } from "../../../flp/FolderLevelPermissions/index.js";
+import { CreateFolderUseCase } from "../abstractions.js";
+import { createDecorator, Result } from "@webiny/feature/api";
+import { FolderNotAuthorizedError } from "../../../../domain/folder/errors.js";
+class CreateFolderWithFolderLevelPermissionsImpl {
+  constructor(folderLevelPermissions, decoretee) {
+    this.folderLevelPermissions = folderLevelPermissions;
+    this.decoretee = decoretee;
+  }
+  async execute(params) {
+    let canCreateFolder;
+    if (params.parentId) {
+      const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(params.parentId);
+      canCreateFolder = await this.folderLevelPermissions.canAccessFolder({
+        permissions,
+        rwd: "w"
+      });
+    } else {
+      canCreateFolder = this.folderLevelPermissions.canCreateFolderInRoot();
+    }
+    if (!canCreateFolder) {
+      return Result.fail(new FolderNotAuthorizedError());
+    }
+    const result = await this.decoretee.execute(params);
+    if (result.isFail()) {
+      return Result.fail(result.error);
+    }
+    const folder = result.value;
+
+    // Let's set default permissions based on the current user.
+    const permissionsWithDefaults = await this.folderLevelPermissions.getDefaultPermissions(folder?.permissions ?? []);
+    return Result.ok({
+      ...folder,
+      permissions: permissionsWithDefaults
+    });
+  }
+}
+export const CreateFolderWithFolderLevelPermissions = createDecorator({
+  abstraction: CreateFolderUseCase,
+  decorator: CreateFolderWithFolderLevelPermissionsImpl,
+  dependencies: [FolderLevelPermissions]
+});
+
+//# sourceMappingURL=CreateFolderWithFolderLevelPermissions.js.map

package/features/folder/CreateFolder/decorators/CreateFolderWithFolderLevelPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FolderLevelPermissions","CreateFolderUseCase","createDecorator","Result","FolderNotAuthorizedError","CreateFolderWithFolderLevelPermissionsImpl","constructor","folderLevelPermissions","decoretee","execute","params","canCreateFolder","parentId","permissions","getFolderLevelPermissions","canAccessFolder","rwd","canCreateFolderInRoot","fail","result","isFail","error","folder","value","permissionsWithDefaults","getDefaultPermissions","ok","CreateFolderWithFolderLevelPermissions","abstraction","decorator","dependencies"],"sources":["CreateFolderWithFolderLevelPermissions.ts"],"sourcesContent":["import { FolderLevelPermissions } from \"~/features/flp/FolderLevelPermissions/index.js\";\nimport { CreateFolderUseCase } from \"../abstractions.js\";\nimport type { CreateFolderParams } from \"~/folder/folder.types.js\";\nimport { createDecorator, Result } from \"@webiny/feature/api\";\nimport { FolderNotAuthorizedError } from \"~/domain/folder/errors.js\";\n\nclass CreateFolderWithFolderLevelPermissionsImpl implements CreateFolderUseCase.Interface {\n    private folderLevelPermissions: FolderLevelPermissions.Interface;\n    private readonly decoretee: CreateFolderUseCase.Interface;\n\n    constructor(\n        folderLevelPermissions: FolderLevelPermissions.Interface,\n        decoretee: CreateFolderUseCase.Interface\n    ) {\n        this.folderLevelPermissions = folderLevelPermissions;\n        this.decoretee = decoretee;\n    }\n\n    async execute(params: CreateFolderParams): CreateFolderUseCase.Return {\n        let canCreateFolder: boolean;\n        if (params.parentId) {\n            const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(\n                params.parentId\n            );\n            canCreateFolder = await this.folderLevelPermissions.canAccessFolder({\n                permissions,\n                rwd: \"w\"\n            });\n        } else {\n            canCreateFolder = this.folderLevelPermissions.canCreateFolderInRoot();\n        }\n\n        if (!canCreateFolder) {\n            return Result.fail(new FolderNotAuthorizedError());\n        }\n\n        const result = await this.decoretee.execute(params);\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const folder = result.value;\n\n        // Let's set default permissions based on the current user.\n        const permissionsWithDefaults = await this.folderLevelPermissions.getDefaultPermissions(\n            folder?.permissions ?? []\n        );\n\n        return Result.ok({\n            ...folder,\n            permissions: permissionsWithDefaults\n        });\n    }\n}\n\nexport const CreateFolderWithFolderLevelPermissions = createDecorator({\n    abstraction: CreateFolderUseCase,\n    decorator: CreateFolderWithFolderLevelPermissionsImpl,\n    dependencies: [FolderLevelPermissions]\n});\n"],"mappings":"AAAA,SAASA,sBAAsB;AAC/B,SAASC,mBAAmB;AAE5B,SAASC,eAAe,EAAEC,MAAM,QAAQ,qBAAqB;AAC7D,SAASC,wBAAwB;AAEjC,MAAMC,0CAA0C,CAA0C;EAItFC,WAAWA,CACPC,sBAAwD,EACxDC,SAAwC,EAC1C;IACE,IAAI,CAACD,sBAAsB,GAAGA,sBAAsB;IACpD,IAAI,CAACC,SAAS,GAAGA,SAAS;EAC9B;EAEA,MAAMC,OAAOA,CAACC,MAA0B,EAA8B;IAClE,IAAIC,eAAwB;IAC5B,IAAID,MAAM,CAACE,QAAQ,EAAE;MACjB,MAAMC,WAAW,GAAG,MAAM,IAAI,CAACN,sBAAsB,CAACO,yBAAyB,CAC3EJ,MAAM,CAACE,QACX,CAAC;MACDD,eAAe,GAAG,MAAM,IAAI,CAACJ,sBAAsB,CAACQ,eAAe,CAAC;QAChEF,WAAW;QACXG,GAAG,EAAE;MACT,CAAC,CAAC;IACN,CAAC,MAAM;MACHL,eAAe,GAAG,IAAI,CAACJ,sBAAsB,CAACU,qBAAqB,CAAC,CAAC;IACzE;IAEA,IAAI,CAACN,eAAe,EAAE;MAClB,OAAOR,MAAM,CAACe,IAAI,CAAC,IAAId,wBAAwB,CAAC,CAAC,CAAC;IACtD;IAEA,MAAMe,MAAM,GAAG,MAAM,IAAI,CAACX,SAAS,CAACC,OAAO,CAACC,MAAM,CAAC;IAEnD,IAAIS,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOjB,MAAM,CAACe,IAAI,CAACC,MAAM,CAACE,KAAK,CAAC;IACpC;IAEA,MAAMC,MAAM,GAAGH,MAAM,CAACI,KAAK;;IAE3B;IACA,MAAMC,uBAAuB,GAAG,MAAM,IAAI,CAACjB,sBAAsB,CAACkB,qBAAqB,CACnFH,MAAM,EAAET,WAAW,IAAI,EAC3B,CAAC;IAED,OAAOV,MAAM,CAACuB,EAAE,CAAC;MACb,GAAGJ,MAAM;MACTT,WAAW,EAAEW;IACjB,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMG,sCAAsC,GAAGzB,eAAe,CAAC;EAClE0B,WAAW,EAAE3B,mBAAmB;EAChC4B,SAAS,EAAExB,0CAA0C;EACrDyB,YAAY,EAAE,CAAC9B,sBAAsB;AACzC,CAAC,CAAC","ignoreList":[]}

package/features/folder/CreateFolder/events.d.ts

@@ -0,0 +1,10 @@
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+import type { FolderBeforeCreatePayload, FolderAfterCreatePayload } from "./abstractions.js";
+export declare class FolderBeforeCreateEvent extends DomainEvent<FolderBeforeCreatePayload> {
+    eventType: "folder.beforeCreate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<DomainEvent<FolderBeforeCreatePayload>>>;
+}
+export declare class FolderAfterCreateEvent extends DomainEvent<FolderAfterCreatePayload> {
+    eventType: "folder.afterCreate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<DomainEvent<FolderAfterCreatePayload>>>;
+}

package/features/folder/CreateFolder/events.js

@@ -0,0 +1,19 @@
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+import { FolderBeforeCreateHandler, FolderAfterCreateHandler } from "./abstractions.js";
+// FolderBeforeCreate Event
+export class FolderBeforeCreateEvent extends DomainEvent {
+  eventType = "folder.beforeCreate";
+  getHandlerAbstraction() {
+    return FolderBeforeCreateHandler;
+  }
+}
+
+// FolderAfterCreate Event
+export class FolderAfterCreateEvent extends DomainEvent {
+  eventType = "folder.afterCreate";
+  getHandlerAbstraction() {
+    return FolderAfterCreateHandler;
+  }
+}
+
+//# sourceMappingURL=events.js.map

package/features/folder/CreateFolder/events.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DomainEvent","FolderBeforeCreateHandler","FolderAfterCreateHandler","FolderBeforeCreateEvent","eventType","getHandlerAbstraction","FolderAfterCreateEvent"],"sources":["events.ts"],"sourcesContent":["import { DomainEvent } from \"@webiny/api-core/features/EventPublisher\";\nimport { FolderBeforeCreateHandler, FolderAfterCreateHandler } from \"./abstractions.js\";\nimport type { FolderBeforeCreatePayload, FolderAfterCreatePayload } from \"./abstractions.js\";\n\n// FolderBeforeCreate Event\nexport class FolderBeforeCreateEvent extends DomainEvent<FolderBeforeCreatePayload> {\n    eventType = \"folder.beforeCreate\" as const;\n\n    getHandlerAbstraction() {\n        return FolderBeforeCreateHandler;\n    }\n}\n\n// FolderAfterCreate Event\nexport class FolderAfterCreateEvent extends DomainEvent<FolderAfterCreatePayload> {\n    eventType = \"folder.afterCreate\" as const;\n\n    getHandlerAbstraction() {\n        return FolderAfterCreateHandler;\n    }\n}\n"],"mappings":"AAAA,SAASA,WAAW,QAAQ,0CAA0C;AACtE,SAASC,yBAAyB,EAAEC,wBAAwB;AAG5D;AACA,OAAO,MAAMC,uBAAuB,SAASH,WAAW,CAA4B;EAChFI,SAAS,GAAG,qBAAqB;EAEjCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOJ,yBAAyB;EACpC;AACJ;;AAEA;AACA,OAAO,MAAMK,sBAAsB,SAASN,WAAW,CAA2B;EAC9EI,SAAS,GAAG,oBAAoB;EAEhCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOH,wBAAwB;EACnC;AACJ","ignoreList":[]}

package/features/folder/CreateFolder/feature.d.ts

@@ -0,0 +1 @@
+export declare const CreateFolderFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/folder/CreateFolder/feature.js

@@ -0,0 +1,14 @@
+import { createFeature } from "@webiny/feature/api";
+import { CreateFolderRepository } from "./CreateFolderRepository.js";
+import { CreateFolderUseCase } from "./CreateFolderUseCase.js";
+import { CreateFolderWithFolderLevelPermissions } from "./decorators/CreateFolderWithFolderLevelPermissions.js";
+export const CreateFolderFeature = createFeature({
+  name: "CreateFolder",
+  register(container) {
+    container.register(CreateFolderRepository).inSingletonScope();
+    container.register(CreateFolderUseCase);
+    container.registerDecorator(CreateFolderWithFolderLevelPermissions);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/folder/CreateFolder/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","CreateFolderRepository","CreateFolderUseCase","CreateFolderWithFolderLevelPermissions","CreateFolderFeature","name","register","container","inSingletonScope","registerDecorator"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { CreateFolderRepository } from \"./CreateFolderRepository.js\";\nimport { CreateFolderUseCase } from \"./CreateFolderUseCase.js\";\nimport { CreateFolderWithFolderLevelPermissions } from \"./decorators/CreateFolderWithFolderLevelPermissions.js\";\n\nexport const CreateFolderFeature = createFeature({\n    name: \"CreateFolder\",\n    register(container: Container) {\n        container.register(CreateFolderRepository).inSingletonScope();\n        container.register(CreateFolderUseCase);\n        container.registerDecorator(CreateFolderWithFolderLevelPermissions);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AAEnD,SAASC,sBAAsB;AAC/B,SAASC,mBAAmB;AAC5B,SAASC,sCAAsC;AAE/C,OAAO,MAAMC,mBAAmB,GAAGJ,aAAa,CAAC;EAC7CK,IAAI,EAAE,cAAc;EACpBC,QAAQA,CAACC,SAAoB,EAAE;IAC3BA,SAAS,CAACD,QAAQ,CAACL,sBAAsB,CAAC,CAACO,gBAAgB,CAAC,CAAC;IAC7DD,SAAS,CAACD,QAAQ,CAACJ,mBAAmB,CAAC;IACvCK,SAAS,CAACE,iBAAiB,CAACN,sCAAsC,CAAC;EACvE;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/folder/CreateFolder/index.d.ts

@@ -0,0 +1,2 @@
+export { CreateFolderFeature } from "./feature.js";
+export { FolderAfterCreateHandler, FolderBeforeCreateHandler, CreateFolderUseCase } from "./abstractions.js";

package/features/folder/CreateFolder/index.js

@@ -0,0 +1,4 @@
+export { CreateFolderFeature } from "./feature.js";
+export { FolderAfterCreateHandler, FolderBeforeCreateHandler, CreateFolderUseCase } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

package/features/folder/CreateFolder/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CreateFolderFeature","FolderAfterCreateHandler","FolderBeforeCreateHandler","CreateFolderUseCase"],"sources":["index.ts"],"sourcesContent":["export { CreateFolderFeature } from \"./feature.js\";\nexport {\n    FolderAfterCreateHandler,\n    FolderBeforeCreateHandler,\n    CreateFolderUseCase\n} from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,mBAAmB;AAC5B,SACIC,wBAAwB,EACxBC,yBAAyB,EACzBC,mBAAmB","ignoreList":[]}

package/features/folder/DeleteFolder/DeleteFolderRepository.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteFolderRepository as RepositoryAbstraction, type IDeleteFolderRepository } from "./abstractions.js";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry";
+import { FolderModel } from "../../../domain/folder/abstractions.js";
+import type { Folder } from "../../../folder/folder.types.js";
+declare class DeleteFolderRepositoryImpl implements IDeleteFolderRepository {
+    private deleteEntry;
+    private folderModel;
+    constructor(deleteEntry: DeleteEntryUseCase.Interface, folderModel: FolderModel.Interface);
+    execute(folder: Folder): Promise<Result<void, RepositoryAbstraction.Error>>;
+}
+export declare const DeleteFolderRepository: typeof DeleteFolderRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IDeleteFolderRepository>;
+};
+export {};

package/features/folder/DeleteFolder/DeleteFolderRepository.js

@@ -0,0 +1,30 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteFolderRepository as RepositoryAbstraction } from "./abstractions.js";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry";
+import { FolderModel } from "../../../domain/folder/abstractions.js";
+import { FolderNotAuthorizedError, FolderPersistenceError } from "../../../domain/folder/errors.js";
+class DeleteFolderRepositoryImpl {
+  constructor(deleteEntry, folderModel) {
+    this.deleteEntry = deleteEntry;
+    this.folderModel = folderModel;
+  }
+  async execute(folder) {
+    const result = await this.deleteEntry.execute(this.folderModel, folder.id, {
+      permanently: true,
+      force: true
+    });
+    if (result.isFail()) {
+      if (result.error.code === "Cms/Entry/NotAuthorized") {
+        return Result.fail(new FolderNotAuthorizedError());
+      }
+      return Result.fail(new FolderPersistenceError(result.error));
+    }
+    return Result.ok();
+  }
+}
+export const DeleteFolderRepository = RepositoryAbstraction.createImplementation({
+  implementation: DeleteFolderRepositoryImpl,
+  dependencies: [DeleteEntryUseCase, FolderModel]
+});
+
+//# sourceMappingURL=DeleteFolderRepository.js.map

package/features/folder/DeleteFolder/DeleteFolderRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","DeleteFolderRepository","RepositoryAbstraction","DeleteEntryUseCase","FolderModel","FolderNotAuthorizedError","FolderPersistenceError","DeleteFolderRepositoryImpl","constructor","deleteEntry","folderModel","execute","folder","result","id","permanently","force","isFail","error","code","fail","ok","createImplementation","implementation","dependencies"],"sources":["DeleteFolderRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    DeleteFolderRepository as RepositoryAbstraction,\n    type IDeleteFolderRepository\n} from \"./abstractions.js\";\nimport { DeleteEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry\";\nimport { FolderModel } from \"~/domain/folder/abstractions.js\";\nimport type { Folder } from \"~/folder/folder.types.js\";\nimport { FolderNotAuthorizedError, FolderPersistenceError } from \"~/domain/folder/errors.js\";\n\nclass DeleteFolderRepositoryImpl implements IDeleteFolderRepository {\n    constructor(\n        private deleteEntry: DeleteEntryUseCase.Interface,\n        private folderModel: FolderModel.Interface\n    ) {}\n\n    async execute(folder: Folder): Promise<Result<void, RepositoryAbstraction.Error>> {\n        const result = await this.deleteEntry.execute(this.folderModel, folder.id, {\n            permanently: true,\n            force: true\n        });\n\n        if (result.isFail()) {\n            if (result.error.code === \"Cms/Entry/NotAuthorized\") {\n                return Result.fail(new FolderNotAuthorizedError());\n            }\n            return Result.fail(new FolderPersistenceError(result.error));\n        }\n\n        return Result.ok();\n    }\n}\n\nexport const DeleteFolderRepository = RepositoryAbstraction.createImplementation({\n    implementation: DeleteFolderRepositoryImpl,\n    dependencies: [DeleteEntryUseCase, FolderModel]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SACIC,sBAAsB,IAAIC,qBAAqB;AAGnD,SAASC,kBAAkB,QAAQ,4DAA4D;AAC/F,SAASC,WAAW;AAEpB,SAASC,wBAAwB,EAAEC,sBAAsB;AAEzD,MAAMC,0BAA0B,CAAoC;EAChEC,WAAWA,CACCC,WAAyC,EACzCC,WAAkC,EAC5C;IAAA,KAFUD,WAAyC,GAAzCA,WAAyC;IAAA,KACzCC,WAAkC,GAAlCA,WAAkC;EAC3C;EAEH,MAAMC,OAAOA,CAACC,MAAc,EAAsD;IAC9E,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACJ,WAAW,CAACE,OAAO,CAAC,IAAI,CAACD,WAAW,EAAEE,MAAM,CAACE,EAAE,EAAE;MACvEC,WAAW,EAAE,IAAI;MACjBC,KAAK,EAAE;IACX,CAAC,CAAC;IAEF,IAAIH,MAAM,CAACI,MAAM,CAAC,CAAC,EAAE;MACjB,IAAIJ,MAAM,CAACK,KAAK,CAACC,IAAI,KAAK,yBAAyB,EAAE;QACjD,OAAOnB,MAAM,CAACoB,IAAI,CAAC,IAAIf,wBAAwB,CAAC,CAAC,CAAC;MACtD;MACA,OAAOL,MAAM,CAACoB,IAAI,CAAC,IAAId,sBAAsB,CAACO,MAAM,CAACK,KAAK,CAAC,CAAC;IAChE;IAEA,OAAOlB,MAAM,CAACqB,EAAE,CAAC,CAAC;EACtB;AACJ;AAEA,OAAO,MAAMpB,sBAAsB,GAAGC,qBAAqB,CAACoB,oBAAoB,CAAC;EAC7EC,cAAc,EAAEhB,0BAA0B;EAC1CiB,YAAY,EAAE,CAACrB,kBAAkB,EAAEC,WAAW;AAClD,CAAC,CAAC","ignoreList":[]}