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

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

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

package/features/folder/GetFolder/GetFolderRepository.js

@@ -0,0 +1,31 @@
+import { Result } from "@webiny/feature/api";
+import { GetFolderRepository as RepositoryAbstraction } from "./abstractions.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { FolderModel } 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, folderModel) {
+    this.getEntryById = getEntryById;
+    this.folderModel = folderModel;
+  }
+  async execute(id) {
+    const entryId = EntryId.from(id);
+    const result = await this.getEntryById.execute(this.folderModel, entryId.toString());
+    if (result.isFail()) {
+      if (result.error.code === "Cms/Entry/NotFound") {
+        return Result.fail(new FolderNotFoundError(id));
+      }
+      return Result.fail(new FolderPersistenceError(result.error));
+    }
+    const folder = EntryToFolderMapper.toFolder(result.value);
+    return Result.ok(folder);
+  }
+}
+export const GetFolderRepository = RepositoryAbstraction.createImplementation({
+  implementation: GetFolderRepositoryImpl,
+  dependencies: [GetEntryByIdUseCase, FolderModel]
+});
+
+//# sourceMappingURL=GetFolderRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","GetFolderRepository","RepositoryAbstraction","GetEntryByIdUseCase","FolderModel","EntryToFolderMapper","FolderNotFoundError","FolderPersistenceError","EntryId","GetFolderRepositoryImpl","constructor","getEntryById","folderModel","execute","id","entryId","from","result","toString","isFail","error","code","fail","folder","toFolder","value","ok","createImplementation","implementation","dependencies"],"sources":["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 { FolderModel } 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 folderModel: FolderModel.Interface\n    ) {}\n\n    async execute(id: string): Promise<Result<Folder, RepositoryAbstraction.Error>> {\n        const entryId = EntryId.from(id);\n        const result = await this.getEntryById.execute<CmsEntryFolder>(\n            this.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, FolderModel]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SACIC,mBAAmB,IAAIC,qBAAqB;AAGhD,SAASC,mBAAmB,QAAQ,6DAA6D;AACjG,SAASC,WAAW;AAEpB,SAASC,mBAAmB;AAC5B,SAASC,mBAAmB,EAAEC,sBAAsB;AACpD,SAASC,OAAO,QAAQ,mDAAmD;AAE3E,MAAMC,uBAAuB,CAAiC;EAC1DC,WAAWA,CACCC,YAA2C,EAC3CC,WAAkC,EAC5C;IAAA,KAFUD,YAA2C,GAA3CA,YAA2C;IAAA,KAC3CC,WAAkC,GAAlCA,WAAkC;EAC3C;EAEH,MAAMC,OAAOA,CAACC,EAAU,EAAwD;IAC5E,MAAMC,OAAO,GAAGP,OAAO,CAACQ,IAAI,CAACF,EAAE,CAAC;IAChC,MAAMG,MAAM,GAAG,MAAM,IAAI,CAACN,YAAY,CAACE,OAAO,CAC1C,IAAI,CAACD,WAAW,EAChBG,OAAO,CAACG,QAAQ,CAAC,CACrB,CAAC;IAED,IAAID,MAAM,CAACE,MAAM,CAAC,CAAC,EAAE;MACjB,IAAIF,MAAM,CAACG,KAAK,CAACC,IAAI,KAAK,oBAAoB,EAAE;QAC5C,OAAOrB,MAAM,CAACsB,IAAI,CAAC,IAAIhB,mBAAmB,CAACQ,EAAE,CAAC,CAAC;MACnD;MAEA,OAAOd,MAAM,CAACsB,IAAI,CAAC,IAAIf,sBAAsB,CAACU,MAAM,CAACG,KAAK,CAAC,CAAC;IAChE;IAEA,MAAMG,MAAM,GAAGlB,mBAAmB,CAACmB,QAAQ,CAACP,MAAM,CAACQ,KAAK,CAAC;IACzD,OAAOzB,MAAM,CAAC0B,EAAE,CAACH,MAAM,CAAC;EAC5B;AACJ;AAEA,OAAO,MAAMtB,mBAAmB,GAAGC,qBAAqB,CAACyB,oBAAoB,CAAC;EAC1EC,cAAc,EAAEnB,uBAAuB;EACvCoB,YAAY,EAAE,CAAC1B,mBAAmB,EAAEC,WAAW;AACnD,CAAC,CAAC","ignoreList":[]}

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,17 @@
+import { createImplementation } from "@webiny/feature/api";
+import { GetFolderUseCase as UseCaseAbstraction, GetFolderRepository } from "./abstractions.js";
+class GetFolderUseCaseImpl {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  async execute(id) {
+    return this.repository.execute(id);
+  }
+}
+export const GetFolderUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: GetFolderUseCaseImpl,
+  dependencies: [GetFolderRepository]
+});
+
+//# sourceMappingURL=GetFolderUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","GetFolderUseCase","UseCaseAbstraction","GetFolderRepository","GetFolderUseCaseImpl","constructor","repository","execute","id","abstraction","implementation","dependencies"],"sources":["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"],"mappings":"AACA,SAASA,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,gBAAgB,IAAIC,kBAAkB,EAAEC,mBAAmB;AAGpE,MAAMC,oBAAoB,CAAyC;EAC/DC,WAAWA,CAASC,UAAyC,EAAE;IAAA,KAA3CA,UAAyC,GAAzCA,UAAyC;EAAG;EAEhE,MAAMC,OAAOA,CAACC,EAAU,EAAqD;IACzE,OAAO,IAAI,CAACF,UAAU,CAACC,OAAO,CAACC,EAAE,CAAC;EACtC;AACJ;AAEA,OAAO,MAAMP,gBAAgB,GAAGD,oBAAoB,CAAC;EACjDS,WAAW,EAAEP,kBAAkB;EAC/BQ,cAAc,EAAEN,oBAAoB;EACpCO,YAAY,EAAE,CAACR,mBAAmB;AACtC,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,54 @@
+import type { Result } from "@webiny/feature/api";
+import { DomainEvent, IEventHandler } from "@webiny/api-core/features/EventPublisher";
+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];
+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;
+}
+export declare const FolderBeforeGetHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<FolderBeforeGetPayload>>>;
+export declare namespace FolderBeforeGetHandler {
+    type Interface = IEventHandler<DomainEvent<FolderBeforeGetPayload>>;
+    type Event = DomainEvent<FolderBeforeGetPayload>;
+}
+export declare const FolderAfterGetHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<FolderAfterGetPayload>>>;
+export declare namespace FolderAfterGetHandler {
+    type Interface = IEventHandler<DomainEvent<FolderAfterGetPayload>>;
+    type Event = DomainEvent<FolderAfterGetPayload>;
+}
+export {};

