@webiny/api-aco 0.0.0-unstable.b14eaecf38 → 0.0.0-unstable.b6d7105cee

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

@@ -0,0 +1,39 @@
+import { FolderLevelPermissions } from "../../../flp/FolderLevelPermissions/index.js";
+import { CreateFolderUseCase } from "../abstractions.js";
+import { Result, createDecorator } 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;
+        const permissionsWithDefaults = await this.folderLevelPermissions.getDefaultPermissions(folder?.permissions ?? []);
+        return Result.ok({
+            ...folder,
+            permissions: permissionsWithDefaults
+        });
+    }
+}
+const CreateFolderWithFolderLevelPermissions = createDecorator({
+    abstraction: CreateFolderUseCase,
+    decorator: CreateFolderWithFolderLevelPermissionsImpl,
+    dependencies: [
+        FolderLevelPermissions
+    ]
+});
+export { CreateFolderWithFolderLevelPermissions };
+
+//# sourceMappingURL=CreateFolderWithFolderLevelPermissions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/CreateFolder/decorators/CreateFolderWithFolderLevelPermissions.js","sources":["../../../../../src/features/folder/CreateFolder/decorators/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"],"names":["CreateFolderWithFolderLevelPermissionsImpl","folderLevelPermissions","decoretee","params","canCreateFolder","permissions","Result","FolderNotAuthorizedError","result","folder","permissionsWithDefaults","CreateFolderWithFolderLevelPermissions","createDecorator","CreateFolderUseCase","FolderLevelPermissions"],"mappings":";;;;AAMA,MAAMA;IAIF,YACIC,sBAAwD,EACxDC,SAAwC,CAC1C;QACE,IAAI,CAAC,sBAAsB,GAAGD;QAC9B,IAAI,CAAC,SAAS,GAAGC;IACrB;IAEA,MAAM,QAAQC,MAA0B,EAA8B;QAClE,IAAIC;QACJ,IAAID,OAAO,QAAQ,EAAE;YACjB,MAAME,cAAc,MAAM,IAAI,CAAC,sBAAsB,CAAC,yBAAyB,CAC3EF,OAAO,QAAQ;YAEnBC,kBAAkB,MAAM,IAAI,CAAC,sBAAsB,CAAC,eAAe,CAAC;gBAChEC;gBACA,KAAK;YACT;QACJ,OACID,kBAAkB,IAAI,CAAC,sBAAsB,CAAC,qBAAqB;QAGvE,IAAI,CAACA,iBACD,OAAOE,OAAO,IAAI,CAAC,IAAIC;QAG3B,MAAMC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACL;QAE5C,IAAIK,OAAO,MAAM,IACb,OAAOF,OAAO,IAAI,CAACE,OAAO,KAAK;QAGnC,MAAMC,SAASD,OAAO,KAAK;QAG3B,MAAME,0BAA0B,MAAM,IAAI,CAAC,sBAAsB,CAAC,qBAAqB,CACnFD,QAAQ,eAAe,EAAE;QAG7B,OAAOH,OAAO,EAAE,CAAC;YACb,GAAGG,MAAM;YACT,aAAaC;QACjB;IACJ;AACJ;AAEO,MAAMC,yCAAyCC,gBAAgB;IAClE,aAAaC;IACb,WAAWb;IACX,cAAc;QAACc;KAAuB;AAC1C"}

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

@@ -0,0 +1,10 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+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/abstractions.js").IEventHandler<DomainEvent<FolderBeforeCreatePayload>>>;
+}
+export declare class FolderAfterCreateEvent extends DomainEvent<FolderAfterCreatePayload> {
+    eventType: "folder.afterCreate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<DomainEvent<FolderAfterCreatePayload>>>;
+}

package/features/folder/CreateFolder/events.js

@@ -0,0 +1,21 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { FolderAfterCreateEventHandler, FolderBeforeCreateEventHandler } from "./abstractions.js";
+class FolderBeforeCreateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return FolderBeforeCreateEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "folder.beforeCreate";
+    }
+}
+class FolderAfterCreateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return FolderAfterCreateEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "folder.afterCreate";
+    }
+}
+export { FolderAfterCreateEvent, FolderBeforeCreateEvent };
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/CreateFolder/events.js","sources":["../../../../src/features/folder/CreateFolder/events.ts"],"sourcesContent":["import { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { FolderBeforeCreateEventHandler, FolderAfterCreateEventHandler } 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 FolderBeforeCreateEventHandler;\n    }\n}\n\n// FolderAfterCreate Event\nexport class FolderAfterCreateEvent extends DomainEvent<FolderAfterCreatePayload> {\n    eventType = \"folder.afterCreate\" as const;\n\n    getHandlerAbstraction() {\n        return FolderAfterCreateEventHandler;\n    }\n}\n"],"names":["FolderBeforeCreateEvent","DomainEvent","FolderBeforeCreateEventHandler","FolderAfterCreateEvent","FolderAfterCreateEventHandler"],"mappings":";;AAKO,MAAMA,gCAAgCC;IAGzC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAGO,MAAMC,+BAA+BF;IAGxC,wBAAwB;QACpB,OAAOG;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB"}

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

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

package/features/folder/CreateFolder/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/CreateFolder/feature.js","sources":["../../../../src/features/folder/CreateFolder/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"],"names":["CreateFolderFeature","createFeature","container","CreateFolderRepository","CreateFolderUseCase","CreateFolderWithFolderLevelPermissions"],"mappings":";;;;AAMO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC,wBAAwB,gBAAgB;QAC3DD,UAAU,QAAQ,CAACE;QACnBF,UAAU,iBAAiB,CAACG;IAChC;AACJ"}

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

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

