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

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";
+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,55 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import { DeleteFolderUseCase as UseCaseAbstraction, DeleteFolderRepository } from "./abstractions.js";
+import { GetFolderRepository } from "../GetFolder/abstractions.js";
+import { FolderBeforeDeleteEvent, FolderAfterDeleteEvent } 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) {
+    // Get the folder before deletion
+    const getFolderResult = await this.getFolderRepository.execute(id);
+    if (getFolderResult.isFail()) {
+      return Result.fail(getFolderResult.error);
+    }
+    const folder = getFolderResult.value;
+
+    // Publish before delete event
+    const beforeDeleteEvent = new FolderBeforeDeleteEvent({
+      folder
+    });
+    try {
+      await this.eventPublisher.publish(beforeDeleteEvent);
+    } catch (err) {
+      if (err.code === "Aco/Folder/NotEmpty") {
+        return Result.fail(new FolderNotEmptyError());
+      }
+      return Result.fail(new FolderNotAuthorizedError());
+    }
+
+    // Execute the delete operation
+    const result = await this.repository.execute(folder);
+    if (result.isFail()) {
+      return result;
+    }
+
+    // Publish after delete event
+    const afterDeleteEvent = new FolderAfterDeleteEvent({
+      folder
+    });
+    await this.eventPublisher.publish(afterDeleteEvent);
+    return Result.ok();
+  }
+}
+export const DeleteFolderUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: DeleteFolderUseCaseImpl,
+  dependencies: [EventPublisher, GetFolderRepository, DeleteFolderRepository]
+});
+
+//# sourceMappingURL=DeleteFolderUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","EventPublisher","DeleteFolderUseCase","UseCaseAbstraction","DeleteFolderRepository","GetFolderRepository","FolderBeforeDeleteEvent","FolderAfterDeleteEvent","createImplementation","FolderNotAuthorizedError","FolderNotEmptyError","DeleteFolderUseCaseImpl","constructor","eventPublisher","getFolderRepository","repository","execute","id","getFolderResult","isFail","fail","error","folder","value","beforeDeleteEvent","publish","err","code","result","afterDeleteEvent","ok","abstraction","implementation","dependencies"],"sources":["DeleteFolderUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    EventPublisher,\n    EventPublisher as EventPublisherAbstraction\n} from \"@webiny/api-core/features/EventPublisher\";\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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SACIC,cAAc,QAEX,0CAA0C;AACjD,SACIC,mBAAmB,IAAIC,kBAAkB,EACzCC,sBAAsB;AAE1B,SAASC,mBAAmB;AAC5B,SAASC,uBAAuB,EAAEC,sBAAsB;AACxD,SAASC,oBAAoB,QAAQ,YAAY;AACjD,SAASC,wBAAwB,EAAEC,mBAAmB;AAEtD,MAAMC,uBAAuB,CAAyC;EAClEC,WAAWA,CACCC,cAAmD,EACnDC,mBAAkD,EAClDC,UAA4C,EACtD;IAAA,KAHUF,cAAmD,GAAnDA,cAAmD;IAAA,KACnDC,mBAAkD,GAAlDA,mBAAkD;IAAA,KAClDC,UAA4C,GAA5CA,UAA4C;EACrD;EAEH,MAAMC,OAAOA,CAACC,EAAU,EAAmD;IACvE;IACA,MAAMC,eAAe,GAAG,MAAM,IAAI,CAACJ,mBAAmB,CAACE,OAAO,CAACC,EAAE,CAAC;IAElE,IAAIC,eAAe,CAACC,MAAM,CAAC,CAAC,EAAE;MAC1B,OAAOnB,MAAM,CAACoB,IAAI,CAACF,eAAe,CAACG,KAAK,CAAC;IAC7C;IAEA,MAAMC,MAAM,GAAGJ,eAAe,CAACK,KAAK;;IAEpC;IACA,MAAMC,iBAAiB,GAAG,IAAIlB,uBAAuB,CAAC;MAClDgB;IACJ,CAAC,CAAC;IAEF,IAAI;MACA,MAAM,IAAI,CAACT,cAAc,CAACY,OAAO,CAACD,iBAAiB,CAAC;IACxD,CAAC,CAAC,OAAOE,GAAG,EAAE;MACV,IAAIA,GAAG,CAACC,IAAI,KAAK,qBAAqB,EAAE;QACpC,OAAO3B,MAAM,CAACoB,IAAI,CAAC,IAAIV,mBAAmB,CAAC,CAAC,CAAC;MACjD;MACA,OAAOV,MAAM,CAACoB,IAAI,CAAC,IAAIX,wBAAwB,CAAC,CAAC,CAAC;IACtD;;IAEA;IACA,MAAMmB,MAAM,GAAG,MAAM,IAAI,CAACb,UAAU,CAACC,OAAO,CAACM,MAAM,CAAC;IAEpD,IAAIM,MAAM,CAACT,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOS,MAAM;IACjB;;IAEA;IACA,MAAMC,gBAAgB,GAAG,IAAItB,sBAAsB,CAAC;MAChDe;IACJ,CAAC,CAAC;IAEF,MAAM,IAAI,CAACT,cAAc,CAACY,OAAO,CAACI,gBAAgB,CAAC;IAEnD,OAAO7B,MAAM,CAAC8B,EAAE,CAAC,CAAC;EACtB;AACJ;AAEA,OAAO,MAAM5B,mBAAmB,GAAGM,oBAAoB,CAAC;EACpDuB,WAAW,EAAE5B,kBAAkB;EAC/B6B,cAAc,EAAErB,uBAAuB;EACvCsB,YAAY,EAAE,CAAChC,cAAc,EAAEI,mBAAmB,EAAED,sBAAsB;AAC9E,CAAC,CAAC","ignoreList":[]}

