@webiny/api-aco 0.0.0-unstable.eb196ccd2f → 0.0.0-unstable.eb81deee7e

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetFolder/decorators/GetFolderWithFolderLevelPermissions.js","sources":["../../../../../src/features/folder/GetFolder/decorators/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"],"names":["GetFolderWithFolderLevelPermissionsImpl","folderLevelPermissions","decoretee","id","result","Result","folder","permissions","canAccessFolder","FolderNotAuthorizedError","GetFolderWithFolderLevelPermissions","GetFolderUseCase","FolderLevelPermissions"],"mappings":";;;;AAKA,MAAMA;IAIF,YACIC,sBAAwD,EACxDC,SAAqC,CACvC;QACE,IAAI,CAAC,sBAAsB,GAAGD;QAC9B,IAAI,CAAC,SAAS,GAAGC;IACrB;IAEA,MAAM,QAAQC,EAAU,EAAE;QACtB,MAAMC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACD;QAC5C,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAACD,OAAO,KAAK;QAGnC,MAAME,SAASF,OAAO,KAAK;QAC3B,MAAMG,cAAc,MAAM,IAAI,CAAC,sBAAsB,CAAC,yBAAyB,CAACD,OAAO,EAAE;QAGzF,MAAME,kBAAkB,MAAM,IAAI,CAAC,sBAAsB,CAAC,eAAe,CAAC;YACtED;YACA,KAAK;QACT;QAEA,IAAI,CAACC,iBACD,OAAOH,OAAO,IAAI,CAAC,IAAII;QAG3B,OAAOJ,OAAO,EAAE,CAAC;YACb,GAAGC,MAAM;YACTC;QACJ;IACJ;AACJ;AAEO,MAAMG,sCAAsCC,iBAAiB,eAAe,CAAC;IAChF,WAAWX;IACX,cAAc;QAACY;KAAuB;AAC1C"}

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

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

package/features/folder/GetFolder/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetFolder/feature.js","sources":["../../../../src/features/folder/GetFolder/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"],"names":["GetFolderFeature","createFeature","container","GetFolderRepository","GetFolderUseCase","GetFolderWithFolderLevelPermissions"],"mappings":";;;;AAMO,MAAMA,mBAAmBC,cAAc;IAC1C,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC,qBAAqB,gBAAgB;QACxDD,UAAU,QAAQ,CAACE;QACnBF,UAAU,iBAAiB,CAACG;IAChC;AACJ"}

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

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

