@webiny/api-aco 0.0.0-unstable.b14eaecf38 → 0.0.0-unstable.b6d7105cee

package/features/flp/CreateFlp/index.d.ts

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

package/features/flp/CreateFlp/index.js

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

package/features/flp/CreateFlpOnFolderCreated/CreateFlpOnFolderCreatedHandler.d.ts

@@ -0,0 +1,14 @@
+import { CreateFlpUseCase } from "../CreateFlp/abstractions.js";
+import { FolderAfterCreateEventHandler } from "../../../features/folder/CreateFolder/abstractions.js";
+import type { FolderAfterCreateEvent } from "../../../features/folder/CreateFolder/events.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+declare class CreateFlpOnFolderCreatedHandlerImpl implements FolderAfterCreateEventHandler.Interface {
+    private createFlpUseCase;
+    private tasks?;
+    constructor(createFlpUseCase: CreateFlpUseCase.Interface, tasks?: TaskService.Interface | undefined);
+    handle(event: FolderAfterCreateEvent): Promise<void>;
+}
+export declare const CreateFlpOnFolderCreatedHandler: typeof CreateFlpOnFolderCreatedHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<import("@webiny/api-core/features/eventPublisher/abstractions.js").DomainEvent<import("~/features/folder/CreateFolder/abstractions.js").FolderAfterCreatePayload>>>;
+};
+export {};

package/features/flp/CreateFlpOnFolderCreated/CreateFlpOnFolderCreatedHandler.js

@@ -0,0 +1,37 @@
+import { CreateFlpUseCase } from "../CreateFlp/abstractions.js";
+import { FolderAfterCreateEventHandler } from "../../folder/CreateFolder/abstractions.js";
+import { CREATE_FLP_TASK_ID } from "../../../flp/tasks/index.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+class CreateFlpOnFolderCreatedHandlerImpl {
+    constructor(createFlpUseCase, tasks){
+        this.createFlpUseCase = createFlpUseCase;
+        this.tasks = tasks;
+    }
+    async handle(event) {
+        const { folder } = event.payload;
+        try {
+            if (this.tasks) await this.tasks.trigger({
+                definition: CREATE_FLP_TASK_ID,
+                input: {
+                    folder
+                }
+            });
+            else await this.createFlpUseCase.execute(folder);
+        } catch  {}
+    }
+}
+const CreateFlpOnFolderCreatedHandler = FolderAfterCreateEventHandler.createImplementation({
+    implementation: CreateFlpOnFolderCreatedHandlerImpl,
+    dependencies: [
+        CreateFlpUseCase,
+        [
+            TaskService,
+            {
+                optional: true
+            }
+        ]
+    ]
+});
+export { CreateFlpOnFolderCreatedHandler };
+
+//# sourceMappingURL=CreateFlpOnFolderCreatedHandler.js.map

package/features/flp/CreateFlpOnFolderCreated/CreateFlpOnFolderCreatedHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/CreateFlpOnFolderCreated/CreateFlpOnFolderCreatedHandler.js","sources":["../../../../src/features/flp/CreateFlpOnFolderCreated/CreateFlpOnFolderCreatedHandler.ts"],"sourcesContent":["import { CreateFlpUseCase } from \"../CreateFlp/abstractions.js\";\nimport { FolderAfterCreateEventHandler } from \"~/features/folder/CreateFolder/abstractions.js\";\nimport type { FolderAfterCreateEvent } from \"~/features/folder/CreateFolder/events.js\";\nimport type { ICreateFlpTaskInput } from \"~/types.js\";\nimport { CREATE_FLP_TASK_ID } from \"~/flp/tasks/index.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\n\nclass CreateFlpOnFolderCreatedHandlerImpl implements FolderAfterCreateEventHandler.Interface {\n    constructor(\n        private createFlpUseCase: CreateFlpUseCase.Interface,\n        private tasks?: TaskService.Interface\n    ) {}\n\n    async handle(event: FolderAfterCreateEvent): Promise<void> {\n        const { folder } = event.payload;\n\n        try {\n            if (this.tasks) {\n                await this.tasks.trigger<ICreateFlpTaskInput>({\n                    definition: CREATE_FLP_TASK_ID,\n                    input: { folder }\n                });\n            } else {\n                await this.createFlpUseCase.execute(folder);\n            }\n        } catch {\n            // Ignore errors\n        }\n    }\n}\n\nexport const CreateFlpOnFolderCreatedHandler = FolderAfterCreateEventHandler.createImplementation({\n    implementation: CreateFlpOnFolderCreatedHandlerImpl,\n    dependencies: [CreateFlpUseCase, [TaskService, { optional: true }]]\n});\n"],"names":["CreateFlpOnFolderCreatedHandlerImpl","createFlpUseCase","tasks","event","folder","CREATE_FLP_TASK_ID","CreateFlpOnFolderCreatedHandler","FolderAfterCreateEventHandler","CreateFlpUseCase","TaskService"],"mappings":";;;;AAOA,MAAMA;IACF,YACYC,gBAA4C,EAC5CC,KAA6B,CACvC;aAFUD,gBAAgB,GAAhBA;aACAC,KAAK,GAALA;IACT;IAEH,MAAM,OAAOC,KAA6B,EAAiB;QACvD,MAAM,EAAEC,MAAM,EAAE,GAAGD,MAAM,OAAO;QAEhC,IAAI;YACA,IAAI,IAAI,CAAC,KAAK,EACV,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAsB;gBAC1C,YAAYE;gBACZ,OAAO;oBAAED;gBAAO;YACpB;iBAEA,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAACA;QAE5C,EAAE,OAAM,CAER;IACJ;AACJ;AAEO,MAAME,kCAAkCC,8BAA8B,oBAAoB,CAAC;IAC9F,gBAAgBP;IAChB,cAAc;QAACQ;QAAkB;YAACC;YAAa;gBAAE,UAAU;YAAK;SAAE;KAAC;AACvE"}