package/features/folder/CreateFolder/index.js

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

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,32 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteFolderRepository } 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 ("Cms/Entry/NotAuthorized" === result.error.code) return Result.fail(new FolderNotAuthorizedError());
+            return Result.fail(new FolderPersistenceError(result.error));
+        }
+        return Result.ok();
+    }
+}
+const DeleteFolderRepository_DeleteFolderRepository = DeleteFolderRepository.createImplementation({
+    implementation: DeleteFolderRepositoryImpl,
+    dependencies: [
+        DeleteEntryUseCase,
+        FolderModel
+    ]
+});
+export { DeleteFolderRepository_DeleteFolderRepository as DeleteFolderRepository };
+
+//# sourceMappingURL=DeleteFolderRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/DeleteFolder/DeleteFolderRepository.js","sources":["../../../../src/features/folder/DeleteFolder/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"],"names":["DeleteFolderRepositoryImpl","deleteEntry","folderModel","folder","result","Result","FolderNotAuthorizedError","FolderPersistenceError","DeleteFolderRepository","RepositoryAbstraction","DeleteEntryUseCase","FolderModel"],"mappings":";;;;;AAUA,MAAMA;IACF,YACYC,WAAyC,EACzCC,WAAkC,CAC5C;aAFUD,WAAW,GAAXA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,QAAQC,MAAc,EAAsD;QAC9E,MAAMC,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,EAAED,OAAO,EAAE,EAAE;YACvE,aAAa;YACb,OAAO;QACX;QAEA,IAAIC,OAAO,MAAM,IAAI;YACjB,IAAIA,AAAsB,8BAAtBA,OAAO,KAAK,CAAC,IAAI,EACjB,OAAOC,OAAO,IAAI,CAAC,IAAIC;YAE3B,OAAOD,OAAO,IAAI,CAAC,IAAIE,uBAAuBH,OAAO,KAAK;QAC9D;QAEA,OAAOC,OAAO,EAAE;IACpB;AACJ;AAEO,MAAMG,gDAAyBC,uBAAAA,oBAA0C,CAAC;IAC7E,gBAAgBT;IAChB,cAAc;QAACU;QAAoBC;KAAY;AACnD"}

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

@@ -0,0 +1,13 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher as EventPublisherAbstraction } from "@webiny/api-core/features/eventPublisher/index.js";
+import { DeleteFolderUseCase as UseCaseAbstraction, DeleteFolderRepository } from "./abstractions.js";
+import { GetFolderRepository } from "../GetFolder/abstractions.js";
+declare class DeleteFolderUseCaseImpl implements UseCaseAbstraction.Interface {
+    private eventPublisher;
+    private getFolderRepository;
+    private repository;
+    constructor(eventPublisher: EventPublisherAbstraction.Interface, getFolderRepository: GetFolderRepository.Interface, repository: DeleteFolderRepository.Interface);
+    execute(id: string): Promise<Result<void, UseCaseAbstraction.Error>>;
+}
+export declare const DeleteFolderUseCase: import("@webiny/di").Implementation<typeof DeleteFolderUseCaseImpl>;
+export {};

package/features/folder/DeleteFolder/DeleteFolderUseCase.js

