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

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 {};

package/features/folder/EnsureHcmsFolderIsEmptyOnDelete/ModelFolderBeforeDeleteHandler.js

@@ -0,0 +1,56 @@
+import { WebinyError } from "@webiny/error";
+import { FolderBeforeDeleteHandler } from "../DeleteFolder/abstractions.js";
+import { EnsureFolderIsEmpty } from "../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";
+class ModelFolderBeforeDeleteHandlerImpl {
+  constructor(ensureFolderIsEmpty, getModel, listEntries) {
+    this.ensureFolderIsEmpty = ensureFolderIsEmpty;
+    this.getModel = getModel;
+    this.listEntries = listEntries;
+  }
+  async handle(event) {
+    const {
+      folder
+    } = event.payload;
+    const {
+      id,
+      type
+    } = folder;
+    const modelId = type.split(":")[1];
+    if (!modelId) {
+      return;
+    }
+    const modelResult = await this.getModel.execute(modelId);
+    if (modelResult.isFail()) {
+      return;
+    }
+    const result = await this.ensureFolderIsEmpty.execute(type, id, async () => {
+      const result = await this.listEntries.execute(modelResult.value, {
+        where: {
+          latest: true,
+          wbyAco_location: {
+            folderId: id
+          }
+        },
+        limit: 1
+      });
+      const {
+        entries
+      } = result.value;
+      return entries.length > 0;
+    });
+    if (result.isFail()) {
+      throw WebinyError.from(result.error, {
+        message: "Error while ensuring HCMS folder is empty before delete.",
+        code: "ACO_BEFORE_FOLDER_DELETE_HCMS_HANDLER"
+      });
+    }
+  }
+}
+export const ModelFolderBeforeDeleteHandler = FolderBeforeDeleteHandler.createImplementation({
+  implementation: ModelFolderBeforeDeleteHandlerImpl,
+  dependencies: [EnsureFolderIsEmpty, GetModelUseCase, ListEntriesUseCase]
+});
+
+//# sourceMappingURL=ModelFolderBeforeDeleteHandler.js.map

