@wbce/projen-d9 0.0.28 → 0.1.0

package/lib/cli/commands/cedar/cedar-format.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.policyToCedarText = policyToCedarText;
+const cedar = require("@cedar-policy/cedar-wasm/nodejs");
+const logger_1 = require("../../logger");
+/** Width of one logical level: the operator column (`|| `) plus the base gap. */
+const LEVEL_INDENT = ' '.repeat(5);
+function booleanOperator(expr) {
+    const key = Object.keys(expr)[0];
+    return key === '&&' || key === '||' ? key : undefined;
+}
+/** Cedar's text for a policy with `All` scopes and a single `when` clause. */
+const LEAF_PREFIX = 'permit(principal, action, resource) when { ';
+const LEAF_SUFFIX = ' };';
+/** Any non-boolean expression, printed by Cedar itself. */
+function leafToText(expr) {
+    const result = cedar.policyToText({
+        effect: 'permit',
+        principal: { op: 'All' },
+        action: { op: 'All' },
+        resource: { op: 'All' },
+        conditions: [{ kind: 'when', body: expr }],
+    });
+    if (result.type === 'failure') {
+        logger_1.logger.error({ expr }, 'failed to transform expression into text');
+        throw new Error(result.errors);
+    }
+    return result.text.slice(LEAF_PREFIX.length, -LEAF_SUFFIX.length);
+}
+/**
+ * Lines of `expr` within a group of `parent`, each starting with a 3-character
+ * operator column; a nested group (other operator) goes one level deeper in parentheses.
+ */
+function toLines(expr, parent) {
+    const operator = booleanOperator(expr);
+    if (!operator)
+        return [`   ${leafToText(expr)}`];
+    // the top level (no parent) is a group without parentheses
+    if (parent && operator !== parent) {
+        return ['   (', ...toLines(expr, operator).map((line) => LEVEL_INDENT + line), '   )'];
+    }
+    // the operator joins the two sides, on the line where the right side starts
+    const [first, ...rest] = toLines(expr[operator].right, operator);
+    return [...toLines(expr[operator].left, operator), `${operator} ${first.slice(3)}`, ...rest];
+}
+/**
+ * Cedar's formatter for the policy head, our own layout for the conditions:
+ * operands of one logical level share an indentation, each nested level adds one,
+ * and the `&&` / `||` operator leads the line.
+ */
+function policyToCedarText(policy) {
+    const head = cedar.policyToText({ ...policy, conditions: [] });
+    if (head.type === 'failure') {
+        logger_1.logger.error({ policy }, 'failed to transform policy into text');
+        throw new Error(head.errors);
+    }
+    const formattedHead = cedar.formatPolicies({
+        policyText: head.text,
+        lineWidth: 100,
+        indentWidth: 2,
+    });
+    if (formattedHead.type === 'failure') {
+        throw new Error(formattedHead);
+    }
+    // a policy without conditions is formatted as `…;\n`
+    const lines = [formattedHead.formatted_policy.slice(0, -2)];
+    // translateToCedar writes at most one `when` clause
+    const [condition] = policy.conditions;
+    if (condition) {
+        const when = toLines(condition.body);
+        lines.push(['when {', ...when.map((line) => `  ${line}`), '}'].join('\n'));
+    }
+    return lines.join('\n') + ';';
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cli/commands/cedar/cedar-to-d9-translations.d.ts

@@ -0,0 +1,12 @@
+import { ConditionSubject } from './cedar-translations';
+import type { Filter } from './d9-permission';
+/** Inverse of `addWhenClauses`: a Cedar Expr tree back into a D9 filter. */
+export declare function exprToFilter(expr?: any, subject?: ConditionSubject): Filter;
+/** Field list from a check-fields policy's `containsAll` clause. */
+export declare function extractFields(expr: any): string[];
+/** Inverse of `refactoPolicies`: expand `action in [...]` into one tuple each. */
+export declare function expandPolicy(policy: any): Array<{
+    collection: string;
+    action: string;
+    conditions: any[];
+}>;

package/lib/cli/commands/cedar/cedar-to-d9-translations.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exprToFilter = exprToFilter;
+exports.extractFields = extractFields;
+exports.expandPolicy = expandPolicy;
+function rightToValue(right) {
+    if (right?.Var === 'principal')
+        return '$CURRENT_USER';
+    if (right?.Value !== undefined)
+        return right.Value;
+    throw new Error(`Unsupported right-hand Cedar expression: ${JSON.stringify(right)}`);
+}
+function pathToFilter(node, subject, leaf) {
+    let acc = leaf;
+    let cur = node;
+    if (subject === 'context.newValue') {
+        while (cur && cur['.']) {
+            const { left, attr } = cur['.'];
+            // Reached the `context.newValue` base: stop without wrapping `newValue`.
+            if (attr === 'newValue' && left?.Var === 'context')
+                return acc;
+            acc = { [attr]: acc };
+            cur = left;
+        }
+        throw new Error(`Unexpected context.newValue base path: ${JSON.stringify(node)}`);
+    }
+    while (cur && cur['.']) {
+        acc = { [cur['.'].attr]: acc };
+        cur = cur['.'].left;
+    }
+    if (!(cur && cur.Var === 'resource')) {
+        throw new Error(`Unexpected resource base path: ${JSON.stringify(node)}`);
+    }
+    return acc;
+}
+function patternToOperation(pattern) {
+    // Cedar splits a `like` pattern into per-character Literal elements.
+    const value = pattern
+        .filter((p) => p !== 'Wildcard')
+        .map((p) => p.Literal)
+        .join('');
+    const startsWildcard = pattern[0] === 'Wildcard';
+    const endsWildcard = pattern[pattern.length - 1] === 'Wildcard';
+    if (startsWildcard && endsWildcard)
+        return { operator: '_contains', value };
+    if (endsWildcard)
+        return { operator: '_starts_with', value };
+    if (startsWildcard)
+        return { operator: '_ends_with', value };
+    throw new Error(`Unsupported like pattern: ${JSON.stringify(pattern)}`);
+}
+const COMPARISON_OPS = {
+    '==': '_eq',
+    '!=': '_neq',
+    '>': '_gt',
+    '>=': '_gte',
+    '<': '_lt',
+    '<=': '_lte',
+};
+/** Inverse of `addWhenClauses`: a Cedar Expr tree back into a D9 filter. */
+function exprToFilter(expr, subject = 'resource') {
+    if (!expr)
+        return {};
+    const key = Object.keys(expr)[0];
+    const node = expr[key];
+    if (key === '&&' || key === '||') {
+        const operator = key === '&&' ? '_and' : '_or';
+        const left = exprToFilter(node.left, subject);
+        const right = exprToFilter(node.right, subject);
+        const operands = [left[operator] ?? left, right[operator] ?? right].flat();
+        return { [operator]: operands };
+    }
+    if (key === 'has') {
+        return pathToFilter(node.left, subject, { [node.attr]: { _nnull: true } });
+    }
+    if (key === '!') {
+        const arg = node.arg;
+        if (arg && arg.has) {
+            return pathToFilter(arg.has.left, subject, {
+                [arg.has.attr]: { _null: true },
+            });
+        }
+        throw new Error(`Unsupported negation expression: ${JSON.stringify(expr)}`);
+    }
+    if (key === 'like') {
+        const { operator, value } = patternToOperation(node.pattern);
+        return pathToFilter(node.left, subject, { [operator]: value });
+    }
+    if (key in COMPARISON_OPS) {
+        return pathToFilter(node.left, subject, {
+            [COMPARISON_OPS[key]]: rightToValue(node.right),
+        });
+    }
+    throw new Error(`Unsupported Cedar expression operator: ${key}`);
+}
+/** Field list from a check-fields policy's `containsAll` clause. */
+function extractFields(expr) {
+    const left = expr?.containsAll?.left;
+    // A literal array is normalized by Cedar into a Set of Value elements.
+    if (Array.isArray(left?.Set))
+        return left.Set.map((e) => e.Value);
+    if (Array.isArray(left?.Value))
+        return left.Value;
+    throw new Error(`Unexpected check-fields policy shape: ${JSON.stringify(expr)}`);
+}
+/** Inverse of `refactoPolicies`: expand `action in [...]` into one tuple each. */
+function expandPolicy(policy) {
+    const action = policy.action;
+    let entities = [];
+    if (action.op === '==') {
+        entities = [action.entity];
+    }
+    else if (action.op === 'in') {
+        // Cedar parses a single-element `action in [X]` as `{ op: 'in', entity }`
+        entities = action.entities ?? [action.entity];
+    }
+    else {
+        // returning no tuple would silently remove the matching rows from the CSV
+        throw new Error(`Unexpected action constraint: ${JSON.stringify(action)}`);
+    }
+    return entities.map((e) => {
+        const ent = e;
+        return {
+            collection: ent.type.replace(/^Db::/, '').replace(/::Action$/, ''),
+            action: ent.id,
+            conditions: policy.conditions ?? [],
+        };
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cedar-to-d9-translations.js","sourceRoot":"","sources":["../../../../src/cli/commands/cedar/cedar-to-d9-translations.ts"],"names":[],"mappings":"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","sourcesContent":["import { ConditionSubject } from './cedar-translations';\nimport type { Filter } from './d9-permission';\n\ntype EntityRef = { type: string; id: string };\n\nfunction rightToValue(right: any): any {\n  if (right?.Var === 'principal') return '$CURRENT_USER';\n  if (right?.Value !== undefined) return right.Value;\n  throw new Error(\n    `Unsupported right-hand Cedar expression: ${JSON.stringify(right)}`,\n  );\n}\n\nfunction pathToFilter(\n  node: any,\n  subject: ConditionSubject,\n  leaf: Record<string, any>,\n): Filter {\n  let acc: any = leaf;\n  let cur = node;\n\n  if (subject === 'context.newValue') {\n    while (cur && cur['.']) {\n      const { left, attr } = cur['.'];\n      // Reached the `context.newValue` base: stop without wrapping `newValue`.\n      if (attr === 'newValue' && left?.Var === 'context') return acc;\n      acc = { [attr]: acc };\n      cur = left;\n    }\n    throw new Error(\n      `Unexpected context.newValue base path: ${JSON.stringify(node)}`,\n    );\n  }\n\n  while (cur && cur['.']) {\n    acc = { [cur['.'].attr]: acc };\n    cur = cur['.'].left;\n  }\n  if (!(cur && cur.Var === 'resource')) {\n    throw new Error(`Unexpected resource base path: ${JSON.stringify(node)}`);\n  }\n  return acc;\n}\n\nfunction patternToOperation(pattern: any[]): { operator: string; value: any } {\n  // Cedar splits a `like` pattern into per-character Literal elements.\n  const value = pattern\n    .filter((p) => p !== 'Wildcard')\n    .map((p) => p.Literal)\n    .join('');\n  const startsWildcard = pattern[0] === 'Wildcard';\n  const endsWildcard = pattern[pattern.length - 1] === 'Wildcard';\n  if (startsWildcard && endsWildcard) return { operator: '_contains', value };\n  if (endsWildcard) return { operator: '_starts_with', value };\n  if (startsWildcard) return { operator: '_ends_with', value };\n  throw new Error(`Unsupported like pattern: ${JSON.stringify(pattern)}`);\n}\n\nconst COMPARISON_OPS: Record<string, string> = {\n  '==': '_eq',\n  '!=': '_neq',\n  '>': '_gt',\n  '>=': '_gte',\n  '<': '_lt',\n  '<=': '_lte',\n};\n\n/** Inverse of `addWhenClauses`: a Cedar Expr tree back into a D9 filter. */\nexport function exprToFilter(\n  expr?: any,\n  subject: ConditionSubject = 'resource',\n): Filter {\n  if (!expr) return {};\n  const key = Object.keys(expr)[0]!;\n  const node = (expr as Record<string, any>)[key];\n\n  if (key === '&&' || key === '||') {\n    const operator = key === '&&' ? '_and' : '_or';\n    const left = exprToFilter(node.left, subject) as Record<string, any>;\n    const right = exprToFilter(node.right, subject) as Record<string, any>;\n    const operands = [left[operator] ?? left, right[operator] ?? right].flat();\n    return { [operator]: operands } as Filter;\n  }\n\n  if (key === 'has') {\n    return pathToFilter(node.left, subject, { [node.attr]: { _nnull: true } });\n  }\n\n  if (key === '!') {\n    const arg = node.arg;\n    if (arg && arg.has) {\n      return pathToFilter(arg.has.left, subject, {\n        [arg.has.attr]: { _null: true },\n      });\n    }\n    throw new Error(`Unsupported negation expression: ${JSON.stringify(expr)}`);\n  }\n\n  if (key === 'like') {\n    const { operator, value } = patternToOperation(node.pattern);\n    return pathToFilter(node.left, subject, { [operator]: value });\n  }\n\n  if (key in COMPARISON_OPS) {\n    return pathToFilter(node.left, subject, {\n      [COMPARISON_OPS[key]!]: rightToValue(node.right),\n    });\n  }\n\n  throw new Error(`Unsupported Cedar expression operator: ${key}`);\n}\n\n/** Field list from a check-fields policy's `containsAll` clause. */\nexport function extractFields(expr: any): string[] {\n  const left = expr?.containsAll?.left;\n  // A literal array is normalized by Cedar into a Set of Value elements.\n  if (Array.isArray(left?.Set)) return left.Set.map((e: any) => e.Value);\n  if (Array.isArray(left?.Value)) return left.Value;\n  throw new Error(\n    `Unexpected check-fields policy shape: ${JSON.stringify(expr)}`,\n  );\n}\n\n/** Inverse of `refactoPolicies`: expand `action in [...]` into one tuple each. */\nexport function expandPolicy(\n  policy: any,\n): Array<{ collection: string; action: string; conditions: any[] }> {\n  const action = policy.action;\n  let entities: any[] = [];\n  if (action.op === '==') {\n    entities = [action.entity];\n  } else if (action.op === 'in') {\n    // Cedar parses a single-element `action in [X]` as `{ op: 'in', entity }`\n    entities = action.entities ?? [action.entity];\n  } else {\n    // returning no tuple would silently remove the matching rows from the CSV\n    throw new Error(`Unexpected action constraint: ${JSON.stringify(action)}`);\n  }\n  return entities.map((e) => {\n    const ent = e as EntityRef;\n    return {\n      collection: ent.type.replace(/^Db::/, '').replace(/::Action$/, ''),\n      action: ent.id,\n      conditions: policy.conditions ?? [],\n    };\n  });\n}\n"]}

package/lib/cli/commands/cedar/cedar-to-d9.d.ts

@@ -0,0 +1,57 @@
+import { D9Permission } from './d9-permission';
+import { RolesTable } from './roles-table';
+/** Map keyed by a tuple of strings (Map indexes arrays by identity, hence the join). */
+declare class TupleKeyMap<Value> {
+    private readonly createValue?;
+    private readonly entries;
+    /** `createValue` is required to use {@link getOrCreate}; omit it for a plain get/set map. */
+    constructor(createValue?: ((parts: string[]) => Value) | undefined);
+    private keyOf;
+    get(parts: string[]): Value | undefined;
+    set(parts: string[], value: Value): void;
+    delete(parts: string[]): void;
+    /** Return the value for `parts`, creating and storing it via the factory if absent. */
+    getOrCreate(parts: string[]): Value;
+    values(): Value[];
+}
+/**
+ * Reverse of d9-to-cedar: reads the per-role Cedar policy files back into D9
+ * permission rows and merges them into directus_permissions.csv. The original
+ * CSV stays the source of truth for the columns Cedar does not carry (`id`,
+ * `role` UUID, `presets`); only `permissions`/`fields`/`validation` are rewritten.
+ */
+export declare class CedarToD9Manager {
+    permissionPath: string;
+    sqlPath: string;
+    outputPath: string;
+    roles: RolesTable;
+    baseRowsByTuple: TupleKeyMap<Record<string, string>>;
+    header: string[];
+    nextId: number;
+    reconstructed: D9Permission[];
+    constructor(opts?: {
+        permissionPath?: string;
+        sqlPath?: string;
+        outputPath?: string;
+    });
+    readBasePermissionFile(): Promise<void>;
+    readRoleFile(): Promise<void>;
+    /** Read one `.cedar` file into expanded (collection, action, conditions) tuples. */
+    parseCedarFile(filePath: string): Promise<Array<{
+        collection: string;
+        action: string;
+        conditions: any[];
+    }>>;
+    parseRoleFolder(roleName: string): Promise<D9Permission[]>;
+    parseAllFolders(): Promise<void>;
+    mergeIntoRows(): void;
+    writeOutput(): Promise<void>;
+    readCedarAndWriteCsv(): Promise<void>;
+}
+/** CLI action: merge Cedar policies back into directus_permissions.csv. */
+export declare function cedarToD9(options?: {
+    permissionPath?: string;
+    sqlPath?: string;
+    outputPath?: string;
+}): Promise<void>;
+export {};

package/lib/cli/commands/cedar/cedar-to-d9.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CedarToD9Manager = void 0;
+exports.cedarToD9 = cedarToD9;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const cedar = require("@cedar-policy/cedar-wasm/nodejs");
+const cedar_to_d9_translations_1 = require("./cedar-to-d9-translations");
+const d9_permission_1 = require("./d9-permission");
+const roles_table_1 = require("./roles-table");
+const logger_1 = require("../../logger");
+const utils_1 = require("../save/utils");
+/** Map keyed by a tuple of strings (Map indexes arrays by identity, hence the join). */
+class TupleKeyMap {
+    /** `createValue` is required to use {@link getOrCreate}; omit it for a plain get/set map. */
+    constructor(createValue) {
+        this.createValue = createValue;
+        this.entries = new Map();
+    }
+    keyOf(parts) {
+        return parts.join(' ');
+    }
+    get(parts) {
+        return this.entries.get(this.keyOf(parts));
+    }
+    set(parts, value) {
+        this.entries.set(this.keyOf(parts), value);
+    }
+    delete(parts) {
+        this.entries.delete(this.keyOf(parts));
+    }
+    /** Return the value for `parts`, creating and storing it via the factory if absent. */
+    getOrCreate(parts) {
+        const key = this.keyOf(parts);
+        let value = this.entries.get(key);
+        if (value === undefined) {
+            if (!this.createValue) {
+                throw new Error('TupleKeyMap.getOrCreate called without a factory');
+            }
+            value = this.createValue(parts);
+            this.entries.set(key, value);
+        }
+        return value;
+    }
+    values() {
+        return [...this.entries.values()];
+    }
+}
+/**
+ * Reverse of d9-to-cedar: reads the per-role Cedar policy files back into D9
+ * permission rows and merges them into directus_permissions.csv. The original
+ * CSV stays the source of truth for the columns Cedar does not carry (`id`,
+ * `role` UUID, `presets`); only `permissions`/`fields`/`validation` are rewritten.
+ */
+class CedarToD9Manager {
+    constructor(opts) {
+        // Rows keyed by (role, collection, action); the map's values (insertion order)
+        // are what gets written back out, so it is the single source of truth for rows.
+        this.baseRowsByTuple = new TupleKeyMap();
+        this.header = [];
+        this.nextId = 0;
+        this.reconstructed = [];
+        this.permissionPath = opts?.permissionPath || './permissions';
+        this.sqlPath = opts?.sqlPath || './sql/data';
+        this.outputPath =
+            opts?.outputPath || `${this.sqlPath}/directus_permissions.csv`;
+    }
+    async readBasePermissionFile() {
+        const filePath = `${this.sqlPath}/directus_permissions.csv`;
+        const rows = await (0, utils_1.readCsvFile)(filePath);
+        const firstLine = await (0, utils_1.readFirstLineOfFile)(filePath);
+        this.header = firstLine.split(',').map((column) => column.trim());
+        for (const row of rows) {
+            this.baseRowsByTuple.set([row.role, row.collection, row.action], row);
+            const id = Number(row.id);
+            if (Number.isFinite(id) && id > this.nextId)
+                this.nextId = id;
+        }
+    }
+    async readRoleFile() {
+        this.roles = await roles_table_1.RolesTable.load(this.sqlPath);
+    }
+    /** Read one `.cedar` file into expanded (collection, action, conditions) tuples. */
+    async parseCedarFile(filePath) {
+        if (!(0, fs_1.existsSync)(filePath)) {
+            return []; // a role may not have every .cedar file (e.g. no validate.cedar)
+        }
+        const text = (await (0, promises_1.readFile)(filePath)).toString();
+        const parts = cedar.policySetTextToParts(text);
+        if (parts.type === 'failure') {
+            logger_1.logger.error(`failed to split policy set ${filePath}`);
+            throw new Error(parts.errors);
+        }
+        const tuples = [];
+        for (const policyText of parts.policies) {
+            const parsed = cedar.policyToJson(policyText);
+            if (parsed.type === 'failure') {
+                logger_1.logger.error({ policyText }, `failed to parse policy in ${filePath}`);
+                throw new Error(parsed.errors);
+            }
+            tuples.push(...(0, cedar_to_d9_translations_1.expandPolicy)(parsed.json));
+        }
+        return tuples;
+    }
+    async parseRoleFolder(roleName) {
+        // A (collection, action) tuple can appear across authorize/check-fields/validate,
+        // so the map creates one permission per tuple and we accumulate clauses onto it.
+        const byTuple = new TupleKeyMap(([collection, action]) => d9_permission_1.D9Permission.empty(roleName, collection, action));
+        const folder = `${this.permissionPath}/${roleName}`;
+        const authorizeTuples = await this.parseCedarFile(`${folder}/authorize.cedar`);
+        for (const tuple of authorizeTuples) {
+            byTuple.getOrCreate([tuple.collection, tuple.action]).permissions =
+                (0, cedar_to_d9_translations_1.exprToFilter)(tuple.conditions[0]?.body, 'resource');
+        }
+        const fieldTuples = await this.parseCedarFile(`${folder}/check-fields.cedar`);
+        for (const tuple of fieldTuples) {
+            if (tuple.conditions.length) {
+                byTuple.getOrCreate([tuple.collection, tuple.action]).fields =
+                    (0, cedar_to_d9_translations_1.extractFields)(tuple.conditions[0].body);
+            }
+        }
+        const validateTuples = await this.parseCedarFile(`${folder}/validate.cedar`);
+        for (const tuple of validateTuples) {
+            if (tuple.conditions.length) {
+                byTuple.getOrCreate([tuple.collection, tuple.action]).validation =
+                    (0, cedar_to_d9_translations_1.exprToFilter)(tuple.conditions[0].body, 'context.newValue');
+            }
+        }
+        return byTuple.values();
+    }
+    async parseAllFolders() {
+        const entries = await (0, promises_1.readdir)(this.permissionPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            this.reconstructed.push(...(await this.parseRoleFolder(entry.name)));
+        }
+    }
+    mergeIntoRows() {
+        let merged = 0;
+        let updated = 0;
+        let added = 0;
+        let removed = 0;
+        const seen = new TupleKeyMap();
+        for (const perm of this.reconstructed) {
+            const roleId = this.roles.getIdFromName(perm.roleName);
+            if (!roleId && perm.roleName !== 'Public') {
+                // In V2, instead of throwing an error, we could create a new role in the CSV.
+                // But for now, we expect the roles to be pre-defined in the CSV.
+                // This is a sanity check: the role should exist in the CSV, otherwise something is wrong.
+                throw new Error(`role "${perm.roleName}" (from ${this.permissionPath}) not found in directus_roles.csv`);
+            }
+            seen.set([roleId, perm.collection, perm.action], true);
+            const row = this.baseRowsByTuple.get([roleId, perm.collection, perm.action]);
+            if (!row) {
+                // New tuple added in the Cedar files; the role exists, so create a row.
+                const newRow = {
+                    id: String(++this.nextId),
+                    role: roleId,
+                    collection: perm.collection,
+                    action: perm.action,
+                    permissions: perm.permissionsCell(),
+                    validation: perm.validationCell(),
+                    fields: perm.fieldsCell(),
+                    presets: '',
+                };
+                this.baseRowsByTuple.set([roleId, perm.collection, perm.action], newRow);
+                logger_1.logger.info(`added ${perm.roleName}/${perm.collection}/${perm.action} (id ${newRow.id})`);
+                added++;
+                merged++;
+                continue;
+            }
+            // The Cedar policies are the source of truth: overwrite the three
+            // derivable columns directly (the round-trip is meaning-preserving, so
+            // this only reshapes representation, e.g. `{_and:[x]}` -> `x`).
+            row.permissions = perm.permissionsCell();
+            row.validation = perm.validationCell();
+            row.fields = perm.fieldsCell();
+            updated++;
+            merged++;
+        }
+        // Every row is written to authorize.cedar by d9-to-cedar, so a row no longer
+        // produced by the Cedar files has been removed from them.
+        for (const row of this.baseRowsByTuple.values()) {
+            const tuple = [row.role, row.collection, row.action];
+            if (seen.get(tuple))
+                continue;
+            this.baseRowsByTuple.delete(tuple);
+            const roleName = row.role ? this.roles.getNameFromId(row.role) : 'Public';
+            logger_1.logger.info(`removed ${roleName}/${row.collection}/${row.action} (id ${row.id})`);
+            removed++;
+        }
+        logger_1.logger.info(`merged ${merged} permissions, ${updated} row(s) updated, ${added} new row(s) added, ${removed} row(s) removed`);
+    }
+    async writeOutput() {
+        await (0, utils_1.writeCsvFile)(this.outputPath, this.header, this.baseRowsByTuple.values());
+        logger_1.logger.info(`wrote ${this.outputPath}`);
+    }
+    async readCedarAndWriteCsv() {
+        logger_1.logger.info('reading base permission file');
+        await this.readBasePermissionFile();
+        logger_1.logger.info(`found ${this.baseRowsByTuple.values().length} base permissions`);
+        logger_1.logger.info('reading role file');
+        await this.readRoleFile();
+        logger_1.logger.info('parsing cedar policy folders');
+        await this.parseAllFolders();
+        logger_1.logger.info(`reconstructed ${this.reconstructed.length} permissions from cedar`);
+        logger_1.logger.info('merging into base rows');
+        this.mergeIntoRows();
+        logger_1.logger.info('writing csv');
+        await this.writeOutput();
+        logger_1.logger.info('done');
+    }
+}
+exports.CedarToD9Manager = CedarToD9Manager;
+/** CLI action: merge Cedar policies back into directus_permissions.csv. */
+async function cedarToD9(options) {
+    const manager = new CedarToD9Manager(options);
+    await manager.readCedarAndWriteCsv();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cedar-to-d9.js","sourceRoot":"","sources":["../../../../src/cli/commands/cedar/cedar-to-d9.ts"],"names":[],"mappings":";;;AAgRA,8BAOC;AAvRD,2BAAgC;AAChC,0CAAgD;AAChD,yDAAyD;AACzD,yEAIoC;AACpC,mDAA+C;AAC/C,+CAA2C;AAC3C,yCAAsC;AACtC,yCAA+E;AAE/E,wFAAwF;AACxF,MAAM,WAAW;IAGf,6FAA6F;IAC7F,YAA6B,WAAwC;QAAxC,gBAAW,GAAX,WAAW,CAA6B;QAHpD,YAAO,GAAG,IAAI,GAAG,EAAiB,CAAC;IAGoB,CAAC;IAEjE,KAAK,CAAC,KAAe;QAC3B,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAEM,GAAG,CAAC,KAAe;QACxB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IAC7C,CAAC;IAEM,GAAG,CAAC,KAAe,EAAE,KAAY;QACtC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;IAC7C,CAAC;IAEM,MAAM,CAAC,KAAe;QAC3B,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IACzC,CAAC;IAED,uFAAuF;IAChF,WAAW,CAAC,KAAe;QAChC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC9B,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;gBACtB,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;YACtE,CAAC;YACD,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;YAChC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC/B,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAEM,MAAM;QACX,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACpC,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAa,gBAAgB;IAa3B,YAAY,IAIX;QAXD,+EAA+E;QAC/E,gFAAgF;QACzE,oBAAe,GAAG,IAAI,WAAW,EAA0B,CAAC;QAC5D,WAAM,GAAa,EAAE,CAAC;QACtB,WAAM,GAAG,CAAC,CAAC;QACX,kBAAa,GAAmB,EAAE,CAAC;QAOxC,IAAI,CAAC,cAAc,GAAG,IAAI,EAAE,cAAc,IAAI,eAAe,CAAC;QAC9D,IAAI,CAAC,OAAO,GAAG,IAAI,EAAE,OAAO,IAAI,YAAY,CAAC;QAC7C,IAAI,CAAC,UAAU;YACb,IAAI,EAAE,UAAU,IAAI,GAAG,IAAI,CAAC,OAAO,2BAA2B,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,sBAAsB;QACjC,MAAM,QAAQ,GAAG,GAAG,IAAI,CAAC,OAAO,2BAA2B,CAAC;QAC5D,MAAM,IAAI,GAAG,MAAM,IAAA,mBAAW,EAAC,QAAQ,CAAC,CAAC;QACzC,MAAM,SAAS,GAAG,MAAM,IAAA,2BAAmB,EAAC,QAAQ,CAAC,CAAC;QACtD,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;QAElE,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC;YACtE,MAAM,EAAE,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC1B,IAAI,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,MAAM;gBAAE,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;QAChE,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,YAAY;QACvB,IAAI,CAAC,KAAK,GAAG,MAAM,wBAAU,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACnD,CAAC;IAED,oFAAoF;IAC7E,KAAK,CAAC,cAAc,CACzB,QAAgB;QAEhB,IAAI,CAAC,IAAA,eAAU,EAAC,QAAQ,CAAC,EAAE,CAAC;YAC1B,OAAO,EAAE,CAAC,CAAC,iEAAiE;QAC9E,CAAC;QACD,MAAM,IAAI,GAAG,CAAC,MAAM,IAAA,mBAAQ,EAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;QACnD,MAAM,KAAK,GAAG,KAAK,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QAC/C,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC7B,eAAM,CAAC,KAAK,CAAC,8BAA8B,QAAQ,EAAE,CAAC,CAAC;YACvD,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC,MAAa,CAAC,CAAC;QACvC,CAAC;QACD,MAAM,MAAM,GAIP,EAAE,CAAC;QACR,KAAK,MAAM,UAAU,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;YACxC,MAAM,MAAM,GAAG,KAAK,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;YAC9C,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;gBAC9B,eAAM,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,EAAE,6BAA6B,QAAQ,EAAE,CAAC,CAAC;gBACtE,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,MAAa,CAAC,CAAC;YACxC,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,GAAG,IAAA,uCAAY,EAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;QAC5C,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAEM,KAAK,CAAC,eAAe,CAAC,QAAgB;QAC3C,kFAAkF;QAClF,iFAAiF;QACjF,MAAM,OAAO,GAAG,IAAI,WAAW,CAAe,CAAC,CAAC,UAAU,EAAE,MAAM,CAAC,EAAE,EAAE,CACrE,4BAAY,CAAC,KAAK,CAAC,QAAQ,EAAE,UAAU,EAAE,MAAM,CAAC,CACjD,CAAC;QAEF,MAAM,MAAM,GAAG,GAAG,IAAI,CAAC,cAAc,IAAI,QAAQ,EAAE,CAAC;QAEpD,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,cAAc,CAC/C,GAAG,MAAM,kBAAkB,CAC5B,CAAC;QACF,KAAK,MAAM,KAAK,IAAI,eAAe,EAAE,CAAC;YACpC,OAAO,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW;gBAC/D,IAAA,uCAAY,EAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;QACxD,CAAC;QAED,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,MAAM,qBAAqB,CAAC,CAAC;QAC9E,KAAK,MAAM,KAAK,IAAI,WAAW,EAAE,CAAC;YAChC,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;gBAC5B,OAAO,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM;oBAC1D,IAAA,wCAAa,EAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YAC5C,CAAC;QACH,CAAC;QAED,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,MAAM,iBAAiB,CAAC,CAAC;QAC7E,KAAK,MAAM,KAAK,IAAI,cAAc,EAAE,CAAC;YACnC,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;gBAC5B,OAAO,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,UAAU;oBAC9D,IAAA,uCAAY,EAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC;YAC/D,CAAC;QACH,CAAC;QAED,OAAO,OAAO,CAAC,MAAM,EAAE,CAAC;IAC1B,CAAC;IAEM,KAAK,CAAC,eAAe;QAC1B,MAAM,OAAO,GAAG,MAAM,IAAA,kBAAO,EAAC,IAAI,CAAC,cAAc,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;QAC5E,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC5B,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE;gBAAE,SAAS;YACnC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACvE,CAAC;IACH,CAAC;IAEM,aAAa;QAClB,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,MAAM,IAAI,GAAG,IAAI,WAAW,EAAQ,CAAC;QAErC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACtC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACvD,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;gBAC1C,8EAA8E;gBAC9E,iEAAiE;gBACjE,0FAA0F;gBAC1F,MAAM,IAAI,KAAK,CACb,SAAS,IAAI,CAAC,QAAQ,WAAW,IAAI,CAAC,cAAc,mCAAmC,CACxF,CAAC;YACJ,CAAC;YAED,IAAI,CAAC,GAAG,CAAC,CAAC,MAAO,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC;YACxD,MAAM,GAAG,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,MAAO,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;YAC9E,IAAI,CAAC,GAAG,EAAE,CAAC;gBACT,wEAAwE;gBACxE,MAAM,MAAM,GAA2B;oBACrC,EAAE,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC;oBACzB,IAAI,EAAE,MAAO;oBACb,UAAU,EAAE,IAAI,CAAC,UAAU;oBAC3B,MAAM,EAAE,IAAI,CAAC,MAAM;oBACnB,WAAW,EAAE,IAAI,CAAC,eAAe,EAAE;oBACnC,UAAU,EAAE,IAAI,CAAC,cAAc,EAAE;oBACjC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE;oBACzB,OAAO,EAAE,EAAE;iBACZ,CAAC;gBACF,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,MAAO,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;gBAC1E,eAAM,CAAC,IAAI,CACT,SAAS,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,MAAM,QAAQ,MAAM,CAAC,EAAE,GAAG,CAC7E,CAAC;gBACF,KAAK,EAAE,CAAC;gBACR,MAAM,EAAE,CAAC;gBACT,SAAS;YACX,CAAC;YAED,kEAAkE;YAClE,uEAAuE;YACvE,gEAAgE;YAChE,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;YACzC,GAAG,CAAC,UAAU,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;YACvC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;YAC/B,OAAO,EAAE,CAAC;YACV,MAAM,EAAE,CAAC;QACX,CAAC;QAED,6EAA6E;QAC7E,0DAA0D;QAC1D,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,EAAE,CAAC;YAChD,MAAM,KAAK,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;YACrD,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;gBAAE,SAAS;YAC9B,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACnC,MAAM,QAAQ,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;YAC1E,eAAM,CAAC,IAAI,CAAC,WAAW,QAAQ,IAAI,GAAG,CAAC,UAAU,IAAI,GAAG,CAAC,MAAM,QAAQ,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;YAClF,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,eAAM,CAAC,IAAI,CACT,UAAU,MAAM,iBAAiB,OAAO,oBAAoB,KAAK,sBAAsB,OAAO,iBAAiB,CAChH,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,WAAW;QACtB,MAAM,IAAA,oBAAY,EAChB,IAAI,CAAC,UAAU,EACf,IAAI,CAAC,MAAM,EACX,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,CAC9B,CAAC;QACF,eAAM,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;IAC1C,CAAC;IAEM,KAAK,CAAC,oBAAoB;QAC/B,eAAM,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;QAC5C,MAAM,IAAI,CAAC,sBAAsB,EAAE,CAAC;QACpC,eAAM,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC,MAAM,mBAAmB,CAAC,CAAC;QAC9E,eAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACjC,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;QAC1B,eAAM,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;QAC5C,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAC7B,eAAM,CAAC,IAAI,CACT,iBAAiB,IAAI,CAAC,aAAa,CAAC,MAAM,yBAAyB,CACpE,CAAC;QACF,eAAM,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;QACtC,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,eAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAC3B,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;QACzB,eAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACtB,CAAC;CAEF;AAhND,4CAgNC;AAED,2EAA2E;AACpE,KAAK,UAAU,SAAS,CAAC,OAI/B;IACC,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAC9C,MAAM,OAAO,CAAC,oBAAoB,EAAE,CAAC;AACvC,CAAC","sourcesContent":["import { existsSync } from 'fs';\nimport { readFile, readdir } from 'fs/promises';\nimport * as cedar from '@cedar-policy/cedar-wasm/nodejs';\nimport {\n  expandPolicy,\n  exprToFilter,\n  extractFields,\n} from './cedar-to-d9-translations';\nimport { D9Permission } from './d9-permission';\nimport { RolesTable } from './roles-table';\nimport { logger } from '../../logger';\nimport { readCsvFile, readFirstLineOfFile, writeCsvFile } from '../save/utils';\n\n/** Map keyed by a tuple of strings (Map indexes arrays by identity, hence the join). */\nclass TupleKeyMap<Value> {\n  private readonly entries = new Map<string, Value>();\n\n  /** `createValue` is required to use {@link getOrCreate}; omit it for a plain get/set map. */\n  constructor(private readonly createValue?: (parts: string[]) => Value) {}\n\n  private keyOf(parts: string[]): string {\n    return parts.join(' ');\n  }\n\n  public get(parts: string[]) {\n    return this.entries.get(this.keyOf(parts));\n  }\n\n  public set(parts: string[], value: Value): void {\n    this.entries.set(this.keyOf(parts), value);\n  }\n\n  public delete(parts: string[]): void {\n    this.entries.delete(this.keyOf(parts));\n  }\n\n  /** Return the value for `parts`, creating and storing it via the factory if absent. */\n  public getOrCreate(parts: string[]): Value {\n    const key = this.keyOf(parts);\n    let value = this.entries.get(key);\n    if (value === undefined) {\n      if (!this.createValue) {\n        throw new Error('TupleKeyMap.getOrCreate called without a factory');\n      }\n      value = this.createValue(parts);\n      this.entries.set(key, value);\n    }\n    return value;\n  }\n\n  public values(): Value[] {\n    return [...this.entries.values()];\n  }\n}\n\n/**\n * Reverse of d9-to-cedar: reads the per-role Cedar policy files back into D9\n * permission rows and merges them into directus_permissions.csv. The original\n * CSV stays the source of truth for the columns Cedar does not carry (`id`,\n * `role` UUID, `presets`); only `permissions`/`fields`/`validation` are rewritten.\n */\nexport class CedarToD9Manager {\n  public permissionPath: string;\n  public sqlPath: string;\n  public outputPath: string;\n\n  public roles!: RolesTable;\n  // Rows keyed by (role, collection, action); the map's values (insertion order)\n  // are what gets written back out, so it is the single source of truth for rows.\n  public baseRowsByTuple = new TupleKeyMap<Record<string, string>>();\n  public header: string[] = [];\n  public nextId = 0;\n  public reconstructed: D9Permission[] = [];\n\n  constructor(opts?: {\n    permissionPath?: string;\n    sqlPath?: string;\n    outputPath?: string;\n  }) {\n    this.permissionPath = opts?.permissionPath || './permissions';\n    this.sqlPath = opts?.sqlPath || './sql/data';\n    this.outputPath =\n      opts?.outputPath || `${this.sqlPath}/directus_permissions.csv`;\n  }\n\n  public async readBasePermissionFile() {\n    const filePath = `${this.sqlPath}/directus_permissions.csv`;\n    const rows = await readCsvFile(filePath);\n    const firstLine = await readFirstLineOfFile(filePath);\n    this.header = firstLine.split(',').map((column) => column.trim());\n\n    for (const row of rows) {\n      this.baseRowsByTuple.set([row.role, row.collection, row.action], row);\n      const id = Number(row.id);\n      if (Number.isFinite(id) && id > this.nextId) this.nextId = id;\n    }\n  }\n\n  public async readRoleFile() {\n    this.roles = await RolesTable.load(this.sqlPath);\n  }\n\n  /** Read one `.cedar` file into expanded (collection, action, conditions) tuples. */\n  public async parseCedarFile(\n    filePath: string,\n  ): Promise<Array<{ collection: string; action: string; conditions: any[] }>> {\n    if (!existsSync(filePath)) {\n      return []; // a role may not have every .cedar file (e.g. no validate.cedar)\n    }\n    const text = (await readFile(filePath)).toString();\n    const parts = cedar.policySetTextToParts(text);\n    if (parts.type === 'failure') {\n      logger.error(`failed to split policy set ${filePath}`);\n      throw new Error(parts.errors as any);\n    }\n    const tuples: Array<{\n      collection: string;\n      action: string;\n      conditions: any[];\n    }> = [];\n    for (const policyText of parts.policies) {\n      const parsed = cedar.policyToJson(policyText);\n      if (parsed.type === 'failure') {\n        logger.error({ policyText }, `failed to parse policy in ${filePath}`);\n        throw new Error(parsed.errors as any);\n      }\n      tuples.push(...expandPolicy(parsed.json));\n    }\n    return tuples;\n  }\n\n  public async parseRoleFolder(roleName: string): Promise<D9Permission[]> {\n    // A (collection, action) tuple can appear across authorize/check-fields/validate,\n    // so the map creates one permission per tuple and we accumulate clauses onto it.\n    const byTuple = new TupleKeyMap<D9Permission>(([collection, action]) =>\n      D9Permission.empty(roleName, collection, action),\n    );\n\n    const folder = `${this.permissionPath}/${roleName}`;\n\n    const authorizeTuples = await this.parseCedarFile(\n      `${folder}/authorize.cedar`,\n    );\n    for (const tuple of authorizeTuples) {\n      byTuple.getOrCreate([tuple.collection, tuple.action]).permissions =\n        exprToFilter(tuple.conditions[0]?.body, 'resource');\n    }\n\n    const fieldTuples = await this.parseCedarFile(`${folder}/check-fields.cedar`);\n    for (const tuple of fieldTuples) {\n      if (tuple.conditions.length) {\n        byTuple.getOrCreate([tuple.collection, tuple.action]).fields =\n          extractFields(tuple.conditions[0].body);\n      }\n    }\n\n    const validateTuples = await this.parseCedarFile(`${folder}/validate.cedar`);\n    for (const tuple of validateTuples) {\n      if (tuple.conditions.length) {\n        byTuple.getOrCreate([tuple.collection, tuple.action]).validation =\n          exprToFilter(tuple.conditions[0].body, 'context.newValue');\n      }\n    }\n\n    return byTuple.values();\n  }\n\n  public async parseAllFolders() {\n    const entries = await readdir(this.permissionPath, { withFileTypes: true });\n    for (const entry of entries) {\n      if (!entry.isDirectory()) continue;\n      this.reconstructed.push(...(await this.parseRoleFolder(entry.name)));\n    }\n  }\n\n  public mergeIntoRows() {\n    let merged = 0;\n    let updated = 0;\n    let added = 0;\n    let removed = 0;\n    const seen = new TupleKeyMap<true>();\n\n    for (const perm of this.reconstructed) {\n      const roleId = this.roles.getIdFromName(perm.roleName);\n      if (!roleId && perm.roleName !== 'Public') {\n        // In V2, instead of throwing an error, we could create a new role in the CSV.\n        // But for now, we expect the roles to be pre-defined in the CSV.\n        // This is a sanity check: the role should exist in the CSV, otherwise something is wrong.\n        throw new Error(\n          `role \"${perm.roleName}\" (from ${this.permissionPath}) not found in directus_roles.csv`,\n        );\n      }\n\n      seen.set([roleId!, perm.collection, perm.action], true);\n      const row = this.baseRowsByTuple.get([roleId!, perm.collection, perm.action]);\n      if (!row) {\n        // New tuple added in the Cedar files; the role exists, so create a row.\n        const newRow: Record<string, string> = {\n          id: String(++this.nextId),\n          role: roleId!,\n          collection: perm.collection,\n          action: perm.action,\n          permissions: perm.permissionsCell(),\n          validation: perm.validationCell(),\n          fields: perm.fieldsCell(),\n          presets: '',\n        };\n        this.baseRowsByTuple.set([roleId!, perm.collection, perm.action], newRow);\n        logger.info(\n          `added ${perm.roleName}/${perm.collection}/${perm.action} (id ${newRow.id})`,\n        );\n        added++;\n        merged++;\n        continue;\n      }\n\n      // The Cedar policies are the source of truth: overwrite the three\n      // derivable columns directly (the round-trip is meaning-preserving, so\n      // this only reshapes representation, e.g. `{_and:[x]}` -> `x`).\n      row.permissions = perm.permissionsCell();\n      row.validation = perm.validationCell();\n      row.fields = perm.fieldsCell();\n      updated++;\n      merged++;\n    }\n\n    // Every row is written to authorize.cedar by d9-to-cedar, so a row no longer\n    // produced by the Cedar files has been removed from them.\n    for (const row of this.baseRowsByTuple.values()) {\n      const tuple = [row.role, row.collection, row.action];\n      if (seen.get(tuple)) continue;\n      this.baseRowsByTuple.delete(tuple);\n      const roleName = row.role ? this.roles.getNameFromId(row.role) : 'Public';\n      logger.info(`removed ${roleName}/${row.collection}/${row.action} (id ${row.id})`);\n      removed++;\n    }\n\n    logger.info(\n      `merged ${merged} permissions, ${updated} row(s) updated, ${added} new row(s) added, ${removed} row(s) removed`,\n    );\n  }\n\n  public async writeOutput() {\n    await writeCsvFile(\n      this.outputPath,\n      this.header,\n      this.baseRowsByTuple.values(),\n    );\n    logger.info(`wrote ${this.outputPath}`);\n  }\n\n  public async readCedarAndWriteCsv() {\n    logger.info('reading base permission file');\n    await this.readBasePermissionFile();\n    logger.info(`found ${this.baseRowsByTuple.values().length} base permissions`);\n    logger.info('reading role file');\n    await this.readRoleFile();\n    logger.info('parsing cedar policy folders');\n    await this.parseAllFolders();\n    logger.info(\n      `reconstructed ${this.reconstructed.length} permissions from cedar`,\n    );\n    logger.info('merging into base rows');\n    this.mergeIntoRows();\n    logger.info('writing csv');\n    await this.writeOutput();\n    logger.info('done');\n  }\n\n}\n\n/** CLI action: merge Cedar policies back into directus_permissions.csv. */\nexport async function cedarToD9(options?: {\n  permissionPath?: string;\n  sqlPath?: string;\n  outputPath?: string;\n}): Promise<void> {\n  const manager = new CedarToD9Manager(options);\n  await manager.readCedarAndWriteCsv();\n}\n"]}

package/lib/cli/commands/cedar/cedar-translations.d.ts

@@ -0,0 +1,9 @@
+import type { PolicyJson } from '@cedar-policy/cedar-wasm/nodejs';
+import { D9Permission, Filter } from './d9-permission';
+export type ConditionSubject = 'resource' | 'context.newValue';
+export declare function addWhenClauses(filter: Filter, subject?: ConditionSubject): any;
+export declare function translateToCedar(permission: D9Permission): {
+    mainPolicy: PolicyJson;
+    fieldPolicy?: PolicyJson;
+    validationPolicy?: PolicyJson;
+};