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

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

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

package/features/flp/UpdateFlp/index.js

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

package/features/flp/UpdateFlpOnFolderUpdated/UpdateFlpOnFolderUpdatedHandler.d.ts

@@ -0,0 +1,14 @@
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { UpdateFlpUseCase } from "../UpdateFlp/abstractions.js";
+import type { FolderAfterUpdateEvent } from "../../../features/folder/UpdateFolder/events.js";
+import { FolderAfterUpdateEventHandler } from "../../../features/folder/UpdateFolder/index.js";
+declare class UpdateFlpOnFolderUpdatedHandlerImpl implements FolderAfterUpdateEventHandler.Interface {
+    private updateFlpUseCase;
+    private tasks?;
+    constructor(updateFlpUseCase: UpdateFlpUseCase.Interface, tasks?: TaskService.Interface | undefined);
+    handle(event: FolderAfterUpdateEvent): Promise<void>;
+}
+export declare const UpdateFlpOnFolderUpdatedHandler: typeof UpdateFlpOnFolderUpdatedHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<import("@webiny/api-core/features/eventPublisher/abstractions.js").DomainEvent<import("../../folder/UpdateFolder/abstractions.js").FolderAfterUpdatePayload>>>;
+};
+export {};

package/features/flp/UpdateFlpOnFolderUpdated/UpdateFlpOnFolderUpdatedHandler.js

@@ -0,0 +1,39 @@
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { UpdateFlpUseCase } from "../UpdateFlp/abstractions.js";
+import { UPDATE_FLP_TASK_ID } from "../../../flp/tasks/index.js";
+import { FolderAfterUpdateEventHandler } from "../../folder/UpdateFolder/index.js";
+class UpdateFlpOnFolderUpdatedHandlerImpl {
+    constructor(updateFlpUseCase, tasks){
+        this.updateFlpUseCase = updateFlpUseCase;
+        this.tasks = tasks;
+    }
+    async handle(event) {
+        const { folder } = event.payload;
+        try {
+            if (this.tasks) await this.tasks.trigger({
+                definition: UPDATE_FLP_TASK_ID,
+                input: {
+                    folder
+                }
+            });
+            else await this.updateFlpUseCase.execute({
+                folder
+            });
+        } catch  {}
+    }
+}
+const UpdateFlpOnFolderUpdatedHandler = FolderAfterUpdateEventHandler.createImplementation({
+    implementation: UpdateFlpOnFolderUpdatedHandlerImpl,
+    dependencies: [
+        UpdateFlpUseCase,
+        [
+            TaskService,
+            {
+                optional: true
+            }
+        ]
+    ]
+});
+export { UpdateFlpOnFolderUpdatedHandler };
+
+//# sourceMappingURL=UpdateFlpOnFolderUpdatedHandler.js.map