package/features/folder/DeleteFolder/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 } 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];
+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];
+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;
+}
+export declare const FolderBeforeDeleteHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<FolderBeforeDeletePayload>>>;
+export declare namespace FolderBeforeDeleteHandler {
+    type Interface = IEventHandler<DomainEvent<FolderBeforeDeletePayload>>;
+    type Event = DomainEvent<FolderBeforeDeletePayload>;
+}
+export declare const FolderAfterDeleteHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<FolderAfterDeletePayload>>>;
+export declare namespace FolderAfterDeleteHandler {
+    type Interface = IEventHandler<DomainEvent<FolderAfterDeletePayload>>;
+    type Event = DomainEvent<FolderAfterDeletePayload>;
+}
+export {};

package/features/folder/DeleteFolder/abstractions.js

@@ -0,0 +1,21 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * DeleteFolder repository interface
+ */
+
+export const DeleteFolderRepository = createAbstraction("DeleteFolderRepository");
+
+/**
+ * DeleteFolder use case interface
+ */
+
+export const DeleteFolderUseCase = createAbstraction("DeleteFolderUseCase");
+
+// Event Payload Types
+
+// Event Handler Abstractions
+export const FolderBeforeDeleteHandler = createAbstraction("FolderBeforeDeleteHandler");
+export const FolderAfterDeleteHandler = createAbstraction("FolderAfterDeleteHandler");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DeleteFolderRepository","DeleteFolderUseCase","FolderBeforeDeleteHandler","FolderAfterDeleteHandler"],"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 } 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\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\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\nexport const FolderBeforeDeleteHandler = createAbstraction<\n    IEventHandler<DomainEvent<FolderBeforeDeletePayload>>\n>(\"FolderBeforeDeleteHandler\");\n\nexport namespace FolderBeforeDeleteHandler {\n    export type Interface = IEventHandler<DomainEvent<FolderBeforeDeletePayload>>;\n    export type Event = DomainEvent<FolderBeforeDeletePayload>;\n}\n\nexport const FolderAfterDeleteHandler = createAbstraction<\n    IEventHandler<DomainEvent<FolderAfterDeletePayload>>\n>(\"FolderAfterDeleteHandler\");\n\nexport namespace FolderAfterDeleteHandler {\n    export type Interface = IEventHandler<DomainEvent<FolderAfterDeletePayload>>;\n    export type Event = DomainEvent<FolderAfterDeletePayload>;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAWvD;AACA;AACA;;AAYA,OAAO,MAAMC,sBAAsB,GAC/BD,iBAAiB,CAA0B,wBAAwB,CAAC;;AAOxE;AACA;AACA;;AAcA,OAAO,MAAME,mBAAmB,GAAGF,iBAAiB,CAAuB,qBAAqB,CAAC;;AAOjG;;AASA;AACA,OAAO,MAAMG,yBAAyB,GAAGH,iBAAiB,CAExD,2BAA2B,CAAC;AAO9B,OAAO,MAAMI,wBAAwB,GAAGJ,iBAAiB,CAEvD,0BAA0B,CAAC","ignoreList":[]}

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").FolderNotFoundError | import("../../../../domain/folder/errors.js").FolderNotAuthorizedError | import("../../../../domain/folder/errors.js").FolderPersistenceError | import("../../../../domain/folder/errors.js").FolderNotEmptyError>>;
+}
+export declare const DeleteFolderWithFolderLevelPermissions: typeof DeleteFolderWithFolderLevelPermissionsImpl;
+export {};

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