@@ -0,0 +1,47 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { DeleteFolderRepository, DeleteFolderUseCase } from "./abstractions.js";
+import { GetFolderRepository } from "../GetFolder/abstractions.js";
+import { FolderAfterDeleteEvent, FolderBeforeDeleteEvent } from "./events.js";
+import { createImplementation } from "@webiny/di";
+import { FolderNotAuthorizedError, FolderNotEmptyError } from "../../../domain/folder/errors.js";
+class DeleteFolderUseCaseImpl {
+    constructor(eventPublisher, getFolderRepository, repository){
+        this.eventPublisher = eventPublisher;
+        this.getFolderRepository = getFolderRepository;
+        this.repository = repository;
+    }
+    async execute(id) {
+        const getFolderResult = await this.getFolderRepository.execute(id);
+        if (getFolderResult.isFail()) return Result.fail(getFolderResult.error);
+        const folder = getFolderResult.value;
+        const beforeDeleteEvent = new FolderBeforeDeleteEvent({
+            folder
+        });
+        try {
+            await this.eventPublisher.publish(beforeDeleteEvent);
+        } catch (err) {
+            if ("Aco/Folder/NotEmpty" === err.code) return Result.fail(new FolderNotEmptyError());
+            return Result.fail(new FolderNotAuthorizedError());
+        }
+        const result = await this.repository.execute(folder);
+        if (result.isFail()) return result;
+        const afterDeleteEvent = new FolderAfterDeleteEvent({
+            folder
+        });
+        await this.eventPublisher.publish(afterDeleteEvent);
+        return Result.ok();
+    }
+}
+const DeleteFolderUseCase_DeleteFolderUseCase = createImplementation({
+    abstraction: DeleteFolderUseCase,
+    implementation: DeleteFolderUseCaseImpl,
+    dependencies: [
+        EventPublisher,
+        GetFolderRepository,
+        DeleteFolderRepository
+    ]
+});
+export { DeleteFolderUseCase_DeleteFolderUseCase as DeleteFolderUseCase };
+
+//# sourceMappingURL=DeleteFolderUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/DeleteFolder/DeleteFolderUseCase.js","sources":["../../../../src/features/folder/DeleteFolder/DeleteFolderUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    EventPublisher,\n    EventPublisher as EventPublisherAbstraction\n} from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport {\n    DeleteFolderUseCase as UseCaseAbstraction,\n    DeleteFolderRepository\n} from \"./abstractions.js\";\nimport { GetFolderRepository } from \"../GetFolder/abstractions.js\";\nimport { FolderBeforeDeleteEvent, FolderAfterDeleteEvent } from \"./events.js\";\nimport { createImplementation } from \"@webiny/di\";\nimport { FolderNotAuthorizedError, FolderNotEmptyError } from \"~/domain/folder/errors.js\";\n\nclass DeleteFolderUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private eventPublisher: EventPublisherAbstraction.Interface,\n        private getFolderRepository: GetFolderRepository.Interface,\n        private repository: DeleteFolderRepository.Interface\n    ) {}\n\n    async execute(id: string): Promise<Result<void, UseCaseAbstraction.Error>> {\n        // Get the folder before deletion\n        const getFolderResult = await this.getFolderRepository.execute(id);\n\n        if (getFolderResult.isFail()) {\n            return Result.fail(getFolderResult.error);\n        }\n\n        const folder = getFolderResult.value;\n\n        // Publish before delete event\n        const beforeDeleteEvent = new FolderBeforeDeleteEvent({\n            folder\n        });\n\n        try {\n            await this.eventPublisher.publish(beforeDeleteEvent);\n        } catch (err) {\n            if (err.code === \"Aco/Folder/NotEmpty\") {\n                return Result.fail(new FolderNotEmptyError());\n            }\n            return Result.fail(new FolderNotAuthorizedError());\n        }\n\n        // Execute the delete operation\n        const result = await this.repository.execute(folder);\n\n        if (result.isFail()) {\n            return result;\n        }\n\n        // Publish after delete event\n        const afterDeleteEvent = new FolderAfterDeleteEvent({\n            folder\n        });\n\n        await this.eventPublisher.publish(afterDeleteEvent);\n\n        return Result.ok();\n    }\n}\n\nexport const DeleteFolderUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: DeleteFolderUseCaseImpl,\n    dependencies: [EventPublisher, GetFolderRepository, DeleteFolderRepository]\n});\n"],"names":["DeleteFolderUseCaseImpl","eventPublisher","getFolderRepository","repository","id","getFolderResult","Result","folder","beforeDeleteEvent","FolderBeforeDeleteEvent","err","FolderNotEmptyError","FolderNotAuthorizedError","result","afterDeleteEvent","FolderAfterDeleteEvent","DeleteFolderUseCase","createImplementation","UseCaseAbstraction","EventPublisher","GetFolderRepository","DeleteFolderRepository"],"mappings":";;;;;;;AAcA,MAAMA;IACF,YACYC,cAAmD,EACnDC,mBAAkD,EAClDC,UAA4C,CACtD;aAHUF,cAAc,GAAdA;aACAC,mBAAmB,GAAnBA;aACAC,UAAU,GAAVA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAmD;QAEvE,MAAMC,kBAAkB,MAAM,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAACD;QAE/D,IAAIC,gBAAgB,MAAM,IACtB,OAAOC,OAAO,IAAI,CAACD,gBAAgB,KAAK;QAG5C,MAAME,SAASF,gBAAgB,KAAK;QAGpC,MAAMG,oBAAoB,IAAIC,wBAAwB;YAClDF;QACJ;QAEA,IAAI;YACA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAACC;QACtC,EAAE,OAAOE,KAAK;YACV,IAAIA,AAAa,0BAAbA,IAAI,IAAI,EACR,OAAOJ,OAAO,IAAI,CAAC,IAAIK;YAE3B,OAAOL,OAAO,IAAI,CAAC,IAAIM;QAC3B;QAGA,MAAMC,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACN;QAE7C,IAAIM,OAAO,MAAM,IACb,OAAOA;QAIX,MAAMC,mBAAmB,IAAIC,uBAAuB;YAChDR;QACJ;QAEA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAACO;QAElC,OAAOR,OAAO,EAAE;IACpB;AACJ;AAEO,MAAMU,0CAAsBC,qBAAqB;IACpD,aAAaC;IACb,gBAAgBlB;IAChB,cAAc;QAACmB;QAAgBC;QAAqBC;KAAuB;AAC/E"}

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

