@webiny/api-aco 0.0.0-unstable.2af142b57e → 0.0.0-unstable.3bc8100a7f

package/folder/onFolderBeforeDeleteHcms.hook.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.onFolderBeforeDeleteHcmsHook = void 0;
+var _error = _interopRequireDefault(require("@webiny/error"));
+var _ensureFolderIsEmpty = require("./ensureFolderIsEmpty");
+const onFolderBeforeDeleteHcmsHook = context => {
+  context.aco.folder.onFolderBeforeDelete.subscribe(async ({
+    folder
+  }) => {
+    try {
+      const {
+        id,
+        type
+      } = folder;
+      const modelId = type.split(":")[1];
+      if (!modelId) {
+        return;
+      }
+      let model;
+      try {
+        model = await context.cms.getModel(modelId);
+        if (!model) {
+          return;
+        }
+      } catch {
+        return;
+      }
+      await (0, _ensureFolderIsEmpty.ensureFolderIsEmpty)({
+        context,
+        folder,
+        hasContentCallback: async () => {
+          const [content] = await context.cms.listEntries(model, {
+            where: {
+              latest: true,
+              wbyAco_location: {
+                folderId: id
+              }
+            },
+            limit: 1
+          });
+          return content.length > 0;
+        }
+      });
+    } catch (error) {
+      throw _error.default.from(error, {
+        message: "Error while executing onFolderBeforeDeleteHcmsHook hook.",
+        code: "ACO_BEFORE_FOLDER_DELETE_HCMS_HOOK"
+      });
+    }
+  });
+};
+exports.onFolderBeforeDeleteHcmsHook = onFolderBeforeDeleteHcmsHook;
+
+//# sourceMappingURL=onFolderBeforeDeleteHcms.hook.js.map

package/folder/onFolderBeforeDeleteHcms.hook.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_error","_interopRequireDefault","require","_ensureFolderIsEmpty","onFolderBeforeDeleteHcmsHook","context","aco","folder","onFolderBeforeDelete","subscribe","id","type","modelId","split","model","cms","getModel","ensureFolderIsEmpty","hasContentCallback","content","listEntries","where","latest","wbyAco_location","folderId","limit","length","error","WebinyError","from","message","code","exports"],"sources":["onFolderBeforeDeleteHcms.hook.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types\";\nimport type { AcoContext } from \"~/types\";\nimport { ensureFolderIsEmpty } from \"~/folder/ensureFolderIsEmpty\";\n\nexport const onFolderBeforeDeleteHcmsHook = (context: AcoContext) => {\n    context.aco.folder.onFolderBeforeDelete.subscribe(async ({ folder }) => {\n        try {\n            const { id, type } = folder;\n\n            const modelId = type.split(\":\")[1];\n            if (!modelId) {\n                return;\n            }\n\n            let model: CmsModel;\n            try {\n                model = await context.cms.getModel(modelId);\n                if (!model) {\n                    return;\n                }\n            } catch {\n                return;\n            }\n\n            await ensureFolderIsEmpty({\n                context,\n                folder,\n                hasContentCallback: async () => {\n                    const [content] = await context.cms.listEntries(model!, {\n                        where: {\n                            latest: true,\n                            wbyAco_location: {\n                                folderId: id\n                            }\n                        },\n                        limit: 1\n                    });\n                    return content.length > 0;\n                }\n            });\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing onFolderBeforeDeleteHcmsHook hook.\",\n                code: \"ACO_BEFORE_FOLDER_DELETE_HCMS_HOOK\"\n            });\n        }\n    });\n};\n"],"mappings":";;;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AAGA,IAAAC,oBAAA,GAAAD,OAAA;AAEO,MAAME,4BAA4B,GAAIC,OAAmB,IAAK;EACjEA,OAAO,CAACC,GAAG,CAACC,MAAM,CAACC,oBAAoB,CAACC,SAAS,CAAC,OAAO;IAAEF;EAAO,CAAC,KAAK;IACpE,IAAI;MACA,MAAM;QAAEG,EAAE;QAAEC;MAAK,CAAC,GAAGJ,MAAM;MAE3B,MAAMK,OAAO,GAAGD,IAAI,CAACE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;MAClC,IAAI,CAACD,OAAO,EAAE;QACV;MACJ;MAEA,IAAIE,KAAe;MACnB,IAAI;QACAA,KAAK,GAAG,MAAMT,OAAO,CAACU,GAAG,CAACC,QAAQ,CAACJ,OAAO,CAAC;QAC3C,IAAI,CAACE,KAAK,EAAE;UACR;QACJ;MACJ,CAAC,CAAC,MAAM;QACJ;MACJ;MAEA,MAAM,IAAAG,wCAAmB,EAAC;QACtBZ,OAAO;QACPE,MAAM;QACNW,kBAAkB,EAAE,MAAAA,CAAA,KAAY;UAC5B,MAAM,CAACC,OAAO,CAAC,GAAG,MAAMd,OAAO,CAACU,GAAG,CAACK,WAAW,CAACN,KAAK,EAAG;YACpDO,KAAK,EAAE;cACHC,MAAM,EAAE,IAAI;cACZC,eAAe,EAAE;gBACbC,QAAQ,EAAEd;cACd;YACJ,CAAC;YACDe,KAAK,EAAE;UACX,CAAC,CAAC;UACF,OAAON,OAAO,CAACO,MAAM,GAAG,CAAC;QAC7B;MACJ,CAAC,CAAC;IACN,CAAC,CAAC,OAAOC,KAAK,EAAE;MACZ,MAAMC,cAAW,CAACC,IAAI,CAACF,KAAK,EAAE;QAC1BG,OAAO,EAAE,0DAA0D;QACnEC,IAAI,EAAE;MACV,CAAC,CAAC;IACN;EACJ,CAAC,CAAC;AACN,CAAC;AAACC,OAAA,CAAA5B,4BAAA,GAAAA,4BAAA","ignoreList":[]}

package/folder/useCases/CreateFolder/CreateFolder.d.ts

@@ -0,0 +1,7 @@
+import type { ICreateFolder } from "./ICreateFolder";
+import type { AcoFolderStorageOperations, CreateFolderParams } from "../../folder.types";
+export declare class CreateFolder implements ICreateFolder {
+    private readonly createOperation;
+    constructor(createOperation: AcoFolderStorageOperations["createFolder"]);
+    execute(params: CreateFolderParams): Promise<import("../../folder.types").Folder>;
+}