package/features/folder/GetFolder/abstractions.js

@@ -0,0 +1,21 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * GetFolder repository interface
+ */
+
+export const GetFolderRepository = createAbstraction("GetFolderRepository");
+
+/**
+ * GetFolder use case interface
+ */
+
+export const GetFolderUseCase = createAbstraction("GetFolderUseCase");
+
+// Event Payload Types
+
+// Event Handler Abstractions
+export const FolderBeforeGetHandler = createAbstraction("FolderBeforeGetHandler");
+export const FolderAfterGetHandler = createAbstraction("FolderAfterGetHandler");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetFolderRepository","GetFolderUseCase","FolderBeforeGetHandler","FolderAfterGetHandler"],"sources":["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\";\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\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\nexport const FolderBeforeGetHandler =\n    createAbstraction<IEventHandler<DomainEvent<FolderBeforeGetPayload>>>(\"FolderBeforeGetHandler\");\n\nexport namespace FolderBeforeGetHandler {\n    export type Interface = IEventHandler<DomainEvent<FolderBeforeGetPayload>>;\n    export type Event = DomainEvent<FolderBeforeGetPayload>;\n}\n\nexport const FolderAfterGetHandler =\n    createAbstraction<IEventHandler<DomainEvent<FolderAfterGetPayload>>>(\"FolderAfterGetHandler\");\n\nexport namespace FolderAfterGetHandler {\n    export type Interface = IEventHandler<DomainEvent<FolderAfterGetPayload>>;\n    export type Event = DomainEvent<FolderAfterGetPayload>;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAUvD;AACA;AACA;;AAYA,OAAO,MAAMC,mBAAmB,GAAGD,iBAAiB,CAAuB,qBAAqB,CAAC;;AAOjG;AACA;AACA;;AAaA,OAAO,MAAME,gBAAgB,GAAGF,iBAAiB,CAAoB,kBAAkB,CAAC;;AAOxF;;AASA;AACA,OAAO,MAAMG,sBAAsB,GAC/BH,iBAAiB,CAAqD,wBAAwB,CAAC;AAOnG,OAAO,MAAMI,qBAAqB,GAC9BJ,iBAAiB,CAAoD,uBAAuB,CAAC","ignoreList":[]}

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, import("~/domain/folder/errors.js").FolderNotFoundError | FolderNotAuthorizedError | import("~/domain/folder/errors.js").FolderPersistenceError> | Result<{
+        permissions: import("@webiny/shared-aco/flp/flp.types.js").FolderPermission[];
+        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;
+        title: string;
+        slug: string;
+        type: string;
+        parentId?: string | null;
+        path: string;
+        extensions?: Record<string, any>;
+    }, 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,37 @@
+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);
+
+    // Let's check if the current user has read access level.
+    const canAccessFolder = await this.folderLevelPermissions.canAccessFolder({
+      permissions,
+      rwd: "r"
+    });
+    if (!canAccessFolder) {
+      return Result.fail(new FolderNotAuthorizedError());
+    }
+    return Result.ok({
+      ...folder,
+      permissions
+    });
+  }
+}
+export const GetFolderWithFolderLevelPermissions = GetFolderUseCase.createDecorator({
+  decorator: GetFolderWithFolderLevelPermissionsImpl,
+  dependencies: [FolderLevelPermissions]
+});
+
+//# sourceMappingURL=GetFolderWithFolderLevelPermissions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["GetFolderUseCase","Result","FolderLevelPermissions","FolderNotAuthorizedError","GetFolderWithFolderLevelPermissionsImpl","constructor","folderLevelPermissions","decoretee","execute","id","result","isFail","fail","error","folder","value","permissions","getFolderLevelPermissions","canAccessFolder","rwd","ok","GetFolderWithFolderLevelPermissions","createDecorator","decorator","dependencies"],"sources":["GetFolderWithFolderLevelPermissions.ts"],"sourcesContent":["import { GetFolderUseCase } from \"../abstractions.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport { FolderLevelPermissions } from \"~/features/flp/FolderLevelPermissions/index.js\";\nimport { FolderNotAuthorizedError } from \"~/domain/folder/errors.js\";\n\nclass GetFolderWithFolderLevelPermissionsImpl implements GetFolderUseCase.Interface {\n    private folderLevelPermissions: FolderLevelPermissions.Interface;\n    private readonly decoretee: GetFolderUseCase.Interface;\n\n    constructor(\n        folderLevelPermissions: FolderLevelPermissions.Interface,\n        decoretee: GetFolderUseCase.Interface\n    ) {\n        this.folderLevelPermissions = folderLevelPermissions;\n        this.decoretee = decoretee;\n    }\n\n    async execute(id: string) {\n        const result = await this.decoretee.execute(id);\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const folder = result.value;\n        const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(folder.id);\n\n        // Let's check if the current user has read access level.\n        const canAccessFolder = await this.folderLevelPermissions.canAccessFolder({\n            permissions,\n            rwd: \"r\"\n        });\n\n        if (!canAccessFolder) {\n            return Result.fail(new FolderNotAuthorizedError());\n        }\n\n        return Result.ok({\n            ...folder,\n            permissions\n        });\n    }\n}\n\nexport const GetFolderWithFolderLevelPermissions = GetFolderUseCase.createDecorator({\n    decorator: GetFolderWithFolderLevelPermissionsImpl,\n    dependencies: [FolderLevelPermissions]\n});\n"],"mappings":"AAAA,SAASA,gBAAgB;AACzB,SAASC,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,sBAAsB;AAC/B,SAASC,wBAAwB;AAEjC,MAAMC,uCAAuC,CAAuC;EAIhFC,WAAWA,CACPC,sBAAwD,EACxDC,SAAqC,EACvC;IACE,IAAI,CAACD,sBAAsB,GAAGA,sBAAsB;IACpD,IAAI,CAACC,SAAS,GAAGA,SAAS;EAC9B;EAEA,MAAMC,OAAOA,CAACC,EAAU,EAAE;IACtB,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACH,SAAS,CAACC,OAAO,CAACC,EAAE,CAAC;IAC/C,IAAIC,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOV,MAAM,CAACW,IAAI,CAACF,MAAM,CAACG,KAAK,CAAC;IACpC;IAEA,MAAMC,MAAM,GAAGJ,MAAM,CAACK,KAAK;IAC3B,MAAMC,WAAW,GAAG,MAAM,IAAI,CAACV,sBAAsB,CAACW,yBAAyB,CAACH,MAAM,CAACL,EAAE,CAAC;;IAE1F;IACA,MAAMS,eAAe,GAAG,MAAM,IAAI,CAACZ,sBAAsB,CAACY,eAAe,CAAC;MACtEF,WAAW;MACXG,GAAG,EAAE;IACT,CAAC,CAAC;IAEF,IAAI,CAACD,eAAe,EAAE;MAClB,OAAOjB,MAAM,CAACW,IAAI,CAAC,IAAIT,wBAAwB,CAAC,CAAC,CAAC;IACtD;IAEA,OAAOF,MAAM,CAACmB,EAAE,CAAC;MACb,GAAGN,MAAM;MACTE;IACJ,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMK,mCAAmC,GAAGrB,gBAAgB,CAACsB,eAAe,CAAC;EAChFC,SAAS,EAAEnB,uCAAuC;EAClDoB,YAAY,EAAE,CAACtB,sBAAsB;AACzC,CAAC,CAAC","ignoreList":[]}

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

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

