@webiny/api-aco 0.0.0-unstable.496cf268ac → 0.0.0-unstable.5387e5f7c8

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/FolderModelProvider.d.ts

@@ -0,0 +1,26 @@
+import type { CmsModel } from "@webiny/api-headless-cms/types";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { FolderModelProvider as Abstraction } from "../../domain/folder/abstractions.js";
+/**
+ * Resolves the tenant's ACO folder model on demand, replacing the per-request hook
+ * (`AcoInitializer`) that used to push an already-resolved model into the container.
+ *
+ * No memoization: `ModelsFetcher` already caches the model list per request (`ModelCache` is a
+ * per-request `createMemoryCache()`). No `withoutAuthorization` either — the folder model is
+ * private, and `PrivateModelBuilder` sets `authorization: false`, which short-circuits
+ * `canAccessModel()` to true for every identity, so the wrapper the initializer used changed
+ * nothing.
+ *
+ * `GetModelUseCase` is an ordinary constructor dependency: this provider is only constructed when a
+ * consumer first awaits `get()`, during request handling — after the CMS has registered everything
+ * the use case needs. That timing is what forced the initializer's lazy `container.resolve()`.
+ */
+declare class FolderModelProviderImpl implements Abstraction.Interface {
+    private getModel;
+    constructor(getModel: GetModelUseCase.Interface);
+    get(): Promise<CmsModel>;
+}
+export declare const FolderModelProvider: typeof FolderModelProviderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/domain/folder/abstractions.js").IFolderModelProvider>;
+};
+export {};

package/features/folder/FolderModelProvider.js

@@ -0,0 +1,22 @@
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { FolderModelProvider } from "../../domain/folder/abstractions.js";
+import { FOLDER_MODEL_ID } from "../../domain/folder/folder.model.js";
+class FolderModelProviderImpl {
+    constructor(getModel){
+        this.getModel = getModel;
+    }
+    async get() {
+        const result = await this.getModel.execute(FOLDER_MODEL_ID);
+        if (result.isFail()) throw result.error;
+        return result.value;
+    }
+}
+const FolderModelProvider_FolderModelProvider = FolderModelProvider.createImplementation({
+    implementation: FolderModelProviderImpl,
+    dependencies: [
+        GetModelUseCase
+    ]
+});
+export { FolderModelProvider_FolderModelProvider as FolderModelProvider };
+
+//# sourceMappingURL=FolderModelProvider.js.map