package/folder/useCases/CreateFolder/CreateFolder.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CreateFolder = void 0;
+class CreateFolder {
+  constructor(createOperation) {
+    this.createOperation = createOperation;
+  }
+  async execute(params) {
+    return await this.createOperation({
+      data: params
+    });
+  }
+}
+exports.CreateFolder = CreateFolder;
+
+//# sourceMappingURL=CreateFolder.js.map

package/folder/useCases/CreateFolder/CreateFolder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CreateFolder","constructor","createOperation","execute","params","data","exports"],"sources":["CreateFolder.ts"],"sourcesContent":["import type { ICreateFolder } from \"./ICreateFolder\";\nimport type { AcoFolderStorageOperations, CreateFolderParams } from \"~/folder/folder.types\";\n\nexport class CreateFolder implements ICreateFolder {\n    private readonly createOperation: AcoFolderStorageOperations[\"createFolder\"];\n\n    constructor(createOperation: AcoFolderStorageOperations[\"createFolder\"]) {\n        this.createOperation = createOperation;\n    }\n\n    async execute(params: CreateFolderParams) {\n        return await this.createOperation({ data: params });\n    }\n}\n"],"mappings":";;;;;;AAGO,MAAMA,YAAY,CAA0B;EAG/CC,WAAWA,CAACC,eAA2D,EAAE;IACrE,IAAI,CAACA,eAAe,GAAGA,eAAe;EAC1C;EAEA,MAAMC,OAAOA,CAACC,MAA0B,EAAE;IACtC,OAAO,MAAM,IAAI,CAACF,eAAe,CAAC;MAAEG,IAAI,EAAED;IAAO,CAAC,CAAC;EACvD;AACJ;AAACE,OAAA,CAAAN,YAAA,GAAAA,YAAA","ignoreList":[]}

package/folder/useCases/CreateFolder/CreateFolderWithEvents.d.ts

@@ -0,0 +1,9 @@
+import type { ICreateFolder } from "./ICreateFolder";
+import type { CreateFolderUseCasesTopics } from "./index";
+import type { CreateFolderParams } from "../../folder.types";
+export declare class CreateFolderWithEvents implements ICreateFolder {
+    private topics;
+    private readonly decoretee;
+    constructor(topics: CreateFolderUseCasesTopics, decoretee: ICreateFolder);
+    execute(params: CreateFolderParams): Promise<import("../../folder.types").Folder>;
+}

package/folder/useCases/CreateFolder/CreateFolderWithEvents.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CreateFolderWithEvents = void 0;
+class CreateFolderWithEvents {
+  constructor(topics, decoretee) {
+    this.topics = topics;
+    this.decoretee = decoretee;
+  }
+  async execute(params) {
+    await this.topics.onFolderBeforeCreate.publish({
+      input: params
+    });
+    const folder = await this.decoretee.execute(params);
+    await this.topics.onFolderAfterCreate.publish({
+      folder
+    });
+    return folder;
+  }
+}
+exports.CreateFolderWithEvents = CreateFolderWithEvents;
+
+//# sourceMappingURL=CreateFolderWithEvents.js.map

package/folder/useCases/CreateFolder/CreateFolderWithEvents.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CreateFolderWithEvents","constructor","topics","decoretee","execute","params","onFolderBeforeCreate","publish","input","folder","onFolderAfterCreate","exports"],"sources":["CreateFolderWithEvents.ts"],"sourcesContent":["import type { ICreateFolder } from \"./ICreateFolder\";\nimport type { CreateFolderUseCasesTopics } from \"./index\";\nimport type { CreateFolderParams } from \"~/folder/folder.types\";\n\nexport class CreateFolderWithEvents implements ICreateFolder {\n    private topics: CreateFolderUseCasesTopics;\n    private readonly decoretee: ICreateFolder;\n\n    constructor(topics: CreateFolderUseCasesTopics, decoretee: ICreateFolder) {\n        this.topics = topics;\n        this.decoretee = decoretee;\n    }\n\n    async execute(params: CreateFolderParams) {\n        await this.topics.onFolderBeforeCreate.publish({ input: params });\n        const folder = await this.decoretee.execute(params);\n        await this.topics.onFolderAfterCreate.publish({ folder });\n        return folder;\n    }\n}\n"],"mappings":";;;;;;AAIO,MAAMA,sBAAsB,CAA0B;EAIzDC,WAAWA,CAACC,MAAkC,EAAEC,SAAwB,EAAE;IACtE,IAAI,CAACD,MAAM,GAAGA,MAAM;IACpB,IAAI,CAACC,SAAS,GAAGA,SAAS;EAC9B;EAEA,MAAMC,OAAOA,CAACC,MAA0B,EAAE;IACtC,MAAM,IAAI,CAACH,MAAM,CAACI,oBAAoB,CAACC,OAAO,CAAC;MAAEC,KAAK,EAAEH;IAAO,CAAC,CAAC;IACjE,MAAMI,MAAM,GAAG,MAAM,IAAI,CAACN,SAAS,CAACC,OAAO,CAACC,MAAM,CAAC;IACnD,MAAM,IAAI,CAACH,MAAM,CAACQ,mBAAmB,CAACH,OAAO,CAAC;MAAEE;IAAO,CAAC,CAAC;IACzD,OAAOA,MAAM;EACjB;AACJ;AAACE,OAAA,CAAAX,sBAAA,GAAAA,sBAAA","ignoreList":[]}

package/folder/useCases/CreateFolder/CreateFolderWithFolderLevelPermissions.d.ts

@@ -0,0 +1,25 @@
+import type { ICreateFolder } from "./ICreateFolder";
+import type { CreateFolderParams } from "../../folder.types";
+import type { FolderLevelPermissions } from "../../../flp";
+export declare class CreateFolderWithFolderLevelPermissions implements ICreateFolder {
+    private folderLevelPermissions;
+    private readonly decoretee;
+    constructor(folderLevelPermissions: FolderLevelPermissions, decoretee: ICreateFolder);
+    execute(params: CreateFolderParams): Promise<{
+        permissions: import("@webiny/shared-aco/flp/flp.types").FolderPermission[];
+        id: string;
+        entryId: string;
+        createdOn: string;
+        modifiedOn: string | null;
+        savedOn: string;
+        createdBy: import("../../../types").User;
+        modifiedBy: import("../../../types").User | null;
+        savedBy: import("../../../types").User;
+        title: string;
+        slug: string;
+        type: string;
+        parentId?: string | null | undefined;
+        path: string;
+        extensions?: Record<string, any> | undefined;
+    }>;
+}