package/features/folder/GetFolder/feature.js

@@ -0,0 +1,14 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetFolderRepository } from "./GetFolderRepository.js";
+import { GetFolderUseCase } from "./GetFolderUseCase.js";
+import { GetFolderWithFolderLevelPermissions } from "./decorators/GetFolderWithFolderLevelPermissions.js";
+export const GetFolderFeature = createFeature({
+  name: "GetFolder",
+  register(container) {
+    container.register(GetFolderRepository).inSingletonScope();
+    container.register(GetFolderUseCase);
+    container.registerDecorator(GetFolderWithFolderLevelPermissions);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetFolderRepository","GetFolderUseCase","GetFolderWithFolderLevelPermissions","GetFolderFeature","name","register","container","inSingletonScope","registerDecorator"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { GetFolderRepository } from \"./GetFolderRepository.js\";\nimport { GetFolderUseCase } from \"./GetFolderUseCase.js\";\nimport { GetFolderWithFolderLevelPermissions } from \"./decorators/GetFolderWithFolderLevelPermissions.js\";\n\nexport const GetFolderFeature = createFeature({\n    name: \"GetFolder\",\n    register(container: Container) {\n        container.register(GetFolderRepository).inSingletonScope();\n        container.register(GetFolderUseCase);\n        container.registerDecorator(GetFolderWithFolderLevelPermissions);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AAEnD,SAASC,mBAAmB;AAC5B,SAASC,gBAAgB;AACzB,SAASC,mCAAmC;AAE5C,OAAO,MAAMC,gBAAgB,GAAGJ,aAAa,CAAC;EAC1CK,IAAI,EAAE,WAAW;EACjBC,QAAQA,CAACC,SAAoB,EAAE;IAC3BA,SAAS,CAACD,QAAQ,CAACL,mBAAmB,CAAC,CAACO,gBAAgB,CAAC,CAAC;IAC1DD,SAAS,CAACD,QAAQ,CAACJ,gBAAgB,CAAC;IACpCK,SAAS,CAACE,iBAAiB,CAACN,mCAAmC,CAAC;EACpE;AACJ,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,2 @@
+export { GetFolderFeature } from "./feature.js";
+export { FolderAfterGetHandler, FolderBeforeGetHandler, GetFolderUseCase } from "./abstractions.js";

package/features/folder/GetFolder/index.js

@@ -0,0 +1,4 @@
+export { GetFolderFeature } from "./feature.js";
+export { FolderAfterGetHandler, FolderBeforeGetHandler, GetFolderUseCase } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["GetFolderFeature","FolderAfterGetHandler","FolderBeforeGetHandler","GetFolderUseCase"],"sources":["index.ts"],"sourcesContent":["export { GetFolderFeature } from \"./feature.js\";\nexport { FolderAfterGetHandler, FolderBeforeGetHandler, GetFolderUseCase } from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,gBAAgB;AACzB,SAASC,qBAAqB,EAAEC,sBAAsB,EAAEC,gBAAgB","ignoreList":[]}

package/features/folder/GetFolderHierarchy/GetFolderHierarchyRepository.d.ts

@@ -0,0 +1,18 @@
+import { Result } from "@webiny/feature/api";
+import { GetFolderHierarchyRepository as RepositoryAbstraction, type IGetFolderHierarchyRepository } from "./abstractions.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { FolderModel } from "../../../domain/folder/abstractions.js";
+import type { GetFolderHierarchyParams, GetFolderHierarchyResponse } from "../../../folder/folder.types.js";
+declare class GetFolderHierarchyRepositoryImpl implements IGetFolderHierarchyRepository {
+    private getEntryById;
+    private listLatestEntries;
+    private folderModel;
+    constructor(getEntryById: GetEntryByIdUseCase.Interface, listLatestEntries: ListLatestEntriesUseCase.Interface, folderModel: FolderModel.Interface);
+    execute(params: GetFolderHierarchyParams): Promise<Result<GetFolderHierarchyResponse, RepositoryAbstraction.Error>>;
+    private getFolderParent;
+}
+export declare const GetFolderHierarchyRepository: typeof GetFolderHierarchyRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IGetFolderHierarchyRepository>;
+};
+export {};

package/features/folder/GetFolderHierarchy/GetFolderHierarchyRepository.js

@@ -0,0 +1,103 @@
+import { Result } from "@webiny/feature/api";
+import { GetFolderHierarchyRepository as RepositoryAbstraction } from "./abstractions.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { EntryId } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { FolderModel } from "../../../domain/folder/abstractions.js";
+import { EntryToFolderMapper } from "../shared/EntryToFolderMapper.js";
+import { FolderPersistenceError } from "../../../domain/folder/errors.js";
+import { ROOT_FOLDER } from "../../../constants.js";
+const FIXED_FOLDER_LISTING_LIMIT = 10_000;
+class GetFolderHierarchyRepositoryImpl {
+  constructor(getEntryById, listLatestEntries, folderModel) {
+    this.getEntryById = getEntryById;
+    this.listLatestEntries = listLatestEntries;
+    this.folderModel = folderModel;
+  }
+  async execute(params) {
+    const parents = [];
+    const siblings = [];
+
+    // Get root folders (siblings at root level)
+    const rootFoldersResult = await this.listLatestEntries.execute(this.folderModel, {
+      where: {
+        values: {
+          type: params.type,
+          parentId: null
+        }
+      },
+      limit: FIXED_FOLDER_LISTING_LIMIT
+    });
+    if (rootFoldersResult.isFail()) {
+      return Result.fail(new FolderPersistenceError(rootFoldersResult.error));
+    }
+    const {
+      entries: rootEntries
+    } = rootFoldersResult.value;
+    siblings.push(...rootEntries.map(entry => EntryToFolderMapper.toFolder(entry)));
+    if (params.id === ROOT_FOLDER) {
+      return Result.ok({
+        parents,
+        siblings
+      });
+    }
+
+    // Get the folder by id
+    const entryId = EntryId.from(params.id);
+    const folderResult = await this.getEntryById.execute(this.folderModel, entryId.toString());
+    if (folderResult.isFail()) {
+      return Result.fail(new FolderPersistenceError(folderResult.error));
+    }
+    const folder = EntryToFolderMapper.toFolder(folderResult.value);
+    parents.push(folder);
+
+    // Recursively get all parent folders
+    const getFolderParentResult = await this.getFolderParent(folder, parents);
+    if (getFolderParentResult.isFail()) {
+      return Result.fail(getFolderParentResult.error);
+    }
+
+    // Get all child folders of all parents (these are siblings at different levels)
+    const parentIds = parents.map(f => f.id);
+    const childFoldersResult = await this.listLatestEntries.execute(this.folderModel, {
+      where: {
+        entryId_not_in: parentIds,
+        values: {
+          type: folder.type,
+          parentId_in: parentIds
+        }
+      },
+      limit: FIXED_FOLDER_LISTING_LIMIT
+    });
+    if (childFoldersResult.isFail()) {
+      return Result.fail(new FolderPersistenceError(childFoldersResult.error));
+    }
+    const {
+      entries: childEntries
+    } = childFoldersResult.value;
+    siblings.push(...childEntries.map(entry => EntryToFolderMapper.toFolder(entry)));
+    return Result.ok({
+      parents,
+      siblings
+    });
+  }
+  async getFolderParent(folder, parents) {
+    let currentFolder = folder;
+    while (currentFolder.parentId) {
+      const parentResult = await this.getEntryById.execute(this.folderModel, EntryId.from(currentFolder.parentId).toString());
+      if (parentResult.isFail()) {
+        return Result.fail(new FolderPersistenceError(parentResult.error));
+      }
+      const parentFolder = EntryToFolderMapper.toFolder(parentResult.value);
+      parents.push(parentFolder);
+      currentFolder = parentFolder;
+    }
+    return Result.ok();
+  }
+}
+export const GetFolderHierarchyRepository = RepositoryAbstraction.createImplementation({
+  implementation: GetFolderHierarchyRepositoryImpl,
+  dependencies: [GetEntryByIdUseCase, ListLatestEntriesUseCase, FolderModel]
+});
+
+//# sourceMappingURL=GetFolderHierarchyRepository.js.map

package/features/folder/GetFolderHierarchy/GetFolderHierarchyRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","GetFolderHierarchyRepository","RepositoryAbstraction","GetEntryByIdUseCase","ListLatestEntriesUseCase","EntryId","FolderModel","EntryToFolderMapper","FolderPersistenceError","ROOT_FOLDER","FIXED_FOLDER_LISTING_LIMIT","GetFolderHierarchyRepositoryImpl","constructor","getEntryById","listLatestEntries","folderModel","execute","params","parents","siblings","rootFoldersResult","where","values","type","parentId","limit","isFail","fail","error","entries","rootEntries","value","push","map","entry","toFolder","id","ok","entryId","from","folderResult","toString","folder","getFolderParentResult","getFolderParent","parentIds","f","childFoldersResult","entryId_not_in","parentId_in","childEntries","currentFolder","parentResult","parentFolder","createImplementation","implementation","dependencies"],"sources":["GetFolderHierarchyRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    GetFolderHierarchyRepository as RepositoryAbstraction,\n    type IGetFolderHierarchyRepository\n} from \"./abstractions.js\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport { EntryId } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { FolderModel } from \"~/domain/folder/abstractions.js\";\nimport type {\n    CmsEntryFolder,\n    Folder,\n    GetFolderHierarchyParams,\n    GetFolderHierarchyResponse\n} 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\nconst FIXED_FOLDER_LISTING_LIMIT = 10_000;\n\nclass GetFolderHierarchyRepositoryImpl implements IGetFolderHierarchyRepository {\n    constructor(\n        private getEntryById: GetEntryByIdUseCase.Interface,\n        private listLatestEntries: ListLatestEntriesUseCase.Interface,\n        private folderModel: FolderModel.Interface\n    ) {}\n\n    async execute(\n        params: GetFolderHierarchyParams\n    ): Promise<Result<GetFolderHierarchyResponse, RepositoryAbstraction.Error>> {\n        const parents: Folder[] = [];\n        const siblings: Folder[] = [];\n\n        // Get root folders (siblings at root level)\n        const rootFoldersResult = await this.listLatestEntries.execute<CmsEntryFolder>(\n            this.folderModel,\n            {\n                where: {\n                    values: {\n                        type: params.type,\n                        parentId: null\n                    }\n                },\n                limit: FIXED_FOLDER_LISTING_LIMIT\n            }\n        );\n\n        if (rootFoldersResult.isFail()) {\n            return Result.fail(new FolderPersistenceError(rootFoldersResult.error));\n        }\n\n        const { entries: rootEntries } = rootFoldersResult.value;\n        siblings.push(...rootEntries.map(entry => EntryToFolderMapper.toFolder(entry)));\n\n        if (params.id === ROOT_FOLDER) {\n            return Result.ok({\n                parents,\n                siblings\n            });\n        }\n\n        // Get the folder by id\n        const entryId = EntryId.from(params.id);\n        const folderResult = await this.getEntryById.execute<CmsEntryFolder>(\n            this.folderModel,\n            entryId.toString()\n        );\n\n        if (folderResult.isFail()) {\n            return Result.fail(new FolderPersistenceError(folderResult.error));\n        }\n\n        const folder = EntryToFolderMapper.toFolder(folderResult.value);\n        parents.push(folder);\n\n        // Recursively get all parent folders\n        const getFolderParentResult = await this.getFolderParent(folder, parents);\n        if (getFolderParentResult.isFail()) {\n            return Result.fail(getFolderParentResult.error);\n        }\n\n        // Get all child folders of all parents (these are siblings at different levels)\n        const parentIds = parents.map(f => f.id);\n\n        const childFoldersResult = await this.listLatestEntries.execute<CmsEntryFolder>(\n            this.folderModel,\n            {\n                where: {\n                    entryId_not_in: parentIds,\n                    values: {\n                        type: folder.type,\n                        parentId_in: parentIds\n                    }\n                },\n                limit: FIXED_FOLDER_LISTING_LIMIT\n            }\n        );\n\n        if (childFoldersResult.isFail()) {\n            return Result.fail(new FolderPersistenceError(childFoldersResult.error));\n        }\n\n        const { entries: childEntries } = childFoldersResult.value;\n        siblings.push(...childEntries.map(entry => EntryToFolderMapper.toFolder(entry)));\n\n        return Result.ok({\n            parents,\n            siblings\n        });\n    }\n\n    private async getFolderParent(\n        folder: Folder,\n        parents: Folder[]\n    ): Promise<Result<void, RepositoryAbstraction.Error>> {\n        let currentFolder = folder;\n\n        while (currentFolder.parentId) {\n            const parentResult = await this.getEntryById.execute<CmsEntryFolder>(\n                this.folderModel,\n                EntryId.from(currentFolder.parentId).toString()\n            );\n\n            if (parentResult.isFail()) {\n                return Result.fail(new FolderPersistenceError(parentResult.error));\n            }\n\n            const parentFolder = EntryToFolderMapper.toFolder(parentResult.value);\n            parents.push(parentFolder);\n            currentFolder = parentFolder;\n        }\n\n        return Result.ok();\n    }\n}\n\nexport const GetFolderHierarchyRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetFolderHierarchyRepositoryImpl,\n    dependencies: [GetEntryByIdUseCase, ListLatestEntriesUseCase, FolderModel]\n});\n"],"mappings":"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","ignoreList":[]}