package/features/flp/UpdateFlpOnFolderUpdated/UpdateFlpOnFolderUpdatedHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/UpdateFlpOnFolderUpdated/UpdateFlpOnFolderUpdatedHandler.js","sources":["../../../../src/features/flp/UpdateFlpOnFolderUpdated/UpdateFlpOnFolderUpdatedHandler.ts"],"sourcesContent":["import { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport { UpdateFlpUseCase } from \"../UpdateFlp/abstractions.js\";\nimport type { FolderAfterUpdateEvent } from \"~/features/folder/UpdateFolder/events.js\";\nimport type { IUpdateFlpTaskInput } from \"~/types.js\";\nimport { UPDATE_FLP_TASK_ID } from \"~/flp/tasks/index.js\";\nimport { FolderAfterUpdateEventHandler } from \"~/features/folder/UpdateFolder/index.js\";\n\nclass UpdateFlpOnFolderUpdatedHandlerImpl implements FolderAfterUpdateEventHandler.Interface {\n    constructor(\n        private updateFlpUseCase: UpdateFlpUseCase.Interface,\n        private tasks?: TaskService.Interface\n    ) {}\n\n    async handle(event: FolderAfterUpdateEvent): Promise<void> {\n        const { folder } = event.payload;\n\n        try {\n            if (this.tasks) {\n                await this.tasks.trigger<IUpdateFlpTaskInput>({\n                    definition: UPDATE_FLP_TASK_ID,\n                    input: { folder }\n                });\n            } else {\n                await this.updateFlpUseCase.execute({ folder });\n            }\n        } catch {\n            // Ignore errors\n        }\n    }\n}\n\nexport const UpdateFlpOnFolderUpdatedHandler = FolderAfterUpdateEventHandler.createImplementation({\n    implementation: UpdateFlpOnFolderUpdatedHandlerImpl,\n    dependencies: [UpdateFlpUseCase, [TaskService, { optional: true }]]\n});\n"],"names":["UpdateFlpOnFolderUpdatedHandlerImpl","updateFlpUseCase","tasks","event","folder","UPDATE_FLP_TASK_ID","UpdateFlpOnFolderUpdatedHandler","FolderAfterUpdateEventHandler","UpdateFlpUseCase","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,CAAC;gBAAEA;YAAO;QAErD,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/UpdateFlpOnFolderUpdated/feature.d.ts

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

package/features/flp/UpdateFlpOnFolderUpdated/feature.js

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

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

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

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

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

package/features/flp/UpdateFlpOnFolderUpdated/index.js

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

package/features/flp/shared/CodeFlpMerger.d.ts

@@ -0,0 +1,26 @@
+import type { FolderLevelPermission, FolderPermission } from "../../../flp/flp.types.js";
+export declare class CodeFlpMerger {
+    /**
+     * Merge code-defined permissions into a stored FLP record.
+     *
+     * A code-defined permission always wins over a stored one for the same target, and that takes
+     * both steps below — ordering alone is not enough, because the two downstream consumers pick a
+     * target's permission in different ways:
+     *
+     * - `CanAccessFolder` takes the first match (`permissions.find(p => p.target === ...)`), so code
+     *   permissions go first.
+     * - `DefaultPermissionsMerger` instead collects *every* permission for the identity and reduces
+     *   them by access level, preferring `no-access` and then `owner`. A leftover duplicate would
+     *   join that reduce and could outrank the code-defined entry — a stored `owner` would beat a
+     *   code-defined `viewer`. Dropping the stored permission for a code-defined target is what
+     *   prevents it.
+     *
+     * So: exactly one permission per target, and for code-defined targets it is the code one.
+     */
+    static merge(flp: FolderLevelPermission, codePermissions: FolderPermission[]): FolderLevelPermission;
+    /**
+     * The same merge, for callers that hold a plain permission list rather than a stored FLP record
+     * — the write paths, which resolve code permissions from the folder's own type and path.
+     */
+    static mergePermissions(permissions: FolderPermission[], codePermissions: FolderPermission[]): FolderPermission[];
+}

package/features/flp/shared/CodeFlpMerger.js

@@ -0,0 +1,20 @@
+class CodeFlpMerger {
+    static merge(flp, codePermissions) {
+        if (!codePermissions.length) return flp;
+        return {
+            ...flp,
+            permissions: CodeFlpMerger.mergePermissions(flp.permissions, codePermissions)
+        };
+    }
+    static mergePermissions(permissions, codePermissions) {
+        if (!codePermissions.length) return permissions;
+        const codeTargets = new Set(codePermissions.map((permission)=>permission.target));
+        return [
+            ...codePermissions,
+            ...permissions.filter((permission)=>!codeTargets.has(permission.target))
+        ];
+    }
+}
+export { CodeFlpMerger };
+
+//# sourceMappingURL=CodeFlpMerger.js.map

package/features/flp/shared/CodeFlpMerger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/shared/CodeFlpMerger.js","sources":["../../../../src/features/flp/shared/CodeFlpMerger.ts"],"sourcesContent":["import type { FolderLevelPermission, FolderPermission } from \"~/flp/flp.types.js\";\n\nexport class CodeFlpMerger {\n    /**\n     * Merge code-defined permissions into a stored FLP record.\n     *\n     * A code-defined permission always wins over a stored one for the same target, and that takes\n     * both steps below — ordering alone is not enough, because the two downstream consumers pick a\n     * target's permission in different ways:\n     *\n     * - `CanAccessFolder` takes the first match (`permissions.find(p => p.target === ...)`), so code\n     *   permissions go first.\n     * - `DefaultPermissionsMerger` instead collects *every* permission for the identity and reduces\n     *   them by access level, preferring `no-access` and then `owner`. A leftover duplicate would\n     *   join that reduce and could outrank the code-defined entry — a stored `owner` would beat a\n     *   code-defined `viewer`. Dropping the stored permission for a code-defined target is what\n     *   prevents it.\n     *\n     * So: exactly one permission per target, and for code-defined targets it is the code one.\n     */\n    static merge(\n        flp: FolderLevelPermission,\n        codePermissions: FolderPermission[]\n    ): FolderLevelPermission {\n        if (!codePermissions.length) {\n            return flp;\n        }\n\n        return {\n            ...flp,\n            permissions: CodeFlpMerger.mergePermissions(flp.permissions, codePermissions)\n        };\n    }\n\n    /**\n     * The same merge, for callers that hold a plain permission list rather than a stored FLP record\n     * — the write paths, which resolve code permissions from the folder's own type and path.\n     */\n    static mergePermissions(\n        permissions: FolderPermission[],\n        codePermissions: FolderPermission[]\n    ): FolderPermission[] {\n        if (!codePermissions.length) {\n            return permissions;\n        }\n\n        const codeTargets = new Set(codePermissions.map(permission => permission.target));\n\n        return [\n            ...codePermissions,\n            ...permissions.filter(permission => !codeTargets.has(permission.target))\n        ];\n    }\n}\n"],"names":["CodeFlpMerger","flp","codePermissions","permissions","codeTargets","Set","permission"],"mappings":"AAEO,MAAMA;IAkBT,OAAO,MACHC,GAA0B,EAC1BC,eAAmC,EACd;QACrB,IAAI,CAACA,gBAAgB,MAAM,EACvB,OAAOD;QAGX,OAAO;YACH,GAAGA,GAAG;YACN,aAAaD,cAAc,gBAAgB,CAACC,IAAI,WAAW,EAAEC;QACjE;IACJ;IAMA,OAAO,iBACHC,WAA+B,EAC/BD,eAAmC,EACjB;QAClB,IAAI,CAACA,gBAAgB,MAAM,EACvB,OAAOC;QAGX,MAAMC,cAAc,IAAIC,IAAIH,gBAAgB,GAAG,CAACI,CAAAA,aAAcA,WAAW,MAAM;QAE/E,OAAO;eACAJ;eACAC,YAAY,MAAM,CAACG,CAAAA,aAAc,CAACF,YAAY,GAAG,CAACE,WAAW,MAAM;SACzE;IACL;AACJ"}

package/features/flp/shared/CodeFlpPath.d.ts

@@ -0,0 +1,15 @@
+interface ParsedPath {
+    /** Normalized path, without the wildcard suffix, e.g. `root/marketing`. */
+    base: string;
+    /** Whether the rule was written with a trailing `/*`, meaning "this folder and its subtree". */
+    subtree: boolean;
+}
+/**
+ * Folder paths are stored as `root/<slug>[/<slug>...]` (see `~/utils/Path.ts`). Code-defined FLPs
+ * are authored by hand, so we accept the friendlier `/marketing` form as well and normalize it.
+ */
+export declare class CodeFlpPath {
+    static parse(path: string): ParsedPath;
+    static matches(rulePath: string, folderPath: string): boolean;
+}
+export {};

package/features/flp/shared/CodeFlpPath.js