package/features/flp/CreateFlpOnFolderCreated/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const CreateFlpOnFolderCreatedFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/flp/CreateFlpOnFolderCreated/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { CreateFlpOnFolderCreatedHandler } from "./CreateFlpOnFolderCreatedHandler.js";
+const CreateFlpOnFolderCreatedFeature = createFeature({
+    name: "CreateFlpOnFolderCreated",
+    register (container) {
+        container.register(CreateFlpOnFolderCreatedHandler);
+    }
+});
+export { CreateFlpOnFolderCreatedFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/flp/CreateFlpOnFolderCreated/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/CreateFlpOnFolderCreated/feature.js","sources":["../../../../src/features/flp/CreateFlpOnFolderCreated/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CreateFlpOnFolderCreatedHandler } from \"./CreateFlpOnFolderCreatedHandler.js\";\n\nexport const CreateFlpOnFolderCreatedFeature = createFeature({\n    name: \"CreateFlpOnFolderCreated\",\n    register(container) {\n        container.register(CreateFlpOnFolderCreatedHandler);\n    }\n});\n"],"names":["CreateFlpOnFolderCreatedFeature","createFeature","container","CreateFlpOnFolderCreatedHandler"],"mappings":";;AAGO,MAAMA,kCAAkCC,cAAc;IACzD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/flp/CreateFlpOnFolderCreated/index.d.ts

@@ -0,0 +1 @@
+export { CreateFlpOnFolderCreatedFeature } from "./feature.js";

package/features/flp/CreateFlpOnFolderCreated/index.js

@@ -0,0 +1 @@
+export { CreateFlpOnFolderCreatedFeature } from "./feature.js";

package/features/flp/DeleteFlp/DeleteFlpUseCase.d.ts

@@ -0,0 +1,8 @@
+import type { DeleteFlpUseCase as UseCaseAbstraction } from "./abstractions.js";
+import type { Folder } from "../../../folder/folder.types.js";
+import type { AcoContext } from "../../../types.js";
+export declare class DeleteFlpUseCase implements UseCaseAbstraction.Interface {
+    private context;
+    constructor(context: AcoContext);
+    execute(folder: Folder): Promise<void>;
+}

package/features/flp/DeleteFlp/DeleteFlpUseCase.js

@@ -0,0 +1,22 @@
+import { WebinyError } from "@webiny/error";
+class DeleteFlpUseCase {
+    constructor(context){
+        this.context = context;
+    }
+    async execute(folder) {
+        try {
+            if (!folder) throw new WebinyError("Missing `folder` from the task input, I can't delete the record from the FLP catalog.", "ERROR_DELETE_FLP_USE_CASE_FOLDER_NOT_PROVIDED", {
+                folder
+            });
+            await this.context.aco.flp.delete(folder.id);
+        } catch (error) {
+            throw WebinyError.from(error, {
+                message: "Error while deleting FLP",
+                code: "ERROR_DELETE_FLP_USE_CASE"
+            });
+        }
+    }
+}
+export { DeleteFlpUseCase };
+
+//# sourceMappingURL=DeleteFlpUseCase.js.map

package/features/flp/DeleteFlp/DeleteFlpUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/DeleteFlp/DeleteFlpUseCase.js","sources":["../../../../src/features/flp/DeleteFlp/DeleteFlpUseCase.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport type { DeleteFlpUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport type { Folder } from \"~/folder/folder.types.js\";\nimport type { AcoContext } from \"~/types.js\";\n\nexport class DeleteFlpUseCase implements UseCaseAbstraction.Interface {\n    constructor(private context: AcoContext) {}\n\n    async execute(folder: Folder): Promise<void> {\n        try {\n            if (!folder) {\n                throw new WebinyError(\n                    \"Missing `folder` from the task input, I can't delete the record from the FLP catalog.\",\n                    \"ERROR_DELETE_FLP_USE_CASE_FOLDER_NOT_PROVIDED\",\n                    { folder }\n                );\n            }\n            await this.context.aco.flp.delete(folder.id);\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while deleting FLP\",\n                code: \"ERROR_DELETE_FLP_USE_CASE\"\n            });\n        }\n    }\n}\n"],"names":["DeleteFlpUseCase","context","folder","WebinyError","error"],"mappings":";AAKO,MAAMA;IACT,YAAoBC,OAAmB,CAAE;aAArBA,OAAO,GAAPA;IAAsB;IAE1C,MAAM,QAAQC,MAAc,EAAiB;QACzC,IAAI;YACA,IAAI,CAACA,QACD,MAAM,IAAIC,YACN,yFACA,iDACA;gBAAED;YAAO;YAGjB,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAACA,OAAO,EAAE;QAC/C,EAAE,OAAOE,OAAO;YACZ,MAAMD,YAAY,IAAI,CAACC,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ"}

package/features/flp/DeleteFlp/abstractions.d.ts

@@ -0,0 +1,9 @@
+import type { Folder } from "../../../folder/folder.types.js";
+export interface IDeleteFlpUseCase {
+    execute: (folder: Folder) => Promise<void>;
+}
+/** Delete a folder-level permission. */
+export declare const DeleteFlpUseCase: import("@webiny/di").Abstraction<IDeleteFlpUseCase>;
+export declare namespace DeleteFlpUseCase {
+    type Interface = IDeleteFlpUseCase;
+}

package/features/flp/DeleteFlp/abstractions.js

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

package/features/flp/DeleteFlp/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/DeleteFlp/abstractions.js","sources":["../../../../src/features/flp/DeleteFlp/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Folder } from \"~/folder/folder.types.js\";\n\n// Use Case Abstraction\nexport interface IDeleteFlpUseCase {\n    execute: (folder: Folder) => Promise<void>;\n}\n\n/** Delete a folder-level permission. */\nexport const DeleteFlpUseCase = createAbstraction<IDeleteFlpUseCase>(\"DeleteFlpUseCase\");\n\nexport namespace DeleteFlpUseCase {\n    export type Interface = IDeleteFlpUseCase;\n}\n"],"names":["DeleteFlpUseCase","createAbstraction"],"mappings":";AASO,MAAMA,mBAAmBC,kBAAqC"}

package/features/flp/DeleteFlp/feature.d.ts

@@ -0,0 +1,10 @@
+import type { Container } from "@webiny/di";
+import type { AcoContext } from "../../../types.js";
+interface LegacyDeps {
+    context: AcoContext;
+}
+export declare const DeleteFlpFeature: {
+    name: string;
+    register(container: Container, context: LegacyDeps): void;
+};
+export {};