package/folder/useCases/CreateFolder/CreateFolderWithFolderLevelPermissions.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CreateFolderWithFolderLevelPermissions = void 0;
+var _apiSecurity = require("@webiny/api-security");
+class CreateFolderWithFolderLevelPermissions {
+  constructor(folderLevelPermissions, decoretee) {
+    this.folderLevelPermissions = folderLevelPermissions;
+    this.decoretee = decoretee;
+  }
+  async execute(params) {
+    let canCreateFolder;
+    if (params.parentId) {
+      const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(params.parentId);
+      canCreateFolder = await this.folderLevelPermissions.canAccessFolder({
+        permissions,
+        rwd: "w"
+      });
+    } else {
+      canCreateFolder = this.folderLevelPermissions.canCreateFolderInRoot();
+    }
+    if (!canCreateFolder) {
+      throw new _apiSecurity.NotAuthorizedError();
+    }
+    const folder = await this.decoretee.execute(params);
+
+    // Let's set default permissions based on the current user.
+    const permissionsWithDefaults = await this.folderLevelPermissions.getDefaultPermissions(folder?.permissions ?? []);
+    return {
+      ...folder,
+      permissions: permissionsWithDefaults
+    };
+  }
+}
+exports.CreateFolderWithFolderLevelPermissions = CreateFolderWithFolderLevelPermissions;
+
+//# sourceMappingURL=CreateFolderWithFolderLevelPermissions.js.map

package/folder/useCases/CreateFolder/CreateFolderWithFolderLevelPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_apiSecurity","require","CreateFolderWithFolderLevelPermissions","constructor","folderLevelPermissions","decoretee","execute","params","canCreateFolder","parentId","permissions","getFolderLevelPermissions","canAccessFolder","rwd","canCreateFolderInRoot","NotAuthorizedError","folder","permissionsWithDefaults","getDefaultPermissions","exports"],"sources":["CreateFolderWithFolderLevelPermissions.ts"],"sourcesContent":["import type { ICreateFolder } from \"./ICreateFolder\";\nimport type { CreateFolderParams } from \"~/folder/folder.types\";\nimport { NotAuthorizedError } from \"@webiny/api-security\";\nimport type { FolderLevelPermissions } from \"~/flp\";\n\nexport class CreateFolderWithFolderLevelPermissions implements ICreateFolder {\n    private folderLevelPermissions: FolderLevelPermissions;\n    private readonly decoretee: ICreateFolder;\n\n    constructor(folderLevelPermissions: FolderLevelPermissions, decoretee: ICreateFolder) {\n        this.folderLevelPermissions = folderLevelPermissions;\n        this.decoretee = decoretee;\n    }\n\n    async execute(params: CreateFolderParams) {\n        let canCreateFolder: boolean;\n        if (params.parentId) {\n            const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(\n                params.parentId\n            );\n            canCreateFolder = await this.folderLevelPermissions.canAccessFolder({\n                permissions,\n                rwd: \"w\"\n            });\n        } else {\n            canCreateFolder = this.folderLevelPermissions.canCreateFolderInRoot();\n        }\n\n        if (!canCreateFolder) {\n            throw new NotAuthorizedError();\n        }\n\n        const folder = await this.decoretee.execute(params);\n\n        // Let's set default permissions based on the current user.\n        const permissionsWithDefaults = await this.folderLevelPermissions.getDefaultPermissions(\n            folder?.permissions ?? []\n        );\n\n        return {\n            ...folder,\n            permissions: permissionsWithDefaults\n        };\n    }\n}\n"],"mappings":";;;;;;AAEA,IAAAA,YAAA,GAAAC,OAAA;AAGO,MAAMC,sCAAsC,CAA0B;EAIzEC,WAAWA,CAACC,sBAA8C,EAAEC,SAAwB,EAAE;IAClF,IAAI,CAACD,sBAAsB,GAAGA,sBAAsB;IACpD,IAAI,CAACC,SAAS,GAAGA,SAAS;EAC9B;EAEA,MAAMC,OAAOA,CAACC,MAA0B,EAAE;IACtC,IAAIC,eAAwB;IAC5B,IAAID,MAAM,CAACE,QAAQ,EAAE;MACjB,MAAMC,WAAW,GAAG,MAAM,IAAI,CAACN,sBAAsB,CAACO,yBAAyB,CAC3EJ,MAAM,CAACE,QACX,CAAC;MACDD,eAAe,GAAG,MAAM,IAAI,CAACJ,sBAAsB,CAACQ,eAAe,CAAC;QAChEF,WAAW;QACXG,GAAG,EAAE;MACT,CAAC,CAAC;IACN,CAAC,MAAM;MACHL,eAAe,GAAG,IAAI,CAACJ,sBAAsB,CAACU,qBAAqB,CAAC,CAAC;IACzE;IAEA,IAAI,CAACN,eAAe,EAAE;MAClB,MAAM,IAAIO,+BAAkB,CAAC,CAAC;IAClC;IAEA,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACX,SAAS,CAACC,OAAO,CAACC,MAAM,CAAC;;IAEnD;IACA,MAAMU,uBAAuB,GAAG,MAAM,IAAI,CAACb,sBAAsB,CAACc,qBAAqB,CACnFF,MAAM,EAAEN,WAAW,IAAI,EAC3B,CAAC;IAED,OAAO;MACH,GAAGM,MAAM;MACTN,WAAW,EAAEO;IACjB,CAAC;EACL;AACJ;AAACE,OAAA,CAAAjB,sCAAA,GAAAA,sCAAA","ignoreList":[]}

package/folder/useCases/CreateFolder/ICreateFolder.d.ts

@@ -0,0 +1,4 @@
+import type { CreateFolderParams, Folder } from "../../folder.types";
+export interface ICreateFolder {
+    execute: (params: CreateFolderParams) => Promise<Folder>;
+}

package/folder/useCases/CreateFolder/ICreateFolder.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+//# sourceMappingURL=ICreateFolder.js.map

package/folder/useCases/CreateFolder/ICreateFolder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["ICreateFolder.ts"],"sourcesContent":["import type { CreateFolderParams, Folder } from \"~/folder/folder.types\";\n\nexport interface ICreateFolder {\n    execute: (params: CreateFolderParams) => Promise<Folder>;\n}\n"],"mappings":"","ignoreList":[]}

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