package/features/folder/EnsureHcmsFolderIsEmptyOnDelete/ModelFolderBeforeDeleteHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebinyError","FolderBeforeDeleteHandler","EnsureFolderIsEmpty","GetModelUseCase","ListEntriesUseCase","ModelFolderBeforeDeleteHandlerImpl","constructor","ensureFolderIsEmpty","getModel","listEntries","handle","event","folder","payload","id","type","modelId","split","modelResult","execute","isFail","result","value","where","latest","wbyAco_location","folderId","limit","entries","length","from","error","message","code","ModelFolderBeforeDeleteHandler","createImplementation","implementation","dependencies"],"sources":["ModelFolderBeforeDeleteHandler.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\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { ListEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries/abstractions.js\";\n\nclass ModelFolderBeforeDeleteHandlerImpl implements FolderBeforeDeleteHandler.Interface {\n    constructor(\n        private ensureFolderIsEmpty: EnsureFolderIsEmpty.Interface,\n        private getModel: GetModelUseCase.Interface,\n        private listEntries: ListEntriesUseCase.Interface\n    ) {}\n\n    async handle(event: FolderBeforeDeleteEvent): Promise<void> {\n        const { folder } = event.payload;\n\n        const { id, type } = folder;\n\n        const modelId = type.split(\":\")[1];\n        if (!modelId) {\n            return;\n        }\n\n        const modelResult = await this.getModel.execute(modelId);\n        if (modelResult.isFail()) {\n            return;\n        }\n\n        const result = await this.ensureFolderIsEmpty.execute(type, id, async () => {\n            const result = await this.listEntries.execute(modelResult.value, {\n                where: {\n                    latest: true,\n                    wbyAco_location: {\n                        folderId: id\n                    }\n                },\n                limit: 1\n            });\n\n            const { entries } = result.value;\n\n            return entries.length > 0;\n        });\n\n        if (result.isFail()) {\n            throw WebinyError.from(result.error, {\n                message: \"Error while ensuring HCMS folder is empty before delete.\",\n                code: \"ACO_BEFORE_FOLDER_DELETE_HCMS_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const ModelFolderBeforeDeleteHandler = FolderBeforeDeleteHandler.createImplementation({\n    implementation: ModelFolderBeforeDeleteHandlerImpl,\n    dependencies: [EnsureFolderIsEmpty, GetModelUseCase, ListEntriesUseCase]\n});\n"],"mappings":"AAAA,SAASA,WAAW,QAAQ,eAAe;AAC3C,SAASC,yBAAyB;AAElC,SAASC,mBAAmB;AAC5B,SAASC,eAAe,QAAQ,kEAAkE;AAClG,SAASC,kBAAkB,QAAQ,4EAA4E;AAE/G,MAAMC,kCAAkC,CAAgD;EACpFC,WAAWA,CACCC,mBAAkD,EAClDC,QAAmC,EACnCC,WAAyC,EACnD;IAAA,KAHUF,mBAAkD,GAAlDA,mBAAkD;IAAA,KAClDC,QAAmC,GAAnCA,QAAmC;IAAA,KACnCC,WAAyC,GAAzCA,WAAyC;EAClD;EAEH,MAAMC,MAAMA,CAACC,KAA8B,EAAiB;IACxD,MAAM;MAAEC;IAAO,CAAC,GAAGD,KAAK,CAACE,OAAO;IAEhC,MAAM;MAAEC,EAAE;MAAEC;IAAK,CAAC,GAAGH,MAAM;IAE3B,MAAMI,OAAO,GAAGD,IAAI,CAACE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAClC,IAAI,CAACD,OAAO,EAAE;MACV;IACJ;IAEA,MAAME,WAAW,GAAG,MAAM,IAAI,CAACV,QAAQ,CAACW,OAAO,CAACH,OAAO,CAAC;IACxD,IAAIE,WAAW,CAACE,MAAM,CAAC,CAAC,EAAE;MACtB;IACJ;IAEA,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACd,mBAAmB,CAACY,OAAO,CAACJ,IAAI,EAAED,EAAE,EAAE,YAAY;MACxE,MAAMO,MAAM,GAAG,MAAM,IAAI,CAACZ,WAAW,CAACU,OAAO,CAACD,WAAW,CAACI,KAAK,EAAE;QAC7DC,KAAK,EAAE;UACHC,MAAM,EAAE,IAAI;UACZC,eAAe,EAAE;YACbC,QAAQ,EAAEZ;UACd;QACJ,CAAC;QACDa,KAAK,EAAE;MACX,CAAC,CAAC;MAEF,MAAM;QAAEC;MAAQ,CAAC,GAAGP,MAAM,CAACC,KAAK;MAEhC,OAAOM,OAAO,CAACC,MAAM,GAAG,CAAC;IAC7B,CAAC,CAAC;IAEF,IAAIR,MAAM,CAACD,MAAM,CAAC,CAAC,EAAE;MACjB,MAAMpB,WAAW,CAAC8B,IAAI,CAACT,MAAM,CAACU,KAAK,EAAE;QACjCC,OAAO,EAAE,0DAA0D;QACnEC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ;AACJ;AAEA,OAAO,MAAMC,8BAA8B,GAAGjC,yBAAyB,CAACkC,oBAAoB,CAAC;EACzFC,cAAc,EAAE/B,kCAAkC;EAClDgC,YAAY,EAAE,CAACnC,mBAAmB,EAAEC,eAAe,EAAEC,kBAAkB;AAC3E,CAAC,CAAC","ignoreList":[]}

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

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

package/features/folder/EnsureHcmsFolderIsEmptyOnDelete/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","ModelFolderBeforeDeleteHandler","EnsureHcmsFolderIsEmptyOnDeleteFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ModelFolderBeforeDeleteHandler } from \"./ModelFolderBeforeDeleteHandler.js\";\n\nexport const EnsureHcmsFolderIsEmptyOnDeleteFeature = createFeature({\n    name: \"EnsureHcmsFolderIsEmptyOnDelete\",\n    register(container) {\n        container.register(ModelFolderBeforeDeleteHandler);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,8BAA8B;AAEvC,OAAO,MAAMC,sCAAsC,GAAGF,aAAa,CAAC;EAChEG,IAAI,EAAE,iCAAiC;EACvCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,8BAA8B,CAAC;EACtD;AACJ,CAAC,CAAC","ignoreList":[]}

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

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