@@ -0,0 +1,28 @@
+import { FolderLevelPermissions } from "../../../flp/FolderLevelPermissions/index.js";
+import { DeleteFolderUseCase } from "../abstractions.js";
+import { createDecorator, Result } 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();
+  }
+}
+export const DeleteFolderWithFolderLevelPermissions = createDecorator({
+  abstraction: DeleteFolderUseCase,
+  decorator: DeleteFolderWithFolderLevelPermissionsImpl,
+  dependencies: [FolderLevelPermissions]
+});
+
+//# sourceMappingURL=DeleteFolderWithFolderLevelPermissions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["FolderLevelPermissions","DeleteFolderUseCase","createDecorator","Result","DeleteFolderWithFolderLevelPermissionsImpl","constructor","folderLevelPermissions","decoretee","execute","id","permissions","getFolderLevelPermissions","ensureCanAccessFolder","rwd","result","isFail","fail","error","ok","DeleteFolderWithFolderLevelPermissions","abstraction","decorator","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,sBAAsB;AAC/B,SAASC,mBAAmB;AAC5B,SAASC,eAAe,EAAEC,MAAM,QAAQ,qBAAqB;AAE7D,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,EAAU,EAAE;IACtB,MAAMC,WAAW,GAAG,MAAM,IAAI,CAACJ,sBAAsB,CAACK,yBAAyB,CAACF,EAAE,CAAC;IACnF,MAAM,IAAI,CAACH,sBAAsB,CAACM,qBAAqB,CAAC;MACpDF,WAAW;MACXG,GAAG,EAAE;IACT,CAAC,CAAC;IAEF,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACP,SAAS,CAACC,OAAO,CAACC,EAAE,CAAC;IAE/C,IAAIK,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOZ,MAAM,CAACa,IAAI,CAACF,MAAM,CAACG,KAAK,CAAC;IACpC;IAEA,OAAOd,MAAM,CAACe,EAAE,CAAC,CAAC;EACtB;AACJ;AAEA,OAAO,MAAMC,sCAAsC,GAAGjB,eAAe,CAAC;EAClEkB,WAAW,EAAEnB,mBAAmB;EAChCoB,SAAS,EAAEjB,0CAA0C;EACrDkB,YAAY,EAAE,CAACtB,sBAAsB;AACzC,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,10 @@
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+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").IEventHandler<DomainEvent<FolderBeforeDeletePayload>>>;
+}
+export declare class FolderAfterDeleteEvent extends DomainEvent<FolderAfterDeletePayload> {
+    eventType: "folder.afterDelete";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<DomainEvent<FolderAfterDeletePayload>>>;
+}