package/features/folder/GetFolderHierarchy/GetFolderHierarchyUseCase.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "@webiny/feature/api";
+import { GetFolderHierarchyUseCase as UseCaseAbstraction, GetFolderHierarchyRepository } from "./abstractions.js";
+import type { GetFolderHierarchyParams, GetFolderHierarchyResponse } from "../../../folder/folder.types.js";
+declare class GetFolderHierarchyUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: GetFolderHierarchyRepository.Interface);
+    execute(params: GetFolderHierarchyParams): Promise<Result<GetFolderHierarchyResponse, UseCaseAbstraction.Error>>;
+}
+export declare const GetFolderHierarchyUseCase: import("@webiny/di").Implementation<typeof GetFolderHierarchyUseCaseImpl>;
+export {};

package/features/folder/GetFolderHierarchy/GetFolderHierarchyUseCase.js

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

package/features/folder/GetFolderHierarchy/GetFolderHierarchyUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["GetFolderHierarchyUseCase","UseCaseAbstraction","GetFolderHierarchyRepository","createImplementation","GetFolderHierarchyUseCaseImpl","constructor","repository","execute","params","abstraction","implementation","dependencies"],"sources":["GetFolderHierarchyUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    GetFolderHierarchyUseCase as UseCaseAbstraction,\n    GetFolderHierarchyRepository\n} from \"./abstractions.js\";\nimport type {\n    GetFolderHierarchyParams,\n    GetFolderHierarchyResponse\n} from \"~/folder/folder.types.js\";\nimport { createImplementation } from \"@webiny/di\";\n\nclass GetFolderHierarchyUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: GetFolderHierarchyRepository.Interface) {}\n\n    async execute(\n        params: GetFolderHierarchyParams\n    ): Promise<Result<GetFolderHierarchyResponse, UseCaseAbstraction.Error>> {\n        return await this.repository.execute(params);\n    }\n}\n\nexport const GetFolderHierarchyUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: GetFolderHierarchyUseCaseImpl,\n    dependencies: [GetFolderHierarchyRepository]\n});\n"],"mappings":"AACA,SACIA,yBAAyB,IAAIC,kBAAkB,EAC/CC,4BAA4B;AAMhC,SAASC,oBAAoB,QAAQ,YAAY;AAEjD,MAAMC,6BAA6B,CAAyC;EACxEC,WAAWA,CAASC,UAAkD,EAAE;IAAA,KAApDA,UAAkD,GAAlDA,UAAkD;EAAG;EAEzE,MAAMC,OAAOA,CACTC,MAAgC,EACqC;IACrE,OAAO,MAAM,IAAI,CAACF,UAAU,CAACC,OAAO,CAACC,MAAM,CAAC;EAChD;AACJ;AAEA,OAAO,MAAMR,yBAAyB,GAAGG,oBAAoB,CAAC;EAC1DM,WAAW,EAAER,kBAAkB;EAC/BS,cAAc,EAAEN,6BAA6B;EAC7CO,YAAY,EAAE,CAACT,4BAA4B;AAC/C,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,36 @@
+import type { Result } from "@webiny/feature/api";
+import type { GetFolderHierarchyParams, GetFolderHierarchyResponse } from "../../../folder/folder.types.js";
+import type { FolderNotAuthorizedError, FolderPersistenceError } from "../../../domain/folder/errors.js";
+/**
+ * GetFolderHierarchy repository interface
+ */
+export interface IGetFolderHierarchyRepository {
+    execute(params: GetFolderHierarchyParams): Promise<Result<GetFolderHierarchyResponse, RepositoryError>>;
+}
+export interface IGetFolderHierarchyRepositoryErrors {
+    persistence: FolderPersistenceError;
+}
+type RepositoryError = IGetFolderHierarchyRepositoryErrors[keyof IGetFolderHierarchyRepositoryErrors];
+export declare const GetFolderHierarchyRepository: import("@webiny/di").Abstraction<IGetFolderHierarchyRepository>;
+export declare namespace GetFolderHierarchyRepository {
+    type Interface = IGetFolderHierarchyRepository;
+    type Error = RepositoryError;
+}
+/**
+ * GetFolderHierarchy use case interface
+ */
+export interface IGetFolderHierarchyUseCase {
+    execute(params: GetFolderHierarchyParams): Promise<Result<GetFolderHierarchyResponse, UseCaseError>>;
+}
+export interface IGetFolderHierarchyUseCaseErrors {
+    notAuthorized: FolderNotAuthorizedError;
+    persistence: FolderPersistenceError;
+}
+type UseCaseError = IGetFolderHierarchyUseCaseErrors[keyof IGetFolderHierarchyUseCaseErrors];
+export declare const GetFolderHierarchyUseCase: import("@webiny/di").Abstraction<IGetFolderHierarchyUseCase>;
+export declare namespace GetFolderHierarchyUseCase {
+    type Interface = IGetFolderHierarchyUseCase;
+    type Return = Promise<Result<GetFolderHierarchyResponse, UseCaseError>>;
+    type Error = UseCaseError;
+}
+export {};