package/features/folder/EnsureHcmsFolderIsEmptyOnDelete/index.js

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

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

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

package/features/folder/GetAncestors/GetAncestorsRepository.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+import { type GetAncestorsParams, GetAncestorsRepository as RepositoryAbstraction, type IGetAncestorsRepository } from "./abstractions.js";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { FolderModel } from "../../../domain/folder/abstractions.js";
+import type { Folder } from "../../../folder/folder.types.js";
+declare class GetAncestorsRepositoryImpl implements IGetAncestorsRepository {
+    private listLatestEntries;
+    private folderModel;
+    constructor(listLatestEntries: ListLatestEntriesUseCase.Interface, folderModel: FolderModel.Interface);
+    execute(params: GetAncestorsParams): Promise<Result<Folder[], RepositoryAbstraction.Error>>;
+}
+export declare const GetAncestorsRepository: typeof GetAncestorsRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IGetAncestorsRepository>;
+};
+export {};

package/features/folder/GetAncestors/GetAncestorsRepository.js

@@ -0,0 +1,88 @@
+import { Result } from "@webiny/feature/api";
+import { GetAncestorsRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { FolderModel } from "../../../domain/folder/abstractions.js";
+import { EntryToFolderMapper } from "../shared/EntryToFolderMapper.js";
+import { FolderPersistenceError } from "../../../domain/folder/errors.js";
+import { ROOT_FOLDER } from "../../../constants.js";
+class GetAncestorsRepositoryImpl {
+  constructor(listLatestEntries, folderModel) {
+    this.listLatestEntries = listLatestEntries;
+    this.folderModel = folderModel;
+  }
+  async execute(params) {
+    const {
+      folder
+    } = params;
+
+    // No folder found: return an empty array
+    if (!folder) {
+      return Result.ok([]);
+    }
+
+    // The folder has no parent (it's at root level): return an array with the folder
+    if (!folder.parentId) {
+      return Result.ok([folder]);
+    }
+
+    // Construct paths for all ancestors of the folder
+    const parts = folder.path.split("/").slice(1);
+    const paths = parts.map((_, index) => {
+      return [ROOT_FOLDER, ...parts.slice(0, index + 1)].join("/");
+    });
+
+    // Retrieve all folders that match the specified type and any of the constructed paths
+    const result = await this.listLatestEntries.execute(this.folderModel, {
+      where: {
+        values: {
+          type: folder.type,
+          path_in: paths
+        }
+      }
+    });
+    if (result.isFail()) {
+      return Result.fail(new FolderPersistenceError(result.error));
+    }
+    const {
+      entries
+    } = result.value;
+    const folders = entries.map(entry => EntryToFolderMapper.toFolder(entry));
+
+    // Create a Map with folders, using folder.id as key
+    const folderMap = new Map();
+    folders.forEach(f => folderMap.set(f.id, f));
+    const findParents = (next, current) => {
+      // No folder found: return the result
+      if (!current) {
+        return next;
+      }
+
+      // Push the current folder into the accumulator array
+      next.push(current);
+
+      // No parentId found: return the result
+      if (!current.parentId) {
+        return next;
+      }
+      const parent = folderMap.get(current.parentId);
+
+      // No parent found: return the result
+      if (!parent) {
+        return next;
+      }
+
+      // Go ahead and find parent for the current parent
+      return findParents(next, parent);
+    };
+
+    // Recursively find parents for a given folder id
+    const ancestors = findParents([], folder);
+    return Result.ok(ancestors);
+  }
+}
+export const GetAncestorsRepository = RepositoryAbstraction.createImplementation({
+  implementation: GetAncestorsRepositoryImpl,
+  dependencies: [ListLatestEntriesUseCase, FolderModel]
+});
+
+//# sourceMappingURL=GetAncestorsRepository.js.map

package/features/folder/GetAncestors/GetAncestorsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","GetAncestorsRepository","RepositoryAbstraction","ListLatestEntriesUseCase","FolderModel","EntryToFolderMapper","FolderPersistenceError","ROOT_FOLDER","GetAncestorsRepositoryImpl","constructor","listLatestEntries","folderModel","execute","params","folder","ok","parentId","parts","path","split","slice","paths","map","_","index","join","result","where","values","type","path_in","isFail","fail","error","entries","value","folders","entry","toFolder","folderMap","Map","forEach","f","set","id","findParents","next","current","push","parent","get","ancestors","createImplementation","implementation","dependencies"],"sources":["GetAncestorsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    type GetAncestorsParams,\n    GetAncestorsRepository as RepositoryAbstraction,\n    type IGetAncestorsRepository\n} from \"./abstractions.js\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport { FolderModel } from \"~/domain/folder/abstractions.js\";\nimport type { CmsEntryFolder, Folder } from \"~/folder/folder.types.js\";\nimport { EntryToFolderMapper } from \"../shared/EntryToFolderMapper.js\";\nimport { FolderPersistenceError } from \"~/domain/folder/errors.js\";\nimport { ROOT_FOLDER } from \"~/constants.js\";\n\nclass GetAncestorsRepositoryImpl implements IGetAncestorsRepository {\n    constructor(\n        private listLatestEntries: ListLatestEntriesUseCase.Interface,\n        private folderModel: FolderModel.Interface\n    ) {}\n\n    async execute(\n        params: GetAncestorsParams\n    ): Promise<Result<Folder[], RepositoryAbstraction.Error>> {\n        const { folder } = params;\n\n        // No folder found: return an empty array\n        if (!folder) {\n            return Result.ok([]);\n        }\n\n        // The folder has no parent (it's at root level): return an array with the folder\n        if (!folder.parentId) {\n            return Result.ok([folder]);\n        }\n\n        // Construct paths for all ancestors of the folder\n        const parts = folder.path.split(\"/\").slice(1);\n        const paths = parts.map((_, index) => {\n            return [ROOT_FOLDER, ...parts.slice(0, index + 1)].join(\"/\");\n        });\n\n        // Retrieve all folders that match the specified type and any of the constructed paths\n        const result = await this.listLatestEntries.execute<CmsEntryFolder>(this.folderModel, {\n            where: {\n                values: {\n                    type: folder.type,\n                    path_in: paths\n                }\n            }\n        });\n\n        if (result.isFail()) {\n            return Result.fail(new FolderPersistenceError(result.error));\n        }\n\n        const { entries } = result.value;\n        const folders = entries.map(entry => EntryToFolderMapper.toFolder(entry));\n\n        // Create a Map with folders, using folder.id as key\n        const folderMap = new Map<string, Folder>();\n        folders.forEach(f => folderMap.set(f.id, f));\n\n        const findParents = (next: Folder[], current: Folder): Folder[] => {\n            // No folder found: return the result\n            if (!current) {\n                return next;\n            }\n\n            // Push the current folder into the accumulator array\n            next.push(current);\n\n            // No parentId found: return the result\n            if (!current.parentId) {\n                return next;\n            }\n\n            const parent = folderMap.get(current.parentId);\n\n            // No parent found: return the result\n            if (!parent) {\n                return next;\n            }\n\n            // Go ahead and find parent for the current parent\n            return findParents(next, parent);\n        };\n\n        // Recursively find parents for a given folder id\n        const ancestors = findParents([], folder);\n        return Result.ok(ancestors);\n    }\n}\n\nexport const GetAncestorsRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetAncestorsRepositoryImpl,\n    dependencies: [ListLatestEntriesUseCase, FolderModel]\n});\n"],"mappings":"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","ignoreList":[]}