package/features/folder/DeleteFolder/events.js

@@ -0,0 +1,19 @@
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+import { FolderBeforeDeleteHandler, FolderAfterDeleteHandler } from "./abstractions.js";
+// FolderBeforeDelete Event
+export class FolderBeforeDeleteEvent extends DomainEvent {
+  eventType = "folder.beforeDelete";
+  getHandlerAbstraction() {
+    return FolderBeforeDeleteHandler;
+  }
+}
+
+// FolderAfterDelete Event
+export class FolderAfterDeleteEvent extends DomainEvent {
+  eventType = "folder.afterDelete";
+  getHandlerAbstraction() {
+    return FolderAfterDeleteHandler;
+  }
+}
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["DomainEvent","FolderBeforeDeleteHandler","FolderAfterDeleteHandler","FolderBeforeDeleteEvent","eventType","getHandlerAbstraction","FolderAfterDeleteEvent"],"sources":["events.ts"],"sourcesContent":["import { DomainEvent } from \"@webiny/api-core/features/EventPublisher\";\nimport { FolderBeforeDeleteHandler, FolderAfterDeleteHandler } 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 FolderBeforeDeleteHandler;\n    }\n}\n\n// FolderAfterDelete Event\nexport class FolderAfterDeleteEvent extends DomainEvent<FolderAfterDeletePayload> {\n    eventType = \"folder.afterDelete\" as const;\n\n    getHandlerAbstraction() {\n        return FolderAfterDeleteHandler;\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/DeleteFolder/feature.d.ts

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

package/features/folder/DeleteFolder/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","DeleteFolderRepository","DeleteFolderUseCase","DeleteFolderWithFolderLevelPermissions","DeleteFolderFeature","name","register","container","inSingletonScope","registerDecorator"],"sources":["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"],"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/DeleteFolder/index.d.ts

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

package/features/folder/DeleteFolder/index.js

@@ -0,0 +1,4 @@
+export { DeleteFolderFeature } from "./feature.js";
+export { FolderAfterDeleteHandler, FolderBeforeDeleteHandler, DeleteFolderUseCase } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

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

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

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,56 @@
+import { FolderLevelPermissions } from "../../flp/FolderLevelPermissions/index.js";
+import { ListFoldersUseCase } from "../ListFolders/index.js";
+import { EnsureFolderIsEmpty as Abstraction } 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
+      });
+      const {
+        folders
+      } = result.value;
+      return folders.length > 0;
+    };
+    const [hasFolders, hasContent] = await Promise.all([hasFoldersCallback(), hasContentCallback()]);
+    if (hasFolders || hasContent) {
+      return Result.fail(new FolderNotEmptyError());
+    }
+
+    // Let's also check if there are folders / content that are not visible because of folder permissions.
+    if (!this.folderLevelPermissions.canUseFolderLevelPermissions()) {
+      // If folder level permissions are not enabled, we can skip this check. This is because
+      // in that case, all folders and content are visible to the user.
+      return Result.ok();
+    }
+    const [hasInvisibleFolders, hasInvisibleContent] = await this.identityContext.withoutAuthorization(async () => {
+      const [hasFolders, hasContent] = await Promise.all([hasFoldersCallback(), hasContentCallback()]);
+      return [hasFolders, hasContent];
+    });
+
+    // In case there are invisible folders or content, we'll throw a different error.
+    // This is to prevent users from deleting folders that contain content they can't see.
+    if (hasInvisibleFolders || hasInvisibleContent) {
+      return Result.fail(new FolderNotAuthorizedError());
+    }
+    return Result.ok();
+  }
+}
+export const EnsureFolderIsEmpty = Abstraction.createImplementation({
+  implementation: EnsureFolderIsEmptyImpl,
+  dependencies: [IdentityContext, FolderLevelPermissions, ListFoldersUseCase]
+});
+
+//# sourceMappingURL=EnsureFolderIsEmpty.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["FolderLevelPermissions","ListFoldersUseCase","EnsureFolderIsEmpty","Abstraction","IdentityContext","FolderNotAuthorizedError","FolderNotEmptyError","Result","EnsureFolderIsEmptyImpl","constructor","identityContext","folderLevelPermissions","listFoldersUseCase","execute","type","id","hasContentCallback","hasFoldersCallback","result","where","parentId","limit","folders","value","length","hasFolders","hasContent","Promise","all","fail","canUseFolderLevelPermissions","ok","hasInvisibleFolders","hasInvisibleContent","withoutAuthorization","createImplementation","implementation","dependencies"],"sources":["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            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"],"mappings":"AAAA,SAASA,sBAAsB;AAC/B,SAASC,kBAAkB;AAC3B,SAASC,mBAAmB,IAAIC,WAAW;AAC3C,SAASC,eAAe,QAAQ,6DAA6D;AAC7F,SAASC,wBAAwB,EAAEC,mBAAmB;AACtD,SAASC,MAAM,QAAQ,qBAAqB;AAE5C,MAAMC,uBAAuB,CAAkC;EAC3DC,WAAWA,CACCC,eAA0C,EAC1CC,sBAAwD,EACxDC,kBAAgD,EAC1D;IAAA,KAHUF,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,sBAAwD,GAAxDA,sBAAwD;IAAA,KACxDC,kBAAgD,GAAhDA,kBAAgD;EACzD;EAEH,MAAMC,OAAOA,CACTC,IAAY,EACZC,EAAU,EACVC,kBAAkD,EAChC;IAClB,MAAMC,kBAAkB,GAAG,MAAAA,CAAA,KAAY;MACnC,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACN,kBAAkB,CAACC,OAAO,CAAC;QACjDM,KAAK,EAAE;UACHL,IAAI;UACJM,QAAQ,EAAEL;QACd,CAAC;QACDM,KAAK,EAAE;MACX,CAAC,CAAC;MAEF,MAAM;QAAEC;MAAQ,CAAC,GAAGJ,MAAM,CAACK,KAAK;MAEhC,OAAOD,OAAO,CAACE,MAAM,GAAG,CAAC;IAC7B,CAAC;IAED,MAAM,CAACC,UAAU,EAAEC,UAAU,CAAC,GAAG,MAAMC,OAAO,CAACC,GAAG,CAAC,CAC/CX,kBAAkB,CAAC,CAAC,EACpBD,kBAAkB,CAAC,CAAC,CACvB,CAAC;IAEF,IAAIS,UAAU,IAAIC,UAAU,EAAE;MAC1B,OAAOnB,MAAM,CAACsB,IAAI,CAAC,IAAIvB,mBAAmB,CAAC,CAAC,CAAC;IACjD;;IAEA;IACA,IAAI,CAAC,IAAI,CAACK,sBAAsB,CAACmB,4BAA4B,CAAC,CAAC,EAAE;MAC7D;MACA;MACA,OAAOvB,MAAM,CAACwB,EAAE,CAAC,CAAC;IACtB;IAEA,MAAM,CAACC,mBAAmB,EAAEC,mBAAmB,CAAC,GAC5C,MAAM,IAAI,CAACvB,eAAe,CAACwB,oBAAoB,CAAC,YAAY;MACxD,MAAM,CAACT,UAAU,EAAEC,UAAU,CAAC,GAAG,MAAMC,OAAO,CAACC,GAAG,CAAC,CAC/CX,kBAAkB,CAAC,CAAC,EACpBD,kBAAkB,CAAC,CAAC,CACvB,CAAC;MACF,OAAO,CAACS,UAAU,EAAEC,UAAU,CAAC;IACnC,CAAC,CAAC;;IAEN;IACA;IACA,IAAIM,mBAAmB,IAAIC,mBAAmB,EAAE;MAC5C,OAAO1B,MAAM,CAACsB,IAAI,CAAC,IAAIxB,wBAAwB,CAAC,CAAC,CAAC;IACtD;IAEA,OAAOE,MAAM,CAACwB,EAAE,CAAC,CAAC;EACtB;AACJ;AAEA,OAAO,MAAM7B,mBAAmB,GAAGC,WAAW,CAACgC,oBAAoB,CAAC;EAChEC,cAAc,EAAE5B,uBAAuB;EACvC6B,YAAY,EAAE,CAACjC,eAAe,EAAEJ,sBAAsB,EAAEC,kBAAkB;AAC9E,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,20 @@
+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];
+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,4 @@
+import { createAbstraction } from "@webiny/feature/api";
+export const EnsureFolderIsEmpty = createAbstraction("EnsureFolderIsEmpty");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","EnsureFolderIsEmpty"],"sources":["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\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"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;AAsB/D,OAAO,MAAMC,mBAAmB,GAAGD,iBAAiB,CAAuB,qBAAqB,CAAC","ignoreList":[]}

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

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