package/features/flp/DeleteFlp/feature.js

@@ -0,0 +1,12 @@
+import { createFeature } from "@webiny/feature/api";
+import { DeleteFlpUseCase } from "./DeleteFlpUseCase.js";
+import { DeleteFlpUseCase as external_abstractions_js_DeleteFlpUseCase } from "./abstractions.js";
+const DeleteFlpFeature = createFeature({
+    name: "DeleteFlp",
+    register (container, deps) {
+        container.registerFactory(external_abstractions_js_DeleteFlpUseCase, ()=>new DeleteFlpUseCase(deps.context));
+    }
+});
+export { DeleteFlpFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/flp/DeleteFlp/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/DeleteFlp/feature.js","sources":["../../../../src/features/flp/DeleteFlp/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { DeleteFlpUseCase } from \"./DeleteFlpUseCase.js\";\nimport { DeleteFlpUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport type { AcoContext } from \"~/types.js\";\n\ninterface LegacyDeps {\n    context: AcoContext;\n}\n\nexport const DeleteFlpFeature = createFeature({\n    name: \"DeleteFlp\",\n    register(container: Container, deps: LegacyDeps) {\n        container.registerFactory(UseCaseAbstraction, () => {\n            return new DeleteFlpUseCase(deps.context);\n        });\n    }\n});\n"],"names":["DeleteFlpFeature","createFeature","container","deps","UseCaseAbstraction","DeleteFlpUseCase"],"mappings":";;;AAUO,MAAMA,mBAAmBC,cAAc;IAC1C,MAAM;IACN,UAASC,SAAoB,EAAEC,IAAgB;QAC3CD,UAAU,eAAe,CAACE,2CAAoB,IACnC,IAAIC,iBAAiBF,KAAK,OAAO;IAEhD;AACJ"}

package/features/flp/DeleteFlp/index.d.ts

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

package/features/flp/DeleteFlp/index.js

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

package/features/flp/DeleteFlpOnFolderDeleted/DeleteFlpOnFolderDeletedHandler.d.ts

@@ -0,0 +1,14 @@
+import { DeleteFlpUseCase } from "../DeleteFlp/abstractions.js";
+import { FolderAfterDeleteEventHandler } from "../../../features/folder/DeleteFolder/abstractions.js";
+import type { FolderAfterDeleteEvent } from "../../../features/folder/DeleteFolder/events.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+declare class DeleteFlpOnFolderDeletedHandlerImpl implements FolderAfterDeleteEventHandler.Interface {
+    private deleteFlpUseCase;
+    private tasks?;
+    constructor(deleteFlpUseCase: DeleteFlpUseCase.Interface, tasks?: TaskService.Interface | undefined);
+    handle(event: FolderAfterDeleteEvent): Promise<void>;
+}
+export declare const DeleteFlpOnFolderDeletedHandler: typeof DeleteFlpOnFolderDeletedHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<import("@webiny/api-core/features/eventPublisher/abstractions.js").DomainEvent<import("~/features/folder/DeleteFolder/abstractions.js").FolderAfterDeletePayload>>>;
+};
+export {};

package/features/flp/DeleteFlpOnFolderDeleted/DeleteFlpOnFolderDeletedHandler.js

@@ -0,0 +1,37 @@
+import { DeleteFlpUseCase } from "../DeleteFlp/abstractions.js";
+import { FolderAfterDeleteEventHandler } from "../../folder/DeleteFolder/abstractions.js";
+import { DELETE_FLP_TASK_ID } from "../../../flp/tasks/index.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+class DeleteFlpOnFolderDeletedHandlerImpl {
+    constructor(deleteFlpUseCase, tasks){
+        this.deleteFlpUseCase = deleteFlpUseCase;
+        this.tasks = tasks;
+    }
+    async handle(event) {
+        const { folder } = event.payload;
+        try {
+            if (this.tasks) await this.tasks.trigger({
+                definition: DELETE_FLP_TASK_ID,
+                input: {
+                    folder
+                }
+            });
+            else await this.deleteFlpUseCase.execute(folder);
+        } catch  {}
+    }
+}
+const DeleteFlpOnFolderDeletedHandler = FolderAfterDeleteEventHandler.createImplementation({
+    implementation: DeleteFlpOnFolderDeletedHandlerImpl,
+    dependencies: [
+        DeleteFlpUseCase,
+        [
+            TaskService,
+            {
+                optional: true
+            }
+        ]
+    ]
+});
+export { DeleteFlpOnFolderDeletedHandler };
+
+//# sourceMappingURL=DeleteFlpOnFolderDeletedHandler.js.map