@@ -0,0 +1,29 @@
+import { ROOT_FOLDER } from "@webiny/shared-aco";
+class CodeFlpPath {
+    static parse(path) {
+        let value = path.trim();
+        let subtree = false;
+        if (value.endsWith("*")) {
+            subtree = true;
+            value = value.slice(0, -1);
+        }
+        value = value.replace(/^\/+/, "").replace(/\/+$/, "");
+        if (value === ROOT_FOLDER || "" === value) return {
+            base: ROOT_FOLDER,
+            subtree: "" === value ? true : subtree
+        };
+        const base = value.startsWith(`${ROOT_FOLDER}/`) ? value : `${ROOT_FOLDER}/${value}`;
+        return {
+            base,
+            subtree
+        };
+    }
+    static matches(rulePath, folderPath) {
+        const { base, subtree } = CodeFlpPath.parse(rulePath);
+        if (folderPath === base) return true;
+        return subtree ? folderPath.startsWith(`${base}/`) : false;
+    }
+}
+export { CodeFlpPath };
+
+//# sourceMappingURL=CodeFlpPath.js.map

package/features/flp/shared/CodeFlpPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/shared/CodeFlpPath.js","sources":["../../../../src/features/flp/shared/CodeFlpPath.ts"],"sourcesContent":["import { ROOT_FOLDER } from \"@webiny/shared-aco\";\n\ninterface ParsedPath {\n    /** Normalized path, without the wildcard suffix, e.g. `root/marketing`. */\n    base: string;\n    /** Whether the rule was written with a trailing `/*`, meaning \"this folder and its subtree\". */\n    subtree: boolean;\n}\n\n/**\n * Folder paths are stored as `root/<slug>[/<slug>...]` (see `~/utils/Path.ts`). Code-defined FLPs\n * are authored by hand, so we accept the friendlier `/marketing` form as well and normalize it.\n */\nexport class CodeFlpPath {\n    static parse(path: string): ParsedPath {\n        let value = path.trim();\n        let subtree = false;\n\n        // A trailing \"*\" (with or without the separator) means \"this folder and everything below\".\n        if (value.endsWith(\"*\")) {\n            subtree = true;\n            value = value.slice(0, -1);\n        }\n\n        // Strip surrounding separators, so \"/marketing/\" and \"marketing\" normalize the same way.\n        value = value.replace(/^\\/+/, \"\").replace(/\\/+$/, \"\");\n\n        if (value === ROOT_FOLDER || value === \"\") {\n            return { base: ROOT_FOLDER, subtree: value === \"\" ? true : subtree };\n        }\n\n        // The \"root\" prefix is an implementation detail of stored paths — make it optional.\n        const base = value.startsWith(`${ROOT_FOLDER}/`) ? value : `${ROOT_FOLDER}/${value}`;\n\n        return { base, subtree };\n    }\n\n    static matches(rulePath: string, folderPath: string): boolean {\n        const { base, subtree } = CodeFlpPath.parse(rulePath);\n\n        if (folderPath === base) {\n            return true;\n        }\n\n        return subtree ? folderPath.startsWith(`${base}/`) : false;\n    }\n}\n"],"names":["CodeFlpPath","path","value","subtree","ROOT_FOLDER","base","rulePath","folderPath"],"mappings":";AAaO,MAAMA;IACT,OAAO,MAAMC,IAAY,EAAc;QACnC,IAAIC,QAAQD,KAAK,IAAI;QACrB,IAAIE,UAAU;QAGd,IAAID,MAAM,QAAQ,CAAC,MAAM;YACrBC,UAAU;YACVD,QAAQA,MAAM,KAAK,CAAC,GAAG;QAC3B;QAGAA,QAAQA,MAAM,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ;QAElD,IAAIA,UAAUE,eAAeF,AAAU,OAAVA,OACzB,OAAO;YAAE,MAAME;YAAa,SAASF,AAAU,OAAVA,QAAe,OAAOC;QAAQ;QAIvE,MAAME,OAAOH,MAAM,UAAU,CAAC,GAAGE,YAAY,CAAC,CAAC,IAAIF,QAAQ,GAAGE,YAAY,CAAC,EAAEF,OAAO;QAEpF,OAAO;YAAEG;YAAMF;QAAQ;IAC3B;IAEA,OAAO,QAAQG,QAAgB,EAAEC,UAAkB,EAAW;QAC1D,MAAM,EAAEF,IAAI,EAAEF,OAAO,EAAE,GAAGH,YAAY,KAAK,CAACM;QAE5C,IAAIC,eAAeF,MACf,OAAO;QAGX,OAAOF,UAAUI,WAAW,UAAU,CAAC,GAAGF,KAAK,CAAC,CAAC,IAAI;IACzD;AACJ"}

package/features/flp/shared/CodeFlpTarget.d.ts

@@ -0,0 +1,10 @@
+import type { CodeFolderPermission } from "./abstractions.js";
+import type { FolderPermission } from "../../../flp/flp.types.js";
+/**
+ * Code-defined permissions are authored as `{ team: "editors" }` or `{ user: "<id>" }`. Internally,
+ * a permission's target is a single string — `team:editors` or `admin:<id>` — so this is where the
+ * authored form is turned into the stored one.
+ */
+export declare class CodeFlpTarget {
+    static resolve(permission: CodeFolderPermission): FolderPermission;
+}

package/features/flp/shared/CodeFlpTarget.js

@@ -0,0 +1,26 @@
+import { WebinyError } from "@webiny/error";
+class CodeFlpTarget {
+    static resolve(permission) {
+        const { team, user, level } = permission;
+        if (void 0 !== team && void 0 !== user) throw new WebinyError("A code-defined folder permission must target either a team or a user, not both.", "CODE_FLP_AMBIGUOUS_TARGET", {
+            team,
+            user
+        });
+        if (void 0 !== team) return {
+            target: `team:${team}`,
+            level,
+            plugin: true
+        };
+        if (void 0 !== user) return {
+            target: `admin:${user}`,
+            level,
+            plugin: true
+        };
+        throw new WebinyError('A code-defined folder permission must specify either "team" or "user".', "CODE_FLP_MISSING_TARGET", {
+            permission
+        });
+    }
+}
+export { CodeFlpTarget };
+
+//# sourceMappingURL=CodeFlpTarget.js.map