package/features/folder/EnsureFolderIsEmpty/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","EnsureFolderIsEmpty","EnsureFolderIsEmptyFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { EnsureFolderIsEmpty } from \"./EnsureFolderIsEmpty.js\";\n\nexport const EnsureFolderIsEmptyFeature = createFeature({\n    name: \"EnsureFolderIsEmptyFeature\",\n    register(container) {\n        container.register(EnsureFolderIsEmpty);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,mBAAmB;AAE5B,OAAO,MAAMC,0BAA0B,GAAGF,aAAa,CAAC;EACpDG,IAAI,EAAE,4BAA4B;EAClCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,mBAAmB,CAAC;EAC3C;AACJ,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1 @@
+export { EnsureFolderIsEmpty } from "./abstractions.js";

package/features/folder/EnsureFolderIsEmpty/index.js

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

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

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

package/features/folder/EnsureFolderIsEmptyOnDelete/GenericFolderBeforeDeleteHandler.d.ts

@@ -0,0 +1,12 @@
+import { FolderBeforeDeleteHandler } from "../../../features/folder/DeleteFolder/abstractions.js";
+import type { FolderBeforeDeleteEvent } from "../../../features/folder/DeleteFolder/events.js";
+import { EnsureFolderIsEmpty } from "../../../features/folder/EnsureFolderIsEmpty/abstractions.js";
+declare class GenericFolderBeforeDeleteHandlerImpl implements FolderBeforeDeleteHandler.Interface {
+    private ensureFolderIsEmpty;
+    constructor(ensureFolderIsEmpty: EnsureFolderIsEmpty.Interface);
+    handle(event: FolderBeforeDeleteEvent): Promise<void>;
+}
+export declare const GenericFolderBeforeDeleteHandler: typeof GenericFolderBeforeDeleteHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-core/features/EventPublisher").DomainEvent<import("~/features/folder/DeleteFolder/abstractions.js").FolderBeforeDeletePayload>>>;
+};
+export {};