package/features/flp/DeleteFlpOnFolderDeleted/DeleteFlpOnFolderDeletedHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/DeleteFlpOnFolderDeleted/DeleteFlpOnFolderDeletedHandler.js","sources":["../../../../src/features/flp/DeleteFlpOnFolderDeleted/DeleteFlpOnFolderDeletedHandler.ts"],"sourcesContent":["import { DeleteFlpUseCase } from \"../DeleteFlp/abstractions.js\";\nimport { FolderAfterDeleteEventHandler } from \"~/features/folder/DeleteFolder/abstractions.js\";\nimport type { FolderAfterDeleteEvent } from \"~/features/folder/DeleteFolder/events.js\";\nimport type { IDeleteFlpTaskInput } from \"~/types.js\";\nimport { DELETE_FLP_TASK_ID } from \"~/flp/tasks/index.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\n\nclass DeleteFlpOnFolderDeletedHandlerImpl implements FolderAfterDeleteEventHandler.Interface {\n    constructor(\n        private deleteFlpUseCase: DeleteFlpUseCase.Interface,\n        private tasks?: TaskService.Interface\n    ) {}\n\n    async handle(event: FolderAfterDeleteEvent): Promise<void> {\n        const { folder } = event.payload;\n\n        try {\n            if (this.tasks) {\n                await this.tasks.trigger<IDeleteFlpTaskInput>({\n                    definition: DELETE_FLP_TASK_ID,\n                    input: { folder }\n                });\n            } else {\n                await this.deleteFlpUseCase.execute(folder);\n            }\n        } catch {\n            // Ignore errors\n        }\n    }\n}\n\nexport const DeleteFlpOnFolderDeletedHandler = FolderAfterDeleteEventHandler.createImplementation({\n    implementation: DeleteFlpOnFolderDeletedHandlerImpl,\n    dependencies: [DeleteFlpUseCase, [TaskService, { optional: true }]]\n});\n"],"names":["DeleteFlpOnFolderDeletedHandlerImpl","deleteFlpUseCase","tasks","event","folder","DELETE_FLP_TASK_ID","DeleteFlpOnFolderDeletedHandler","FolderAfterDeleteEventHandler","DeleteFlpUseCase","TaskService"],"mappings":";;;;AAOA,MAAMA;IACF,YACYC,gBAA4C,EAC5CC,KAA6B,CACvC;aAFUD,gBAAgB,GAAhBA;aACAC,KAAK,GAALA;IACT;IAEH,MAAM,OAAOC,KAA6B,EAAiB;QACvD,MAAM,EAAEC,MAAM,EAAE,GAAGD,MAAM,OAAO;QAEhC,IAAI;YACA,IAAI,IAAI,CAAC,KAAK,EACV,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAsB;gBAC1C,YAAYE;gBACZ,OAAO;oBAAED;gBAAO;YACpB;iBAEA,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAACA;QAE5C,EAAE,OAAM,CAER;IACJ;AACJ;AAEO,MAAME,kCAAkCC,8BAA8B,oBAAoB,CAAC;IAC9F,gBAAgBP;IAChB,cAAc;QAACQ;QAAkB;YAACC;YAAa;gBAAE,UAAU;YAAK;SAAE;KAAC;AACvE"}

package/features/flp/DeleteFlpOnFolderDeleted/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const DeleteFlpOnFolderDeletedFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/flp/DeleteFlpOnFolderDeleted/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { DeleteFlpOnFolderDeletedHandler } from "./DeleteFlpOnFolderDeletedHandler.js";
+const DeleteFlpOnFolderDeletedFeature = createFeature({
+    name: "DeleteFlpOnFolderDeleted",
+    register (container) {
+        container.register(DeleteFlpOnFolderDeletedHandler);
+    }
+});
+export { DeleteFlpOnFolderDeletedFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/flp/DeleteFlpOnFolderDeleted/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/DeleteFlpOnFolderDeleted/feature.js","sources":["../../../../src/features/flp/DeleteFlpOnFolderDeleted/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { DeleteFlpOnFolderDeletedHandler } from \"./DeleteFlpOnFolderDeletedHandler.js\";\n\nexport const DeleteFlpOnFolderDeletedFeature = createFeature({\n    name: \"DeleteFlpOnFolderDeleted\",\n    register(container) {\n        container.register(DeleteFlpOnFolderDeletedHandler);\n    }\n});\n"],"names":["DeleteFlpOnFolderDeletedFeature","createFeature","container","DeleteFlpOnFolderDeletedHandler"],"mappings":";;AAGO,MAAMA,kCAAkCC,cAAc;IACzD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/flp/DeleteFlpOnFolderDeleted/index.d.ts

@@ -0,0 +1 @@
+export { DeleteFlpOnFolderDeletedFeature } from "./feature.js";

package/features/flp/DeleteFlpOnFolderDeleted/index.js

@@ -0,0 +1 @@
+export { DeleteFlpOnFolderDeletedFeature } from "./feature.js";

package/features/flp/FolderLevelPermissions/FolderLevelPermissions.d.ts

@@ -0,0 +1,35 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { WcpContext } from "@webiny/api-core/features/wcp/WcpContext/index.js";
+import { ListUserTeamsUseCase } from "@webiny/api-core/features/users/ListUserTeams/index.js";
+import { type CanAccessFolderContentParams, type CanAccessFolderParams } from "./useCases/index.js";
+import { FolderLevelPermissions as FolderLevelPermissionsAbstraction } from "./abstractions.js";
+import type { FolderLevelPermission, FolderPermission, ListFlpsParams } from "../../../types.js";
+import { ListFlpsUseCase } from "../../../features/flp/ListFlps/index.js";
+import { GetFlpUseCase } from "../../../features/flp/GetFlp/index.js";
+declare class FolderLevelPermissionsImpl implements FolderLevelPermissionsAbstraction.Interface {
+    private identityContext;
+    private wcpContext;
+    private listUserTeamsUseCase;
+    private getFlpUseCase;
+    private listFlpsUseCase;
+    constructor(identityContext: IdentityContext.Interface, wcpContext: WcpContext.Interface, listUserTeamsUseCase: ListUserTeamsUseCase.Interface, getFlpUseCase: GetFlpUseCase.Interface, listFlpsUseCase: ListFlpsUseCase.Interface);
+    canUseFolderLevelPermissions(enabled?: boolean): boolean;
+    canUseTeams(): boolean;
+    canCreateFolderInRoot(): boolean;
+    permissionsIncludeNonInheritedPermissions(permissions: FolderPermission[]): boolean;
+    canAccessFolder(params: CanAccessFolderParams): Promise<boolean>;
+    canAccessFolderContent(params: CanAccessFolderContentParams): Promise<boolean>;
+    ensureCanAccessFolder(params: CanAccessFolderParams): Promise<void>;
+    ensureCanAccessFolderContent(params: CanAccessFolderContentParams): Promise<void>;
+    canManageFolderContent(flp: FolderLevelPermission): Promise<boolean>;
+    canManageFolderStructure(flp: FolderLevelPermission): Promise<boolean>;
+    canManageFolderPermissions(flp: FolderLevelPermission): Promise<boolean>;
+    getDefaultPermissions(permissions: FolderPermission[]): Promise<FolderPermission[]>;
+    listFolderLevelPermissions(params: ListFlpsParams): Promise<Array<{
+        id: string;
+        permissions: FolderPermission[];
+    }>>;
+    getFolderLevelPermissions(id: string): Promise<FolderPermission[]>;
+}
+export declare const FolderLevelPermissions: import("@webiny/di").Implementation<typeof FolderLevelPermissionsImpl>;
+export {};

package/features/flp/FolderLevelPermissions/FolderLevelPermissions.js

