@webiny/api-aco 0.0.0-unstable.06b2ede40f → 0.0.0-unstable.0d717d18dd

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

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

package/features/folder/EnsureFolderIsEmpty/EnsureFolderIsEmpty.js

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

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

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

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

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

package/features/folder/EnsureFolderIsEmpty/abstractions.js

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

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

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

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

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

package/features/folder/EnsureFolderIsEmpty/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/EnsureFolderIsEmpty/feature.js","sources":["../../../../src/features/folder/EnsureFolderIsEmpty/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"],"names":["EnsureFolderIsEmptyFeature","createFeature","container","EnsureFolderIsEmpty"],"mappings":";;AAGO,MAAMA,6BAA6BC,cAAc;IACpD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

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

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

package/features/folder/EnsureFolderIsEmpty/index.js

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

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

@@ -0,0 +1,12 @@
+import { FolderBeforeDeleteEventHandler } 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 FolderBeforeDeleteEventHandler.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,25 @@
+import { WebinyError } from "@webiny/error";
+import { FolderBeforeDeleteEventHandler } 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, ()=>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"
+        });
+    }
+}
+const GenericFolderBeforeDeleteHandler = FolderBeforeDeleteEventHandler.createImplementation({
+    implementation: GenericFolderBeforeDeleteHandlerImpl,
+    dependencies: [
+        EnsureFolderIsEmpty
+    ]
+});
+export { GenericFolderBeforeDeleteHandler };
+
+//# sourceMappingURL=GenericFolderBeforeDeleteHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/EnsureFolderIsEmptyOnDelete/GenericFolderBeforeDeleteHandler.js","sources":["../../../../src/features/folder/EnsureFolderIsEmptyOnDelete/GenericFolderBeforeDeleteHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { FolderBeforeDeleteEventHandler } 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 FolderBeforeDeleteEventHandler.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 = FolderBeforeDeleteEventHandler.createImplementation(\n    {\n        implementation: GenericFolderBeforeDeleteHandlerImpl,\n        dependencies: [EnsureFolderIsEmpty]\n    }\n);\n"],"names":["GenericFolderBeforeDeleteHandlerImpl","ensureFolderIsEmpty","event","folder","result","WebinyError","GenericFolderBeforeDeleteHandler","FolderBeforeDeleteEventHandler","EnsureFolderIsEmpty"],"mappings":";;;AAKA,MAAMA;IACF,YAAoBC,mBAAkD,CAAE;aAApDA,mBAAmB,GAAnBA;IAAqD;IAEzE,MAAM,OAAOC,KAA8B,EAAiB;QACxD,MAAM,EAAEC,MAAM,EAAE,GAAGD,MAAM,OAAO;QAEhC,MAAME,SAAS,MAAM,IAAI,CAAC,mBAAmB,CAAC,OAAO,CACjDD,OAAO,IAAI,EACXA,OAAO,EAAE,EAGT,IAAM;QAGV,IAAIC,OAAO,MAAM,IACb,MAAMC,YAAY,IAAI,CAACD,OAAO,KAAK,EAAE;YACjC,SAAS;YACT,MAAM;QACV;IAER;AACJ;AAEO,MAAME,mCAAmCC,+BAA+B,oBAAoB,CAC/F;IACI,gBAAgBP;IAChB,cAAc;QAACQ;KAAoB;AACvC"}

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