@@ -0,0 +1,17 @@
+import type { Topic } from "@webiny/pubsub/types";
+import { type AcoFolderStorageOperations, type OnFolderAfterCreateTopicParams, type OnFolderBeforeCreateTopicParams } from "../../folder.types";
+import { CreateFolderWithFolderLevelPermissions } from "./CreateFolderWithFolderLevelPermissions";
+import type { FolderLevelPermissions } from "../../../flp";
+export interface CreateFolderUseCasesTopics {
+    onFolderBeforeCreate: Topic<OnFolderBeforeCreateTopicParams>;
+    onFolderAfterCreate: Topic<OnFolderAfterCreateTopicParams>;
+}
+interface CreateFolderUseCasesParams {
+    createOperation: AcoFolderStorageOperations["createFolder"];
+    folderLevelPermissions: FolderLevelPermissions;
+    topics: CreateFolderUseCasesTopics;
+}
+export declare const getCreateFolderUseCases: (params: CreateFolderUseCasesParams) => {
+    createFolderUseCase: CreateFolderWithFolderLevelPermissions;
+};
+export {};

package/folder/useCases/CreateFolder/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCreateFolderUseCases = void 0;
+var _CreateFolder = require("./CreateFolder");
+var _CreateFolderWithEvents = require("./CreateFolderWithEvents");
+var _CreateFolderWithFolderLevelPermissions = require("./CreateFolderWithFolderLevelPermissions");
+const getCreateFolderUseCases = params => {
+  const createFolder = new _CreateFolder.CreateFolder(params.createOperation);
+  const createFolderUseCaseWithEvents = new _CreateFolderWithEvents.CreateFolderWithEvents(params.topics, createFolder);
+  const createFolderUseCase = new _CreateFolderWithFolderLevelPermissions.CreateFolderWithFolderLevelPermissions(params.folderLevelPermissions, createFolderUseCaseWithEvents);
+  return {
+    createFolderUseCase
+  };
+};
+exports.getCreateFolderUseCases = getCreateFolderUseCases;
+
+//# sourceMappingURL=index.js.map

package/folder/useCases/CreateFolder/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_CreateFolder","require","_CreateFolderWithEvents","_CreateFolderWithFolderLevelPermissions","getCreateFolderUseCases","params","createFolder","CreateFolder","createOperation","createFolderUseCaseWithEvents","CreateFolderWithEvents","topics","createFolderUseCase","CreateFolderWithFolderLevelPermissions","folderLevelPermissions","exports"],"sources":["index.ts"],"sourcesContent":["import type { Topic } from \"@webiny/pubsub/types\";\nimport {\n    type AcoFolderStorageOperations,\n    type OnFolderAfterCreateTopicParams,\n    type OnFolderBeforeCreateTopicParams\n} from \"~/folder/folder.types\";\nimport { CreateFolder } from \"./CreateFolder\";\nimport { CreateFolderWithEvents } from \"./CreateFolderWithEvents\";\nimport { CreateFolderWithFolderLevelPermissions } from \"./CreateFolderWithFolderLevelPermissions\";\nimport type { FolderLevelPermissions } from \"~/flp\";\n\nexport interface CreateFolderUseCasesTopics {\n    onFolderBeforeCreate: Topic<OnFolderBeforeCreateTopicParams>;\n    onFolderAfterCreate: Topic<OnFolderAfterCreateTopicParams>;\n}\n\ninterface CreateFolderUseCasesParams {\n    createOperation: AcoFolderStorageOperations[\"createFolder\"];\n    folderLevelPermissions: FolderLevelPermissions;\n    topics: CreateFolderUseCasesTopics;\n}\n\nexport const getCreateFolderUseCases = (params: CreateFolderUseCasesParams) => {\n    const createFolder = new CreateFolder(params.createOperation);\n    const createFolderUseCaseWithEvents = new CreateFolderWithEvents(params.topics, createFolder);\n    const createFolderUseCase = new CreateFolderWithFolderLevelPermissions(\n        params.folderLevelPermissions,\n        createFolderUseCaseWithEvents\n    );\n\n    return {\n        createFolderUseCase\n    };\n};\n"],"mappings":";;;;;;AAMA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,uBAAA,GAAAD,OAAA;AACA,IAAAE,uCAAA,GAAAF,OAAA;AAcO,MAAMG,uBAAuB,GAAIC,MAAkC,IAAK;EAC3E,MAAMC,YAAY,GAAG,IAAIC,0BAAY,CAACF,MAAM,CAACG,eAAe,CAAC;EAC7D,MAAMC,6BAA6B,GAAG,IAAIC,8CAAsB,CAACL,MAAM,CAACM,MAAM,EAAEL,YAAY,CAAC;EAC7F,MAAMM,mBAAmB,GAAG,IAAIC,8EAAsC,CAClER,MAAM,CAACS,sBAAsB,EAC7BL,6BACJ,CAAC;EAED,OAAO;IACHG;EACJ,CAAC;AACL,CAAC;AAACG,OAAA,CAAAX,uBAAA,GAAAA,uBAAA","ignoreList":[]}

package/folder/useCases/DeleteFolder/DeleteFolder.d.ts

@@ -0,0 +1,7 @@
+import type { IDeleteFolder } from "./IDeleteFolder";
+import type { AcoFolderStorageOperations, DeleteFolderParams } from "../../folder.types";
+export declare class DeleteFolder implements IDeleteFolder {
+    private readonly deleteOperation;
+    constructor(deleteOperation: AcoFolderStorageOperations["deleteFolder"]);
+    execute(params: DeleteFolderParams): Promise<boolean>;
+}

package/folder/useCases/DeleteFolder/DeleteFolder.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DeleteFolder = void 0;
+class DeleteFolder {
+  constructor(deleteOperation) {
+    this.deleteOperation = deleteOperation;
+  }
+  async execute(params) {
+    await this.deleteOperation(params);
+    return true;
+  }
+}
+exports.DeleteFolder = DeleteFolder;
+
+//# sourceMappingURL=DeleteFolder.js.map