package/features/flp/shared/CodeFlpTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/shared/CodeFlpTarget.js","sources":["../../../../src/features/flp/shared/CodeFlpTarget.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport type { CodeFolderPermission } from \"./abstractions.js\";\nimport type { FolderPermission } from \"~/flp/flp.types.js\";\n\n/**\n * Code-defined permissions are authored as `{ team: \"editors\" }` or `{ user: \"<id>\" }`. Internally,\n * a permission's target is a single string — `team:editors` or `admin:<id>` — so this is where the\n * authored form is turned into the stored one.\n */\nexport class CodeFlpTarget {\n    static resolve(permission: CodeFolderPermission): FolderPermission {\n        const { team, user, level } = permission;\n\n        if (team !== undefined && user !== undefined) {\n            throw new WebinyError(\n                `A code-defined folder permission must target either a team or a user, not both.`,\n                \"CODE_FLP_AMBIGUOUS_TARGET\",\n                { team, user }\n            );\n        }\n\n        if (team !== undefined) {\n            return { target: `team:${team}`, level, plugin: true };\n        }\n\n        if (user !== undefined) {\n            return { target: `admin:${user}`, level, plugin: true };\n        }\n\n        // Without a target we'd silently produce a permission that matches nobody. For a rule that\n        // denies access, dropping it quietly would mean accidental exposure — so fail loudly.\n        throw new WebinyError(\n            `A code-defined folder permission must specify either \"team\" or \"user\".`,\n            \"CODE_FLP_MISSING_TARGET\",\n            { permission }\n        );\n    }\n}\n"],"names":["CodeFlpTarget","permission","team","user","level","undefined","WebinyError"],"mappings":";AASO,MAAMA;IACT,OAAO,QAAQC,UAAgC,EAAoB;QAC/D,MAAM,EAAEC,IAAI,EAAEC,IAAI,EAAEC,KAAK,EAAE,GAAGH;QAE9B,IAAIC,AAASG,WAATH,QAAsBC,AAASE,WAATF,MACtB,MAAM,IAAIG,YACN,mFACA,6BACA;YAAEJ;YAAMC;QAAK;QAIrB,IAAID,AAASG,WAATH,MACA,OAAO;YAAE,QAAQ,CAAC,KAAK,EAAEA,MAAM;YAAEE;YAAO,QAAQ;QAAK;QAGzD,IAAID,AAASE,WAATF,MACA,OAAO;YAAE,QAAQ,CAAC,MAAM,EAAEA,MAAM;YAAEC;YAAO,QAAQ;QAAK;QAK1D,MAAM,IAAIE,YACN,0EACA,2BACA;YAAEL;QAAW;IAErB;AACJ"}

package/features/flp/shared/CodeFlpsProvider.d.ts

@@ -0,0 +1,14 @@
+import { CodeFlpsProvider as CodeFlpsProviderAbstraction, FlpFactory, type GetCodePermissionsParams } from "./abstractions.js";
+import type { FolderPermission } from "../../../flp/flp.types.js";
+declare class CodeFlpsProviderImpl implements CodeFlpsProviderAbstraction.Interface {
+    private flpFactories;
+    private cache;
+    constructor(flpFactories: FlpFactory.Interface[]);
+    getPermissions({ type, path }: GetCodePermissionsParams): Promise<FolderPermission[]>;
+    /** All code-defined FLPs, collected from every registered `FlpFactory`. */
+    private getCodeFlps;
+}
+export declare const CodeFlpsProvider: typeof CodeFlpsProviderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICodeFlpsProvider>;
+};
+export {};

package/features/flp/shared/CodeFlpsProvider.js