@@ -0,0 +1,10 @@
+/**
+ * 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: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/folder/EnsureFolderIsEmptyOnDelete/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/EnsureFolderIsEmptyOnDelete/feature.js","sources":["../../../../src/features/folder/EnsureFolderIsEmptyOnDelete/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"],"names":["EnsureFolderIsEmptyOnDeleteFeature","createFeature","container","GenericFolderBeforeDeleteHandler"],"mappings":";;AASO,MAAMA,qCAAqCC,cAAc;IAC5D,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

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

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

package/features/folder/EnsureFolderIsEmptyOnDelete/index.js

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

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

@@ -0,0 +1,16 @@
+import { FolderBeforeDeleteEventHandler } 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 FolderBeforeDeleteEventHandler.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,52 @@
+import { WebinyError } from "@webiny/error";
+import { FolderBeforeDeleteEventHandler } 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
+            });
+            if (result.isFail()) {
+                console.error(result.error.message);
+                return true;
+            }
+            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"
+        });
+    }
+}
+const ModelFolderBeforeDeleteHandler = FolderBeforeDeleteEventHandler.createImplementation({
+    implementation: ModelFolderBeforeDeleteHandlerImpl,
+    dependencies: [
+        EnsureFolderIsEmpty,
+        GetModelUseCase,
+        ListEntriesUseCase
+    ]
+});
+export { ModelFolderBeforeDeleteHandler };
+
+//# sourceMappingURL=ModelFolderBeforeDeleteHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/EnsureHcmsFolderIsEmptyOnDelete/ModelFolderBeforeDeleteHandler.js","sources":["../../../../src/features/folder/EnsureHcmsFolderIsEmptyOnDelete/ModelFolderBeforeDeleteHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { FolderBeforeDeleteEventHandler } 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 FolderBeforeDeleteEventHandler.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            if (result.isFail()) {\n                console.error(result.error.message);\n                return true;\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 = FolderBeforeDeleteEventHandler.createImplementation({\n    implementation: ModelFolderBeforeDeleteHandlerImpl,\n    dependencies: [EnsureFolderIsEmpty, GetModelUseCase, ListEntriesUseCase]\n});\n"],"names":["ModelFolderBeforeDeleteHandlerImpl","ensureFolderIsEmpty","getModel","listEntries","event","folder","id","type","modelId","modelResult","result","console","entries","WebinyError","ModelFolderBeforeDeleteHandler","FolderBeforeDeleteEventHandler","EnsureFolderIsEmpty","GetModelUseCase","ListEntriesUseCase"],"mappings":";;;;;AAOA,MAAMA;IACF,YACYC,mBAAkD,EAClDC,QAAmC,EACnCC,WAAyC,CACnD;aAHUF,mBAAmB,GAAnBA;aACAC,QAAQ,GAARA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,OAAOC,KAA8B,EAAiB;QACxD,MAAM,EAAEC,MAAM,EAAE,GAAGD,MAAM,OAAO;QAEhC,MAAM,EAAEE,EAAE,EAAEC,IAAI,EAAE,GAAGF;QAErB,MAAMG,UAAUD,KAAK,KAAK,CAAC,IAAI,CAAC,EAAE;QAClC,IAAI,CAACC,SACD;QAGJ,MAAMC,cAAc,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACD;QAChD,IAAIC,YAAY,MAAM,IAClB;QAGJ,MAAMC,SAAS,MAAM,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAACH,MAAMD,IAAI;YAC5D,MAAMI,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAACD,YAAY,KAAK,EAAE;gBAC7D,OAAO;oBACH,QAAQ;oBACR,iBAAiB;wBACb,UAAUH;oBACd;gBACJ;gBACA,OAAO;YACX;YACA,IAAII,OAAO,MAAM,IAAI;gBACjBC,QAAQ,KAAK,CAACD,OAAO,KAAK,CAAC,OAAO;gBAClC,OAAO;YACX;YAEA,MAAM,EAAEE,OAAO,EAAE,GAAGF,OAAO,KAAK;YAEhC,OAAOE,QAAQ,MAAM,GAAG;QAC5B;QAEA,IAAIF,OAAO,MAAM,IACb,MAAMG,YAAY,IAAI,CAACH,OAAO,KAAK,EAAE;YACjC,SAAS;YACT,MAAM;QACV;IAER;AACJ;AAEO,MAAMI,iCAAiCC,+BAA+B,oBAAoB,CAAC;IAC9F,gBAAgBf;IAChB,cAAc;QAACgB;QAAqBC;QAAiBC;KAAmB;AAC5E"}

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

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

package/features/folder/EnsureHcmsFolderIsEmptyOnDelete/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/EnsureHcmsFolderIsEmptyOnDelete/feature.js","sources":["../../../../src/features/folder/EnsureHcmsFolderIsEmptyOnDelete/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"],"names":["EnsureHcmsFolderIsEmptyOnDeleteFeature","createFeature","container","ModelFolderBeforeDeleteHandler"],"mappings":";;AAGO,MAAMA,yCAAyCC,cAAc;IAChE,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

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

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

package/features/folder/EnsureHcmsFolderIsEmptyOnDelete/index.js

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

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,58 @@
+import { Result } from "@webiny/feature/api";
+import { GetAncestorsRepository } 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;
+        if (!folder) return Result.ok([]);
+        if (!folder.parentId) return Result.ok([
+            folder
+        ]);
+        const parts = folder.path.split("/").slice(1);
+        const paths = parts.map((_, index)=>[
+                ROOT_FOLDER,
+                ...parts.slice(0, index + 1)
+            ].join("/"));
+        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));
+        const folderMap = new Map();
+        folders.forEach((f)=>folderMap.set(f.id, f));
+        const findParents = (next, current)=>{
+            if (!current) return next;
+            next.push(current);
+            if (!current.parentId) return next;
+            const parent = folderMap.get(current.parentId);
+            if (!parent) return next;
+            return findParents(next, parent);
+        };
+        const ancestors = findParents([], folder);
+        return Result.ok(ancestors);
+    }
+}
+const GetAncestorsRepository_GetAncestorsRepository = GetAncestorsRepository.createImplementation({
+    implementation: GetAncestorsRepositoryImpl,
+    dependencies: [
+        ListLatestEntriesUseCase,
+        FolderModel
+    ]
+});
+export { GetAncestorsRepository_GetAncestorsRepository as GetAncestorsRepository };
+
+//# sourceMappingURL=GetAncestorsRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetAncestors/GetAncestorsRepository.js","sources":["../../../../src/features/folder/GetAncestors/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"],"names":["GetAncestorsRepositoryImpl","listLatestEntries","folderModel","params","folder","Result","parts","paths","_","index","ROOT_FOLDER","result","FolderPersistenceError","entries","folders","entry","EntryToFolderMapper","folderMap","Map","f","findParents","next","current","parent","ancestors","GetAncestorsRepository","RepositoryAbstraction","ListLatestEntriesUseCase","FolderModel"],"mappings":";;;;;;;AAaA,MAAMA;IACF,YACYC,iBAAqD,EACrDC,WAAkC,CAC5C;aAFUD,iBAAiB,GAAjBA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,QACFC,MAA0B,EAC4B;QACtD,MAAM,EAAEC,MAAM,EAAE,GAAGD;QAGnB,IAAI,CAACC,QACD,OAAOC,OAAO,EAAE,CAAC,EAAE;QAIvB,IAAI,CAACD,OAAO,QAAQ,EAChB,OAAOC,OAAO,EAAE,CAAC;YAACD;SAAO;QAI7B,MAAME,QAAQF,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC;QAC3C,MAAMG,QAAQD,MAAM,GAAG,CAAC,CAACE,GAAGC,QACjB;gBAACC;mBAAgBJ,MAAM,KAAK,CAAC,GAAGG,QAAQ;aAAG,CAAC,IAAI,CAAC;QAI5D,MAAME,SAAS,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAiB,IAAI,CAAC,WAAW,EAAE;YAClF,OAAO;gBACH,QAAQ;oBACJ,MAAMP,OAAO,IAAI;oBACjB,SAASG;gBACb;YACJ;QACJ;QAEA,IAAII,OAAO,MAAM,IACb,OAAON,OAAO,IAAI,CAAC,IAAIO,uBAAuBD,OAAO,KAAK;QAG9D,MAAM,EAAEE,OAAO,EAAE,GAAGF,OAAO,KAAK;QAChC,MAAMG,UAAUD,QAAQ,GAAG,CAACE,CAAAA,QAASC,oBAAoB,QAAQ,CAACD;QAGlE,MAAME,YAAY,IAAIC;QACtBJ,QAAQ,OAAO,CAACK,CAAAA,IAAKF,UAAU,GAAG,CAACE,EAAE,EAAE,EAAEA;QAEzC,MAAMC,cAAc,CAACC,MAAgBC;YAEjC,IAAI,CAACA,SACD,OAAOD;YAIXA,KAAK,IAAI,CAACC;YAGV,IAAI,CAACA,QAAQ,QAAQ,EACjB,OAAOD;YAGX,MAAME,SAASN,UAAU,GAAG,CAACK,QAAQ,QAAQ;YAG7C,IAAI,CAACC,QACD,OAAOF;YAIX,OAAOD,YAAYC,MAAME;QAC7B;QAGA,MAAMC,YAAYJ,YAAY,EAAE,EAAEhB;QAClC,OAAOC,OAAO,EAAE,CAACmB;IACrB;AACJ;AAEO,MAAMC,gDAAyBC,uBAAAA,oBAA0C,CAAC;IAC7E,gBAAgB1B;IAChB,cAAc;QAAC2B;QAA0BC;KAAY;AACzD"}

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,20 @@
+import { GetAncestorsRepository, GetAncestorsUseCase } from "./abstractions.js";
+import { createImplementation } from "@webiny/di";
+class GetAncestorsUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(params) {
+        return await this.repository.execute(params);
+    }
+}
+const GetAncestorsUseCase_GetAncestorsUseCase = createImplementation({
+    abstraction: GetAncestorsUseCase,
+    implementation: GetAncestorsUseCaseImpl,
+    dependencies: [
+        GetAncestorsRepository
+    ]
+});
+export { GetAncestorsUseCase_GetAncestorsUseCase as GetAncestorsUseCase };
+
+//# sourceMappingURL=GetAncestorsUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetAncestors/GetAncestorsUseCase.js","sources":["../../../../src/features/folder/GetAncestors/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"],"names":["GetAncestorsUseCaseImpl","repository","params","GetAncestorsUseCase","createImplementation","UseCaseAbstraction","GetAncestorsRepository"],"mappings":";;AASA,MAAMA;IACF,YAAoBC,UAA4C,CAAE;aAA9CA,UAAU,GAAVA;IAA+C;IAEnE,MAAa,QACTC,MAA0B,EACyB;QACnD,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACzC;AACJ;AAEO,MAAMC,0CAAsBC,qBAAqB;IACpD,aAAaC;IACb,gBAAgBL;IAChB,cAAc;QAACM;KAAuB;AAC1C"}

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

@@ -0,0 +1,40 @@
+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];
+/** Fetch ancestor folders from storage. */
+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];
+/** Retrieve ancestor folders in the hierarchy. */
+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,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const GetAncestorsRepository = createAbstraction("GetAncestorsRepository");
+const GetAncestorsUseCase = createAbstraction("GetAncestorsUseCase");
+export { GetAncestorsRepository, GetAncestorsUseCase };
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetAncestors/abstractions.js","sources":["../../../../src/features/folder/GetAncestors/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\n/** Fetch ancestor folders from storage. */\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\n/** Retrieve ancestor folders in the hierarchy. */\nexport const GetAncestorsUseCase = createAbstraction<IGetAncestorsUseCase>(\"GetAncestorsUseCase\");\n\nexport namespace GetAncestorsUseCase {\n    export type Interface = IGetAncestorsUseCase;\n    export type Error = UseCaseError;\n}\n"],"names":["GetAncestorsRepository","createAbstraction","GetAncestorsUseCase"],"mappings":";AAmBO,MAAMA,yBACTC,kBAA2C;AA0BxC,MAAMC,sBAAsBD,kBAAwC"}

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

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

package/features/folder/GetAncestors/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetAncestors/feature.js","sources":["../../../../src/features/folder/GetAncestors/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"],"names":["GetAncestorsFeature","createFeature","container","GetAncestorsRepository","GetAncestorsUseCase"],"mappings":";;;AAKO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC,wBAAwB,gBAAgB;QAC3DD,UAAU,QAAQ,CAACE;IACvB;AACJ"}

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,2 @@
+export { GetAncestorsFeature } from "./feature.js";
+export { GetAncestorsUseCase } from "./abstractions.js";

package/features/folder/GetFolder/GetFolderRepository.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+import { GetFolderRepository as RepositoryAbstraction, type IGetFolderRepository } from "./abstractions.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { FolderModel } from "../../../domain/folder/abstractions.js";
+import type { Folder } from "../../../folder/folder.types.js";
+declare class GetFolderRepositoryImpl implements IGetFolderRepository {
+    private getEntryById;
+    private folderModel;
+    constructor(getEntryById: GetEntryByIdUseCase.Interface, folderModel: FolderModel.Interface);
+    execute(id: string): Promise<Result<Folder, RepositoryAbstraction.Error>>;
+}
+export declare const GetFolderRepository: typeof GetFolderRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IGetFolderRepository>;
+};
+export {};