package/folder/useCases/DeleteFolder/DeleteFolder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DeleteFolder","constructor","deleteOperation","execute","params","exports"],"sources":["DeleteFolder.ts"],"sourcesContent":["import type { IDeleteFolder } from \"./IDeleteFolder\";\nimport type { AcoFolderStorageOperations, DeleteFolderParams } from \"~/folder/folder.types\";\n\nexport class DeleteFolder implements IDeleteFolder {\n    private readonly deleteOperation: AcoFolderStorageOperations[\"deleteFolder\"];\n\n    constructor(deleteOperation: AcoFolderStorageOperations[\"deleteFolder\"]) {\n        this.deleteOperation = deleteOperation;\n    }\n\n    async execute(params: DeleteFolderParams): Promise<boolean> {\n        await this.deleteOperation(params);\n        return true;\n    }\n}\n"],"mappings":";;;;;;AAGO,MAAMA,YAAY,CAA0B;EAG/CC,WAAWA,CAACC,eAA2D,EAAE;IACrE,IAAI,CAACA,eAAe,GAAGA,eAAe;EAC1C;EAEA,MAAMC,OAAOA,CAACC,MAA0B,EAAoB;IACxD,MAAM,IAAI,CAACF,eAAe,CAACE,MAAM,CAAC;IAClC,OAAO,IAAI;EACf;AACJ;AAACC,OAAA,CAAAL,YAAA,GAAAA,YAAA","ignoreList":[]}

package/folder/useCases/DeleteFolder/DeleteFolderWithEvents.d.ts

@@ -0,0 +1,10 @@
+import type { DeleteFolderUseCasesTopics } from "./index";
+import type { AcoFolderStorageOperations, DeleteFolderParams } from "../../folder.types";
+import type { IDeleteFolder } from "./IDeleteFolder";
+export declare class DeleteFolderWithEvents implements IDeleteFolder {
+    private topics;
+    private readonly getOperation;
+    private readonly decoretee;
+    constructor(topics: DeleteFolderUseCasesTopics, getOperation: AcoFolderStorageOperations["getFolder"], decoretee: IDeleteFolder);
+    execute(params: DeleteFolderParams): Promise<boolean>;
+}

package/folder/useCases/DeleteFolder/DeleteFolderWithEvents.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DeleteFolderWithEvents = void 0;
+class DeleteFolderWithEvents {
+  constructor(topics, getOperation, decoretee) {
+    this.topics = topics;
+    this.getOperation = getOperation;
+    this.decoretee = decoretee;
+  }
+  async execute(params) {
+    const folder = await this.getOperation({
+      id: params.id
+    });
+    await this.topics.onFolderBeforeDelete.publish({
+      folder
+    });
+    await this.decoretee.execute(params);
+    await this.topics.onFolderAfterDelete.publish({
+      folder
+    });
+    return true;
+  }
+}
+exports.DeleteFolderWithEvents = DeleteFolderWithEvents;
+
+//# sourceMappingURL=DeleteFolderWithEvents.js.map

package/folder/useCases/DeleteFolder/DeleteFolderWithEvents.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DeleteFolderWithEvents","constructor","topics","getOperation","decoretee","execute","params","folder","id","onFolderBeforeDelete","publish","onFolderAfterDelete","exports"],"sources":["DeleteFolderWithEvents.ts"],"sourcesContent":["import type { DeleteFolderUseCasesTopics } from \"./index\";\nimport type { AcoFolderStorageOperations, DeleteFolderParams } from \"~/folder/folder.types\";\nimport type { IDeleteFolder } from \"~/folder/useCases/DeleteFolder/IDeleteFolder\";\n\nexport class DeleteFolderWithEvents implements IDeleteFolder {\n    private topics: DeleteFolderUseCasesTopics;\n    private readonly getOperation: AcoFolderStorageOperations[\"getFolder\"];\n    private readonly decoretee: IDeleteFolder;\n\n    constructor(\n        topics: DeleteFolderUseCasesTopics,\n        getOperation: AcoFolderStorageOperations[\"getFolder\"],\n        decoretee: IDeleteFolder\n    ) {\n        this.topics = topics;\n        this.getOperation = getOperation;\n        this.decoretee = decoretee;\n    }\n\n    async execute(params: DeleteFolderParams) {\n        const folder = await this.getOperation({ id: params.id });\n        await this.topics.onFolderBeforeDelete.publish({ folder });\n        await this.decoretee.execute(params);\n        await this.topics.onFolderAfterDelete.publish({ folder });\n        return true;\n    }\n}\n"],"mappings":";;;;;;AAIO,MAAMA,sBAAsB,CAA0B;EAKzDC,WAAWA,CACPC,MAAkC,EAClCC,YAAqD,EACrDC,SAAwB,EAC1B;IACE,IAAI,CAACF,MAAM,GAAGA,MAAM;IACpB,IAAI,CAACC,YAAY,GAAGA,YAAY;IAChC,IAAI,CAACC,SAAS,GAAGA,SAAS;EAC9B;EAEA,MAAMC,OAAOA,CAACC,MAA0B,EAAE;IACtC,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACJ,YAAY,CAAC;MAAEK,EAAE,EAAEF,MAAM,CAACE;IAAG,CAAC,CAAC;IACzD,MAAM,IAAI,CAACN,MAAM,CAACO,oBAAoB,CAACC,OAAO,CAAC;MAAEH;IAAO,CAAC,CAAC;IAC1D,MAAM,IAAI,CAACH,SAAS,CAACC,OAAO,CAACC,MAAM,CAAC;IACpC,MAAM,IAAI,CAACJ,MAAM,CAACS,mBAAmB,CAACD,OAAO,CAAC;MAAEH;IAAO,CAAC,CAAC;IACzD,OAAO,IAAI;EACf;AACJ;AAACK,OAAA,CAAAZ,sBAAA,GAAAA,sBAAA","ignoreList":[]}

package/folder/useCases/DeleteFolder/DeleteFolderWithFolderLevelPermissions.d.ts

@@ -0,0 +1,9 @@
+import type { FolderLevelPermissions } from "../../../flp";
+import type { IDeleteFolder } from "./IDeleteFolder";
+import type { DeleteFolderParams } from "../../folder.types";
+export declare class DeleteFolderWithFolderLevelPermissions implements IDeleteFolder {
+    private folderLevelPermissions;
+    private readonly decoretee;
+    constructor(folderLevelPermissions: FolderLevelPermissions, decoretee: IDeleteFolder);
+    execute(params: DeleteFolderParams): Promise<boolean>;
+}