package/features/folder/FolderModelProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/FolderModelProvider.js","sources":["../../../src/features/folder/FolderModelProvider.ts"],"sourcesContent":["import type { CmsModel } from \"@webiny/api-headless-cms/types\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { FolderModelProvider as Abstraction } from \"~/domain/folder/abstractions.js\";\nimport { FOLDER_MODEL_ID } from \"~/domain/folder/folder.model.js\";\n\n/**\n * Resolves the tenant's ACO folder model on demand, replacing the per-request hook\n * (`AcoInitializer`) that used to push an already-resolved model into the container.\n *\n * No memoization: `ModelsFetcher` already caches the model list per request (`ModelCache` is a\n * per-request `createMemoryCache()`). No `withoutAuthorization` either — the folder model is\n * private, and `PrivateModelBuilder` sets `authorization: false`, which short-circuits\n * `canAccessModel()` to true for every identity, so the wrapper the initializer used changed\n * nothing.\n *\n * `GetModelUseCase` is an ordinary constructor dependency: this provider is only constructed when a\n * consumer first awaits `get()`, during request handling — after the CMS has registered everything\n * the use case needs. That timing is what forced the initializer's lazy `container.resolve()`.\n */\nclass FolderModelProviderImpl implements Abstraction.Interface {\n    constructor(private getModel: GetModelUseCase.Interface) {}\n\n    async get(): Promise<CmsModel> {\n        const result = await this.getModel.execute(FOLDER_MODEL_ID);\n        if (result.isFail()) {\n            throw result.error;\n        }\n        return result.value;\n    }\n}\n\nexport const FolderModelProvider = Abstraction.createImplementation({\n    implementation: FolderModelProviderImpl,\n    dependencies: [GetModelUseCase]\n});\n"],"names":["FolderModelProviderImpl","getModel","result","FOLDER_MODEL_ID","FolderModelProvider","Abstraction","GetModelUseCase"],"mappings":";;;AAmBA,MAAMA;IACF,YAAoBC,QAAmC,CAAE;aAArCA,QAAQ,GAARA;IAAsC;IAE1D,MAAM,MAAyB;QAC3B,MAAMC,SAAS,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACC;QAC3C,IAAID,OAAO,MAAM,IACb,MAAMA,OAAO,KAAK;QAEtB,OAAOA,OAAO,KAAK;IACvB;AACJ;AAEO,MAAME,0CAAsBC,oBAAAA,oBAAgC,CAAC;IAChE,gBAAgBL;IAChB,cAAc;QAACM;KAAgB;AACnC"}

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 { FolderModelProvider } from "../../../domain/folder/abstractions.js";
+import type { Folder } from "../../../folder/folder.types.js";
+declare class GetAncestorsRepositoryImpl implements IGetAncestorsRepository {
+    private listLatestEntries;
+    private folderModelProvider;
+    constructor(listLatestEntries: ListLatestEntriesUseCase.Interface, folderModelProvider: FolderModelProvider.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,59 @@
+import { Result } from "@webiny/feature/api";
+import { GetAncestorsRepository } from "./abstractions.js";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { FolderModelProvider } 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, folderModelProvider){
+        this.listLatestEntries = listLatestEntries;
+        this.folderModelProvider = folderModelProvider;
+    }
+    async execute(params) {
+        const folderModel = await this.folderModelProvider.get();
+        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(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,
+        FolderModelProvider
+    ]
+});
+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 { FolderModelProvider } 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 folderModelProvider: FolderModelProvider.Interface\n    ) {}\n\n    async execute(\n        params: GetAncestorsParams\n    ): Promise<Result<Folder[], RepositoryAbstraction.Error>> {\n        const folderModel = await this.folderModelProvider.get();\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>(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, FolderModelProvider]\n});\n"],"names":["GetAncestorsRepositoryImpl","listLatestEntries","folderModelProvider","params","folderModel","folder","Result","parts","paths","_","index","ROOT_FOLDER","result","FolderPersistenceError","entries","folders","entry","EntryToFolderMapper","folderMap","Map","f","findParents","next","current","parent","ancestors","GetAncestorsRepository","RepositoryAbstraction","ListLatestEntriesUseCase","FolderModelProvider"],"mappings":";;;;;;;AAaA,MAAMA;IACF,YACYC,iBAAqD,EACrDC,mBAAkD,CAC5D;aAFUD,iBAAiB,GAAjBA;aACAC,mBAAmB,GAAnBA;IACT;IAEH,MAAM,QACFC,MAA0B,EAC4B;QACtD,MAAMC,cAAc,MAAM,IAAI,CAAC,mBAAmB,CAAC,GAAG;QACtD,MAAM,EAAEC,MAAM,EAAE,GAAGF;QAGnB,IAAI,CAACE,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,CAAiBR,aAAa;YAC7E,OAAO;gBACH,QAAQ;oBACJ,MAAMC,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,gBAAgB3B;IAChB,cAAc;QAAC4B;QAA0BC;KAAoB;AACjE"}

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

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

package/features/folder/GetAncestors/GetAncestorsUseCase.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetAncestors/GetAncestorsUseCase.js","sources":["../../../../src/features/folder/GetAncestors/GetAncestorsUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    GetAncestorsUseCase as UseCaseAbstraction,\n    GetAncestorsRepository,\n    type GetAncestorsParams\n} from \"./abstractions.js\";\nimport type { Folder } from \"~/folder/folder.types.js\";\nimport { createImplementation } from \"@webiny/di\";\n\nclass GetAncestorsUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: GetAncestorsRepository.Interface) {}\n\n    public async execute(\n        params: GetAncestorsParams\n    ): Promise<Result<Folder[], UseCaseAbstraction.Error>> {\n        return await this.repository.execute(params);\n    }\n}\n\nexport const GetAncestorsUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: GetAncestorsUseCaseImpl,\n    dependencies: [GetAncestorsRepository]\n});\n"],"names":["GetAncestorsUseCaseImpl","repository","params","GetAncestorsUseCase","createImplementation","UseCaseAbstraction","GetAncestorsRepository"],"mappings":";;AASA,MAAMA;IACF,YAAoBC,UAA4C,CAAE;aAA9CA,UAAU,GAAVA;IAA+C;IAEnE,MAAa,QACTC,MAA0B,EACyB;QACnD,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACzC;AACJ;AAEO,MAAMC,0CAAsBC,qBAAqB;IACpD,aAAaC;IACb,gBAAgBL;IAChB,cAAc;QAACM;KAAuB;AAC1C"}

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

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