@@ -0,0 +1,59 @@
+import type { Result } from "@webiny/feature/api";
+import type { DomainEvent, IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { Folder } from "../../../folder/folder.types.js";
+import { type FolderNotAuthorizedError, FolderNotEmptyError, type FolderNotFoundError, type FolderPersistenceError } from "../../../domain/folder/errors.js";
+/**
+ * DeleteFolder repository interface
+ */
+export interface IDeleteFolderRepository {
+    execute(folder: Folder): Promise<Result<void, RepositoryError>>;
+}
+export interface IDeleteFolderRepositoryErrors {
+    notAuthorized: FolderNotAuthorizedError;
+    persistence: FolderPersistenceError;
+}
+type RepositoryError = IDeleteFolderRepositoryErrors[keyof IDeleteFolderRepositoryErrors];
+/** Persist folder deletion. */
+export declare const DeleteFolderRepository: import("@webiny/di").Abstraction<IDeleteFolderRepository>;
+export declare namespace DeleteFolderRepository {
+    type Interface = IDeleteFolderRepository;
+    type Error = RepositoryError;
+}
+/**
+ * DeleteFolder use case interface
+ */
+export interface IDeleteFolderUseCase {
+    execute(id: string): Promise<Result<void, UseCaseError>>;
+}
+export interface IDeleteFolderUseCaseErrors {
+    notAuthorized: FolderNotAuthorizedError;
+    notFound: FolderNotFoundError;
+    notEmpty: FolderNotEmptyError;
+    persistence: FolderPersistenceError;
+}
+type UseCaseError = IDeleteFolderUseCaseErrors[keyof IDeleteFolderUseCaseErrors];
+/** Delete a folder. */
+export declare const DeleteFolderUseCase: import("@webiny/di").Abstraction<IDeleteFolderUseCase>;
+export declare namespace DeleteFolderUseCase {
+    type Interface = IDeleteFolderUseCase;
+    type Error = UseCaseError;
+}
+export interface FolderBeforeDeletePayload {
+    folder: Folder;
+}
+export interface FolderAfterDeletePayload {
+    folder: Folder;
+}
+/** Hook into folder lifecycle before a folder is deleted. */
+export declare const FolderBeforeDeleteEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<FolderBeforeDeletePayload>>>;
+export declare namespace FolderBeforeDeleteEventHandler {
+    type Interface = IEventHandler<DomainEvent<FolderBeforeDeletePayload>>;
+    type Event = DomainEvent<FolderBeforeDeletePayload>;
+}
+/** Hook into folder lifecycle after a folder is deleted. */
+export declare const FolderAfterDeleteEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<FolderAfterDeletePayload>>>;
+export declare namespace FolderAfterDeleteEventHandler {
+    type Interface = IEventHandler<DomainEvent<FolderAfterDeletePayload>>;
+    type Event = DomainEvent<FolderAfterDeletePayload>;
+}
+export {};

package/features/folder/DeleteFolder/abstractions.js

@@ -0,0 +1,8 @@
+import { createAbstraction } from "@webiny/feature/api";
+const DeleteFolderRepository = createAbstraction("DeleteFolderRepository");
+const DeleteFolderUseCase = createAbstraction("DeleteFolderUseCase");
+const FolderBeforeDeleteEventHandler = createAbstraction("FolderBeforeDeleteEventHandler");
+const FolderAfterDeleteEventHandler = createAbstraction("FolderAfterDeleteEventHandler");
+export { DeleteFolderRepository, DeleteFolderUseCase, FolderAfterDeleteEventHandler, FolderBeforeDeleteEventHandler };
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/DeleteFolder/abstractions.js","sources":["../../../../src/features/folder/DeleteFolder/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/index.js\";\nimport type { Folder } from \"~/folder/folder.types.js\";\nimport {\n    type FolderNotAuthorizedError,\n    FolderNotEmptyError,\n    type FolderNotFoundError,\n    type FolderPersistenceError\n} from \"~/domain/folder/errors.js\";\n\n/**\n * DeleteFolder repository interface\n */\nexport interface IDeleteFolderRepository {\n    execute(folder: Folder): Promise<Result<void, RepositoryError>>;\n}\n\nexport interface IDeleteFolderRepositoryErrors {\n    notAuthorized: FolderNotAuthorizedError;\n    persistence: FolderPersistenceError;\n}\n\ntype RepositoryError = IDeleteFolderRepositoryErrors[keyof IDeleteFolderRepositoryErrors];\n\n/** Persist folder deletion. */\nexport const DeleteFolderRepository =\n    createAbstraction<IDeleteFolderRepository>(\"DeleteFolderRepository\");\n\nexport namespace DeleteFolderRepository {\n    export type Interface = IDeleteFolderRepository;\n    export type Error = RepositoryError;\n}\n\n/**\n * DeleteFolder use case interface\n */\nexport interface IDeleteFolderUseCase {\n    execute(id: string): Promise<Result<void, UseCaseError>>;\n}\n\nexport interface IDeleteFolderUseCaseErrors {\n    notAuthorized: FolderNotAuthorizedError;\n    notFound: FolderNotFoundError;\n    notEmpty: FolderNotEmptyError;\n    persistence: FolderPersistenceError;\n}\n\ntype UseCaseError = IDeleteFolderUseCaseErrors[keyof IDeleteFolderUseCaseErrors];\n\n/** Delete a folder. */\nexport const DeleteFolderUseCase = createAbstraction<IDeleteFolderUseCase>(\"DeleteFolderUseCase\");\n\nexport namespace DeleteFolderUseCase {\n    export type Interface = IDeleteFolderUseCase;\n    export type Error = UseCaseError;\n}\n\n// Event Payload Types\nexport interface FolderBeforeDeletePayload {\n    folder: Folder;\n}\n\nexport interface FolderAfterDeletePayload {\n    folder: Folder;\n}\n\n// Event Handler Abstractions\n/** Hook into folder lifecycle before a folder is deleted. */\nexport const FolderBeforeDeleteEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<FolderBeforeDeletePayload>>\n>(\"FolderBeforeDeleteEventHandler\");\n\nexport namespace FolderBeforeDeleteEventHandler {\n    export type Interface = IEventHandler<DomainEvent<FolderBeforeDeletePayload>>;\n    export type Event = DomainEvent<FolderBeforeDeletePayload>;\n}\n\n/** Hook into folder lifecycle after a folder is deleted. */\nexport const FolderAfterDeleteEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<FolderAfterDeletePayload>>\n>(\"FolderAfterDeleteEventHandler\");\n\nexport namespace FolderAfterDeleteEventHandler {\n    export type Interface = IEventHandler<DomainEvent<FolderAfterDeletePayload>>;\n    export type Event = DomainEvent<FolderAfterDeletePayload>;\n}\n"],"names":["DeleteFolderRepository","createAbstraction","DeleteFolderUseCase","FolderBeforeDeleteEventHandler","FolderAfterDeleteEventHandler"],"mappings":";AA0BO,MAAMA,yBACTC,kBAA2C;AAwBxC,MAAMC,sBAAsBD,kBAAwC;AAkBpE,MAAME,iCAAiCF,kBAE5C;AAQK,MAAMG,gCAAgCH,kBAE3C"}