package/features/folder/GetFolder/index.js

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

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 { FolderModelProvider } from "../../../domain/folder/abstractions.js";
+import type { GetFolderHierarchyParams, GetFolderHierarchyResponse } from "../../../folder/folder.types.js";
+declare class GetFolderHierarchyRepositoryImpl implements IGetFolderHierarchyRepository {
+    private getEntryById;
+    private listLatestEntries;
+    private folderModelProvider;
+    constructor(getEntryById: GetEntryByIdUseCase.Interface, listLatestEntries: ListLatestEntriesUseCase.Interface, folderModelProvider: FolderModelProvider.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,86 @@
+import { Result } from "@webiny/feature/api";
+import { GetFolderHierarchyRepository } 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 { 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";
+const FIXED_FOLDER_LISTING_LIMIT = 10000;
+class GetFolderHierarchyRepositoryImpl {
+    constructor(getEntryById, listLatestEntries, folderModelProvider){
+        this.getEntryById = getEntryById;
+        this.listLatestEntries = listLatestEntries;
+        this.folderModelProvider = folderModelProvider;
+    }
+    async execute(params) {
+        const folderModel = await this.folderModelProvider.get();
+        const parents = [];
+        const siblings = [];
+        const rootFoldersResult = await this.listLatestEntries.execute(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
+        });
+        const entryId = EntryId.from(params.id);
+        const folderResult = await this.getEntryById.execute(folderModel, entryId.toString());
+        if (folderResult.isFail()) return Result.fail(new FolderPersistenceError(folderResult.error));
+        const folder = EntryToFolderMapper.toFolder(folderResult.value);
+        parents.push(folder);
+        const getFolderParentResult = await this.getFolderParent(folder, parents);
+        if (getFolderParentResult.isFail()) return Result.fail(getFolderParentResult.error);
+        const parentIds = parents.map((f)=>f.id);
+        const childFoldersResult = await this.listLatestEntries.execute(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) {
+        const folderModel = await this.folderModelProvider.get();
+        let currentFolder = folder;
+        while(currentFolder.parentId){
+            const parentResult = await this.getEntryById.execute(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();
+    }
+}
+const GetFolderHierarchyRepository_GetFolderHierarchyRepository = GetFolderHierarchyRepository.createImplementation({
+    implementation: GetFolderHierarchyRepositoryImpl,
+    dependencies: [
+        GetEntryByIdUseCase,
+        ListLatestEntriesUseCase,
+        FolderModelProvider
+    ]
+});
+export { GetFolderHierarchyRepository_GetFolderHierarchyRepository as GetFolderHierarchyRepository };
+
+//# sourceMappingURL=GetFolderHierarchyRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetFolderHierarchy/GetFolderHierarchyRepository.js","sources":["../../../../src/features/folder/GetFolderHierarchy/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 { FolderModelProvider } 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 folderModelProvider: FolderModelProvider.Interface\n    ) {}\n\n    async execute(\n        params: GetFolderHierarchyParams\n    ): Promise<Result<GetFolderHierarchyResponse, RepositoryAbstraction.Error>> {\n        const folderModel = await this.folderModelProvider.get();\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            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            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            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        const folderModel = await this.folderModelProvider.get();\n        let currentFolder = folder;\n\n        while (currentFolder.parentId) {\n            const parentResult = await this.getEntryById.execute<CmsEntryFolder>(\n                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, FolderModelProvider]\n});\n"],"names":["FIXED_FOLDER_LISTING_LIMIT","GetFolderHierarchyRepositoryImpl","getEntryById","listLatestEntries","folderModelProvider","params","folderModel","parents","siblings","rootFoldersResult","Result","FolderPersistenceError","rootEntries","entry","EntryToFolderMapper","ROOT_FOLDER","entryId","EntryId","folderResult","folder","getFolderParentResult","parentIds","f","childFoldersResult","childEntries","currentFolder","parentResult","parentFolder","GetFolderHierarchyRepository","RepositoryAbstraction","GetEntryByIdUseCase","ListLatestEntriesUseCase","FolderModelProvider"],"mappings":"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"}

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetFolderHierarchy/GetFolderHierarchyUseCase.js","sources":["../../../../src/features/folder/GetFolderHierarchy/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"],"names":["GetFolderHierarchyUseCaseImpl","repository","params","GetFolderHierarchyUseCase","createImplementation","UseCaseAbstraction","GetFolderHierarchyRepository"],"mappings":";;AAWA,MAAMA;IACF,YAAoBC,UAAkD,CAAE;aAApDA,UAAU,GAAVA;IAAqD;IAEzE,MAAM,QACFC,MAAgC,EACqC;QACrE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACzC;AACJ;AAEO,MAAMC,sDAA4BC,qBAAqB;IAC1D,aAAaC;IACb,gBAAgBL;IAChB,cAAc;QAACM;KAA6B;AAChD"}

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

@@ -0,0 +1,38 @@
+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];
+/** Fetch folder hierarchy from storage. */
+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];
+/** Retrieve the full folder hierarchy. */
+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,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const GetFolderHierarchyRepository = createAbstraction("GetFolderHierarchyRepository");
+const GetFolderHierarchyUseCase = createAbstraction("GetFolderHierarchyUseCase");
+export { GetFolderHierarchyRepository, GetFolderHierarchyUseCase };
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetFolderHierarchy/abstractions.js","sources":["../../../../src/features/folder/GetFolderHierarchy/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\n/** Fetch folder hierarchy from storage. */\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\n/** Retrieve the full folder hierarchy. */\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"],"names":["GetFolderHierarchyRepository","createAbstraction","GetFolderHierarchyUseCase"],"mappings":";AAyBO,MAAMA,+BAA+BC,kBACxC;AAyBG,MAAMC,4BAA4BD,kBACrC"}

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 {};