package/features/folder/GetAncestors/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetAncestors/abstractions.js","sources":["../../../../src/features/folder/GetAncestors/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { Folder } from \"~/folder/folder.types.js\";\nimport type { FolderNotAuthorizedError, FolderPersistenceError } from \"~/domain/folder/errors.js\";\n\n/**\n * GetAncestors repository interface\n */\nexport interface IGetAncestorsRepository {\n    execute(params: GetAncestorsParams): Promise<Result<Folder[], RepositoryError>>;\n}\n\nexport interface IGetAncestorsRepositoryErrors {\n    persistence: FolderPersistenceError;\n}\n\ntype RepositoryError = IGetAncestorsRepositoryErrors[keyof IGetAncestorsRepositoryErrors];\n\n/** Fetch ancestor folders from storage. */\nexport const GetAncestorsRepository =\n    createAbstraction<IGetAncestorsRepository>(\"GetAncestorsRepository\");\n\nexport namespace GetAncestorsRepository {\n    export type Interface = IGetAncestorsRepository;\n    export type Error = RepositoryError;\n}\n\n/**\n * GetAncestors use case interface\n */\nexport interface GetAncestorsParams {\n    folder: Folder;\n}\n\nexport interface IGetAncestorsUseCase {\n    execute(params: GetAncestorsParams): Promise<Result<Folder[], UseCaseError>>;\n}\n\nexport interface IGetAncestorsUseCaseErrors {\n    notAuthorized: FolderNotAuthorizedError;\n    persistence: FolderPersistenceError;\n}\n\ntype UseCaseError = IGetAncestorsUseCaseErrors[keyof IGetAncestorsUseCaseErrors];\n\n/** Retrieve ancestor folders in the hierarchy. */\nexport const GetAncestorsUseCase = createAbstraction<IGetAncestorsUseCase>(\"GetAncestorsUseCase\");\n\nexport namespace GetAncestorsUseCase {\n    export type Interface = IGetAncestorsUseCase;\n    export type Error = UseCaseError;\n}\n"],"names":["GetAncestorsRepository","createAbstraction","GetAncestorsUseCase"],"mappings":";AAmBO,MAAMA,yBACTC,kBAA2C;AA0BxC,MAAMC,sBAAsBD,kBAAwC"}

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

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

package/features/folder/GetAncestors/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetAncestors/feature.js","sources":["../../../../src/features/folder/GetAncestors/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { GetAncestorsRepository } from \"./GetAncestorsRepository.js\";\nimport { GetAncestorsUseCase } from \"./GetAncestorsUseCase.js\";\n\nexport const GetAncestorsFeature = createFeature({\n    name: \"GetAncestors\",\n    register(container: Container) {\n        container.register(GetAncestorsRepository).inSingletonScope();\n        container.register(GetAncestorsUseCase);\n    }\n});\n"],"names":["GetAncestorsFeature","createFeature","container","GetAncestorsRepository","GetAncestorsUseCase"],"mappings":";;;AAKO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC,wBAAwB,gBAAgB;QAC3DD,UAAU,QAAQ,CAACE;IACvB;AACJ"}

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

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

package/features/folder/GetAncestors/index.js

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

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

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

package/features/folder/GetFolder/GetFolderRepository.js