package/features/folder/DeleteFolder/decorators/DeleteFolderWithFolderLevelPermissions.d.ts

@@ -0,0 +1,11 @@
+import { FolderLevelPermissions } from "../../../../features/flp/FolderLevelPermissions/index.js";
+import { DeleteFolderUseCase } from "../abstractions.js";
+import { Result } from "@webiny/feature/api";
+declare class DeleteFolderWithFolderLevelPermissionsImpl implements DeleteFolderUseCase.Interface {
+    private folderLevelPermissions;
+    private readonly decoretee;
+    constructor(folderLevelPermissions: FolderLevelPermissions.Interface, decoretee: DeleteFolderUseCase.Interface);
+    execute(id: string): Promise<Result<void, never> | Result<never, import("../../../../domain/folder/errors.js").FolderNotAuthorizedError | import("../../../../domain/folder/errors.js").FolderNotEmptyError | import("../../../../domain/folder/errors.js").FolderNotFoundError | import("../../../../domain/folder/errors.js").FolderPersistenceError>>;
+}
+export declare const DeleteFolderWithFolderLevelPermissions: typeof DeleteFolderWithFolderLevelPermissionsImpl;
+export {};

package/features/folder/DeleteFolder/decorators/DeleteFolderWithFolderLevelPermissions.js

@@ -0,0 +1,29 @@
+import { FolderLevelPermissions } from "../../../flp/FolderLevelPermissions/index.js";
+import { DeleteFolderUseCase } from "../abstractions.js";
+import { Result, createDecorator } from "@webiny/feature/api";
+class DeleteFolderWithFolderLevelPermissionsImpl {
+    constructor(folderLevelPermissions, decoretee){
+        this.folderLevelPermissions = folderLevelPermissions;
+        this.decoretee = decoretee;
+    }
+    async execute(id) {
+        const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(id);
+        await this.folderLevelPermissions.ensureCanAccessFolder({
+            permissions,
+            rwd: "d"
+        });
+        const result = await this.decoretee.execute(id);
+        if (result.isFail()) return Result.fail(result.error);
+        return Result.ok();
+    }
+}
+const DeleteFolderWithFolderLevelPermissions = createDecorator({
+    abstraction: DeleteFolderUseCase,
+    decorator: DeleteFolderWithFolderLevelPermissionsImpl,
+    dependencies: [
+        FolderLevelPermissions
+    ]
+});
+export { DeleteFolderWithFolderLevelPermissions };
+
+//# sourceMappingURL=DeleteFolderWithFolderLevelPermissions.js.map

package/features/folder/DeleteFolder/decorators/DeleteFolderWithFolderLevelPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/DeleteFolder/decorators/DeleteFolderWithFolderLevelPermissions.js","sources":["../../../../../src/features/folder/DeleteFolder/decorators/DeleteFolderWithFolderLevelPermissions.ts"],"sourcesContent":["import { FolderLevelPermissions } from \"~/features/flp/FolderLevelPermissions/index.js\";\nimport { DeleteFolderUseCase } from \"../abstractions.js\";\nimport { createDecorator, Result } from \"@webiny/feature/api\";\n\nclass DeleteFolderWithFolderLevelPermissionsImpl implements DeleteFolderUseCase.Interface {\n    private folderLevelPermissions: FolderLevelPermissions.Interface;\n    private readonly decoretee: DeleteFolderUseCase.Interface;\n\n    constructor(\n        folderLevelPermissions: FolderLevelPermissions.Interface,\n        decoretee: DeleteFolderUseCase.Interface\n    ) {\n        this.folderLevelPermissions = folderLevelPermissions;\n        this.decoretee = decoretee;\n    }\n\n    async execute(id: string) {\n        const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(id);\n        await this.folderLevelPermissions.ensureCanAccessFolder({\n            permissions,\n            rwd: \"d\"\n        });\n\n        const result = await this.decoretee.execute(id);\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        return Result.ok();\n    }\n}\n\nexport const DeleteFolderWithFolderLevelPermissions = createDecorator({\n    abstraction: DeleteFolderUseCase,\n    decorator: DeleteFolderWithFolderLevelPermissionsImpl,\n    dependencies: [FolderLevelPermissions]\n});\n"],"names":["DeleteFolderWithFolderLevelPermissionsImpl","folderLevelPermissions","decoretee","id","permissions","result","Result","DeleteFolderWithFolderLevelPermissions","createDecorator","DeleteFolderUseCase","FolderLevelPermissions"],"mappings":";;;AAIA,MAAMA;IAIF,YACIC,sBAAwD,EACxDC,SAAwC,CAC1C;QACE,IAAI,CAAC,sBAAsB,GAAGD;QAC9B,IAAI,CAAC,SAAS,GAAGC;IACrB;IAEA,MAAM,QAAQC,EAAU,EAAE;QACtB,MAAMC,cAAc,MAAM,IAAI,CAAC,sBAAsB,CAAC,yBAAyB,CAACD;QAChF,MAAM,IAAI,CAAC,sBAAsB,CAAC,qBAAqB,CAAC;YACpDC;YACA,KAAK;QACT;QAEA,MAAMC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACF;QAE5C,IAAIE,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAACD,OAAO,KAAK;QAGnC,OAAOC,OAAO,EAAE;IACpB;AACJ;AAEO,MAAMC,yCAAyCC,gBAAgB;IAClE,aAAaC;IACb,WAAWT;IACX,cAAc;QAACU;KAAuB;AAC1C"}

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