package/folder/useCases/DeleteFolder/DeleteFolderWithFolderLevelPermissions.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DeleteFolderWithFolderLevelPermissions = void 0;
+class DeleteFolderWithFolderLevelPermissions {
+  constructor(folderLevelPermissions, decoretee) {
+    this.folderLevelPermissions = folderLevelPermissions;
+    this.decoretee = decoretee;
+  }
+  async execute(params) {
+    const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(params.id);
+    await this.folderLevelPermissions.ensureCanAccessFolder({
+      permissions,
+      rwd: "d"
+    });
+    await this.decoretee.execute(params);
+    return true;
+  }
+}
+exports.DeleteFolderWithFolderLevelPermissions = DeleteFolderWithFolderLevelPermissions;
+
+//# sourceMappingURL=DeleteFolderWithFolderLevelPermissions.js.map

package/folder/useCases/DeleteFolder/DeleteFolderWithFolderLevelPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DeleteFolderWithFolderLevelPermissions","constructor","folderLevelPermissions","decoretee","execute","params","permissions","getFolderLevelPermissions","id","ensureCanAccessFolder","rwd","exports"],"sources":["DeleteFolderWithFolderLevelPermissions.ts"],"sourcesContent":["import type { FolderLevelPermissions } from \"~/flp\";\nimport type { IDeleteFolder } from \"./IDeleteFolder\";\nimport type { DeleteFolderParams } from \"~/folder/folder.types\";\n\nexport class DeleteFolderWithFolderLevelPermissions implements IDeleteFolder {\n    private folderLevelPermissions: FolderLevelPermissions;\n    private readonly decoretee: IDeleteFolder;\n\n    constructor(folderLevelPermissions: FolderLevelPermissions, decoretee: IDeleteFolder) {\n        this.folderLevelPermissions = folderLevelPermissions;\n        this.decoretee = decoretee;\n    }\n\n    async execute(params: DeleteFolderParams) {\n        const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(params.id);\n        await this.folderLevelPermissions.ensureCanAccessFolder({\n            permissions,\n            rwd: \"d\"\n        });\n        await this.decoretee.execute(params);\n        return true;\n    }\n}\n"],"mappings":";;;;;;AAIO,MAAMA,sCAAsC,CAA0B;EAIzEC,WAAWA,CAACC,sBAA8C,EAAEC,SAAwB,EAAE;IAClF,IAAI,CAACD,sBAAsB,GAAGA,sBAAsB;IACpD,IAAI,CAACC,SAAS,GAAGA,SAAS;EAC9B;EAEA,MAAMC,OAAOA,CAACC,MAA0B,EAAE;IACtC,MAAMC,WAAW,GAAG,MAAM,IAAI,CAACJ,sBAAsB,CAACK,yBAAyB,CAACF,MAAM,CAACG,EAAE,CAAC;IAC1F,MAAM,IAAI,CAACN,sBAAsB,CAACO,qBAAqB,CAAC;MACpDH,WAAW;MACXI,GAAG,EAAE;IACT,CAAC,CAAC;IACF,MAAM,IAAI,CAACP,SAAS,CAACC,OAAO,CAACC,MAAM,CAAC;IACpC,OAAO,IAAI;EACf;AACJ;AAACM,OAAA,CAAAX,sCAAA,GAAAA,sCAAA","ignoreList":[]}

package/folder/useCases/DeleteFolder/IDeleteFolder.d.ts

@@ -0,0 +1,4 @@
+import type { DeleteFolderParams } from "../../folder.types";
+export interface IDeleteFolder {
+    execute: (params: DeleteFolderParams) => Promise<boolean>;
+}

package/folder/useCases/DeleteFolder/IDeleteFolder.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+//# sourceMappingURL=IDeleteFolder.js.map

package/folder/useCases/DeleteFolder/IDeleteFolder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["IDeleteFolder.ts"],"sourcesContent":["import type { DeleteFolderParams } from \"~/folder/folder.types\";\n\nexport interface IDeleteFolder {\n    execute: (params: DeleteFolderParams) => Promise<boolean>;\n}\n"],"mappings":"","ignoreList":[]}

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

@@ -0,0 +1,18 @@
+import type { Topic } from "@webiny/pubsub/types";
+import { type AcoFolderStorageOperations, type OnFolderAfterDeleteTopicParams, type OnFolderBeforeDeleteTopicParams } from "../../folder.types";
+import { DeleteFolderWithFolderLevelPermissions } from "./DeleteFolderWithFolderLevelPermissions";
+import type { FolderLevelPermissions } from "../../../flp";
+export interface DeleteFolderUseCasesTopics {
+    onFolderBeforeDelete: Topic<OnFolderBeforeDeleteTopicParams>;
+    onFolderAfterDelete: Topic<OnFolderAfterDeleteTopicParams>;
+}
+interface DeleteFolderUseCasesParams {
+    deleteOperation: AcoFolderStorageOperations["deleteFolder"];
+    getOperation: AcoFolderStorageOperations["getFolder"];
+    folderLevelPermissions: FolderLevelPermissions;
+    topics: DeleteFolderUseCasesTopics;
+}
+export declare const getDeleteFolderUseCases: (params: DeleteFolderUseCasesParams) => {
+    deleteFolderUseCase: DeleteFolderWithFolderLevelPermissions;
+};
+export {};