@@ -0,0 +1,33 @@
+import { CodeFlpsProvider, FlpFactory } from "./abstractions.js";
+import { CodeFlpPath } from "./CodeFlpPath.js";
+import { CodeFlpTarget } from "./CodeFlpTarget.js";
+class CodeFlpsProviderImpl {
+    constructor(flpFactories){
+        this.flpFactories = flpFactories;
+    }
+    async getPermissions({ type, path }) {
+        const codeFlps = await this.getCodeFlps();
+        return codeFlps.filter((flp)=>flp.type === type && CodeFlpPath.matches(flp.path, path)).flatMap((flp)=>flp.permissions.map((permission)=>CodeFlpTarget.resolve(permission)));
+    }
+    async getCodeFlps() {
+        if (void 0 === this.cache) {
+            const results = await Promise.all(this.flpFactories.map((factory)=>factory.execute()));
+            this.cache = results.flat();
+        }
+        return this.cache;
+    }
+}
+const CodeFlpsProvider_CodeFlpsProvider = CodeFlpsProvider.createImplementation({
+    implementation: CodeFlpsProviderImpl,
+    dependencies: [
+        [
+            FlpFactory,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { CodeFlpsProvider_CodeFlpsProvider as CodeFlpsProvider };
+
+//# sourceMappingURL=CodeFlpsProvider.js.map

package/features/flp/shared/CodeFlpsProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/shared/CodeFlpsProvider.js","sources":["../../../../src/features/flp/shared/CodeFlpsProvider.ts"],"sourcesContent":["import {\n    type CodeFlp,\n    CodeFlpsProvider as CodeFlpsProviderAbstraction,\n    FlpFactory,\n    type GetCodePermissionsParams\n} from \"./abstractions.js\";\nimport { CodeFlpPath } from \"./CodeFlpPath.js\";\nimport { CodeFlpTarget } from \"./CodeFlpTarget.js\";\nimport type { FolderPermission } from \"~/flp/flp.types.js\";\n\nclass CodeFlpsProviderImpl implements CodeFlpsProviderAbstraction.Interface {\n    private cache: CodeFlp[] | undefined;\n\n    constructor(private flpFactories: FlpFactory.Interface[]) {}\n\n    async getPermissions({ type, path }: GetCodePermissionsParams): Promise<FolderPermission[]> {\n        const codeFlps = await this.getCodeFlps();\n\n        return codeFlps\n            .filter(flp => flp.type === type && CodeFlpPath.matches(flp.path, path))\n            .flatMap<FolderPermission>(flp => {\n                return flp.permissions.map(permission => CodeFlpTarget.resolve(permission));\n            });\n    }\n\n    /** All code-defined FLPs, collected from every registered `FlpFactory`. */\n    private async getCodeFlps(): Promise<CodeFlp[]> {\n        if (this.cache === undefined) {\n            const results = await Promise.all(this.flpFactories.map(factory => factory.execute()));\n            this.cache = results.flat();\n        }\n\n        return this.cache;\n    }\n}\n\nexport const CodeFlpsProvider = CodeFlpsProviderAbstraction.createImplementation({\n    implementation: CodeFlpsProviderImpl,\n    dependencies: [[FlpFactory, { multiple: true }]]\n});\n"],"names":["CodeFlpsProviderImpl","flpFactories","type","path","codeFlps","flp","CodeFlpPath","permission","CodeFlpTarget","undefined","results","Promise","factory","CodeFlpsProvider","CodeFlpsProviderAbstraction","FlpFactory"],"mappings":";;;AAUA,MAAMA;IAGF,YAAoBC,YAAoC,CAAE;aAAtCA,YAAY,GAAZA;IAAuC;IAE3D,MAAM,eAAe,EAAEC,IAAI,EAAEC,IAAI,EAA4B,EAA+B;QACxF,MAAMC,WAAW,MAAM,IAAI,CAAC,WAAW;QAEvC,OAAOA,SACF,MAAM,CAACC,CAAAA,MAAOA,IAAI,IAAI,KAAKH,QAAQI,YAAY,OAAO,CAACD,IAAI,IAAI,EAAEF,OACjE,OAAO,CAAmBE,CAAAA,MAChBA,IAAI,WAAW,CAAC,GAAG,CAACE,CAAAA,aAAcC,cAAc,OAAO,CAACD;IAE3E;IAGA,MAAc,cAAkC;QAC5C,IAAI,AAAeE,WAAf,IAAI,CAAC,KAAK,EAAgB;YAC1B,MAAMC,UAAU,MAAMC,QAAQ,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAACC,CAAAA,UAAWA,QAAQ,OAAO;YAClF,IAAI,CAAC,KAAK,GAAGF,QAAQ,IAAI;QAC7B;QAEA,OAAO,IAAI,CAAC,KAAK;IACrB;AACJ;AAEO,MAAMG,oCAAmBC,iBAAAA,oBAAgD,CAAC;IAC7E,gBAAgBd;IAChB,cAAc;QAAC;YAACe;YAAY;gBAAE,UAAU;YAAK;SAAE;KAAC;AACpD"}

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

@@ -0,0 +1,77 @@
+import type { FolderAccessLevel, FolderPermission } from "../../../flp/flp.types.js";
+interface CodeTeamPermission {
+    /** Slug of the team the permission is granted to. */
+    team: string;
+    user?: never;
+    level: FolderAccessLevel;
+}
+interface CodeUserPermission {
+    /** ID of the admin user the permission is granted to. */
+    user: string;
+    team?: never;
+    level: FolderAccessLevel;
+}
+/**
+ * A permission grants a level to exactly one target: either a team or a single admin user. The
+ * `team:` / `admin:` target strings used internally are generated from these.
+ *
+ * Prefer `team` — team slugs are authored by hand and stable, while user IDs are generated at
+ * runtime and differ per environment.
+ */
+export type CodeFolderPermission = CodeTeamPermission | CodeUserPermission;
+export type CodeFlp = {
+    /**
+     * Folder type the rule applies to. Use `FlpFactory.FolderType` to build the built-in ones
+     * instead of writing the string by hand.
+     */
+    type: string;
+    /**
+     * Folder path the rule binds to. The leading `root` segment is optional, so both `/marketing`
+     * and `root/marketing` are accepted. A trailing `/*` matches the folder and its whole subtree.
+     */
+    path: string;
+    permissions: CodeFolderPermission[];
+};
+export interface IFlpFactory {
+    execute(): Promise<CodeFlp[]>;
+}
+/** Provide code-defined folder-level permissions. */
+export declare const FlpFactory: import("@webiny/di").Abstraction<IFlpFactory> & {
+    FolderType: {
+        /** File Manager folders. */
+        FileManager: {
+            /** Folders holding files. */
+            Files: string;
+        };
+        /** Headless CMS folders. */
+        Cms: {
+            /** Folders holding entries of a content model, addressed by its `modelId`. */
+            Entries(modelId: string): string;
+        };
+    };
+};
+export declare namespace FlpFactory {
+    type Interface = IFlpFactory;
+    type Return = Promise<CodeFlp[]>;
+    type Flp = CodeFlp;
+    type Permission = CodeFolderPermission;
+}
+export interface GetCodePermissionsParams {
+    type: string;
+    path: string;
+}
+export interface ICodeFlpsProvider {
+    /**
+     * Return all code-defined permissions that apply to the given folder type and path.
+     */
+    getPermissions(params: GetCodePermissionsParams): Promise<FolderPermission[]>;
+}
+/**
+ * Resolve code-defined folder-level permissions for a given folder. Only permissions contributed by
+ * an `FlpFactory` are considered — the ones stored in the database are loaded separately.
+ */
+export declare const CodeFlpsProvider: import("@webiny/di").Abstraction<ICodeFlpsProvider>;
+export declare namespace CodeFlpsProvider {
+    type Interface = ICodeFlpsProvider;
+}
+export {};

package/features/flp/shared/abstractions.js

@@ -0,0 +1,19 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { FM_FILE_TYPE } from "../../../constants.js";
+const FolderType = {
+    FileManager: {
+        Files: FM_FILE_TYPE
+    },
+    Cms: {
+        Entries (modelId) {
+            return `cms:${modelId}`;
+        }
+    }
+};
+const FlpFactory = Object.assign(createAbstraction("FlpFactory"), {
+    FolderType: FolderType
+});
+const CodeFlpsProvider = createAbstraction("CodeFlpsProvider");
+export { CodeFlpsProvider, FlpFactory };
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/shared/abstractions.js","sources":["../../../../src/features/flp/shared/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { FM_FILE_TYPE } from \"~/constants.js\";\nimport type { FolderAccessLevel, FolderPermission } from \"~/flp/flp.types.js\";\n\ninterface CodeTeamPermission {\n    /** Slug of the team the permission is granted to. */\n    team: string;\n    user?: never;\n    level: FolderAccessLevel;\n}\n\ninterface CodeUserPermission {\n    /** ID of the admin user the permission is granted to. */\n    user: string;\n    team?: never;\n    level: FolderAccessLevel;\n}\n\n/**\n * A permission grants a level to exactly one target: either a team or a single admin user. The\n * `team:` / `admin:` target strings used internally are generated from these.\n *\n * Prefer `team` — team slugs are authored by hand and stable, while user IDs are generated at\n * runtime and differ per environment.\n */\nexport type CodeFolderPermission = CodeTeamPermission | CodeUserPermission;\n\nexport type CodeFlp = {\n    /**\n     * Folder type the rule applies to. Use `FlpFactory.FolderType` to build the built-in ones\n     * instead of writing the string by hand.\n     */\n    type: string;\n    /**\n     * Folder path the rule binds to. The leading `root` segment is optional, so both `/marketing`\n     * and `root/marketing` are accepted. A trailing `/*` matches the folder and its whole subtree.\n     */\n    path: string;\n    permissions: CodeFolderPermission[];\n};\n\nexport interface IFlpFactory {\n    execute(): Promise<CodeFlp[]>;\n}\n\n/**\n * The folder types shipped with Webiny, grouped by the app that owns them, so `CodeFlp.type` does\n * not have to be written by hand.\n *\n * Folder types stay open-ended — every app registering folders picks its own type — so `type`\n * remains a plain `string` and a custom app can still pass its own value directly.\n */\nconst FolderType = {\n    /** File Manager folders. */\n    FileManager: {\n        /** Folders holding files. */\n        Files: FM_FILE_TYPE as string\n    },\n    /** Headless CMS folders. */\n    Cms: {\n        /** Folders holding entries of a content model, addressed by its `modelId`. */\n        Entries(modelId: string): string {\n            return `cms:${modelId}`;\n        }\n    }\n};\n\n/** Provide code-defined folder-level permissions. */\nexport const FlpFactory = Object.assign(createAbstraction<IFlpFactory>(\"FlpFactory\"), {\n    FolderType\n});\n\nexport namespace FlpFactory {\n    export type Interface = IFlpFactory;\n    export type Return = Promise<CodeFlp[]>;\n    export type Flp = CodeFlp;\n    export type Permission = CodeFolderPermission;\n}\n\nexport interface GetCodePermissionsParams {\n    type: string;\n    path: string;\n}\n\nexport interface ICodeFlpsProvider {\n    /**\n     * Return all code-defined permissions that apply to the given folder type and path.\n     */\n    getPermissions(params: GetCodePermissionsParams): Promise<FolderPermission[]>;\n}\n\n/**\n * Resolve code-defined folder-level permissions for a given folder. Only permissions contributed by\n * an `FlpFactory` are considered — the ones stored in the database are loaded separately.\n */\nexport const CodeFlpsProvider = createAbstraction<ICodeFlpsProvider>(\"CodeFlpsProvider\");\n\nexport namespace CodeFlpsProvider {\n    export type Interface = ICodeFlpsProvider;\n}\n"],"names":["FolderType","FM_FILE_TYPE","modelId","FlpFactory","Object","createAbstraction","CodeFlpsProvider"],"mappings":";;AAoDA,MAAMA,aAAa;IAEf,aAAa;QAET,OAAOC;IACX;IAEA,KAAK;QAED,SAAQC,OAAe;YACnB,OAAO,CAAC,IAAI,EAAEA,SAAS;QAC3B;IACJ;AACJ;AAGO,MAAMC,aAAaC,OAAO,MAAM,CAACC,kBAA+B,eAAe;IAClFL,YAAAA;AACJ;AAyBO,MAAMM,mBAAmBD,kBAAqC"}

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

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