@@ -0,0 +1,112 @@
+import { createImplementation } from "@webiny/di";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { WcpContext } from "@webiny/api-core/features/wcp/WcpContext/index.js";
+import { ListUserTeamsUseCase } from "@webiny/api-core/features/users/ListUserTeams/index.js";
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/index.js";
+import { CanAccessFolder, CanAccessFolderContent, CanCreateFolderInRoot, CheckNotInheritedPermissions, GetDefaultPermissions, GetDefaultPermissionsWithTeams } from "./useCases/index.js";
+import { FolderLevelPermissions } from "./abstractions.js";
+import { ListFlpsUseCase } from "../ListFlps/index.js";
+import { GetFlpUseCase } from "../GetFlp/index.js";
+class FolderLevelPermissionsImpl {
+    constructor(identityContext, wcpContext, listUserTeamsUseCase, getFlpUseCase, listFlpsUseCase){
+        this.identityContext = identityContext;
+        this.wcpContext = wcpContext;
+        this.listUserTeamsUseCase = listUserTeamsUseCase;
+        this.getFlpUseCase = getFlpUseCase;
+        this.listFlpsUseCase = listFlpsUseCase;
+    }
+    canUseFolderLevelPermissions(enabled) {
+        if (false === enabled) return false;
+        const identity = this.identityContext.getIdentity();
+        if (!identity) return false;
+        if ("admin" !== identity.type) return false;
+        return this.wcpContext.canUseFolderLevelPermissions();
+    }
+    canUseTeams() {
+        return this.wcpContext.canUseTeams();
+    }
+    canCreateFolderInRoot() {
+        const canCreateFolderInRootUseCase = new CanCreateFolderInRoot();
+        return canCreateFolderInRootUseCase.execute();
+    }
+    permissionsIncludeNonInheritedPermissions(permissions) {
+        const checkNotInheritedPermissionsUseCase = new CheckNotInheritedPermissions();
+        return checkNotInheritedPermissionsUseCase.execute(permissions);
+    }
+    async canAccessFolder(params) {
+        if (!this.canUseFolderLevelPermissions() || !this.identityContext.isAuthorizationEnabled()) return true;
+        const canAccessFolderUseCase = new CanAccessFolder(this.identityContext);
+        return await canAccessFolderUseCase.execute(params);
+    }
+    async canAccessFolderContent(params) {
+        const canUseFlp = this.canUseFolderLevelPermissions();
+        const authEnabled = this.identityContext.isAuthorizationEnabled();
+        if (!canUseFlp || !authEnabled) return true;
+        const canAccessFolderContentUseCase = new CanAccessFolderContent(this.identityContext);
+        return await canAccessFolderContentUseCase.execute(params);
+    }
+    async ensureCanAccessFolder(params) {
+        const result = await this.canAccessFolder(params);
+        if (!result) throw new NotAuthorizedError();
+    }
+    async ensureCanAccessFolderContent(params) {
+        const result = await this.canAccessFolderContent(params);
+        if (!result) throw new NotAuthorizedError();
+    }
+    async canManageFolderContent(flp) {
+        if (!this.canUseFolderLevelPermissions() || !this.identityContext.isAuthorizationEnabled()) return true;
+        return await this.canAccessFolderContent({
+            permissions: flp.permissions,
+            rwd: "w"
+        });
+    }
+    async canManageFolderStructure(flp) {
+        if (!this.canUseFolderLevelPermissions() || !this.identityContext.isAuthorizationEnabled()) return true;
+        return await this.canAccessFolder({
+            permissions: flp.permissions,
+            rwd: "w"
+        });
+    }
+    async canManageFolderPermissions(flp) {
+        if (!this.canUseFolderLevelPermissions()) return false;
+        if (!this.identityContext.isAuthorizationEnabled()) return true;
+        return await this.canAccessFolder({
+            permissions: flp.permissions,
+            rwd: "w",
+            managePermissions: true
+        });
+    }
+    getDefaultPermissions(permissions) {
+        const getDefaultPermissionsUseCase = new GetDefaultPermissions(this.identityContext);
+        if (this.canUseTeams()) {
+            const getDefaultPermissionsWithTeams = new GetDefaultPermissionsWithTeams(this.identityContext, this.listUserTeamsUseCase, getDefaultPermissionsUseCase);
+            return getDefaultPermissionsWithTeams.execute(permissions);
+        }
+        return getDefaultPermissionsUseCase.execute(permissions);
+    }
+    async listFolderLevelPermissions(params) {
+        const flps = await this.listFlpsUseCase.execute(params);
+        return Promise.all(flps.map(async (flp)=>({
+                id: flp.id,
+                permissions: await this.getDefaultPermissions(flp.permissions)
+            })));
+    }
+    async getFolderLevelPermissions(id) {
+        const flp = await this.getFlpUseCase.execute(id);
+        return await this.getDefaultPermissions(flp?.permissions ?? []);
+    }
+}
+const FolderLevelPermissions_FolderLevelPermissions = createImplementation({
+    abstraction: FolderLevelPermissions,
+    implementation: FolderLevelPermissionsImpl,
+    dependencies: [
+        IdentityContext,
+        WcpContext,
+        ListUserTeamsUseCase,
+        GetFlpUseCase,
+        ListFlpsUseCase
+    ]
+});
+export { FolderLevelPermissions_FolderLevelPermissions as FolderLevelPermissions };
+
+//# sourceMappingURL=FolderLevelPermissions.js.map