package/features/folder/EnsureFolderIsEmptyOnDelete/GenericFolderBeforeDeleteHandler.js

@@ -0,0 +1,29 @@
+import { WebinyError } from "@webiny/error";
+import { FolderBeforeDeleteHandler } from "../DeleteFolder/abstractions.js";
+import { EnsureFolderIsEmpty } from "../EnsureFolderIsEmpty/abstractions.js";
+class GenericFolderBeforeDeleteHandlerImpl {
+  constructor(ensureFolderIsEmpty) {
+    this.ensureFolderIsEmpty = ensureFolderIsEmpty;
+  }
+  async handle(event) {
+    const {
+      folder
+    } = event.payload;
+    const result = await this.ensureFolderIsEmpty.execute(folder.type, folder.id,
+    // We can only check if a folder has child folders.
+    // Content is controlled by individual apps, so content checks are implemented there.
+    () => false);
+    if (result.isFail()) {
+      throw WebinyError.from(result.error, {
+        message: "Error while ensuring folder is empty before delete.",
+        code: "ACO_BEFORE_FOLDER_DELETE_FILE_HANDLER"
+      });
+    }
+  }
+}
+export const GenericFolderBeforeDeleteHandler = FolderBeforeDeleteHandler.createImplementation({
+  implementation: GenericFolderBeforeDeleteHandlerImpl,
+  dependencies: [EnsureFolderIsEmpty]
+});
+
+//# sourceMappingURL=GenericFolderBeforeDeleteHandler.js.map

