@webiny/api-aco 0.0.0-unstable.7be00a75a9 → 0.0.0-unstable.7c2def32a7

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

@@ -3,14 +3,14 @@ import { CreateFolderRepository as RepositoryAbstraction, type ICreateFolderRepo
 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 { FolderModel } from "../../../domain/folder/abstractions.js";
+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 folderModel;
-    constructor(createEntry: CreateEntryUseCase.Interface, listLatestEntries: ListLatestEntriesUseCase.Interface, getEntryById: GetEntryByIdUseCase.Interface, folderModel: FolderModel.Interface);
+    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;

package/features/folder/CreateFolder/CreateFolderRepository.js

@@ -3,19 +3,20 @@ 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 { FolderModel } from "../../../domain/folder/abstractions.js";
+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, folderModel){
+    constructor(createEntry, listLatestEntries, getEntryById, folderModelProvider){
         this.createEntry = createEntry;
         this.listLatestEntries = listLatestEntries;
         this.getEntryById = getEntryById;
-        this.folderModel = folderModel;
+        this.folderModelProvider = folderModelProvider;
     }
     async execute(data) {
+        const folderModel = await this.folderModelProvider.get();
         const checkResult = await this.checkExistingFolder({
             type: data.type,
             slug: data.slug,
@@ -27,7 +28,7 @@ class CreateFolderRepositoryImpl {
             parentId: data.parentId
         });
         if (pathResult.isFail()) return Result.fail(pathResult.error);
-        const result = await this.createEntry.execute(this.folderModel, {
+        const result = await this.createEntry.execute(folderModel, {
             values: {
                 ...data,
                 parentId: data.parentId || null,
@@ -42,8 +43,9 @@ class CreateFolderRepositoryImpl {
         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(this.folderModel, {
+        const result = await this.listLatestEntries.execute(folderModel, {
             where: {
                 latest: true,
                 values: {
@@ -63,9 +65,10 @@ class CreateFolderRepositoryImpl {
         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(this.folderModel, EntryId.from(parentId).toString());
+        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));
@@ -77,7 +80,7 @@ const CreateFolderRepository_CreateFolderRepository = CreateFolderRepository.cre
         CreateEntryUseCase,
         ListLatestEntriesUseCase,
         GetEntryByIdUseCase,
-        FolderModel
+        FolderModelProvider
     ]
 });
 export { CreateFolderRepository_CreateFolderRepository as CreateFolderRepository };

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

@@ -1 +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 { FolderModel } 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 folderModel: FolderModel.Interface\n    ) {}\n\n    async execute(data: CreateFolderParams): Promise<Result<Folder, RepositoryAbstraction.Error>> {\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>(this.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 { type, slug, parentId, excludeId } = params;\n\n        const result = await this.listLatestEntries.execute<CmsEntryFolder>(this.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 { 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            this.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: [CreateEntryUseCase, ListLatestEntriesUseCase, GetEntryByIdUseCase, FolderModel]\n});\n"],"names":["CreateFolderRepositoryImpl","createEntry","listLatestEntries","getEntryById","folderModel","data","checkResult","Result","pathResult","result","FolderValidationError","FolderPersistenceError","folder","EntryToFolderMapper","params","type","slug","parentId","excludeId","entries","Path","parentResult","EntryId","Error","parentFolder","CreateFolderRepository","RepositoryAbstraction","CreateEntryUseCase","ListLatestEntriesUseCase","GetEntryByIdUseCase","FolderModel"],"mappings":"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"}
+{"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/decorators/CreateFolderWithFolderLevelPermissions.d.ts

@@ -1,11 +1,19 @@
 import { FolderLevelPermissions } from "../../../../features/flp/FolderLevelPermissions/index.js";
 import { CreateFolderUseCase } from "../abstractions.js";
 import type { CreateFolderParams } from "../../../../folder/folder.types.js";
+import { CodeFlpsProvider } from "../../../../features/flp/shared/index.js";
 declare class CreateFolderWithFolderLevelPermissionsImpl implements CreateFolderUseCase.Interface {
     private folderLevelPermissions;
     private readonly decoretee;
-    constructor(folderLevelPermissions: FolderLevelPermissions.Interface, decoretee: CreateFolderUseCase.Interface);
+    private readonly codeFlpsProvider?;
+    constructor(folderLevelPermissions: FolderLevelPermissions.Interface, codeFlpsProvider: CodeFlpsProvider.Interface | undefined, decoretee: CreateFolderUseCase.Interface);
     execute(params: CreateFolderParams): CreateFolderUseCase.Return;
+    /**
+     * Code-defined permissions are resolved from the folder's own type and path rather than the FLP
+     * catalog: the record for a folder this new is written by an event handler and may not exist
+     * yet. Without this the response would omit them until something refetched the folder.
+     */
+    private withCodePermissions;
 }
 export declare const CreateFolderWithFolderLevelPermissions: typeof CreateFolderWithFolderLevelPermissionsImpl;
 export {};

package/features/folder/CreateFolder/decorators/CreateFolderWithFolderLevelPermissions.js

@@ -2,9 +2,11 @@ import { FolderLevelPermissions } from "../../../flp/FolderLevelPermissions/inde
 import { CreateFolderUseCase } from "../abstractions.js";
 import { Result, createDecorator } from "@webiny/feature/api";
 import { FolderNotAuthorizedError } from "../../../../domain/folder/errors.js";
+import { CodeFlpMerger, CodeFlpsProvider } from "../../../flp/shared/index.js";
 class CreateFolderWithFolderLevelPermissionsImpl {
-    constructor(folderLevelPermissions, decoretee){
+    constructor(folderLevelPermissions, codeFlpsProvider, decoretee){
         this.folderLevelPermissions = folderLevelPermissions;
+        this.codeFlpsProvider = codeFlpsProvider;
         this.decoretee = decoretee;
     }
     async execute(params) {
@@ -20,18 +22,33 @@ class CreateFolderWithFolderLevelPermissionsImpl {
         const result = await this.decoretee.execute(params);
         if (result.isFail()) return Result.fail(result.error);
         const folder = result.value;
-        const permissionsWithDefaults = await this.folderLevelPermissions.getDefaultPermissions(folder?.permissions ?? []);
+        const permissions = await this.withCodePermissions(folder, folder?.permissions ?? []);
+        const permissionsWithDefaults = await this.folderLevelPermissions.getDefaultPermissions(permissions);
         return Result.ok({
             ...folder,
             permissions: permissionsWithDefaults
         });
     }
+    async withCodePermissions(folder, permissions) {
+        if (!this.codeFlpsProvider) return permissions;
+        const codePermissions = await this.codeFlpsProvider.getPermissions({
+            type: folder.type,
+            path: folder.path
+        });
+        return CodeFlpMerger.mergePermissions(permissions, codePermissions);
+    }
 }
 const CreateFolderWithFolderLevelPermissions = createDecorator({
     abstraction: CreateFolderUseCase,
     decorator: CreateFolderWithFolderLevelPermissionsImpl,
     dependencies: [
-        FolderLevelPermissions
+        FolderLevelPermissions,
+        [
+            CodeFlpsProvider,
+            {
+                optional: true
+            }
+        ]
     ]
 });
 export { CreateFolderWithFolderLevelPermissions };

package/features/folder/CreateFolder/decorators/CreateFolderWithFolderLevelPermissions.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/folder/CreateFolder/decorators/CreateFolderWithFolderLevelPermissions.js","sources":["../../../../../src/features/folder/CreateFolder/decorators/CreateFolderWithFolderLevelPermissions.ts"],"sourcesContent":["import { FolderLevelPermissions } from \"~/features/flp/FolderLevelPermissions/index.js\";\nimport { CreateFolderUseCase } from \"../abstractions.js\";\nimport type { CreateFolderParams } from \"~/folder/folder.types.js\";\nimport { createDecorator, Result } from \"@webiny/feature/api\";\nimport { FolderNotAuthorizedError } from \"~/domain/folder/errors.js\";\n\nclass CreateFolderWithFolderLevelPermissionsImpl implements CreateFolderUseCase.Interface {\n    private folderLevelPermissions: FolderLevelPermissions.Interface;\n    private readonly decoretee: CreateFolderUseCase.Interface;\n\n    constructor(\n        folderLevelPermissions: FolderLevelPermissions.Interface,\n        decoretee: CreateFolderUseCase.Interface\n    ) {\n        this.folderLevelPermissions = folderLevelPermissions;\n        this.decoretee = decoretee;\n    }\n\n    async execute(params: CreateFolderParams): CreateFolderUseCase.Return {\n        let canCreateFolder: boolean;\n        if (params.parentId) {\n            const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(\n                params.parentId\n            );\n            canCreateFolder = await this.folderLevelPermissions.canAccessFolder({\n                permissions,\n                rwd: \"w\"\n            });\n        } else {\n            canCreateFolder = this.folderLevelPermissions.canCreateFolderInRoot();\n        }\n\n        if (!canCreateFolder) {\n            return Result.fail(new FolderNotAuthorizedError());\n        }\n\n        const result = await this.decoretee.execute(params);\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const folder = result.value;\n\n        // Let's set default permissions based on the current user.\n        const permissionsWithDefaults = await this.folderLevelPermissions.getDefaultPermissions(\n            folder?.permissions ?? []\n        );\n\n        return Result.ok({\n            ...folder,\n            permissions: permissionsWithDefaults\n        });\n    }\n}\n\nexport const CreateFolderWithFolderLevelPermissions = createDecorator({\n    abstraction: CreateFolderUseCase,\n    decorator: CreateFolderWithFolderLevelPermissionsImpl,\n    dependencies: [FolderLevelPermissions]\n});\n"],"names":["CreateFolderWithFolderLevelPermissionsImpl","folderLevelPermissions","decoretee","params","canCreateFolder","permissions","Result","FolderNotAuthorizedError","result","folder","permissionsWithDefaults","CreateFolderWithFolderLevelPermissions","createDecorator","CreateFolderUseCase","FolderLevelPermissions"],"mappings":";;;;AAMA,MAAMA;IAIF,YACIC,sBAAwD,EACxDC,SAAwC,CAC1C;QACE,IAAI,CAAC,sBAAsB,GAAGD;QAC9B,IAAI,CAAC,SAAS,GAAGC;IACrB;IAEA,MAAM,QAAQC,MAA0B,EAA8B;QAClE,IAAIC;QACJ,IAAID,OAAO,QAAQ,EAAE;YACjB,MAAME,cAAc,MAAM,IAAI,CAAC,sBAAsB,CAAC,yBAAyB,CAC3EF,OAAO,QAAQ;YAEnBC,kBAAkB,MAAM,IAAI,CAAC,sBAAsB,CAAC,eAAe,CAAC;gBAChEC;gBACA,KAAK;YACT;QACJ,OACID,kBAAkB,IAAI,CAAC,sBAAsB,CAAC,qBAAqB;QAGvE,IAAI,CAACA,iBACD,OAAOE,OAAO,IAAI,CAAC,IAAIC;QAG3B,MAAMC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACL;QAE5C,IAAIK,OAAO,MAAM,IACb,OAAOF,OAAO,IAAI,CAACE,OAAO,KAAK;QAGnC,MAAMC,SAASD,OAAO,KAAK;QAG3B,MAAME,0BAA0B,MAAM,IAAI,CAAC,sBAAsB,CAAC,qBAAqB,CACnFD,QAAQ,eAAe,EAAE;QAG7B,OAAOH,OAAO,EAAE,CAAC;YACb,GAAGG,MAAM;YACT,aAAaC;QACjB;IACJ;AACJ;AAEO,MAAMC,yCAAyCC,gBAAgB;IAClE,aAAaC;IACb,WAAWb;IACX,cAAc;QAACc;KAAuB;AAC1C"}
+{"version":3,"file":"features/folder/CreateFolder/decorators/CreateFolderWithFolderLevelPermissions.js","sources":["../../../../../src/features/folder/CreateFolder/decorators/CreateFolderWithFolderLevelPermissions.ts"],"sourcesContent":["import { FolderLevelPermissions } from \"~/features/flp/FolderLevelPermissions/index.js\";\nimport { CreateFolderUseCase } from \"../abstractions.js\";\nimport type { CreateFolderParams } from \"~/folder/folder.types.js\";\nimport type { Folder } from \"~/folder/folder.types.js\";\nimport type { FolderPermission } from \"~/flp/flp.types.js\";\nimport { createDecorator, Result } from \"@webiny/feature/api\";\nimport { FolderNotAuthorizedError } from \"~/domain/folder/errors.js\";\nimport { CodeFlpMerger } from \"~/features/flp/shared/index.js\";\nimport { CodeFlpsProvider } from \"~/features/flp/shared/index.js\";\n\nclass CreateFolderWithFolderLevelPermissionsImpl implements CreateFolderUseCase.Interface {\n    private folderLevelPermissions: FolderLevelPermissions.Interface;\n    private readonly decoretee: CreateFolderUseCase.Interface;\n    private readonly codeFlpsProvider?: CodeFlpsProvider.Interface;\n\n    constructor(\n        folderLevelPermissions: FolderLevelPermissions.Interface,\n        codeFlpsProvider: CodeFlpsProvider.Interface | undefined,\n        decoretee: CreateFolderUseCase.Interface\n    ) {\n        this.folderLevelPermissions = folderLevelPermissions;\n        this.codeFlpsProvider = codeFlpsProvider;\n        this.decoretee = decoretee;\n    }\n\n    async execute(params: CreateFolderParams): CreateFolderUseCase.Return {\n        let canCreateFolder: boolean;\n        if (params.parentId) {\n            const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(\n                params.parentId\n            );\n            canCreateFolder = await this.folderLevelPermissions.canAccessFolder({\n                permissions,\n                rwd: \"w\"\n            });\n        } else {\n            canCreateFolder = this.folderLevelPermissions.canCreateFolderInRoot();\n        }\n\n        if (!canCreateFolder) {\n            return Result.fail(new FolderNotAuthorizedError());\n        }\n\n        const result = await this.decoretee.execute(params);\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const folder = result.value;\n\n        const permissions = await this.withCodePermissions(folder, folder?.permissions ?? []);\n\n        // Let's set default permissions based on the current user.\n        const permissionsWithDefaults =\n            await this.folderLevelPermissions.getDefaultPermissions(permissions);\n\n        return Result.ok({\n            ...folder,\n            permissions: permissionsWithDefaults\n        });\n    }\n\n    /**\n     * Code-defined permissions are resolved from the folder's own type and path rather than the FLP\n     * catalog: the record for a folder this new is written by an event handler and may not exist\n     * yet. Without this the response would omit them until something refetched the folder.\n     */\n    private async withCodePermissions(\n        folder: Pick<Folder, \"type\" | \"path\">,\n        permissions: FolderPermission[]\n    ): Promise<FolderPermission[]> {\n        if (!this.codeFlpsProvider) {\n            return permissions;\n        }\n\n        const codePermissions = await this.codeFlpsProvider.getPermissions({\n            type: folder.type,\n            path: folder.path\n        });\n\n        return CodeFlpMerger.mergePermissions(permissions, codePermissions);\n    }\n}\n\nexport const CreateFolderWithFolderLevelPermissions = createDecorator({\n    abstraction: CreateFolderUseCase,\n    decorator: CreateFolderWithFolderLevelPermissionsImpl,\n    // `CodeFlpsProvider` is optional: `CodeFlpsFeature` does not register it unless the project has\n    // the folder-level permissions entitlement.\n    dependencies: [FolderLevelPermissions, [CodeFlpsProvider, { optional: true }]]\n});\n"],"names":["CreateFolderWithFolderLevelPermissionsImpl","folderLevelPermissions","codeFlpsProvider","decoretee","params","canCreateFolder","permissions","Result","FolderNotAuthorizedError","result","folder","permissionsWithDefaults","codePermissions","CodeFlpMerger","CreateFolderWithFolderLevelPermissions","createDecorator","CreateFolderUseCase","FolderLevelPermissions","CodeFlpsProvider"],"mappings":";;;;;AAUA,MAAMA;IAKF,YACIC,sBAAwD,EACxDC,gBAAwD,EACxDC,SAAwC,CAC1C;QACE,IAAI,CAAC,sBAAsB,GAAGF;QAC9B,IAAI,CAAC,gBAAgB,GAAGC;QACxB,IAAI,CAAC,SAAS,GAAGC;IACrB;IAEA,MAAM,QAAQC,MAA0B,EAA8B;QAClE,IAAIC;QACJ,IAAID,OAAO,QAAQ,EAAE;YACjB,MAAME,cAAc,MAAM,IAAI,CAAC,sBAAsB,CAAC,yBAAyB,CAC3EF,OAAO,QAAQ;YAEnBC,kBAAkB,MAAM,IAAI,CAAC,sBAAsB,CAAC,eAAe,CAAC;gBAChEC;gBACA,KAAK;YACT;QACJ,OACID,kBAAkB,IAAI,CAAC,sBAAsB,CAAC,qBAAqB;QAGvE,IAAI,CAACA,iBACD,OAAOE,OAAO,IAAI,CAAC,IAAIC;QAG3B,MAAMC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACL;QAE5C,IAAIK,OAAO,MAAM,IACb,OAAOF,OAAO,IAAI,CAACE,OAAO,KAAK;QAGnC,MAAMC,SAASD,OAAO,KAAK;QAE3B,MAAMH,cAAc,MAAM,IAAI,CAAC,mBAAmB,CAACI,QAAQA,QAAQ,eAAe,EAAE;QAGpF,MAAMC,0BACF,MAAM,IAAI,CAAC,sBAAsB,CAAC,qBAAqB,CAACL;QAE5D,OAAOC,OAAO,EAAE,CAAC;YACb,GAAGG,MAAM;YACT,aAAaC;QACjB;IACJ;IAOA,MAAc,oBACVD,MAAqC,EACrCJ,WAA+B,EACJ;QAC3B,IAAI,CAAC,IAAI,CAAC,gBAAgB,EACtB,OAAOA;QAGX,MAAMM,kBAAkB,MAAM,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC;YAC/D,MAAMF,OAAO,IAAI;YACjB,MAAMA,OAAO,IAAI;QACrB;QAEA,OAAOG,cAAc,gBAAgB,CAACP,aAAaM;IACvD;AACJ;AAEO,MAAME,yCAAyCC,gBAAgB;IAClE,aAAaC;IACb,WAAWhB;IAGX,cAAc;QAACiB;QAAwB;YAACC;YAAkB;gBAAE,UAAU;YAAK;SAAE;KAAC;AAClF"}

package/features/folder/DeleteFolder/DeleteFolderRepository.d.ts

@@ -1,12 +1,12 @@
 import { Result } from "@webiny/feature/api";
 import { DeleteFolderRepository as RepositoryAbstraction, type IDeleteFolderRepository } from "./abstractions.js";
 import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry";
-import { FolderModel } from "../../../domain/folder/abstractions.js";
+import { FolderModelProvider } from "../../../domain/folder/abstractions.js";
 import type { Folder } from "../../../folder/folder.types.js";
 declare class DeleteFolderRepositoryImpl implements IDeleteFolderRepository {
     private deleteEntry;
-    private folderModel;
-    constructor(deleteEntry: DeleteEntryUseCase.Interface, folderModel: FolderModel.Interface);
+    private folderModelProvider;
+    constructor(deleteEntry: DeleteEntryUseCase.Interface, folderModelProvider: FolderModelProvider.Interface);
     execute(folder: Folder): Promise<Result<void, RepositoryAbstraction.Error>>;
 }
 export declare const DeleteFolderRepository: typeof DeleteFolderRepositoryImpl & {

package/features/folder/DeleteFolder/DeleteFolderRepository.js

@@ -1,15 +1,16 @@
 import { Result } from "@webiny/feature/api";
 import { DeleteFolderRepository } from "./abstractions.js";
 import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry";
-import { FolderModel } from "../../../domain/folder/abstractions.js";
+import { FolderModelProvider } from "../../../domain/folder/abstractions.js";
 import { FolderNotAuthorizedError, FolderPersistenceError } from "../../../domain/folder/errors.js";
 class DeleteFolderRepositoryImpl {
-    constructor(deleteEntry, folderModel){
+    constructor(deleteEntry, folderModelProvider){
         this.deleteEntry = deleteEntry;
-        this.folderModel = folderModel;
+        this.folderModelProvider = folderModelProvider;
     }
     async execute(folder) {
-        const result = await this.deleteEntry.execute(this.folderModel, folder.id, {
+        const folderModel = await this.folderModelProvider.get();
+        const result = await this.deleteEntry.execute(folderModel, folder.id, {
             permanently: true,
             force: true
         });
@@ -24,7 +25,7 @@ const DeleteFolderRepository_DeleteFolderRepository = DeleteFolderRepository.cre
     implementation: DeleteFolderRepositoryImpl,
     dependencies: [
         DeleteEntryUseCase,
-        FolderModel
+        FolderModelProvider
     ]
 });
 export { DeleteFolderRepository_DeleteFolderRepository as DeleteFolderRepository };