package/folder/useCases/DeleteFolder/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDeleteFolderUseCases = void 0;
+var _DeleteFolder = require("./DeleteFolder");
+var _DeleteFolderWithEvents = require("./DeleteFolderWithEvents");
+var _DeleteFolderWithFolderLevelPermissions = require("./DeleteFolderWithFolderLevelPermissions");
+const getDeleteFolderUseCases = params => {
+  const deleteFolder = new _DeleteFolder.DeleteFolder(params.deleteOperation);
+  const deleteFolderUseCaseWithEvents = new _DeleteFolderWithEvents.DeleteFolderWithEvents(params.topics, params.getOperation, deleteFolder);
+  const deleteFolderUseCase = new _DeleteFolderWithFolderLevelPermissions.DeleteFolderWithFolderLevelPermissions(params.folderLevelPermissions, deleteFolderUseCaseWithEvents);
+  return {
+    deleteFolderUseCase
+  };
+};
+exports.getDeleteFolderUseCases = getDeleteFolderUseCases;
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_DeleteFolder","require","_DeleteFolderWithEvents","_DeleteFolderWithFolderLevelPermissions","getDeleteFolderUseCases","params","deleteFolder","DeleteFolder","deleteOperation","deleteFolderUseCaseWithEvents","DeleteFolderWithEvents","topics","getOperation","deleteFolderUseCase","DeleteFolderWithFolderLevelPermissions","folderLevelPermissions","exports"],"sources":["index.ts"],"sourcesContent":["import type { Topic } from \"@webiny/pubsub/types\";\nimport {\n    type AcoFolderStorageOperations,\n    type OnFolderAfterDeleteTopicParams,\n    type OnFolderBeforeDeleteTopicParams\n} from \"~/folder/folder.types\";\nimport { DeleteFolder } from \"./DeleteFolder\";\nimport { DeleteFolderWithEvents } from \"./DeleteFolderWithEvents\";\nimport { DeleteFolderWithFolderLevelPermissions } from \"./DeleteFolderWithFolderLevelPermissions\";\nimport type { FolderLevelPermissions } from \"~/flp\";\n\nexport interface DeleteFolderUseCasesTopics {\n    onFolderBeforeDelete: Topic<OnFolderBeforeDeleteTopicParams>;\n    onFolderAfterDelete: Topic<OnFolderAfterDeleteTopicParams>;\n}\n\ninterface DeleteFolderUseCasesParams {\n    deleteOperation: AcoFolderStorageOperations[\"deleteFolder\"];\n    getOperation: AcoFolderStorageOperations[\"getFolder\"];\n    folderLevelPermissions: FolderLevelPermissions;\n    topics: DeleteFolderUseCasesTopics;\n}\n\nexport const getDeleteFolderUseCases = (params: DeleteFolderUseCasesParams) => {\n    const deleteFolder = new DeleteFolder(params.deleteOperation);\n    const deleteFolderUseCaseWithEvents = new DeleteFolderWithEvents(\n        params.topics,\n        params.getOperation,\n        deleteFolder\n    );\n    const deleteFolderUseCase = new DeleteFolderWithFolderLevelPermissions(\n        params.folderLevelPermissions,\n        deleteFolderUseCaseWithEvents\n    );\n\n    return {\n        deleteFolderUseCase\n    };\n};\n"],"mappings":";;;;;;AAMA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,uBAAA,GAAAD,OAAA;AACA,IAAAE,uCAAA,GAAAF,OAAA;AAeO,MAAMG,uBAAuB,GAAIC,MAAkC,IAAK;EAC3E,MAAMC,YAAY,GAAG,IAAIC,0BAAY,CAACF,MAAM,CAACG,eAAe,CAAC;EAC7D,MAAMC,6BAA6B,GAAG,IAAIC,8CAAsB,CAC5DL,MAAM,CAACM,MAAM,EACbN,MAAM,CAACO,YAAY,EACnBN,YACJ,CAAC;EACD,MAAMO,mBAAmB,GAAG,IAAIC,8EAAsC,CAClET,MAAM,CAACU,sBAAsB,EAC7BN,6BACJ,CAAC;EAED,OAAO;IACHI;EACJ,CAAC;AACL,CAAC;AAACG,OAAA,CAAAZ,uBAAA,GAAAA,uBAAA","ignoreList":[]}

package/folder/useCases/GetAncestors/GetAncestors.d.ts

@@ -0,0 +1,9 @@
+import type { GetAncestorsParams, IGetAncestors } from "./IGetAncestors";
+import type { Folder } from "../../folder.types";
+import type { IListFolders } from "../ListFolders/IListFolders";
+export declare class GetAncestors implements IGetAncestors {
+    private listFoldersUseCase;
+    constructor(listFoldersUseCase: IListFolders);
+    execute(params: GetAncestorsParams): Promise<Folder[]>;
+    private listFolders;
+}

package/folder/useCases/GetAncestors/GetAncestors.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GetAncestors = void 0;
+var _constants = require("../../../constants");
+class GetAncestors {
+  constructor(listFoldersUseCase) {
+    this.listFoldersUseCase = listFoldersUseCase;
+  }
+  async execute(params) {
+    const {
+      folder
+    } = params;
+    const folders = await this.listFolders(folder);
+
+    // Create a Map with folders, using folder.id as key
+    const folderMap = new Map();
+    folders.forEach(folder => folderMap.set(folder.id, folder));
+    const findParents = (next, current) => {
+      // No folder found: return the result
+      if (!current) {
+        return next;
+      }
+
+      // Push the current folder into the accumulator array
+      next.push(current);
+
+      // No parentId found: return the result
+      if (!current.parentId) {
+        return next;
+      }
+      const parent = folderMap.get(current.parentId);
+
+      // No parent found: return the result
+      if (!parent) {
+        return next;
+      }
+
+      // Go ahead and find parent for the current parent
+      return findParents(next, parent);
+    };
+
+    // No folder found: return an empty array
+    if (!folder) {
+      return [];
+    }
+
+    // The folder has no parent (it's at root level): return an array with the folder
+    if (!folder.parentId) {
+      return [folder];
+    }
+
+    // Recursively find parents for a given folder id
+    return findParents([], folder);
+  }
+  async listFolders(folder) {
+    // Construct paths for all ancestors of the folder
+    const parts = folder.path.split("/").slice(1);
+    const paths = parts.map((_, index) => {
+      return [_constants.ROOT_FOLDER, ...parts.slice(0, index + 1)].join("/");
+    });
+
+    // Retrieve all folders that match the specified type and any of the constructed paths
+    const [folders] = await this.listFoldersUseCase.execute({
+      where: {
+        type: folder.type,
+        path_in: paths
+      }
+    });
+    return folders;
+  }
+}
+exports.GetAncestors = GetAncestors;
+
+//# sourceMappingURL=GetAncestors.js.map