package/features/flp/FolderLevelPermissions/FolderLevelPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/FolderLevelPermissions/FolderLevelPermissions.js","sources":["../../../../src/features/flp/FolderLevelPermissions/FolderLevelPermissions.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/di\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { WcpContext } from \"@webiny/api-core/features/wcp/WcpContext/index.js\";\nimport { ListUserTeamsUseCase } from \"@webiny/api-core/features/users/ListUserTeams/index.js\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/index.js\";\nimport {\n    CanAccessFolder,\n    CanAccessFolderContent,\n    type CanAccessFolderContentParams,\n    type CanAccessFolderParams,\n    CanCreateFolderInRoot,\n    CheckNotInheritedPermissions,\n    GetDefaultPermissions,\n    GetDefaultPermissionsWithTeams\n} from \"./useCases/index.js\";\nimport { FolderLevelPermissions as FolderLevelPermissionsAbstraction } from \"./abstractions.js\";\nimport type { FolderLevelPermission, FolderPermission, ListFlpsParams } from \"~/types.js\";\nimport { ListFlpsUseCase } from \"~/features/flp/ListFlps/index.js\";\nimport { GetFlpUseCase } from \"~/features/flp/GetFlp/index.js\";\n\nclass FolderLevelPermissionsImpl implements FolderLevelPermissionsAbstraction.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private wcpContext: WcpContext.Interface,\n        private listUserTeamsUseCase: ListUserTeamsUseCase.Interface,\n        private getFlpUseCase: GetFlpUseCase.Interface,\n        private listFlpsUseCase: ListFlpsUseCase.Interface\n    ) {}\n\n    public canUseFolderLevelPermissions(enabled?: boolean): boolean {\n        if (enabled === false) {\n            return false;\n        }\n\n        const identity = this.identityContext.getIdentity();\n\n        // FLPs only work with authenticated identities (logged-in users).\n        if (!identity) {\n            return false;\n        }\n\n        // At the moment, we only want FLP to be used with identities of type \"admin\".\n        // This temporarily addresses the issue of API keys not being able to access content, because\n        // FLPs doesn't work with them. Once we start adding FLPs to API keys, we can remove this check.\n        if (identity.type !== \"admin\") {\n            return false;\n        }\n\n        return this.wcpContext.canUseFolderLevelPermissions();\n    }\n\n    public canUseTeams(): boolean {\n        return this.wcpContext.canUseTeams();\n    }\n\n    public canCreateFolderInRoot(): boolean {\n        const canCreateFolderInRootUseCase = new CanCreateFolderInRoot();\n        return canCreateFolderInRootUseCase.execute();\n    }\n\n    public permissionsIncludeNonInheritedPermissions(permissions: FolderPermission[]): boolean {\n        const checkNotInheritedPermissionsUseCase = new CheckNotInheritedPermissions();\n        return checkNotInheritedPermissionsUseCase.execute(permissions);\n    }\n\n    public async canAccessFolder(params: CanAccessFolderParams): Promise<boolean> {\n        if (\n            !this.canUseFolderLevelPermissions() ||\n            !this.identityContext.isAuthorizationEnabled()\n        ) {\n            return true;\n        }\n\n        const canAccessFolderUseCase = new CanAccessFolder(this.identityContext);\n        return await canAccessFolderUseCase.execute(params);\n    }\n\n    public async canAccessFolderContent(params: CanAccessFolderContentParams): Promise<boolean> {\n        const canUseFlp = this.canUseFolderLevelPermissions();\n        const authEnabled = this.identityContext.isAuthorizationEnabled();\n\n        if (!canUseFlp || !authEnabled) {\n            return true;\n        }\n\n        const canAccessFolderContentUseCase = new CanAccessFolderContent(this.identityContext);\n        return await canAccessFolderContentUseCase.execute(params);\n    }\n\n    public async ensureCanAccessFolder(params: CanAccessFolderParams): Promise<void> {\n        const result = await this.canAccessFolder(params);\n        if (!result) {\n            throw new NotAuthorizedError();\n        }\n    }\n\n    public async ensureCanAccessFolderContent(params: CanAccessFolderContentParams): Promise<void> {\n        const result = await this.canAccessFolderContent(params);\n        if (!result) {\n            throw new NotAuthorizedError();\n        }\n    }\n\n    public async canManageFolderContent(flp: FolderLevelPermission): Promise<boolean> {\n        if (\n            !this.canUseFolderLevelPermissions() ||\n            !this.identityContext.isAuthorizationEnabled()\n        ) {\n            return true;\n        }\n\n        return await this.canAccessFolderContent({ permissions: flp.permissions, rwd: \"w\" });\n    }\n\n    public async canManageFolderStructure(flp: FolderLevelPermission): Promise<boolean> {\n        if (\n            !this.canUseFolderLevelPermissions() ||\n            !this.identityContext.isAuthorizationEnabled()\n        ) {\n            return true;\n        }\n\n        return await this.canAccessFolder({ permissions: flp.permissions, rwd: \"w\" });\n    }\n\n    public async canManageFolderPermissions(flp: FolderLevelPermission): Promise<boolean> {\n        if (!this.canUseFolderLevelPermissions()) {\n            return false;\n        }\n\n        if (!this.identityContext.isAuthorizationEnabled()) {\n            return true;\n        }\n\n        return await this.canAccessFolder({\n            permissions: flp.permissions,\n            rwd: \"w\",\n            managePermissions: true\n        });\n    }\n\n    public getDefaultPermissions(permissions: FolderPermission[]): Promise<FolderPermission[]> {\n        const getDefaultPermissionsUseCase = new GetDefaultPermissions(this.identityContext);\n\n        if (this.canUseTeams()) {\n            const getDefaultPermissionsWithTeams = new GetDefaultPermissionsWithTeams(\n                this.identityContext,\n                this.listUserTeamsUseCase,\n                getDefaultPermissionsUseCase\n            );\n\n            return getDefaultPermissionsWithTeams.execute(permissions);\n        }\n\n        return getDefaultPermissionsUseCase.execute(permissions);\n    }\n\n    public async listFolderLevelPermissions(params: ListFlpsParams): Promise<\n        Array<{\n            id: string;\n            permissions: FolderPermission[];\n        }>\n    > {\n        const flps = await this.listFlpsUseCase.execute(params);\n\n        return Promise.all(\n            flps.map(async flp => ({\n                id: flp.id,\n                permissions: await this.getDefaultPermissions(flp.permissions)\n            }))\n        );\n    }\n\n    public async getFolderLevelPermissions(id: string): Promise<FolderPermission[]> {\n        const flp = await this.getFlpUseCase.execute(id);\n        return await this.getDefaultPermissions(flp?.permissions ?? []);\n    }\n}\n\nexport const FolderLevelPermissions = createImplementation({\n    abstraction: FolderLevelPermissionsAbstraction,\n    implementation: FolderLevelPermissionsImpl,\n    dependencies: [\n        IdentityContext,\n        WcpContext,\n        ListUserTeamsUseCase,\n        GetFlpUseCase,\n        ListFlpsUseCase\n    ]\n});\n"],"names":["FolderLevelPermissionsImpl","identityContext","wcpContext","listUserTeamsUseCase","getFlpUseCase","listFlpsUseCase","enabled","identity","canCreateFolderInRootUseCase","CanCreateFolderInRoot","permissions","checkNotInheritedPermissionsUseCase","CheckNotInheritedPermissions","params","canAccessFolderUseCase","CanAccessFolder","canUseFlp","authEnabled","canAccessFolderContentUseCase","CanAccessFolderContent","result","NotAuthorizedError","flp","getDefaultPermissionsUseCase","GetDefaultPermissions","getDefaultPermissionsWithTeams","GetDefaultPermissionsWithTeams","flps","Promise","id","FolderLevelPermissions","createImplementation","FolderLevelPermissionsAbstraction","IdentityContext","WcpContext","ListUserTeamsUseCase","GetFlpUseCase","ListFlpsUseCase"],"mappings":"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"}