@@ -0,0 +1,34 @@
+import { Result } from "@webiny/feature/api";
+import { GetFolderRepository } from "./abstractions.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { FolderModelProvider } from "../../../domain/folder/abstractions.js";
+import { EntryToFolderMapper } from "../shared/EntryToFolderMapper.js";
+import { FolderNotFoundError, FolderPersistenceError } from "../../../domain/folder/errors.js";
+import { EntryId } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+class GetFolderRepositoryImpl {
+    constructor(getEntryById, folderModelProvider){
+        this.getEntryById = getEntryById;
+        this.folderModelProvider = folderModelProvider;
+    }
+    async execute(id) {
+        const folderModel = await this.folderModelProvider.get();
+        const entryId = EntryId.from(id);
+        const result = await this.getEntryById.execute(folderModel, entryId.toString());
+        if (result.isFail()) {
+            if ("Cms/Entry/NotFound" === result.error.code) return Result.fail(new FolderNotFoundError(id));
+            return Result.fail(new FolderPersistenceError(result.error));
+        }
+        const folder = EntryToFolderMapper.toFolder(result.value);
+        return Result.ok(folder);
+    }
+}
+const GetFolderRepository_GetFolderRepository = GetFolderRepository.createImplementation({
+    implementation: GetFolderRepositoryImpl,
+    dependencies: [
+        GetEntryByIdUseCase,
+        FolderModelProvider
+    ]
+});
+export { GetFolderRepository_GetFolderRepository as GetFolderRepository };
+
+//# sourceMappingURL=GetFolderRepository.js.map

package/features/folder/GetFolder/GetFolderRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetFolder/GetFolderRepository.js","sources":["../../../../src/features/folder/GetFolder/GetFolderRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    GetFolderRepository as RepositoryAbstraction,\n    type IGetFolderRepository\n} from \"./abstractions.js\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { FolderModelProvider } from \"~/domain/folder/abstractions.js\";\nimport type { CmsEntryFolder, Folder } from \"~/folder/folder.types.js\";\nimport { EntryToFolderMapper } from \"../shared/EntryToFolderMapper.js\";\nimport { FolderNotFoundError, FolderPersistenceError } from \"~/domain/folder/errors.js\";\nimport { EntryId } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\n\nclass GetFolderRepositoryImpl implements IGetFolderRepository {\n    constructor(\n        private getEntryById: GetEntryByIdUseCase.Interface,\n        private folderModelProvider: FolderModelProvider.Interface\n    ) {}\n\n    async execute(id: string): Promise<Result<Folder, RepositoryAbstraction.Error>> {\n        const folderModel = await this.folderModelProvider.get();\n        const entryId = EntryId.from(id);\n        const result = await this.getEntryById.execute<CmsEntryFolder>(\n            folderModel,\n            entryId.toString()\n        );\n\n        if (result.isFail()) {\n            if (result.error.code === \"Cms/Entry/NotFound\") {\n                return Result.fail(new FolderNotFoundError(id));\n            }\n\n            return Result.fail(new FolderPersistenceError(result.error));\n        }\n\n        const folder = EntryToFolderMapper.toFolder(result.value);\n        return Result.ok(folder);\n    }\n}\n\nexport const GetFolderRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetFolderRepositoryImpl,\n    dependencies: [GetEntryByIdUseCase, FolderModelProvider]\n});\n"],"names":["GetFolderRepositoryImpl","getEntryById","folderModelProvider","id","folderModel","entryId","EntryId","result","Result","FolderNotFoundError","FolderPersistenceError","folder","EntryToFolderMapper","GetFolderRepository","RepositoryAbstraction","GetEntryByIdUseCase","FolderModelProvider"],"mappings":";;;;;;;AAYA,MAAMA;IACF,YACYC,YAA2C,EAC3CC,mBAAkD,CAC5D;aAFUD,YAAY,GAAZA;aACAC,mBAAmB,GAAnBA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAwD;QAC5E,MAAMC,cAAc,MAAM,IAAI,CAAC,mBAAmB,CAAC,GAAG;QACtD,MAAMC,UAAUC,QAAQ,IAAI,CAACH;QAC7B,MAAMI,SAAS,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAC1CH,aACAC,QAAQ,QAAQ;QAGpB,IAAIE,OAAO,MAAM,IAAI;YACjB,IAAIA,AAAsB,yBAAtBA,OAAO,KAAK,CAAC,IAAI,EACjB,OAAOC,OAAO,IAAI,CAAC,IAAIC,oBAAoBN;YAG/C,OAAOK,OAAO,IAAI,CAAC,IAAIE,uBAAuBH,OAAO,KAAK;QAC9D;QAEA,MAAMI,SAASC,oBAAoB,QAAQ,CAACL,OAAO,KAAK;QACxD,OAAOC,OAAO,EAAE,CAACG;IACrB;AACJ;AAEO,MAAME,0CAAsBC,oBAAAA,oBAA0C,CAAC;IAC1E,gBAAgBd;IAChB,cAAc;QAACe;QAAqBC;KAAoB;AAC5D"}

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