package/features/folder/EnsureFolderIsEmptyOnDelete/GenericFolderBeforeDeleteHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","FolderBeforeDeleteHandler","EnsureFolderIsEmpty","GenericFolderBeforeDeleteHandlerImpl","constructor","ensureFolderIsEmpty","handle","event","folder","payload","result","execute","type","id","isFail","from","error","message","code","GenericFolderBeforeDeleteHandler","createImplementation","implementation","dependencies"],"sources":["GenericFolderBeforeDeleteHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { FolderBeforeDeleteHandler } from \"~/features/folder/DeleteFolder/abstractions.js\";\nimport type { FolderBeforeDeleteEvent } from \"~/features/folder/DeleteFolder/events.js\";\nimport { EnsureFolderIsEmpty } from \"~/features/folder/EnsureFolderIsEmpty/abstractions.js\";\n\nclass GenericFolderBeforeDeleteHandlerImpl implements FolderBeforeDeleteHandler.Interface {\n    constructor(private ensureFolderIsEmpty: EnsureFolderIsEmpty.Interface) {}\n\n    async handle(event: FolderBeforeDeleteEvent): Promise<void> {\n        const { folder } = event.payload;\n\n        const result = await this.ensureFolderIsEmpty.execute(\n            folder.type,\n            folder.id,\n            // We can only check if a folder has child folders.\n            // Content is controlled by individual apps, so content checks are implemented there.\n            () => false\n        );\n\n        if (result.isFail()) {\n            throw WebinyError.from(result.error, {\n                message: \"Error while ensuring folder is empty before delete.\",\n                code: \"ACO_BEFORE_FOLDER_DELETE_FILE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const GenericFolderBeforeDeleteHandler = FolderBeforeDeleteHandler.createImplementation({\n    implementation: GenericFolderBeforeDeleteHandlerImpl,\n    dependencies: [EnsureFolderIsEmpty]\n});\n"],"mappings":"AAAA,SAASA,WAAW,QAAQ,eAAe;AAC3C,SAASC,yBAAyB;AAElC,SAASC,mBAAmB;AAE5B,MAAMC,oCAAoC,CAAgD;EACtFC,WAAWA,CAASC,mBAAkD,EAAE;IAAA,KAApDA,mBAAkD,GAAlDA,mBAAkD;EAAG;EAEzE,MAAMC,MAAMA,CAACC,KAA8B,EAAiB;IACxD,MAAM;MAAEC;IAAO,CAAC,GAAGD,KAAK,CAACE,OAAO;IAEhC,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACL,mBAAmB,CAACM,OAAO,CACjDH,MAAM,CAACI,IAAI,EACXJ,MAAM,CAACK,EAAE;IACT;IACA;IACA,MAAM,KACV,CAAC;IAED,IAAIH,MAAM,CAACI,MAAM,CAAC,CAAC,EAAE;MACjB,MAAMd,WAAW,CAACe,IAAI,CAACL,MAAM,CAACM,KAAK,EAAE;QACjCC,OAAO,EAAE,qDAAqD;QAC9DC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,gCAAgC,GAAGlB,yBAAyB,CAACmB,oBAAoB,CAAC;EAC3FC,cAAc,EAAElB,oCAAoC;EACpDmB,YAAY,EAAE,CAACpB,mBAAmB;AACtC,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,7 @@
+/**
+ * This feature checks whether a folder is allowed to be deleted.
+ * This generic check simply checks if there are child folders within the given folder.
+ * Actual content cannot be checked, as folders do not have information about their records.
+ * Individual apps (like File Manager, Headless CMS, etc.) need to implement their own event handlers.
+ */
+export declare const EnsureFolderIsEmptyOnDeleteFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/folder/EnsureFolderIsEmptyOnDelete/feature.js