package/features/flp/FolderLevelPermissions/NoopFolderLevelPermissions.d.ts

@@ -0,0 +1,25 @@
+import { type IFolderLevelPermissions } from "./abstractions.js";
+import type { FolderPermission } from "../../../types.js";
+declare class NoopFolderLevelPermissionsImpl implements IFolderLevelPermissions {
+    canUseFolderLevelPermissions(): boolean;
+    canUseTeams(): boolean;
+    canCreateFolderInRoot(): boolean;
+    permissionsIncludeNonInheritedPermissions(): boolean;
+    canAccessFolder(): Promise<boolean>;
+    canAccessFolderContent(): Promise<boolean>;
+    ensureCanAccessFolder(): Promise<void>;
+    ensureCanAccessFolderContent(): Promise<void>;
+    canManageFolderContent(): Promise<boolean>;
+    canManageFolderStructure(): Promise<boolean>;
+    canManageFolderPermissions(): Promise<boolean>;
+    getDefaultPermissions(permissions: FolderPermission[]): Promise<FolderPermission[]>;
+    listFolderLevelPermissions(): Promise<Array<{
+        id: string;
+        permissions: FolderPermission[];
+    }>>;
+    getFolderLevelPermissions(): Promise<FolderPermission[]>;
+}
+export declare const NoopFolderLevelPermissions: typeof NoopFolderLevelPermissionsImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IFolderLevelPermissions>;
+};
+export {};

package/features/flp/FolderLevelPermissions/NoopFolderLevelPermissions.js

@@ -0,0 +1,48 @@
+import { FolderLevelPermissions } from "./abstractions.js";
+class NoopFolderLevelPermissionsImpl {
+    canUseFolderLevelPermissions() {
+        return false;
+    }
+    canUseTeams() {
+        return false;
+    }
+    canCreateFolderInRoot() {
+        return true;
+    }
+    permissionsIncludeNonInheritedPermissions() {
+        return false;
+    }
+    async canAccessFolder() {
+        return true;
+    }
+    async canAccessFolderContent() {
+        return true;
+    }
+    async ensureCanAccessFolder() {}
+    async ensureCanAccessFolderContent() {}
+    async canManageFolderContent() {
+        return true;
+    }
+    async canManageFolderStructure() {
+        return true;
+    }
+    async canManageFolderPermissions() {
+        return true;
+    }
+    async getDefaultPermissions(permissions) {
+        return permissions;
+    }
+    async listFolderLevelPermissions() {
+        return [];
+    }
+    async getFolderLevelPermissions() {
+        return [];
+    }
+}
+const NoopFolderLevelPermissions = FolderLevelPermissions.createImplementation({
+    implementation: NoopFolderLevelPermissionsImpl,
+    dependencies: []
+});
+export { NoopFolderLevelPermissions };
+
+//# sourceMappingURL=NoopFolderLevelPermissions.js.map

package/features/flp/FolderLevelPermissions/NoopFolderLevelPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/FolderLevelPermissions/NoopFolderLevelPermissions.js","sources":["../../../../src/features/flp/FolderLevelPermissions/NoopFolderLevelPermissions.ts"],"sourcesContent":["import { FolderLevelPermissions, type IFolderLevelPermissions } from \"./abstractions.js\";\nimport type { FolderPermission } from \"~/types.js\";\n\nclass NoopFolderLevelPermissionsImpl implements IFolderLevelPermissions {\n    canUseFolderLevelPermissions(): boolean {\n        return false;\n    }\n\n    canUseTeams(): boolean {\n        return false;\n    }\n\n    canCreateFolderInRoot(): boolean {\n        return true;\n    }\n\n    permissionsIncludeNonInheritedPermissions(): boolean {\n        return false;\n    }\n\n    async canAccessFolder(): Promise<boolean> {\n        return true;\n    }\n\n    async canAccessFolderContent(): Promise<boolean> {\n        return true;\n    }\n\n    async ensureCanAccessFolder(): Promise<void> {\n        return;\n    }\n\n    async ensureCanAccessFolderContent(): Promise<void> {\n        return;\n    }\n\n    async canManageFolderContent(): Promise<boolean> {\n        return true;\n    }\n\n    async canManageFolderStructure(): Promise<boolean> {\n        return true;\n    }\n\n    async canManageFolderPermissions(): Promise<boolean> {\n        return true;\n    }\n\n    async getDefaultPermissions(permissions: FolderPermission[]): Promise<FolderPermission[]> {\n        return permissions;\n    }\n\n    async listFolderLevelPermissions(): Promise<\n        Array<{ id: string; permissions: FolderPermission[] }>\n    > {\n        return [];\n    }\n\n    async getFolderLevelPermissions(): Promise<FolderPermission[]> {\n        return [];\n    }\n}\n\nexport const NoopFolderLevelPermissions = FolderLevelPermissions.createImplementation({\n    implementation: NoopFolderLevelPermissionsImpl,\n    dependencies: []\n});\n"],"names":["NoopFolderLevelPermissionsImpl","permissions","NoopFolderLevelPermissions","FolderLevelPermissions"],"mappings":";AAGA,MAAMA;IACF,+BAAwC;QACpC,OAAO;IACX;IAEA,cAAuB;QACnB,OAAO;IACX;IAEA,wBAAiC;QAC7B,OAAO;IACX;IAEA,4CAAqD;QACjD,OAAO;IACX;IAEA,MAAM,kBAAoC;QACtC,OAAO;IACX;IAEA,MAAM,yBAA2C;QAC7C,OAAO;IACX;IAEA,MAAM,wBAAuC,CAE7C;IAEA,MAAM,+BAA8C,CAEpD;IAEA,MAAM,yBAA2C;QAC7C,OAAO;IACX;IAEA,MAAM,2BAA6C;QAC/C,OAAO;IACX;IAEA,MAAM,6BAA+C;QACjD,OAAO;IACX;IAEA,MAAM,sBAAsBC,WAA+B,EAA+B;QACtF,OAAOA;IACX;IAEA,MAAM,6BAEJ;QACE,OAAO,EAAE;IACb;IAEA,MAAM,4BAAyD;QAC3D,OAAO,EAAE;IACb;AACJ;AAEO,MAAMC,6BAA6BC,uBAAuB,oBAAoB,CAAC;IAClF,gBAAgBH;IAChB,cAAc,EAAE;AACpB"}