package/features/folder/GetAncestors/GetAncestorsUseCase.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "@webiny/feature/api";
+import { GetAncestorsUseCase as UseCaseAbstraction, GetAncestorsRepository, type GetAncestorsParams } from "./abstractions.js";
+import type { Folder } from "../../../folder/folder.types.js";
+declare class GetAncestorsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: GetAncestorsRepository.Interface);
+    execute(params: GetAncestorsParams): Promise<Result<Folder[], UseCaseAbstraction.Error>>;
+}
+export declare const GetAncestorsUseCase: import("@webiny/di").Implementation<typeof GetAncestorsUseCaseImpl>;
+export {};

package/features/folder/GetAncestors/GetAncestorsUseCase.js

@@ -0,0 +1,17 @@
+import { GetAncestorsUseCase as UseCaseAbstraction, GetAncestorsRepository } from "./abstractions.js";
+import { createImplementation } from "@webiny/di";
+class GetAncestorsUseCaseImpl {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  async execute(params) {
+    return await this.repository.execute(params);
+  }
+}
+export const GetAncestorsUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: GetAncestorsUseCaseImpl,
+  dependencies: [GetAncestorsRepository]
+});
+
+//# sourceMappingURL=GetAncestorsUseCase.js.map

package/features/folder/GetAncestors/GetAncestorsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["GetAncestorsUseCase","UseCaseAbstraction","GetAncestorsRepository","createImplementation","GetAncestorsUseCaseImpl","constructor","repository","execute","params","abstraction","implementation","dependencies"],"sources":["GetAncestorsUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    GetAncestorsUseCase as UseCaseAbstraction,\n    GetAncestorsRepository,\n    type GetAncestorsParams\n} from \"./abstractions.js\";\nimport type { Folder } from \"~/folder/folder.types.js\";\nimport { createImplementation } from \"@webiny/di\";\n\nclass GetAncestorsUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: GetAncestorsRepository.Interface) {}\n\n    public async execute(\n        params: GetAncestorsParams\n    ): Promise<Result<Folder[], UseCaseAbstraction.Error>> {\n        return await this.repository.execute(params);\n    }\n}\n\nexport const GetAncestorsUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: GetAncestorsUseCaseImpl,\n    dependencies: [GetAncestorsRepository]\n});\n"],"mappings":"AACA,SACIA,mBAAmB,IAAIC,kBAAkB,EACzCC,sBAAsB;AAI1B,SAASC,oBAAoB,QAAQ,YAAY;AAEjD,MAAMC,uBAAuB,CAAyC;EAClEC,WAAWA,CAASC,UAA4C,EAAE;IAAA,KAA9CA,UAA4C,GAA5CA,UAA4C;EAAG;EAEnE,MAAaC,OAAOA,CAChBC,MAA0B,EACyB;IACnD,OAAO,MAAM,IAAI,CAACF,UAAU,CAACC,OAAO,CAACC,MAAM,CAAC;EAChD;AACJ;AAEA,OAAO,MAAMR,mBAAmB,GAAGG,oBAAoB,CAAC;EACpDM,WAAW,EAAER,kBAAkB;EAC/BS,cAAc,EAAEN,uBAAuB;EACvCO,YAAY,EAAE,CAACT,sBAAsB;AACzC,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,38 @@
+import type { Result } from "@webiny/feature/api";
+import type { Folder } from "../../../folder/folder.types.js";
+import type { FolderNotAuthorizedError, FolderPersistenceError } from "../../../domain/folder/errors.js";
+/**
+ * GetAncestors repository interface
+ */
+export interface IGetAncestorsRepository {
+    execute(params: GetAncestorsParams): Promise<Result<Folder[], RepositoryError>>;
+}
+export interface IGetAncestorsRepositoryErrors {
+    persistence: FolderPersistenceError;
+}
+type RepositoryError = IGetAncestorsRepositoryErrors[keyof IGetAncestorsRepositoryErrors];
+export declare const GetAncestorsRepository: import("@webiny/di").Abstraction<IGetAncestorsRepository>;
+export declare namespace GetAncestorsRepository {
+    type Interface = IGetAncestorsRepository;
+    type Error = RepositoryError;
+}
+/**
+ * GetAncestors use case interface
+ */
+export interface GetAncestorsParams {
+    folder: Folder;
+}
+export interface IGetAncestorsUseCase {
+    execute(params: GetAncestorsParams): Promise<Result<Folder[], UseCaseError>>;
+}
+export interface IGetAncestorsUseCaseErrors {
+    notAuthorized: FolderNotAuthorizedError;
+    persistence: FolderPersistenceError;
+}
+type UseCaseError = IGetAncestorsUseCaseErrors[keyof IGetAncestorsUseCaseErrors];
+export declare const GetAncestorsUseCase: import("@webiny/di").Abstraction<IGetAncestorsUseCase>;
+export declare namespace GetAncestorsUseCase {
+    type Interface = IGetAncestorsUseCase;
+    type Error = UseCaseError;
+}
+export {};