@@ -0,0 +1,10 @@
+import { Result } from "@webiny/feature/api";
+import { GetFolderUseCase as UseCaseAbstraction, GetFolderRepository } from "./abstractions.js";
+import type { Folder } from "../../../folder/folder.types.js";
+declare class GetFolderUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: GetFolderRepository.Interface);
+    execute(id: string): Promise<Result<Folder, UseCaseAbstraction.Error>>;
+}
+export declare const GetFolderUseCase: import("@webiny/di").Implementation<typeof GetFolderUseCaseImpl>;
+export {};

package/features/folder/GetFolder/GetFolderUseCase.js

@@ -0,0 +1,20 @@
+import { createImplementation } from "@webiny/feature/api";
+import { GetFolderRepository, GetFolderUseCase } from "./abstractions.js";
+class GetFolderUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(id) {
+        return this.repository.execute(id);
+    }
+}
+const GetFolderUseCase_GetFolderUseCase = createImplementation({
+    abstraction: GetFolderUseCase,
+    implementation: GetFolderUseCaseImpl,
+    dependencies: [
+        GetFolderRepository
+    ]
+});
+export { GetFolderUseCase_GetFolderUseCase as GetFolderUseCase };
+
+//# sourceMappingURL=GetFolderUseCase.js.map

package/features/folder/GetFolder/GetFolderUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetFolder/GetFolderUseCase.js","sources":["../../../../src/features/folder/GetFolder/GetFolderUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { GetFolderUseCase as UseCaseAbstraction, GetFolderRepository } from \"./abstractions.js\";\nimport type { Folder } from \"~/folder/folder.types.js\";\n\nclass GetFolderUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: GetFolderRepository.Interface) {}\n\n    async execute(id: string): Promise<Result<Folder, UseCaseAbstraction.Error>> {\n        return this.repository.execute(id);\n    }\n}\n\nexport const GetFolderUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: GetFolderUseCaseImpl,\n    dependencies: [GetFolderRepository]\n});\n"],"names":["GetFolderUseCaseImpl","repository","id","GetFolderUseCase","createImplementation","UseCaseAbstraction","GetFolderRepository"],"mappings":";;AAKA,MAAMA;IACF,YAAoBC,UAAyC,CAAE;aAA3CA,UAAU,GAAVA;IAA4C;IAEhE,MAAM,QAAQC,EAAU,EAAqD;QACzE,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACnC;AACJ;AAEO,MAAMC,oCAAmBC,qBAAqB;IACjD,aAAaC;IACb,gBAAgBL;IAChB,cAAc;QAACM;KAAoB;AACvC"}

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