package/features/folder/GetFolderHierarchy/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetFolderHierarchyRepository","GetFolderHierarchyUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type {\n    GetFolderHierarchyParams,\n    GetFolderHierarchyResponse\n} from \"~/folder/folder.types.js\";\nimport type { FolderNotAuthorizedError, FolderPersistenceError } from \"~/domain/folder/errors.js\";\n\n/**\n * GetFolderHierarchy repository interface\n */\nexport interface IGetFolderHierarchyRepository {\n    execute(\n        params: GetFolderHierarchyParams\n    ): Promise<Result<GetFolderHierarchyResponse, RepositoryError>>;\n}\n\nexport interface IGetFolderHierarchyRepositoryErrors {\n    persistence: FolderPersistenceError;\n}\n\ntype RepositoryError =\n    IGetFolderHierarchyRepositoryErrors[keyof IGetFolderHierarchyRepositoryErrors];\n\nexport const GetFolderHierarchyRepository = createAbstraction<IGetFolderHierarchyRepository>(\n    \"GetFolderHierarchyRepository\"\n);\n\nexport namespace GetFolderHierarchyRepository {\n    export type Interface = IGetFolderHierarchyRepository;\n    export type Error = RepositoryError;\n}\n\n/**\n * GetFolderHierarchy use case interface\n */\nexport interface IGetFolderHierarchyUseCase {\n    execute(\n        params: GetFolderHierarchyParams\n    ): Promise<Result<GetFolderHierarchyResponse, UseCaseError>>;\n}\n\nexport interface IGetFolderHierarchyUseCaseErrors {\n    notAuthorized: FolderNotAuthorizedError;\n    persistence: FolderPersistenceError;\n}\n\ntype UseCaseError = IGetFolderHierarchyUseCaseErrors[keyof IGetFolderHierarchyUseCaseErrors];\n\nexport const GetFolderHierarchyUseCase = createAbstraction<IGetFolderHierarchyUseCase>(\n    \"GetFolderHierarchyUseCase\"\n);\n\nexport namespace GetFolderHierarchyUseCase {\n    export type Interface = IGetFolderHierarchyUseCase;\n    export type Return = Promise<Result<GetFolderHierarchyResponse, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAQvD;AACA;AACA;;AAcA,OAAO,MAAMC,4BAA4B,GAAGD,iBAAiB,CACzD,8BACJ,CAAC;;AAOD;AACA;AACA;;AAcA,OAAO,MAAME,yBAAyB,GAAGF,iBAAiB,CACtD,2BACJ,CAAC","ignoreList":[]}