package/features/flp/FolderLevelPermissions/abstractions.d.ts

@@ -0,0 +1,26 @@
+import type { CanAccessFolderContentParams, CanAccessFolderParams } from "./useCases/index.js";
+import type { FolderLevelPermission, FolderPermission, ListFlpsParams } from "../../../types.js";
+export interface IFolderLevelPermissions {
+    canUseFolderLevelPermissions(enabled?: boolean): boolean;
+    canUseTeams(): boolean;
+    canCreateFolderInRoot(): boolean;
+    permissionsIncludeNonInheritedPermissions(permissions: FolderPermission[]): boolean;
+    canAccessFolder(params: CanAccessFolderParams): Promise<boolean>;
+    canAccessFolderContent(params: CanAccessFolderContentParams): Promise<boolean>;
+    ensureCanAccessFolder(params: CanAccessFolderParams): Promise<void>;
+    ensureCanAccessFolderContent(params: CanAccessFolderContentParams): Promise<void>;
+    canManageFolderContent(flp: FolderLevelPermission): Promise<boolean>;
+    canManageFolderStructure(flp: FolderLevelPermission): Promise<boolean>;
+    canManageFolderPermissions(flp: FolderLevelPermission): Promise<boolean>;
+    getDefaultPermissions(permissions: FolderPermission[]): Promise<FolderPermission[]>;
+    listFolderLevelPermissions(params: ListFlpsParams): Promise<Array<{
+        id: string;
+        permissions: FolderPermission[];
+    }>>;
+    getFolderLevelPermissions(id: string): Promise<FolderPermission[]>;
+}
+/** Manage folder-level access control. */
+export declare const FolderLevelPermissions: import("@webiny/di").Abstraction<IFolderLevelPermissions>;
+export declare namespace FolderLevelPermissions {
+    type Interface = IFolderLevelPermissions;
+}

package/features/flp/FolderLevelPermissions/abstractions.js

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

package/features/flp/FolderLevelPermissions/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/FolderLevelPermissions/abstractions.js","sources":["../../../../src/features/flp/FolderLevelPermissions/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { CanAccessFolderContentParams, CanAccessFolderParams } from \"./useCases/index.js\";\nimport type { FolderLevelPermission, FolderPermission, ListFlpsParams } from \"~/types.js\";\n\nexport interface IFolderLevelPermissions {\n    canUseFolderLevelPermissions(enabled?: boolean): boolean;\n    canUseTeams(): boolean;\n    canCreateFolderInRoot(): boolean;\n    permissionsIncludeNonInheritedPermissions(permissions: FolderPermission[]): boolean;\n    canAccessFolder(params: CanAccessFolderParams): Promise<boolean>;\n    canAccessFolderContent(params: CanAccessFolderContentParams): Promise<boolean>;\n    ensureCanAccessFolder(params: CanAccessFolderParams): Promise<void>;\n    ensureCanAccessFolderContent(params: CanAccessFolderContentParams): Promise<void>;\n    canManageFolderContent(flp: FolderLevelPermission): Promise<boolean>;\n    canManageFolderStructure(flp: FolderLevelPermission): Promise<boolean>;\n    canManageFolderPermissions(flp: FolderLevelPermission): Promise<boolean>;\n    getDefaultPermissions(permissions: FolderPermission[]): Promise<FolderPermission[]>;\n    listFolderLevelPermissions(params: ListFlpsParams): Promise<\n        Array<{\n            id: string;\n            permissions: FolderPermission[];\n        }>\n    >;\n    getFolderLevelPermissions(id: string): Promise<FolderPermission[]>;\n}\n\n/** Manage folder-level access control. */\nexport const FolderLevelPermissions =\n    createAbstraction<IFolderLevelPermissions>(\"FolderLevelPermissions\");\n\nexport namespace FolderLevelPermissions {\n    export type Interface = IFolderLevelPermissions;\n}\n"],"names":["FolderLevelPermissions","createAbstraction"],"mappings":";AA2BO,MAAMA,yBACTC,kBAA2C"}

package/features/flp/FolderLevelPermissions/feature.d.ts

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

package/features/flp/FolderLevelPermissions/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { FolderLevelPermissions } from "./FolderLevelPermissions.js";
+const FolderLevelPermissionsFeature = createFeature({
+    name: "FolderLevelPermissions",
+    register (container) {
+        container.register(FolderLevelPermissions);
+    }
+});
+export { FolderLevelPermissionsFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/flp/FolderLevelPermissions/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/FolderLevelPermissions/feature.js","sources":["../../../../src/features/flp/FolderLevelPermissions/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { FolderLevelPermissions } from \"./FolderLevelPermissions.js\";\n\nexport const FolderLevelPermissionsFeature = createFeature({\n    name: \"FolderLevelPermissions\",\n    register(container: Container) {\n        container.register(FolderLevelPermissions);\n    }\n});\n"],"names":["FolderLevelPermissionsFeature","createFeature","container","FolderLevelPermissions"],"mappings":";;AAIO,MAAMA,gCAAgCC,cAAc;IACvD,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC;IACvB;AACJ"}