package/features/flp/shared/feature.js

@@ -0,0 +1,17 @@
+import { createFeature } from "@webiny/feature/api";
+import { FeatureFlags } from "@webiny/api-core/features/featureFlags/abstractions.js";
+import { CodeFlpsProvider } from "./CodeFlpsProvider.js";
+import { GetFlpWithCodeFlps } from "../GetFlp/decorators/GetFlpWithCodeFlps.js";
+import { ListFlpsWithCodeFlps } from "../ListFlps/decorators/ListFlpsWithCodeFlps.js";
+const CodeFlpsFeature = createFeature({
+    name: "CodeFlps",
+    register (container) {
+        if (!container.resolve(FeatureFlags).get().isEnabled("advancedAccessControlLayer.folderLevelPermissions")) return;
+        container.register(CodeFlpsProvider).inSingletonScope();
+        container.registerDecorator(GetFlpWithCodeFlps);
+        container.registerDecorator(ListFlpsWithCodeFlps);
+    }
+});
+export { CodeFlpsFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/shared/feature.js","sources":["../../../../src/features/flp/shared/feature.ts"],"sourcesContent":["import { type Container, createFeature } from \"@webiny/feature/api\";\nimport { FeatureFlags } from \"@webiny/api-core/features/featureFlags/abstractions.js\";\nimport { CodeFlpsProvider } from \"./CodeFlpsProvider.js\";\nimport { GetFlpWithCodeFlps } from \"~/features/flp/GetFlp/decorators/GetFlpWithCodeFlps.js\";\nimport { ListFlpsWithCodeFlps } from \"~/features/flp/ListFlps/decorators/ListFlpsWithCodeFlps.js\";\n\nexport const CodeFlpsFeature = createFeature({\n    name: \"CodeFlps\",\n    register(container: Container) {\n        // Code-defined FLPs are part of folder-level permissions, which is license-gated. Check at\n        // register time so nothing wires up — and no code permission is ever enforced — without the\n        // entitlement.\n        if (\n            !container\n                .resolve(FeatureFlags)\n                .get()\n                .isEnabled(\"advancedAccessControlLayer.folderLevelPermissions\")\n        ) {\n            return;\n        }\n\n        container.register(CodeFlpsProvider).inSingletonScope();\n        container.registerDecorator(GetFlpWithCodeFlps);\n        container.registerDecorator(ListFlpsWithCodeFlps);\n    }\n});\n"],"names":["CodeFlpsFeature","createFeature","container","FeatureFlags","CodeFlpsProvider","GetFlpWithCodeFlps","ListFlpsWithCodeFlps"],"mappings":";;;;;AAMO,MAAMA,kBAAkBC,cAAc;IACzC,MAAM;IACN,UAASC,SAAoB;QAIzB,IACI,CAACA,UACI,OAAO,CAACC,cACR,GAAG,GACH,SAAS,CAAC,sDAEf;QAGJD,UAAU,QAAQ,CAACE,kBAAkB,gBAAgB;QACrDF,UAAU,iBAAiB,CAACG;QAC5BH,UAAU,iBAAiB,CAACI;IAChC;AACJ"}

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