package/features/folder/GetAncestors/abstractions.js

@@ -0,0 +1,15 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * GetAncestors repository interface
+ */
+
+export const GetAncestorsRepository = createAbstraction("GetAncestorsRepository");
+
+/**
+ * GetAncestors use case interface
+ */
+
+export const GetAncestorsUseCase = createAbstraction("GetAncestorsUseCase");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetAncestorsRepository","GetAncestorsUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { Folder } from \"~/folder/folder.types.js\";\nimport type { FolderNotAuthorizedError, FolderPersistenceError } from \"~/domain/folder/errors.js\";\n\n/**\n * GetAncestors repository interface\n */\nexport interface IGetAncestorsRepository {\n    execute(params: GetAncestorsParams): Promise<Result<Folder[], RepositoryError>>;\n}\n\nexport interface IGetAncestorsRepositoryErrors {\n    persistence: FolderPersistenceError;\n}\n\ntype RepositoryError = IGetAncestorsRepositoryErrors[keyof IGetAncestorsRepositoryErrors];\n\nexport const GetAncestorsRepository =\n    createAbstraction<IGetAncestorsRepository>(\"GetAncestorsRepository\");\n\nexport namespace GetAncestorsRepository {\n    export type Interface = IGetAncestorsRepository;\n    export type Error = RepositoryError;\n}\n\n/**\n * GetAncestors use case interface\n */\nexport interface GetAncestorsParams {\n    folder: Folder;\n}\n\nexport interface IGetAncestorsUseCase {\n    execute(params: GetAncestorsParams): Promise<Result<Folder[], UseCaseError>>;\n}\n\nexport interface IGetAncestorsUseCaseErrors {\n    notAuthorized: FolderNotAuthorizedError;\n    persistence: FolderPersistenceError;\n}\n\ntype UseCaseError = IGetAncestorsUseCaseErrors[keyof IGetAncestorsUseCaseErrors];\n\nexport const GetAncestorsUseCase = createAbstraction<IGetAncestorsUseCase>(\"GetAncestorsUseCase\");\n\nexport namespace GetAncestorsUseCase {\n    export type Interface = IGetAncestorsUseCase;\n    export type Error = UseCaseError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAKvD;AACA;AACA;;AAWA,OAAO,MAAMC,sBAAsB,GAC/BD,iBAAiB,CAA0B,wBAAwB,CAAC;;AAOxE;AACA;AACA;;AAgBA,OAAO,MAAME,mBAAmB,GAAGF,iBAAiB,CAAuB,qBAAqB,CAAC","ignoreList":[]}

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

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