@@ -0,0 +1,57 @@
+import type { Result } from "@webiny/feature/api";
+import { DomainEvent, IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { Folder, GetFolderParams } from "../../../folder/folder.types.js";
+import type { FolderNotAuthorizedError, FolderNotFoundError, FolderPersistenceError } from "../../../domain/folder/errors.js";
+/**
+ * GetFolder repository interface
+ */
+export interface IGetFolderRepository {
+    execute(id: string): Promise<Result<Folder, RepositoryError>>;
+}
+export interface IGetFolderRepositoryErrors {
+    notFound: FolderNotFoundError;
+    persistence: FolderPersistenceError;
+}
+type RepositoryError = IGetFolderRepositoryErrors[keyof IGetFolderRepositoryErrors];
+export declare const GetFolderRepository: import("@webiny/di").Abstraction<IGetFolderRepository>;
+export declare namespace GetFolderRepository {
+    type Interface = IGetFolderRepository;
+    type Error = RepositoryError;
+}
+/**
+ * GetFolder use case interface
+ */
+export interface IGetFolderUseCase {
+    execute(id: string): Promise<Result<Folder, UseCaseError>>;
+}
+export interface IGetFolderUseCaseErrors {
+    notAuthorized: FolderNotAuthorizedError;
+    notFound: FolderNotFoundError;
+    persistence: FolderPersistenceError;
+}
+type UseCaseError = IGetFolderUseCaseErrors[keyof IGetFolderUseCaseErrors];
+/** Retrieve a folder. */
+export declare const GetFolderUseCase: import("@webiny/di").Abstraction<IGetFolderUseCase>;
+export declare namespace GetFolderUseCase {
+    type Interface = IGetFolderUseCase;
+    type Error = UseCaseError;
+}
+export interface FolderBeforeGetPayload {
+    params: GetFolderParams;
+}
+export interface FolderAfterGetPayload {
+    folder: Folder;
+}
+/** Hook into folder lifecycle before a folder is retrieved. */
+export declare const FolderBeforeGetEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<FolderBeforeGetPayload>>>;
+export declare namespace FolderBeforeGetEventHandler {
+    type Interface = IEventHandler<DomainEvent<FolderBeforeGetPayload>>;
+    type Event = DomainEvent<FolderBeforeGetPayload>;
+}
+/** Hook into folder lifecycle after a folder is retrieved. */
+export declare const FolderAfterGetEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<FolderAfterGetPayload>>>;
+export declare namespace FolderAfterGetEventHandler {
+    type Interface = IEventHandler<DomainEvent<FolderAfterGetPayload>>;
+    type Event = DomainEvent<FolderAfterGetPayload>;
+}
+export {};

package/features/folder/GetFolder/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetFolder/abstractions.js","sources":["../../../../src/features/folder/GetFolder/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport { DomainEvent, IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { Folder, GetFolderParams } from \"~/folder/folder.types.js\";\nimport type {\n    FolderNotAuthorizedError,\n    FolderNotFoundError,\n    FolderPersistenceError\n} from \"~/domain/folder/errors.js\";\n\n/**\n * GetFolder repository interface\n */\nexport interface IGetFolderRepository {\n    execute(id: string): Promise<Result<Folder, RepositoryError>>;\n}\n\nexport interface IGetFolderRepositoryErrors {\n    notFound: FolderNotFoundError;\n    persistence: FolderPersistenceError;\n}\n\ntype RepositoryError = IGetFolderRepositoryErrors[keyof IGetFolderRepositoryErrors];\n\nexport const GetFolderRepository = createAbstraction<IGetFolderRepository>(\"GetFolderRepository\");\n\nexport namespace GetFolderRepository {\n    export type Interface = IGetFolderRepository;\n    export type Error = RepositoryError;\n}\n\n/**\n * GetFolder use case interface\n */\nexport interface IGetFolderUseCase {\n    execute(id: string): Promise<Result<Folder, UseCaseError>>;\n}\n\nexport interface IGetFolderUseCaseErrors {\n    notAuthorized: FolderNotAuthorizedError;\n    notFound: FolderNotFoundError;\n    persistence: FolderPersistenceError;\n}\n\ntype UseCaseError = IGetFolderUseCaseErrors[keyof IGetFolderUseCaseErrors];\n\n/** Retrieve a folder. */\nexport const GetFolderUseCase = createAbstraction<IGetFolderUseCase>(\"GetFolderUseCase\");\n\nexport namespace GetFolderUseCase {\n    export type Interface = IGetFolderUseCase;\n    export type Error = UseCaseError;\n}\n\n// Event Payload Types\nexport interface FolderBeforeGetPayload {\n    params: GetFolderParams;\n}\n\nexport interface FolderAfterGetPayload {\n    folder: Folder;\n}\n\n// Event Handler Abstractions\n/** Hook into folder lifecycle before a folder is retrieved. */\nexport const FolderBeforeGetEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<FolderBeforeGetPayload>>\n>(\"FolderBeforeGetEventHandler\");\n\nexport namespace FolderBeforeGetEventHandler {\n    export type Interface = IEventHandler<DomainEvent<FolderBeforeGetPayload>>;\n    export type Event = DomainEvent<FolderBeforeGetPayload>;\n}\n\n/** Hook into folder lifecycle after a folder is retrieved. */\nexport const FolderAfterGetEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<FolderAfterGetPayload>>\n>(\"FolderAfterGetEventHandler\");\n\nexport namespace FolderAfterGetEventHandler {\n    export type Interface = IEventHandler<DomainEvent<FolderAfterGetPayload>>;\n    export type Event = DomainEvent<FolderAfterGetPayload>;\n}\n"],"names":["GetFolderRepository","createAbstraction","GetFolderUseCase","FolderBeforeGetEventHandler","FolderAfterGetEventHandler"],"mappings":";AAwBO,MAAMA,sBAAsBC,kBAAwC;AAuBpE,MAAMC,mBAAmBD,kBAAqC;AAkB9D,MAAME,8BAA8BF,kBAEzC;AAQK,MAAMG,6BAA6BH,kBAExC"}