@@ -0,0 +1,4 @@
+export * from "./abstractions.js";
+export * from "./CodeFlpMerger.js";
+export * from "./CodeFlpPath.js";
+export * from "./CodeFlpTarget.js";

package/features/flp/shared/index.js

@@ -0,0 +1,4 @@
+export * from "./abstractions.js";
+export * from "./CodeFlpMerger.js";
+export * from "./CodeFlpPath.js";
+export * from "./CodeFlpTarget.js";

package/features/folder/CreateFolder/CreateFolderRepository.d.ts

@@ -0,0 +1,21 @@
+import { Result } from "@webiny/feature/api";
+import { CreateFolderRepository as RepositoryAbstraction, type ICreateFolderRepository } from "./abstractions.js";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { FolderModelProvider } from "../../../domain/folder/abstractions.js";
+import type { CreateFolderParams, Folder } from "../../../folder/folder.types.js";
+declare class CreateFolderRepositoryImpl implements ICreateFolderRepository {
+    private createEntry;
+    private listLatestEntries;
+    private getEntryById;
+    private folderModelProvider;
+    constructor(createEntry: CreateEntryUseCase.Interface, listLatestEntries: ListLatestEntriesUseCase.Interface, getEntryById: GetEntryByIdUseCase.Interface, folderModelProvider: FolderModelProvider.Interface);
+    execute(data: CreateFolderParams): Promise<Result<Folder, RepositoryAbstraction.Error>>;
+    private checkExistingFolder;
+    private createFolderPath;
+}
+export declare const CreateFolderRepository: typeof CreateFolderRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<ICreateFolderRepository>;
+};
+export {};

package/features/folder/CreateFolder/CreateFolderRepository.js

@@ -0,0 +1,88 @@
+import { Result } from "@webiny/feature/api";
+import { CreateFolderRepository } from "./abstractions.js";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { FolderModelProvider } from "../../../domain/folder/abstractions.js";
+import { EntryToFolderMapper } from "../shared/EntryToFolderMapper.js";
+import { FolderPersistenceError, FolderValidationError } from "../../../domain/folder/errors.js";
+import { Path } from "../../../utils/Path.js";
+import { EntryId } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+class CreateFolderRepositoryImpl {
+    constructor(createEntry, listLatestEntries, getEntryById, folderModelProvider){
+        this.createEntry = createEntry;
+        this.listLatestEntries = listLatestEntries;
+        this.getEntryById = getEntryById;
+        this.folderModelProvider = folderModelProvider;
+    }
+    async execute(data) {
+        const folderModel = await this.folderModelProvider.get();
+        const checkResult = await this.checkExistingFolder({
+            type: data.type,
+            slug: data.slug,
+            parentId: data.parentId
+        });
+        if (checkResult.isFail()) return Result.fail(checkResult.error);
+        const pathResult = await this.createFolderPath({
+            slug: data.slug,
+            parentId: data.parentId
+        });
+        if (pathResult.isFail()) return Result.fail(pathResult.error);
+        const result = await this.createEntry.execute(folderModel, {
+            values: {
+                ...data,
+                parentId: data.parentId || null,
+                path: pathResult.value
+            }
+        });
+        if (result.isFail()) {
+            if ("Cms/Entry/ValidationError" === result.error.code) return Result.fail(new FolderValidationError(result.error.message));
+            return Result.fail(new FolderPersistenceError(result.error));
+        }
+        const folder = EntryToFolderMapper.toFolder(result.value);
+        return Result.ok(folder);
+    }
+    async checkExistingFolder(params) {
+        const folderModel = await this.folderModelProvider.get();
+        const { type, slug, parentId, excludeId } = params;
+        const result = await this.listLatestEntries.execute(folderModel, {
+            where: {
+                latest: true,
+                values: {
+                    type,
+                    slug,
+                    parentId
+                },
+                ...excludeId ? {
+                    entryId_not: excludeId
+                } : {}
+            },
+            limit: 1
+        });
+        if (result.isFail()) return Result.fail(new FolderPersistenceError(result.error));
+        const { entries } = result.value;
+        if (entries.length > 0) return Result.fail(new FolderValidationError(`Folder with slug "${slug}" already exists at this level.`));
+        return Result.ok();
+    }
+    async createFolderPath(params) {
+        const folderModel = await this.folderModelProvider.get();
+        const { slug, parentId } = params;
+        if (!parentId) return Result.ok(Path.create(slug));
+        const parentResult = await this.getEntryById.execute(folderModel, EntryId.from(parentId).toString());
+        if (parentResult.isFail()) return Result.fail(new FolderPersistenceError(new Error("Parent folder not found. Unable to create the folder path")));
+        const parentFolder = EntryToFolderMapper.toFolder(parentResult.value);
+        return Result.ok(Path.create(slug, parentFolder.path));
+    }
+}
+const CreateFolderRepository_CreateFolderRepository = CreateFolderRepository.createImplementation({
+    implementation: CreateFolderRepositoryImpl,
+    dependencies: [
+        CreateEntryUseCase,
+        ListLatestEntriesUseCase,
+        GetEntryByIdUseCase,
+        FolderModelProvider
+    ]
+});
+export { CreateFolderRepository_CreateFolderRepository as CreateFolderRepository };
+
+//# sourceMappingURL=CreateFolderRepository.js.map

