@webiny/api-aco 0.0.0-unstable.a4637c5ce6 → 0.0.0-unstable.a4f3e4ea8b

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

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

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

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

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

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

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

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

package/features/folder/DeleteFolder/events.js

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

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

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

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

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

package/features/folder/DeleteFolder/feature.js

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

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

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

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

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

package/features/folder/DeleteFolder/index.js

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

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

@@ -0,0 +1,17 @@
+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 { Logger } from "@webiny/api-core/exports/api/logger.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+declare class EnsureFolderIsEmptyImpl implements Abstraction.Interface {
+    private identityContext;
+    private folderLevelPermissions;
+    private listFoldersUseCase;
+    private logger;
+    constructor(identityContext: IdentityContext.Interface, folderLevelPermissions: FolderLevelPermissions.Interface, listFoldersUseCase: ListFoldersUseCase.Interface, logger: Logger.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,62 @@
+import { FolderLevelPermissions } from "../../flp/FolderLevelPermissions/index.js";
+import { ListFoldersUseCase } from "../ListFolders/index.js";
+import { EnsureFolderIsEmpty } from "./abstractions.js";
+import { Logger } from "@webiny/api-core/exports/api/logger.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, logger){
+        this.identityContext = identityContext;
+        this.folderLevelPermissions = folderLevelPermissions;
+        this.listFoldersUseCase = listFoldersUseCase;
+        this.logger = logger;
+    }
+    async execute(type, id, hasContentCallback) {
+        const hasFoldersCallback = async ()=>{
+            const result = await this.listFoldersUseCase.execute({
+                where: {
+                    type,
+                    parentId: id
+                },
+                limit: 1
+            });
+            if (result.isFail()) {
+                this.logger.error(result.error);
+                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,
+        Logger
+    ]
+});
+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 { Logger } from \"@webiny/api-core/exports/api/logger.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        private logger: Logger.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            if (result.isFail()) {\n                this.logger.error(result.error);\n                // Report the folder as non-empty so a failed lookup cannot green-light a delete.\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, Logger]\n});\n"],"names":["EnsureFolderIsEmptyImpl","identityContext","folderLevelPermissions","listFoldersUseCase","logger","type","id","hasContentCallback","hasFoldersCallback","result","folders","hasFolders","hasContent","Promise","Result","FolderNotEmptyError","hasInvisibleFolders","hasInvisibleContent","FolderNotAuthorizedError","EnsureFolderIsEmpty","Abstraction","IdentityContext","FolderLevelPermissions","ListFoldersUseCase","Logger"],"mappings":";;;;;;;AAQA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,sBAAwD,EACxDC,kBAAgD,EAChDC,MAAwB,CAClC;aAJUH,eAAe,GAAfA;aACAC,sBAAsB,GAAtBA;aACAC,kBAAkB,GAAlBA;aACAC,MAAM,GAANA;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;YACA,IAAIG,OAAO,MAAM,IAAI;gBACjB,IAAI,CAAC,MAAM,CAAC,KAAK,CAACA,OAAO,KAAK;gBAE9B,OAAO;YACX;YAEA,MAAM,EAAEC,OAAO,EAAE,GAAGD,OAAO,KAAK;YAEhC,OAAOC,QAAQ,MAAM,GAAG;QAC5B;QAEA,MAAM,CAACC,YAAYC,WAAW,GAAG,MAAMC,QAAQ,GAAG,CAAC;YAC/CL;YACAD;SACH;QAED,IAAII,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/CL;gBACAD;aACH;YACD,OAAO;gBAACI;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;QAAoBC;KAAO;AACvF"}

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