@@ -0,0 +1,10 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { FolderBeforeDeletePayload, FolderAfterDeletePayload } from "./abstractions.js";
+export declare class FolderBeforeDeleteEvent extends DomainEvent<FolderBeforeDeletePayload> {
+    eventType: "folder.beforeDelete";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<DomainEvent<FolderBeforeDeletePayload>>>;
+}
+export declare class FolderAfterDeleteEvent extends DomainEvent<FolderAfterDeletePayload> {
+    eventType: "folder.afterDelete";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<DomainEvent<FolderAfterDeletePayload>>>;
+}

package/features/folder/DeleteFolder/events.js

@@ -0,0 +1,21 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { FolderAfterDeleteEventHandler, FolderBeforeDeleteEventHandler } from "./abstractions.js";
+class FolderBeforeDeleteEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return FolderBeforeDeleteEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "folder.beforeDelete";
+    }
+}
+class FolderAfterDeleteEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return FolderAfterDeleteEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "folder.afterDelete";
+    }
+}
+export { FolderAfterDeleteEvent, FolderBeforeDeleteEvent };
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/DeleteFolder/events.js","sources":["../../../../src/features/folder/DeleteFolder/events.ts"],"sourcesContent":["import { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { FolderBeforeDeleteEventHandler, FolderAfterDeleteEventHandler } from \"./abstractions.js\";\nimport type { FolderBeforeDeletePayload, FolderAfterDeletePayload } from \"./abstractions.js\";\n\n// FolderBeforeDelete Event\nexport class FolderBeforeDeleteEvent extends DomainEvent<FolderBeforeDeletePayload> {\n    eventType = \"folder.beforeDelete\" as const;\n\n    getHandlerAbstraction() {\n        return FolderBeforeDeleteEventHandler;\n    }\n}\n\n// FolderAfterDelete Event\nexport class FolderAfterDeleteEvent extends DomainEvent<FolderAfterDeletePayload> {\n    eventType = \"folder.afterDelete\" as const;\n\n    getHandlerAbstraction() {\n        return FolderAfterDeleteEventHandler;\n    }\n}\n"],"names":["FolderBeforeDeleteEvent","DomainEvent","FolderBeforeDeleteEventHandler","FolderAfterDeleteEvent","FolderAfterDeleteEventHandler"],"mappings":";;AAKO,MAAMA,gCAAgCC;IAGzC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAGO,MAAMC,+BAA+BF;IAGxC,wBAAwB;QACpB,OAAOG;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB"}

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

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

package/features/folder/DeleteFolder/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { DeleteFolderRepository } from "./DeleteFolderRepository.js";
+import { DeleteFolderUseCase } from "./DeleteFolderUseCase.js";
+import { DeleteFolderWithFolderLevelPermissions } from "./decorators/DeleteFolderWithFolderLevelPermissions.js";
+const DeleteFolderFeature = createFeature({
+    name: "DeleteFolder",
+    register (container) {
+        container.register(DeleteFolderRepository).inSingletonScope();
+        container.register(DeleteFolderUseCase);
+        container.registerDecorator(DeleteFolderWithFolderLevelPermissions);
+    }
+});
+export { DeleteFolderFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/DeleteFolder/feature.js","sources":["../../../../src/features/folder/DeleteFolder/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { DeleteFolderRepository } from \"./DeleteFolderRepository.js\";\nimport { DeleteFolderUseCase } from \"./DeleteFolderUseCase.js\";\nimport { DeleteFolderWithFolderLevelPermissions } from \"./decorators/DeleteFolderWithFolderLevelPermissions.js\";\n\nexport const DeleteFolderFeature = createFeature({\n    name: \"DeleteFolder\",\n    register(container: Container) {\n        container.register(DeleteFolderRepository).inSingletonScope();\n        container.register(DeleteFolderUseCase);\n        container.registerDecorator(DeleteFolderWithFolderLevelPermissions);\n    }\n});\n"],"names":["DeleteFolderFeature","createFeature","container","DeleteFolderRepository","DeleteFolderUseCase","DeleteFolderWithFolderLevelPermissions"],"mappings":";;;;AAMO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC,wBAAwB,gBAAgB;QAC3DD,UAAU,QAAQ,CAACE;QACnBF,UAAU,iBAAiB,CAACG;IAChC;AACJ"}

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

@@ -0,0 +1,2 @@
+export { DeleteFolderFeature } from "./feature.js";
+export { FolderAfterDeleteEventHandler, FolderBeforeDeleteEventHandler, DeleteFolderUseCase } from "./abstractions.js";

package/features/folder/DeleteFolder/index.js

@@ -0,0 +1,2 @@
+export { DeleteFolderFeature } from "./feature.js";
+export { DeleteFolderUseCase, FolderAfterDeleteEventHandler, FolderBeforeDeleteEventHandler } from "./abstractions.js";

package/features/folder/EnsureFolderIsEmpty/EnsureFolderIsEmpty.d.ts

@@ -0,0 +1,15 @@
+import { FolderLevelPermissions } from "../../../features/flp/FolderLevelPermissions/index.js";
+import { ListFoldersUseCase } from "../../../features/folder/ListFolders/index.js";
+import { EnsureFolderIsEmpty as Abstraction } from "../../../features/folder/EnsureFolderIsEmpty/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+declare class EnsureFolderIsEmptyImpl implements Abstraction.Interface {
+    private identityContext;
+    private folderLevelPermissions;
+    private listFoldersUseCase;
+    constructor(identityContext: IdentityContext.Interface, folderLevelPermissions: FolderLevelPermissions.Interface, listFoldersUseCase: ListFoldersUseCase.Interface);
+    execute(type: string, id: string, hasContentCallback: Abstraction.HasContentCallback): Abstraction.Return;
+}
+export declare const EnsureFolderIsEmpty: typeof EnsureFolderIsEmptyImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/features/folder/EnsureFolderIsEmpty/abstractions.js").IEnsureFolderIsEmpty>;
+};
+export {};