package/features/folder/CreateFolder/CreateFolderRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/CreateFolder/CreateFolderRepository.js","sources":["../../../../src/features/folder/CreateFolder/CreateFolderRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    CreateFolderRepository as RepositoryAbstraction,\n    type ICreateFolderRepository\n} from \"./abstractions.js\";\nimport { CreateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { FolderModelProvider } from \"~/domain/folder/abstractions.js\";\nimport type { CmsEntryFolder, CreateFolderParams, Folder } from \"~/folder/folder.types.js\";\nimport { EntryToFolderMapper } from \"../shared/EntryToFolderMapper.js\";\nimport { FolderPersistenceError, FolderValidationError } from \"~/domain/folder/errors.js\";\nimport { Path } from \"~/utils/Path.js\";\nimport { EntryId } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\n\nclass CreateFolderRepositoryImpl implements ICreateFolderRepository {\n    constructor(\n        private createEntry: CreateEntryUseCase.Interface,\n        private listLatestEntries: ListLatestEntriesUseCase.Interface,\n        private getEntryById: GetEntryByIdUseCase.Interface,\n        private folderModelProvider: FolderModelProvider.Interface\n    ) {}\n\n    async execute(data: CreateFolderParams): Promise<Result<Folder, RepositoryAbstraction.Error>> {\n        const folderModel = await this.folderModelProvider.get();\n        // Check if folder already exists\n        const checkResult = await this.checkExistingFolder({\n            type: data.type,\n            slug: data.slug,\n            parentId: data.parentId\n        });\n\n        if (checkResult.isFail()) {\n            return Result.fail(checkResult.error);\n        }\n\n        // Create folder path\n        const pathResult = await this.createFolderPath({\n            slug: data.slug,\n            parentId: data.parentId\n        });\n\n        if (pathResult.isFail()) {\n            return Result.fail(pathResult.error);\n        }\n\n        // Create the entry\n        const result = await this.createEntry.execute<CmsEntryFolder>(folderModel, {\n            values: {\n                ...data,\n                parentId: data.parentId || null,\n                path: pathResult.value\n            }\n        });\n\n        if (result.isFail()) {\n            if (result.error.code === \"Cms/Entry/ValidationError\") {\n                return Result.fail(new FolderValidationError(result.error.message));\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    private async checkExistingFolder(params: {\n        type: string;\n        slug: string;\n        parentId?: string | null;\n        excludeId?: string;\n    }): Promise<Result<void, RepositoryAbstraction.Error>> {\n        const folderModel = await this.folderModelProvider.get();\n        const { type, slug, parentId, excludeId } = params;\n\n        const result = await this.listLatestEntries.execute<CmsEntryFolder>(folderModel, {\n            where: {\n                latest: true,\n                values: {\n                    type,\n                    slug,\n                    parentId\n                },\n                ...(excludeId ? { entryId_not: excludeId } : {})\n            },\n            limit: 1\n        });\n\n        if (result.isFail()) {\n            return Result.fail(new FolderPersistenceError(result.error));\n        }\n\n        const { entries } = result.value;\n\n        if (entries.length > 0) {\n            return Result.fail(\n                new FolderValidationError(\n                    `Folder with slug \"${slug}\" already exists at this level.`\n                )\n            );\n        }\n\n        return Result.ok();\n    }\n\n    private async createFolderPath(params: {\n        slug: string;\n        parentId?: string | null;\n    }): Promise<Result<string, RepositoryAbstraction.Error>> {\n        const folderModel = await this.folderModelProvider.get();\n        const { slug, parentId } = params;\n\n        if (!parentId) {\n            return Result.ok(Path.create(slug));\n        }\n\n        const parentResult = await this.getEntryById.execute<CmsEntryFolder>(\n            folderModel,\n            EntryId.from(parentId).toString()\n        );\n\n        if (parentResult.isFail()) {\n            return Result.fail(\n                new FolderPersistenceError(\n                    new Error(\"Parent folder not found. Unable to create the folder path\")\n                )\n            );\n        }\n\n        const parentFolder = EntryToFolderMapper.toFolder(parentResult.value);\n        return Result.ok(Path.create(slug, parentFolder.path));\n    }\n}\n\nexport const CreateFolderRepository = RepositoryAbstraction.createImplementation({\n    implementation: CreateFolderRepositoryImpl,\n    dependencies: [\n        CreateEntryUseCase,\n        ListLatestEntriesUseCase,\n        GetEntryByIdUseCase,\n        FolderModelProvider\n    ]\n});\n"],"names":["CreateFolderRepositoryImpl","createEntry","listLatestEntries","getEntryById","folderModelProvider","data","folderModel","checkResult","Result","pathResult","result","FolderValidationError","FolderPersistenceError","folder","EntryToFolderMapper","params","type","slug","parentId","excludeId","entries","Path","parentResult","EntryId","Error","parentFolder","CreateFolderRepository","RepositoryAbstraction","CreateEntryUseCase","ListLatestEntriesUseCase","GetEntryByIdUseCase","FolderModelProvider"],"mappings":"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"}

package/features/folder/CreateFolder/CreateFolderUseCase.d.ts

@@ -0,0 +1,12 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher as EventPublisherAbstraction } from "@webiny/api-core/features/eventPublisher/index.js";
+import { CreateFolderUseCase as UseCaseAbstraction, CreateFolderRepository } from "./abstractions.js";
+import type { Folder, CreateFolderParams } from "../../../folder/folder.types.js";
+declare class CreateFolderUseCaseImpl implements UseCaseAbstraction.Interface {
+    private eventPublisher;
+    private repository;
+    constructor(eventPublisher: EventPublisherAbstraction.Interface, repository: CreateFolderRepository.Interface);
+    execute(params: CreateFolderParams): Promise<Result<Folder, UseCaseAbstraction.Error>>;
+}
+export declare const CreateFolderUseCase: import("@webiny/di").Implementation<typeof CreateFolderUseCaseImpl>;
+export {};