package/features/folder/GetFolder/decorators/GetFolderWithFolderLevelPermissions.d.ts

@@ -0,0 +1,29 @@
+import { GetFolderUseCase } from "../abstractions.js";
+import { Result } from "@webiny/feature/api";
+import { FolderLevelPermissions } from "../../../../features/flp/FolderLevelPermissions/index.js";
+import { FolderNotAuthorizedError } from "../../../../domain/folder/errors.js";
+declare class GetFolderWithFolderLevelPermissionsImpl implements GetFolderUseCase.Interface {
+    private folderLevelPermissions;
+    private readonly decoretee;
+    constructor(folderLevelPermissions: FolderLevelPermissions.Interface, decoretee: GetFolderUseCase.Interface);
+    execute(id: string): Promise<Result<never, FolderNotAuthorizedError | import("~/domain/folder/errors.js").FolderNotFoundError | import("~/domain/folder/errors.js").FolderPersistenceError> | Result<{
+        title: string;
+        slug: string;
+        type: string;
+        parentId?: string | null;
+        path: string;
+        extensions?: Record<string, any>;
+        id: string;
+        createdOn: string;
+        modifiedOn: string | null;
+        savedOn: string;
+        createdBy: import("../../../../types.js").User;
+        modifiedBy: import("../../../../types.js").User | null;
+        savedBy: import("../../../../types.js").User;
+        permissions: import("@webiny/shared-aco/flp/flp.types.js").FolderPermission[];
+    }, never>>;
+}
+export declare const GetFolderWithFolderLevelPermissions: typeof GetFolderWithFolderLevelPermissionsImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions.js").IGetFolderUseCase>;
+};
+export {};

package/features/folder/GetFolder/decorators/GetFolderWithFolderLevelPermissions.js

@@ -0,0 +1,34 @@
+import { GetFolderUseCase } from "../abstractions.js";
+import { Result } from "@webiny/feature/api";
+import { FolderLevelPermissions } from "../../../flp/FolderLevelPermissions/index.js";
+import { FolderNotAuthorizedError } from "../../../../domain/folder/errors.js";
+class GetFolderWithFolderLevelPermissionsImpl {
+    constructor(folderLevelPermissions, decoretee){
+        this.folderLevelPermissions = folderLevelPermissions;
+        this.decoretee = decoretee;
+    }
+    async execute(id) {
+        const result = await this.decoretee.execute(id);
+        if (result.isFail()) return Result.fail(result.error);
+        const folder = result.value;
+        const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(folder.id);
+        const canAccessFolder = await this.folderLevelPermissions.canAccessFolder({
+            permissions,
+            rwd: "r"
+        });
+        if (!canAccessFolder) return Result.fail(new FolderNotAuthorizedError());
+        return Result.ok({
+            ...folder,
+            permissions
+        });
+    }
+}
+const GetFolderWithFolderLevelPermissions = GetFolderUseCase.createDecorator({
+    decorator: GetFolderWithFolderLevelPermissionsImpl,
+    dependencies: [
+        FolderLevelPermissions
+    ]
+});
+export { GetFolderWithFolderLevelPermissions };
+
+//# sourceMappingURL=GetFolderWithFolderLevelPermissions.js.map