package/features/folder/GetFolderHierarchy/decorators/GetFolderHierarchyWithFolderLevelPermissions.d.ts

@@ -0,0 +1,16 @@
+import { FolderLevelPermissions } from "../../../../features/flp/FolderLevelPermissions/index.js";
+import { GetFolderHierarchyUseCase } from "../abstractions.js";
+import type { GetFolderHierarchyParams } from "../../../../folder/folder.types.js";
+declare class GetFolderHierarchyWithFolderLevelPermissionsImpl implements GetFolderHierarchyUseCase.Interface {
+    private folderLevelPermissions;
+    private decoratee;
+    private flpCatalog;
+    constructor(folderLevelPermissions: FolderLevelPermissions.Interface, decoratee: GetFolderHierarchyUseCase.Interface);
+    execute(params: GetFolderHierarchyParams): GetFolderHierarchyUseCase.Return;
+    private filterAccessibleFolders;
+    private hasFlp;
+    private getFlp;
+    private setFlp;
+}
+export declare const GetFolderHierarchyWithFolderLevelPermissions: typeof GetFolderHierarchyWithFolderLevelPermissionsImpl;
+export {};

package/features/folder/GetFolderHierarchy/decorators/GetFolderHierarchyWithFolderLevelPermissions.js

@@ -0,0 +1,64 @@
+import { createDecorator, Result } from "@webiny/feature/api";
+import { FolderLevelPermissions } from "../../../flp/FolderLevelPermissions/index.js";
+import { GetFolderHierarchyUseCase } from "../abstractions.js";
+class GetFolderHierarchyWithFolderLevelPermissionsImpl {
+  flpCatalog = new Map();
+  constructor(folderLevelPermissions, decoratee) {
+    this.folderLevelPermissions = folderLevelPermissions;
+    this.decoratee = decoratee;
+  }
+  async execute(params) {
+    const result = await this.decoratee.execute(params);
+    if (result.isFail()) {
+      return Result.fail(result.error);
+    }
+    const {
+      siblings,
+      parents
+    } = result.value;
+    const folders = [...parents, ...siblings];
+    await Promise.all(folders.map(async folder => {
+      if (!this.hasFlp(folder.id)) {
+        const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(folder.id);
+        this.setFlp(folder.id, permissions);
+      }
+    }));
+    return Result.ok({
+      parents: await this.filterAccessibleFolders(parents),
+      siblings: await this.filterAccessibleFolders(siblings)
+    });
+  }
+  async filterAccessibleFolders(folders) {
+    const results = await Promise.all(folders.map(async folder => {
+      const permissions = this.getFlp(folder.id);
+      if (!permissions) {
+        return folder;
+      }
+      const canAccess = await this.folderLevelPermissions.canAccessFolder({
+        permissions,
+        rwd: "r"
+      });
+      return canAccess ? {
+        ...folder,
+        permissions
+      } : null;
+    }));
+    return results.filter(folder => folder !== null);
+  }
+  hasFlp(id) {
+    return this.flpCatalog.has(id);
+  }
+  getFlp(id) {
+    return this.flpCatalog.get(id);
+  }
+  setFlp(id, permissions) {
+    this.flpCatalog.set(id, permissions);
+  }
+}
+export const GetFolderHierarchyWithFolderLevelPermissions = createDecorator({
+  abstraction: GetFolderHierarchyUseCase,
+  decorator: GetFolderHierarchyWithFolderLevelPermissionsImpl,
+  dependencies: [FolderLevelPermissions]
+});
+
+//# sourceMappingURL=GetFolderHierarchyWithFolderLevelPermissions.js.map