package/folder/useCases/GetAncestors/GetAncestors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_constants","require","GetAncestors","constructor","listFoldersUseCase","execute","params","folder","folders","listFolders","folderMap","Map","forEach","set","id","findParents","next","current","push","parentId","parent","get","parts","path","split","slice","paths","map","_","index","ROOT_FOLDER","join","where","type","path_in","exports"],"sources":["GetAncestors.ts"],"sourcesContent":["import type { GetAncestorsParams, IGetAncestors } from \"./IGetAncestors\";\nimport type { Folder } from \"~/folder/folder.types\";\nimport type { IListFolders } from \"~/folder/useCases/ListFolders/IListFolders\";\nimport { ROOT_FOLDER } from \"~/constants\";\n\nexport class GetAncestors implements IGetAncestors {\n    private listFoldersUseCase: IListFolders;\n\n    constructor(listFoldersUseCase: IListFolders) {\n        this.listFoldersUseCase = listFoldersUseCase;\n    }\n\n    public async execute(params: GetAncestorsParams) {\n        const { folder } = params;\n\n        const folders = await this.listFolders(folder);\n\n        // Create a Map with folders, using folder.id as key\n        const folderMap = new Map<string, Folder>();\n        folders.forEach(folder => folderMap.set(folder.id, folder));\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        // No folder found: return an empty array\n        if (!folder) {\n            return [];\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 [folder];\n        }\n\n        // Recursively find parents for a given folder id\n        return findParents([], folder);\n    }\n\n    private async listFolders(folder: Folder) {\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 [folders] = await this.listFoldersUseCase.execute({\n            where: {\n                type: folder.type,\n                path_in: paths\n            }\n        });\n\n        return folders;\n    }\n}\n"],"mappings":";;;;;;AAGA,IAAAA,UAAA,GAAAC,OAAA;AAEO,MAAMC,YAAY,CAA0B;EAG/CC,WAAWA,CAACC,kBAAgC,EAAE;IAC1C,IAAI,CAACA,kBAAkB,GAAGA,kBAAkB;EAChD;EAEA,MAAaC,OAAOA,CAACC,MAA0B,EAAE;IAC7C,MAAM;MAAEC;IAAO,CAAC,GAAGD,MAAM;IAEzB,MAAME,OAAO,GAAG,MAAM,IAAI,CAACC,WAAW,CAACF,MAAM,CAAC;;IAE9C;IACA,MAAMG,SAAS,GAAG,IAAIC,GAAG,CAAiB,CAAC;IAC3CH,OAAO,CAACI,OAAO,CAACL,MAAM,IAAIG,SAAS,CAACG,GAAG,CAACN,MAAM,CAACO,EAAE,EAAEP,MAAM,CAAC,CAAC;IAE3D,MAAMQ,WAAW,GAAGA,CAACC,IAAc,EAAEC,OAAe,KAAe;MAC/D;MACA,IAAI,CAACA,OAAO,EAAE;QACV,OAAOD,IAAI;MACf;;MAEA;MACAA,IAAI,CAACE,IAAI,CAACD,OAAO,CAAC;;MAElB;MACA,IAAI,CAACA,OAAO,CAACE,QAAQ,EAAE;QACnB,OAAOH,IAAI;MACf;MAEA,MAAMI,MAAM,GAAGV,SAAS,CAACW,GAAG,CAACJ,OAAO,CAACE,QAAQ,CAAC;;MAE9C;MACA,IAAI,CAACC,MAAM,EAAE;QACT,OAAOJ,IAAI;MACf;;MAEA;MACA,OAAOD,WAAW,CAACC,IAAI,EAAEI,MAAM,CAAC;IACpC,CAAC;;IAED;IACA,IAAI,CAACb,MAAM,EAAE;MACT,OAAO,EAAE;IACb;;IAEA;IACA,IAAI,CAACA,MAAM,CAACY,QAAQ,EAAE;MAClB,OAAO,CAACZ,MAAM,CAAC;IACnB;;IAEA;IACA,OAAOQ,WAAW,CAAC,EAAE,EAAER,MAAM,CAAC;EAClC;EAEA,MAAcE,WAAWA,CAACF,MAAc,EAAE;IACtC;IACA,MAAMe,KAAK,GAAGf,MAAM,CAACgB,IAAI,CAACC,KAAK,CAAC,GAAG,CAAC,CAACC,KAAK,CAAC,CAAC,CAAC;IAC7C,MAAMC,KAAK,GAAGJ,KAAK,CAACK,GAAG,CAAC,CAACC,CAAC,EAAEC,KAAK,KAAK;MAClC,OAAO,CAACC,sBAAW,EAAE,GAAGR,KAAK,CAACG,KAAK,CAAC,CAAC,EAAEI,KAAK,GAAG,CAAC,CAAC,CAAC,CAACE,IAAI,CAAC,GAAG,CAAC;IAChE,CAAC,CAAC;;IAEF;IACA,MAAM,CAACvB,OAAO,CAAC,GAAG,MAAM,IAAI,CAACJ,kBAAkB,CAACC,OAAO,CAAC;MACpD2B,KAAK,EAAE;QACHC,IAAI,EAAE1B,MAAM,CAAC0B,IAAI;QACjBC,OAAO,EAAER;MACb;IACJ,CAAC,CAAC;IAEF,OAAOlB,OAAO;EAClB;AACJ;AAAC2B,OAAA,CAAAjC,YAAA,GAAAA,YAAA","ignoreList":[]}

package/folder/useCases/GetAncestors/IGetAncestors.d.ts

@@ -0,0 +1,7 @@
+import type { Folder } from "../../folder.types";
+export interface GetAncestorsParams {
+    folder: Folder;
+}
+export interface IGetAncestors {
+    execute: (params: GetAncestorsParams) => Promise<Folder[]>;
+}

package/folder/useCases/GetAncestors/IGetAncestors.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+//# sourceMappingURL=IGetAncestors.js.map

package/folder/useCases/GetAncestors/IGetAncestors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["IGetAncestors.ts"],"sourcesContent":["import type { Folder } from \"~/folder/folder.types\";\n\nexport interface GetAncestorsParams {\n    folder: Folder;\n}\n\nexport interface IGetAncestors {\n    execute: (params: GetAncestorsParams) => Promise<Folder[]>;\n}\n"],"mappings":"","ignoreList":[]}

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

@@ -0,0 +1,9 @@
+import { GetAncestors } from "./GetAncestors";
+import type { IListFolders } from "../ListFolders/IListFolders";
+interface GetAncestorsUseCasesParams {
+    listFoldersUseCase: IListFolders;
+}
+export declare const getGetAncestors: (params: GetAncestorsUseCasesParams) => {
+    getAncestorsUseCase: GetAncestors;
+};
+export {};

package/folder/useCases/GetAncestors/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getGetAncestors = void 0;
+var _GetAncestors = require("./GetAncestors");
+const getGetAncestors = params => {
+  const getAncestorsUseCase = new _GetAncestors.GetAncestors(params.listFoldersUseCase);
+  return {
+    getAncestorsUseCase
+  };
+};
+exports.getGetAncestors = getGetAncestors;
+
+//# sourceMappingURL=index.js.map