package/features/folder/EnsureFolderIsEmpty/EnsureFolderIsEmpty.js

@@ -0,0 +1,59 @@
+import { FolderLevelPermissions } from "../../flp/FolderLevelPermissions/index.js";
+import { ListFoldersUseCase } from "../ListFolders/index.js";
+import { EnsureFolderIsEmpty } from "./abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { FolderNotAuthorizedError, FolderNotEmptyError } from "../../../domain/folder/errors.js";
+import { Result } from "@webiny/feature/api";
+class EnsureFolderIsEmptyImpl {
+    constructor(identityContext, folderLevelPermissions, listFoldersUseCase){
+        this.identityContext = identityContext;
+        this.folderLevelPermissions = folderLevelPermissions;
+        this.listFoldersUseCase = listFoldersUseCase;
+    }
+    async execute(type, id, hasContentCallback) {
+        const hasFoldersCallback = async ()=>{
+            const result = await this.listFoldersUseCase.execute({
+                where: {
+                    type,
+                    parentId: id
+                },
+                limit: 1
+            });
+            if (result.isFail()) {
+                console.error(result.error.message);
+                return true;
+            }
+            const { folders } = result.value;
+            return folders.length > 0;
+        };
+        const [hasFolders, hasContent] = await Promise.all([
+            hasFoldersCallback(),
+            hasContentCallback()
+        ]);
+        if (hasFolders || hasContent) return Result.fail(new FolderNotEmptyError());
+        if (!this.folderLevelPermissions.canUseFolderLevelPermissions()) return Result.ok();
+        const [hasInvisibleFolders, hasInvisibleContent] = await this.identityContext.withoutAuthorization(async ()=>{
+            const [hasFolders, hasContent] = await Promise.all([
+                hasFoldersCallback(),
+                hasContentCallback()
+            ]);
+            return [
+                hasFolders,
+                hasContent
+            ];
+        });
+        if (hasInvisibleFolders || hasInvisibleContent) return Result.fail(new FolderNotAuthorizedError());
+        return Result.ok();
+    }
+}
+const EnsureFolderIsEmpty_EnsureFolderIsEmpty = EnsureFolderIsEmpty.createImplementation({
+    implementation: EnsureFolderIsEmptyImpl,
+    dependencies: [
+        IdentityContext,
+        FolderLevelPermissions,
+        ListFoldersUseCase
+    ]
+});
+export { EnsureFolderIsEmpty_EnsureFolderIsEmpty as EnsureFolderIsEmpty };
+
+//# sourceMappingURL=EnsureFolderIsEmpty.js.map

package/features/folder/EnsureFolderIsEmpty/EnsureFolderIsEmpty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/EnsureFolderIsEmpty/EnsureFolderIsEmpty.js","sources":["../../../../src/features/folder/EnsureFolderIsEmpty/EnsureFolderIsEmpty.ts"],"sourcesContent":["import { FolderLevelPermissions } from \"~/features/flp/FolderLevelPermissions/index.js\";\nimport { ListFoldersUseCase } from \"~/features/folder/ListFolders/index.js\";\nimport { EnsureFolderIsEmpty as Abstraction } from \"~/features/folder/EnsureFolderIsEmpty/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { FolderNotAuthorizedError, FolderNotEmptyError } from \"~/domain/folder/errors.js\";\nimport { Result } from \"@webiny/feature/api\";\n\nclass EnsureFolderIsEmptyImpl implements Abstraction.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private folderLevelPermissions: FolderLevelPermissions.Interface,\n        private listFoldersUseCase: ListFoldersUseCase.Interface\n    ) {}\n\n    async execute(\n        type: string,\n        id: string,\n        hasContentCallback: Abstraction.HasContentCallback\n    ): Abstraction.Return {\n        const hasFoldersCallback = async () => {\n            const result = await this.listFoldersUseCase.execute({\n                where: {\n                    type,\n                    parentId: id\n                },\n                limit: 1\n            });\n\n            if (result.isFail()) {\n                console.error(result.error.message);\n                return true;\n            }\n\n            const { folders } = result.value;\n\n            return folders.length > 0;\n        };\n\n        const [hasFolders, hasContent] = await Promise.all([\n            hasFoldersCallback(),\n            hasContentCallback()\n        ]);\n\n        if (hasFolders || hasContent) {\n            return Result.fail(new FolderNotEmptyError());\n        }\n\n        // Let's also check if there are folders / content that are not visible because of folder permissions.\n        if (!this.folderLevelPermissions.canUseFolderLevelPermissions()) {\n            // If folder level permissions are not enabled, we can skip this check. This is because\n            // in that case, all folders and content are visible to the user.\n            return Result.ok();\n        }\n\n        const [hasInvisibleFolders, hasInvisibleContent] =\n            await this.identityContext.withoutAuthorization(async () => {\n                const [hasFolders, hasContent] = await Promise.all([\n                    hasFoldersCallback(),\n                    hasContentCallback()\n                ]);\n                return [hasFolders, hasContent];\n            });\n\n        // In case there are invisible folders or content, we'll throw a different error.\n        // This is to prevent users from deleting folders that contain content they can't see.\n        if (hasInvisibleFolders || hasInvisibleContent) {\n            return Result.fail(new FolderNotAuthorizedError());\n        }\n\n        return Result.ok();\n    }\n}\n\nexport const EnsureFolderIsEmpty = Abstraction.createImplementation({\n    implementation: EnsureFolderIsEmptyImpl,\n    dependencies: [IdentityContext, FolderLevelPermissions, ListFoldersUseCase]\n});\n"],"names":["EnsureFolderIsEmptyImpl","identityContext","folderLevelPermissions","listFoldersUseCase","type","id","hasContentCallback","hasFoldersCallback","result","console","folders","hasFolders","hasContent","Promise","Result","FolderNotEmptyError","hasInvisibleFolders","hasInvisibleContent","FolderNotAuthorizedError","EnsureFolderIsEmpty","Abstraction","IdentityContext","FolderLevelPermissions","ListFoldersUseCase"],"mappings":";;;;;;AAOA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,sBAAwD,EACxDC,kBAAgD,CAC1D;aAHUF,eAAe,GAAfA;aACAC,sBAAsB,GAAtBA;aACAC,kBAAkB,GAAlBA;IACT;IAEH,MAAM,QACFC,IAAY,EACZC,EAAU,EACVC,kBAAkD,EAChC;QAClB,MAAMC,qBAAqB;YACvB,MAAMC,SAAS,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;gBACjD,OAAO;oBACHJ;oBACA,UAAUC;gBACd;gBACA,OAAO;YACX;YAEA,IAAIG,OAAO,MAAM,IAAI;gBACjBC,QAAQ,KAAK,CAACD,OAAO,KAAK,CAAC,OAAO;gBAClC,OAAO;YACX;YAEA,MAAM,EAAEE,OAAO,EAAE,GAAGF,OAAO,KAAK;YAEhC,OAAOE,QAAQ,MAAM,GAAG;QAC5B;QAEA,MAAM,CAACC,YAAYC,WAAW,GAAG,MAAMC,QAAQ,GAAG,CAAC;YAC/CN;YACAD;SACH;QAED,IAAIK,cAAcC,YACd,OAAOE,OAAO,IAAI,CAAC,IAAIC;QAI3B,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,4BAA4B,IAGzD,OAAOD,OAAO,EAAE;QAGpB,MAAM,CAACE,qBAAqBC,oBAAoB,GAC5C,MAAM,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC;YAC5C,MAAM,CAACN,YAAYC,WAAW,GAAG,MAAMC,QAAQ,GAAG,CAAC;gBAC/CN;gBACAD;aACH;YACD,OAAO;gBAACK;gBAAYC;aAAW;QACnC;QAIJ,IAAII,uBAAuBC,qBACvB,OAAOH,OAAO,IAAI,CAAC,IAAII;QAG3B,OAAOJ,OAAO,EAAE;IACpB;AACJ;AAEO,MAAMK,0CAAsBC,oBAAAA,oBAAgC,CAAC;IAChE,gBAAgBpB;IAChB,cAAc;QAACqB;QAAiBC;QAAwBC;KAAmB;AAC/E"}

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