@@ -0,0 +1,17 @@
+import { createFeature } from "@webiny/feature/api";
+import { GenericFolderBeforeDeleteHandler } from "./GenericFolderBeforeDeleteHandler.js";
+
+/**
+ * This feature checks whether a folder is allowed to be deleted.
+ * This generic check simply checks if there are child folders within the given folder.
+ * Actual content cannot be checked, as folders do not have information about their records.
+ * Individual apps (like File Manager, Headless CMS, etc.) need to implement their own event handlers.
+ */
+export const EnsureFolderIsEmptyOnDeleteFeature = createFeature({
+  name: "EnsureFolderIsEmptyOnDelete",
+  register(container) {
+    container.register(GenericFolderBeforeDeleteHandler);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GenericFolderBeforeDeleteHandler","EnsureFolderIsEmptyOnDeleteFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GenericFolderBeforeDeleteHandler } from \"./GenericFolderBeforeDeleteHandler.js\";\n\n/**\n * This feature checks whether a folder is allowed to be deleted.\n * This generic check simply checks if there are child folders within the given folder.\n * Actual content cannot be checked, as folders do not have information about their records.\n * Individual apps (like File Manager, Headless CMS, etc.) need to implement their own event handlers.\n */\nexport const EnsureFolderIsEmptyOnDeleteFeature = createFeature({\n    name: \"EnsureFolderIsEmptyOnDelete\",\n    register(container) {\n        container.register(GenericFolderBeforeDeleteHandler);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,gCAAgC;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,kCAAkC,GAAGF,aAAa,CAAC;EAC5DG,IAAI,EAAE,6BAA6B;EACnCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,gCAAgC,CAAC;EACxD;AACJ,CAAC,CAAC","ignoreList":[]}

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

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

package/features/folder/EnsureFolderIsEmptyOnDelete/index.js

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

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

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

package/features/folder/EnsureHcmsFolderIsEmptyOnDelete/ModelFolderBeforeDeleteHandler.d.ts

@@ -0,0 +1,16 @@
+import { FolderBeforeDeleteHandler } from "../../../features/folder/DeleteFolder/abstractions.js";
+import type { FolderBeforeDeleteEvent } from "../../../features/folder/DeleteFolder/events.js";
+import { EnsureFolderIsEmpty } from "../../../features/folder/EnsureFolderIsEmpty/abstractions.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { ListEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries/abstractions.js";
+declare class ModelFolderBeforeDeleteHandlerImpl implements FolderBeforeDeleteHandler.Interface {
+    private ensureFolderIsEmpty;
+    private getModel;
+    private listEntries;
+    constructor(ensureFolderIsEmpty: EnsureFolderIsEmpty.Interface, getModel: GetModelUseCase.Interface, listEntries: ListEntriesUseCase.Interface);
+    handle(event: FolderBeforeDeleteEvent): Promise<void>;
+}
+export declare const ModelFolderBeforeDeleteHandler: typeof ModelFolderBeforeDeleteHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-core/features/EventPublisher").DomainEvent<import("~/features/folder/DeleteFolder/abstractions.js").FolderBeforeDeletePayload>>>;
+};
+export {};