package/features/folder/GetAncestors/feature.js

@@ -0,0 +1,12 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetAncestorsRepository } from "./GetAncestorsRepository.js";
+import { GetAncestorsUseCase } from "./GetAncestorsUseCase.js";
+export const GetAncestorsFeature = createFeature({
+  name: "GetAncestors",
+  register(container) {
+    container.register(GetAncestorsRepository).inSingletonScope();
+    container.register(GetAncestorsUseCase);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetAncestorsRepository","GetAncestorsUseCase","GetAncestorsFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { GetAncestorsRepository } from \"./GetAncestorsRepository.js\";\nimport { GetAncestorsUseCase } from \"./GetAncestorsUseCase.js\";\n\nexport const GetAncestorsFeature = createFeature({\n    name: \"GetAncestors\",\n    register(container: Container) {\n        container.register(GetAncestorsRepository).inSingletonScope();\n        container.register(GetAncestorsUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AAEnD,SAASC,sBAAsB;AAC/B,SAASC,mBAAmB;AAE5B,OAAO,MAAMC,mBAAmB,GAAGH,aAAa,CAAC;EAC7CI,IAAI,EAAE,cAAc;EACpBC,QAAQA,CAACC,SAAoB,EAAE;IAC3BA,SAAS,CAACD,QAAQ,CAACJ,sBAAsB,CAAC,CAACM,gBAAgB,CAAC,CAAC;IAC7DD,SAAS,CAACD,QAAQ,CAACH,mBAAmB,CAAC;EAC3C;AACJ,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,2 @@
+export { GetAncestorsFeature } from "./feature.js";
+export { GetAncestorsUseCase } from "./abstractions.js";

package/features/folder/GetAncestors/index.js

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

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

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