@@ -0,0 +1,21 @@
+import { Result } from "@webiny/feature/api";
+import { FolderNotAuthorizedError, FolderNotEmptyError } from "../../../domain/folder/errors.js";
+export interface IHasContentCallback {
+    (): boolean | Promise<boolean>;
+}
+export interface IEnsureFolderIsEmpty {
+    execute(type: string, id: string, hasContentCallback: IHasContentCallback): Promise<Result<void, UseCaseError>>;
+}
+export interface IEnsureFolderIsEmptyError {
+    notAuthorized: FolderNotAuthorizedError;
+    notEmpty: FolderNotEmptyError;
+}
+type UseCaseError = IEnsureFolderIsEmptyError[keyof IEnsureFolderIsEmptyError];
+/** Verify a folder has no children before deletion. */
+export declare const EnsureFolderIsEmpty: import("@webiny/di").Abstraction<IEnsureFolderIsEmpty>;
+export declare namespace EnsureFolderIsEmpty {
+    type Interface = IEnsureFolderIsEmpty;
+    type HasContentCallback = IHasContentCallback;
+    type Return = Promise<Result<void, UseCaseError>>;
+}
+export {};

package/features/folder/EnsureFolderIsEmpty/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/EnsureFolderIsEmpty/abstractions.js","sources":["../../../../src/features/folder/EnsureFolderIsEmpty/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport { FolderNotAuthorizedError, FolderNotEmptyError } from \"~/domain/folder/errors.js\";\n\nexport interface IHasContentCallback {\n    (): boolean | Promise<boolean>;\n}\n\nexport interface IEnsureFolderIsEmpty {\n    execute(\n        type: string,\n        id: string,\n        hasContentCallback: IHasContentCallback\n    ): Promise<Result<void, UseCaseError>>;\n}\n\nexport interface IEnsureFolderIsEmptyError {\n    notAuthorized: FolderNotAuthorizedError;\n    notEmpty: FolderNotEmptyError;\n}\n\ntype UseCaseError = IEnsureFolderIsEmptyError[keyof IEnsureFolderIsEmptyError];\n\n/** Verify a folder has no children before deletion. */\nexport const EnsureFolderIsEmpty = createAbstraction<IEnsureFolderIsEmpty>(\"EnsureFolderIsEmpty\");\n\nexport namespace EnsureFolderIsEmpty {\n    export type Interface = IEnsureFolderIsEmpty;\n    export type HasContentCallback = IHasContentCallback;\n    export type Return = Promise<Result<void, UseCaseError>>;\n}\n"],"names":["EnsureFolderIsEmpty","createAbstraction"],"mappings":";AAuBO,MAAMA,sBAAsBC,kBAAwC"}

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

@@ -0,0 +1,4 @@
+export declare const EnsureFolderIsEmptyFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/folder/EnsureFolderIsEmpty/feature.js

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