@wbce/projen-d9 0.0.27 → 0.1.0

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

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addWhenClauses = addWhenClauses;
+exports.translateToCedar = translateToCedar;
+/** Local stand-in for lodash's `isPlainObject`, which this package does not depend on. */
+function isPlainObject(value) {
+    if (Object.prototype.toString.call(value) !== '[object Object]')
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === null || proto === Object.prototype;
+}
+function getOperation(key, value) {
+    if (key.startsWith('_') && !['_and', '_or', '_none', '_some'].includes(key)) {
+        return { operator: key, value };
+    }
+    else if (isPlainObject(value) === false) {
+        return { operator: '_eq', value };
+    }
+    return getOperation(Object.keys(value)[0], Object.values(value)[0]);
+}
+function getFilterPath(key, value) {
+    const path = [key];
+    const childKey = Object.keys(value)[0];
+    if (typeof childKey === 'string' &&
+        childKey.startsWith('_') === true &&
+        !['_none', '_some'].includes(childKey)) {
+        return path;
+    }
+    if (isPlainObject(value)) {
+        path.push(...getFilterPath(childKey, Object.values(value)[0]));
+    }
+    return path;
+}
+function addWhenClauses(filter, subject = 'resource') {
+    const entries = Object.entries(filter);
+    if (!entries.length)
+        return;
+    const key = entries[0][0];
+    const value = entries[0][1];
+    if (key === '_or' || key === '_and') {
+        if (key === '_or' &&
+            value.some((subFilter) => Object.keys(subFilter).length === 0)) {
+            return;
+        }
+        const left = value[0];
+        const rightVal = value[1];
+        const operator = key === '_or' ? '||' : '&&';
+        if (rightVal) {
+            return {
+                [operator]: {
+                    left: addWhenClauses(left, subject),
+                    right: addWhenClauses({ [key]: value.slice(1) }, subject),
+                },
+            };
+        }
+        else {
+            return addWhenClauses(left, subject);
+        }
+    }
+    const filterPath = getFilterPath(key, value);
+    const { operator: filterOperator, value: filterValue } = getOperation(key, value);
+    if (entries.length > 1) {
+        delete filter[key];
+        return {
+            '&&': {
+                left: applyFilterToQuery(filterPath, filterOperator, filterValue, subject),
+                right: addWhenClauses(filter, subject),
+            },
+        };
+    }
+    else {
+        return applyFilterToQuery(filterPath, filterOperator, filterValue, subject);
+    }
+    function applyFilterToQuery(path, operator, compareValue, subjectVar = 'resource') {
+        function buildLeft(pathSegments, subj) {
+            let node = subj === 'context.newValue'
+                ? { '.': { left: { Var: 'context' }, attr: 'newValue' } }
+                : { Var: 'resource' };
+            for (const attr of pathSegments) {
+                node = { '.': { left: node, attr } };
+            }
+            return node;
+        }
+        const buildRight = (v) => v === '$CURRENT_USER' ? { Var: 'principal' } : { Value: v };
+        const left = buildLeft(path, subjectVar);
+        const right = buildRight(compareValue);
+        let expr = null;
+        const baseForParent = path.length <= 1
+            ? subjectVar === 'context.newValue'
+                ? { '.': { left: { Var: 'context' }, attr: 'newValue' } }
+                : { Var: 'resource' }
+            : buildLeft(path.slice(0, -1), subjectVar);
+        if (operator === '_null' ||
+            (operator === '_nnull' && compareValue === false)) {
+            expr = {
+                '!': {
+                    arg: { has: { left: baseForParent, attr: path[path.length - 1] } },
+                },
+            };
+        }
+        if (operator === '_nnull' ||
+            (operator === '_null' && compareValue === false)) {
+            expr = { has: { left: baseForParent, attr: path[path.length - 1] } };
+        }
+        if (compareValue !== undefined && expr === null) {
+            if (operator === '_eq')
+                expr = { '==': { left, right } };
+            if (operator === '_neq')
+                expr = { '!=': { left, right } };
+            if (operator === '_gt')
+                expr = { '>': { left, right } };
+            if (operator === '_gte')
+                expr = { '>=': { left, right } };
+            if (operator === '_lt')
+                expr = { '<': { left, right } };
+            if (operator === '_lte')
+                expr = { '<=': { left, right } };
+            if (operator === '_icontains') {
+                // Cedar has no case-insensitive matching. Normalize the stored data and use
+                // _contains — https://docs.cedarpolicy.com/bestpractices/bp-normalize-data-input.html
+                throw new Error('_icontains is not supported in Cedar policies: normalize the data (e.g. lowercase) and use _contains instead');
+            }
+            if (operator === '_contains') {
+                expr = {
+                    like: {
+                        left,
+                        pattern: ['Wildcard', { Literal: compareValue }, 'Wildcard'],
+                    },
+                };
+            }
+            if (operator === '_starts_with') {
+                expr = { like: { left, pattern: [{ Literal: compareValue }, 'Wildcard'] } };
+            }
+            if (operator === '_ends_with') {
+                expr = { like: { left, pattern: ['Wildcard', { Literal: compareValue }] } };
+            }
+        }
+        if (expr === null)
+            return;
+        return expr;
+    }
+}
+function translateToCedar(permission) {
+    const principalConstraint = {
+        op: 'in',
+        entity: {
+            type: 'd9::UserGroup',
+            id: permission.roleName,
+        },
+    };
+    const action = {
+        op: '==',
+        entity: {
+            type: `Db::${permission.collection}::Action`,
+            id: permission.action,
+        },
+    };
+    const mainConditionBody = addWhenClauses(permission.permissions || {});
+    const mainConditions = mainConditionBody
+        ? [{ kind: 'when', body: mainConditionBody }]
+        : [];
+    const mainPolicy = {
+        effect: 'permit',
+        principal: principalConstraint,
+        action: action,
+        resource: { op: 'All' },
+        conditions: mainConditions,
+    };
+    // Field-level policy only when there is a fields restriction and/or validation
+    const fields = permission.fields ?? [];
+    const hasFields = fields.length > 0;
+    const hasValidationCond = permission.validation && Object.entries(permission.validation).length > 0;
+    let fieldPolicy;
+    let validationPolicy;
+    if (hasFields) {
+        const fieldConditions = [];
+        fieldConditions.push({
+            kind: 'when',
+            body: {
+                containsAll: {
+                    left: { Value: fields },
+                    right: {
+                        '.': {
+                            left: { Var: 'context' },
+                            attr: 'requestedFields',
+                        },
+                    },
+                },
+            },
+        });
+        fieldPolicy = {
+            effect: 'permit',
+            principal: principalConstraint,
+            action: action,
+            resource: { op: 'All' },
+            conditions: fieldConditions,
+        };
+    }
+    if (hasValidationCond) {
+        const validationConditions = [];
+        const validationBody = addWhenClauses(permission.validation || {}, 'context.newValue');
+        validationConditions.push({ kind: 'when', body: validationBody });
+        validationPolicy = {
+            effect: 'permit',
+            principal: principalConstraint,
+            action: action,
+            resource: { op: 'All' },
+            conditions: validationConditions,
+        };
+    }
+    return { mainPolicy, fieldPolicy, validationPolicy };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cedar-translations.js","sourceRoot":"","sources":["../../../../src/cli/commands/cedar/cedar-translations.ts"],"names":[],"mappings":"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","sourcesContent":["import type { PolicyJson } from '@cedar-policy/cedar-wasm/nodejs';\nimport { D9Permission, Filter } from './d9-permission';\n\n/** Local stand-in for lodash's `isPlainObject`, which this package does not depend on. */\nfunction isPlainObject(value: any): boolean {\n  if (Object.prototype.toString.call(value) !== '[object Object]') return false;\n  const proto = Object.getPrototypeOf(value);\n  return proto === null || proto === Object.prototype;\n}\n\nfunction getOperation(\n  key: string,\n  value: Record<string, any>,\n): { operator: string; value: any } {\n  if (key.startsWith('_') && !['_and', '_or', '_none', '_some'].includes(key)) {\n    return { operator: key as string, value };\n  } else if (isPlainObject(value) === false) {\n    return { operator: '_eq', value };\n  }\n\n  return getOperation(Object.keys(value)[0]!, Object.values(value)[0]);\n}\n\nfunction getFilterPath(key: string, value: Record<string, any>) {\n  const path = [key];\n  const childKey = Object.keys(value)[0]!;\n\n  if (\n    typeof childKey === 'string' &&\n    childKey.startsWith('_') === true &&\n    !['_none', '_some'].includes(childKey)\n  ) {\n    return path;\n  }\n\n  if (isPlainObject(value)) {\n    path.push(...getFilterPath(childKey, Object.values(value)[0]));\n  }\n\n  return path;\n}\n\nexport type ConditionSubject = 'resource' | 'context.newValue';\n\nexport function addWhenClauses(\n  filter: Filter,\n  subject: ConditionSubject = 'resource',\n): any {\n  const entries = Object.entries(filter);\n  if (!entries.length) return;\n  const key = entries[0][0];\n  const value = entries[0][1];\n\n  if (key === '_or' || key === '_and') {\n    if (\n      key === '_or' &&\n      value.some(\n        (subFilter: Record<string, any>) => Object.keys(subFilter).length === 0,\n      )\n    ) {\n      return;\n    }\n    const left = value[0];\n    const rightVal = value[1];\n    const operator = key === '_or' ? '||' : '&&';\n    if (rightVal) {\n      return {\n        [operator]: {\n          left: addWhenClauses(left, subject),\n          right: addWhenClauses({ [key]: value.slice(1) }, subject),\n        },\n      };\n    } else {\n      return addWhenClauses(left, subject);\n    }\n  }\n\n  const filterPath = getFilterPath(key, value);\n  const { operator: filterOperator, value: filterValue } = getOperation(\n    key,\n    value,\n  );\n\n  if (entries.length > 1) {\n    delete filter[key];\n    return {\n      '&&': {\n        left: applyFilterToQuery(filterPath, filterOperator, filterValue, subject),\n        right: addWhenClauses(filter, subject),\n      },\n    };\n  } else {\n    return applyFilterToQuery(filterPath, filterOperator, filterValue, subject);\n  }\n\n  function applyFilterToQuery(\n    path: string[],\n    operator: string,\n    compareValue: any,\n    subjectVar: ConditionSubject = 'resource',\n  ) {\n    function buildLeft(pathSegments: string[], subj: ConditionSubject): any {\n      let node: any =\n        subj === 'context.newValue'\n          ? { '.': { left: { Var: 'context' as const }, attr: 'newValue' } }\n          : { Var: 'resource' as const };\n      for (const attr of pathSegments) {\n        node = { '.': { left: node, attr } };\n      }\n      return node;\n    }\n\n    const buildRight = (v: any) =>\n      v === '$CURRENT_USER' ? { Var: 'principal' as const } : { Value: v };\n\n    const left = buildLeft(path, subjectVar);\n    const right = buildRight(compareValue);\n\n    let expr: any = null;\n\n    const baseForParent =\n      path.length <= 1\n        ? subjectVar === 'context.newValue'\n          ? { '.': { left: { Var: 'context' as const }, attr: 'newValue' } }\n          : { Var: 'resource' as const }\n        : buildLeft(path.slice(0, -1), subjectVar);\n\n    if (\n      operator === '_null' ||\n      (operator === '_nnull' && compareValue === false)\n    ) {\n      expr = {\n        '!': {\n          arg: { has: { left: baseForParent, attr: path[path.length - 1]! } },\n        },\n      };\n    }\n    if (\n      operator === '_nnull' ||\n      (operator === '_null' && compareValue === false)\n    ) {\n      expr = { has: { left: baseForParent, attr: path[path.length - 1]! } };\n    }\n\n    if (compareValue !== undefined && expr === null) {\n      if (operator === '_eq') expr = { '==': { left, right } };\n      if (operator === '_neq') expr = { '!=': { left, right } };\n      if (operator === '_gt') expr = { '>': { left, right } };\n      if (operator === '_gte') expr = { '>=': { left, right } };\n      if (operator === '_lt') expr = { '<': { left, right } };\n      if (operator === '_lte') expr = { '<=': { left, right } };\n      if (operator === '_icontains') {\n        // Cedar has no case-insensitive matching. Normalize the stored data and use\n        // _contains — https://docs.cedarpolicy.com/bestpractices/bp-normalize-data-input.html\n        throw new Error(\n          '_icontains is not supported in Cedar policies: normalize the data (e.g. lowercase) and use _contains instead',\n        );\n      }\n      if (operator === '_contains') {\n        expr = {\n          like: {\n            left,\n            pattern: ['Wildcard', { Literal: compareValue }, 'Wildcard'],\n          },\n        };\n      }\n      if (operator === '_starts_with') {\n        expr = { like: { left, pattern: [{ Literal: compareValue }, 'Wildcard'] } };\n      }\n      if (operator === '_ends_with') {\n        expr = { like: { left, pattern: ['Wildcard', { Literal: compareValue }] } };\n      }\n    }\n\n    if (expr === null) return;\n    return expr;\n  }\n}\n\nexport function translateToCedar(permission: D9Permission): {\n  mainPolicy: PolicyJson;\n  fieldPolicy?: PolicyJson;\n  validationPolicy?: PolicyJson;\n} {\n  const principalConstraint = {\n    op: 'in',\n    entity: {\n      type: 'd9::UserGroup',\n      id: permission.roleName,\n    },\n  };\n\n  const action = {\n    op: '==',\n    entity: {\n      type: `Db::${permission.collection}::Action`,\n      id: permission.action,\n    },\n  };\n\n  const mainConditionBody = addWhenClauses(permission.permissions || {});\n\n  const mainConditions = mainConditionBody\n    ? [{ kind: 'when' as const, body: mainConditionBody }]\n    : [];\n\n  const mainPolicy: PolicyJson = {\n    effect: 'permit',\n    principal: principalConstraint as any,\n    action: action as any,\n    resource: { op: 'All' },\n    conditions: mainConditions as any,\n  };\n\n  // Field-level policy only when there is a fields restriction and/or validation\n  const fields = permission.fields ?? [];\n  const hasFields = fields.length > 0;\n  const hasValidationCond =\n    permission.validation && Object.entries(permission.validation).length > 0;\n\n  let fieldPolicy: PolicyJson | undefined;\n  let validationPolicy: PolicyJson | undefined;\n  if (hasFields) {\n    const fieldConditions: Array<{ kind: 'when'; body: any }> = [];\n\n    fieldConditions.push({\n      kind: 'when',\n      body: {\n        containsAll: {\n          left: { Value: fields },\n          right: {\n            '.': {\n              left: { Var: 'context' },\n              attr: 'requestedFields',\n            },\n          },\n        },\n      },\n    });\n    fieldPolicy = {\n      effect: 'permit',\n      principal: principalConstraint as any,\n      action: action as any,\n      resource: { op: 'All' },\n      conditions: fieldConditions,\n    };\n  }\n\n  if (hasValidationCond) {\n    const validationConditions: Array<{ kind: 'when'; body: any }> = [];\n\n    const validationBody = addWhenClauses(\n      permission.validation || {},\n      'context.newValue',\n    );\n    validationConditions.push({ kind: 'when', body: validationBody });\n\n    validationPolicy = {\n      effect: 'permit',\n      principal: principalConstraint as any,\n      action: action as any,\n      resource: { op: 'All' },\n      conditions: validationConditions as any,\n    };\n  }\n\n  return { mainPolicy, fieldPolicy, validationPolicy };\n}\n"]}

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

@@ -0,0 +1,27 @@
+/** The `Filter` type of `@wbce-d9/types`, inlined so the CLI does not depend on it. */
+export type Filter = Record<string, any>;
+/**
+ * A d9 permission, shared by both translation directions:
+ *  - forward (d9-to-cedar): `new D9Permission(row)` parses a CSV row;
+ *  - reverse (cedar-to-d9): `D9Permission.empty(...)` starts a blank permission that
+ *    is filled as each `.cedar` file is parsed, then rendered back via `*Cell()`.
+ * `id`/`role`/`presets` are CSV-only columns, populated only on the forward side.
+ */
+export declare class D9Permission {
+    /** Blank permission to accumulate reconstructed Cedar clauses onto (reverse direction). */
+    static empty(roleName: string, collection: string, action: string): D9Permission;
+    roleName: string;
+    collection: string;
+    action: string;
+    permissions?: Filter;
+    validation?: Filter;
+    fields?: string[];
+    id?: number;
+    role?: string;
+    presets?: Record<string, any>;
+    /** Parse a `directus_permissions.csv` row. `roleName` is resolved separately from the role UUID. */
+    constructor(row: Record<string, string>);
+    permissionsCell(): string;
+    validationCell(): string;
+    fieldsCell(): string;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.D9Permission = void 0;
+function parseStringFieldToJSON(field) {
+    return field?.length ? JSON.parse(field) : undefined;
+}
+/**
+ * A d9 permission, shared by both translation directions:
+ *  - forward (d9-to-cedar): `new D9Permission(row)` parses a CSV row;
+ *  - reverse (cedar-to-d9): `D9Permission.empty(...)` starts a blank permission that
+ *    is filled as each `.cedar` file is parsed, then rendered back via `*Cell()`.
+ * `id`/`role`/`presets` are CSV-only columns, populated only on the forward side.
+ */
+class D9Permission {
+    /** Blank permission to accumulate reconstructed Cedar clauses onto (reverse direction). */
+    static empty(roleName, collection, action) {
+        const perm = Object.create(D9Permission.prototype);
+        perm.roleName = roleName;
+        perm.collection = collection;
+        perm.action = action;
+        return perm;
+    }
+    /** Parse a `directus_permissions.csv` row. `roleName` is resolved separately from the role UUID. */
+    constructor(row) {
+        this.collection = row.collection;
+        this.action = row.action;
+        this.id = Number(row.id);
+        this.role = row.role;
+        this.permissions = parseStringFieldToJSON(row.permissions);
+        this.validation = parseStringFieldToJSON(row.validation);
+        this.fields = row.fields?.split(',') || [];
+        this.presets = parseStringFieldToJSON(row.presets);
+    }
+    permissionsCell() {
+        return JSON.stringify(this.permissions ?? {});
+    }
+    validationCell() {
+        return JSON.stringify(this.validation ?? {});
+    }
+    fieldsCell() {
+        return this.fields ? this.fields.join(',') : '*';
+    }
+}
+exports.D9Permission = D9Permission;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,33 @@
+import type { PolicyJson } from '@cedar-policy/cedar-wasm/nodejs';
+import { D9Permission } from './d9-permission';
+import { RolesTable } from './roles-table';
+export declare class CedarManager {
+    permissionPath: string;
+    sqlPath: string;
+    fieldsPolicies: Map<string, PolicyJson[]>;
+    mainPolicies: Map<string, PolicyJson[]>;
+    validationPolicies: Map<string, PolicyJson[]>;
+    roles: RolesTable;
+    d9Permissions: D9Permission[];
+    constructor(opts?: {
+        permissionPath?: string;
+        sqlPath?: string;
+    });
+    readPermissionFile(): Promise<void>;
+    readRoleFile(): Promise<void>;
+    refactoPolicies(policyKey: 'mainPolicies' | 'fieldsPolicies' | 'validationPolicies'): void;
+    sortPolicies(policyKey: 'mainPolicies' | 'fieldsPolicies' | 'validationPolicies'): void;
+    translateAndSortPermission(): Promise<void>;
+    writePoliciesToFile(roleName: string, fileTitle: string, policies: PolicyJson[]): Promise<void>;
+    writePolicies(policyKey: 'mainPolicies' | 'fieldsPolicies' | 'validationPolicies', fileName: string): Promise<void>;
+    readCsvAndWriteAllFiles(): Promise<void>;
+}
+/**
+ * CLI action: regenerate the Cedar policy folders from directus_permissions.csv.
+ * The folder is wiped first, reproducing what `formatePermission` does in app-api2,
+ * so a role removed from the CSV leaves no orphan files.
+ */
+export declare function d9ToCedar(options?: {
+    permissionPath?: string;
+    sqlPath?: string;
+}): Promise<void>;

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

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CedarManager = void 0;
+exports.d9ToCedar = d9ToCedar;
+const promises_1 = require("fs/promises");
+const cedar = require("@cedar-policy/cedar-wasm/nodejs");
+const cedar_format_1 = require("./cedar-format");
+const cedar_translations_1 = require("./cedar-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");
+class CedarManager {
+    constructor(opts) {
+        this.fieldsPolicies = new Map();
+        this.mainPolicies = new Map();
+        this.validationPolicies = new Map();
+        this.d9Permissions = [];
+        this.permissionPath = opts?.permissionPath || './permissions';
+        this.sqlPath = opts?.sqlPath || './sql/data';
+    }
+    async readPermissionFile() {
+        const permissions = await (0, utils_1.readCsvFile)(`${this.sqlPath}/directus_permissions.csv`);
+        this.d9Permissions = permissions.map((p) => new d9_permission_1.D9Permission(p));
+    }
+    async readRoleFile() {
+        this.roles = await roles_table_1.RolesTable.load(this.sqlPath);
+        for (const permission of this.d9Permissions) {
+            permission.roleName = permission.role
+                ? this.roles.getNameFromId(permission.role)
+                : 'Public';
+        }
+    }
+    refactoPolicies(policyKey) {
+        for (const [groupName, policies] of this[policyKey]) {
+            const groupedPolicies = new Map();
+            for (const policy of policies) {
+                const conditionsKey = JSON.stringify(policy.conditions.map((c) => c.body));
+                if (!groupedPolicies.has(conditionsKey)) {
+                    groupedPolicies.set(conditionsKey, []);
+                }
+                groupedPolicies.get(conditionsKey).push(policy);
+            }
+            // Combine policies in each group
+            const refactored = [];
+            for (const group of groupedPolicies.values()) {
+                if (group.length === 1) {
+                    // No optimization needed for single policy
+                    refactored.push(group[0]);
+                }
+                else {
+                    // Multiple policies with same conditions - combine actions
+                    const actions = group
+                        .map((p) => p.action.entity)
+                        .sort((a, b) => `${a.id}${a.type}`.localeCompare(`${b.id}${b.type}`));
+                    // Create combined policy with "action in [...]"
+                    const combinedPolicy = {
+                        effect: group[0].effect,
+                        principal: group[0].principal,
+                        action: {
+                            op: 'in',
+                            entities: actions,
+                        },
+                        resource: group[0].resource,
+                        conditions: group[0].conditions,
+                    };
+                    refactored.push(combinedPolicy);
+                }
+            }
+            this[policyKey].set(groupName, refactored);
+        }
+    }
+    sortPolicies(policyKey) {
+        for (const [groupName, policies] of this[policyKey]) {
+            this[policyKey].set(groupName, policies.sort((p1, p2) => {
+                const a1 = p1.action;
+                const a2 = p2.action;
+                const t1 = (a1.entities?.[0] || a1.entity).type;
+                const t2 = (a2.entities?.[0] || a2.entity).type;
+                return t1.localeCompare(t2);
+            }));
+        }
+    }
+    async translateAndSortPermission() {
+        for (const permission of this.d9Permissions) {
+            const cedarPolicies = await (0, cedar_translations_1.translateToCedar)(permission);
+            const mainPolicies = this.mainPolicies.get(permission.roleName) || [];
+            this.mainPolicies.set(permission.roleName, [
+                ...mainPolicies,
+                cedarPolicies.mainPolicy,
+            ]);
+            if (cedarPolicies.fieldPolicy) {
+                const fieldPolicies = this.fieldsPolicies.get(permission.roleName) || [];
+                this.fieldsPolicies.set(permission.roleName, [
+                    ...fieldPolicies,
+                    cedarPolicies.fieldPolicy,
+                ]);
+            }
+            if (cedarPolicies.validationPolicy) {
+                const validationPolicies = this.validationPolicies.get(permission.roleName) || [];
+                this.validationPolicies.set(permission.roleName, [
+                    ...validationPolicies,
+                    cedarPolicies.validationPolicy,
+                ]);
+            }
+        }
+        const policyKeys = ['mainPolicies', 'fieldsPolicies', 'validationPolicies'];
+        for (const pKey of policyKeys) {
+            this.refactoPolicies(pKey);
+            this.sortPolicies(pKey);
+        }
+    }
+    async writePoliciesToFile(roleName, fileTitle, policies) {
+        await (0, promises_1.mkdir)(`${this.permissionPath}/${roleName}`, { recursive: true });
+        const policiesText = policies.map(cedar_format_1.policyToCedarText).join('\n\n') + '\n';
+        // Our own condition layout must still be valid Cedar.
+        const parsed = cedar.policySetTextToParts(policiesText);
+        if (parsed.type === 'failure') {
+            logger_1.logger.error({ policiesText }, 'generated policies are not valid Cedar');
+            throw new Error(parsed.errors);
+        }
+        await (0, promises_1.writeFile)(`${this.permissionPath}/${roleName}/${fileTitle}`, policiesText);
+    }
+    async writePolicies(policyKey, fileName) {
+        for (const [group, policies] of this[policyKey]) {
+            await this.writePoliciesToFile(group, fileName, policies);
+        }
+    }
+    async readCsvAndWriteAllFiles() {
+        logger_1.logger.info('read permission file');
+        await this.readPermissionFile();
+        logger_1.logger.info(`found ${this.d9Permissions.length} permissions`);
+        logger_1.logger.info('read role file');
+        await this.readRoleFile();
+        logger_1.logger.info('roles imported');
+        logger_1.logger.info('grouping and sorting permissions');
+        await this.translateAndSortPermission();
+        logger_1.logger.info(`having ${this.mainPolicies.size} main policies and ${this.fieldsPolicies.size} fields policies`);
+        logger_1.logger.info('writing cedar policies files');
+        await this.writePolicies('mainPolicies', 'authorize.cedar');
+        await this.writePolicies('fieldsPolicies', 'check-fields.cedar');
+        await this.writePolicies('validationPolicies', 'validate.cedar');
+        logger_1.logger.info('files wroten');
+    }
+}
+exports.CedarManager = CedarManager;
+/**
+ * CLI action: regenerate the Cedar policy folders from directus_permissions.csv.
+ * The folder is wiped first, reproducing what `formatePermission` does in app-api2,
+ * so a role removed from the CSV leaves no orphan files.
+ */
+async function d9ToCedar(options) {
+    const manager = new CedarManager(options);
+    await (0, promises_1.rm)(manager.permissionPath, { recursive: true, force: true });
+    await manager.readCsvAndWriteAllFiles();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"d9-to-cedar.js","sourceRoot":"","sources":["../../../../src/cli/commands/cedar/d9-to-cedar.ts"],"names":[],"mappings":"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","sourcesContent":["import { mkdir, rm, writeFile } from 'fs/promises';\nimport * as cedar from '@cedar-policy/cedar-wasm/nodejs';\nimport type { PolicyJson } from '@cedar-policy/cedar-wasm/nodejs';\nimport { policyToCedarText } from './cedar-format';\nimport { translateToCedar } from './cedar-translations';\nimport { D9Permission } from './d9-permission';\nimport { RolesTable } from './roles-table';\nimport { logger } from '../../logger';\nimport { readCsvFile } from '../save/utils';\n\nexport class CedarManager {\n  public permissionPath: string;\n  public sqlPath: string;\n\n  public fieldsPolicies: Map<string, PolicyJson[]> = new Map();\n  public mainPolicies: Map<string, PolicyJson[]> = new Map();\n  public validationPolicies: Map<string, PolicyJson[]> = new Map();\n\n  public roles!: RolesTable;\n  public d9Permissions: D9Permission[] = [];\n\n  constructor(opts?: { permissionPath?: string; sqlPath?: string }) {\n    this.permissionPath = opts?.permissionPath || './permissions';\n    this.sqlPath = opts?.sqlPath || './sql/data';\n  }\n\n  public async readPermissionFile() {\n    const permissions = await readCsvFile(\n      `${this.sqlPath}/directus_permissions.csv`,\n    );\n    this.d9Permissions = permissions.map((p) => new D9Permission(p));\n  }\n\n  public async readRoleFile() {\n    this.roles = await RolesTable.load(this.sqlPath);\n    for (const permission of this.d9Permissions) {\n      permission.roleName = permission.role\n        ? this.roles.getNameFromId(permission.role)!\n        : 'Public';\n    }\n  }\n\n  public refactoPolicies(\n    policyKey: 'mainPolicies' | 'fieldsPolicies' | 'validationPolicies',\n  ) {\n    for (const [groupName, policies] of this[policyKey]) {\n      const groupedPolicies = new Map<string, any[]>();\n      for (const policy of policies) {\n        const conditionsKey = JSON.stringify(policy.conditions.map((c) => c.body));\n        if (!groupedPolicies.has(conditionsKey)) {\n          groupedPolicies.set(conditionsKey, []);\n        }\n        groupedPolicies.get(conditionsKey)!.push(policy);\n      }\n      // Combine policies in each group\n      const refactored: any[] = [];\n\n      for (const group of groupedPolicies.values()) {\n        if (group.length === 1) {\n          // No optimization needed for single policy\n          refactored.push(group[0]);\n        } else {\n          // Multiple policies with same conditions - combine actions\n          const actions = group\n            .map((p) => p.action.entity)\n            .sort((a, b) => `${a.id}${a.type}`.localeCompare(`${b.id}${b.type}`));\n\n          // Create combined policy with \"action in [...]\"\n          const combinedPolicy = {\n            effect: group[0].effect,\n            principal: group[0].principal,\n            action: {\n              op: 'in',\n              entities: actions,\n            },\n            resource: group[0].resource,\n            conditions: group[0].conditions,\n          };\n          refactored.push(combinedPolicy);\n        }\n      }\n      this[policyKey].set(groupName, refactored);\n    }\n  }\n\n  public sortPolicies(\n    policyKey: 'mainPolicies' | 'fieldsPolicies' | 'validationPolicies',\n  ) {\n    for (const [groupName, policies] of this[policyKey]) {\n      this[policyKey].set(\n        groupName,\n        policies.sort((p1, p2) => {\n          const a1 = p1.action as any;\n          const a2 = p2.action as any;\n          const t1 = (a1.entities?.[0] || a1.entity).type;\n          const t2 = (a2.entities?.[0] || a2.entity).type;\n          return t1.localeCompare(t2);\n        }),\n      );\n    }\n  }\n\n  public async translateAndSortPermission() {\n    for (const permission of this.d9Permissions) {\n      const cedarPolicies = await translateToCedar(permission);\n      const mainPolicies = this.mainPolicies.get(permission.roleName) || [];\n      this.mainPolicies.set(permission.roleName, [\n        ...mainPolicies,\n        cedarPolicies.mainPolicy,\n      ]);\n      if (cedarPolicies.fieldPolicy) {\n        const fieldPolicies = this.fieldsPolicies.get(permission.roleName) || [];\n        this.fieldsPolicies.set(permission.roleName, [\n          ...fieldPolicies,\n          cedarPolicies.fieldPolicy,\n        ]);\n      }\n      if (cedarPolicies.validationPolicy) {\n        const validationPolicies =\n          this.validationPolicies.get(permission.roleName) || [];\n        this.validationPolicies.set(permission.roleName, [\n          ...validationPolicies,\n          cedarPolicies.validationPolicy,\n        ]);\n      }\n    }\n    const policyKeys: (\n      | 'mainPolicies'\n      | 'fieldsPolicies'\n      | 'validationPolicies'\n    )[] = ['mainPolicies', 'fieldsPolicies', 'validationPolicies'];\n    for (const pKey of policyKeys) {\n      this.refactoPolicies(pKey);\n      this.sortPolicies(pKey);\n    }\n  }\n\n  public async writePoliciesToFile(\n    roleName: string,\n    fileTitle: string,\n    policies: PolicyJson[],\n  ) {\n    await mkdir(`${this.permissionPath}/${roleName}`, { recursive: true });\n    const policiesText = policies.map(policyToCedarText).join('\\n\\n') + '\\n';\n    // Our own condition layout must still be valid Cedar.\n    const parsed = cedar.policySetTextToParts(policiesText);\n    if (parsed.type === 'failure') {\n      logger.error({ policiesText }, 'generated policies are not valid Cedar');\n      throw new Error(parsed.errors as any);\n    }\n    await writeFile(\n      `${this.permissionPath}/${roleName}/${fileTitle}`,\n      policiesText,\n    );\n  }\n\n  public async writePolicies(\n    policyKey: 'mainPolicies' | 'fieldsPolicies' | 'validationPolicies',\n    fileName: string,\n  ) {\n    for (const [group, policies] of this[policyKey]) {\n      await this.writePoliciesToFile(group, fileName, policies);\n    }\n  }\n\n  public async readCsvAndWriteAllFiles() {\n    logger.info('read permission file');\n    await this.readPermissionFile();\n    logger.info(`found ${this.d9Permissions.length} permissions`);\n    logger.info('read role file');\n    await this.readRoleFile();\n    logger.info('roles imported');\n    logger.info('grouping and sorting permissions');\n    await this.translateAndSortPermission();\n    logger.info(\n      `having ${this.mainPolicies.size} main policies and ${this.fieldsPolicies.size} fields policies`,\n    );\n    logger.info('writing cedar policies files');\n    await this.writePolicies('mainPolicies', 'authorize.cedar');\n    await this.writePolicies('fieldsPolicies', 'check-fields.cedar');\n    await this.writePolicies('validationPolicies', 'validate.cedar');\n    logger.info('files wroten');\n  }\n}\n\n/**\n * CLI action: regenerate the Cedar policy folders from directus_permissions.csv.\n * The folder is wiped first, reproducing what `formatePermission` does in app-api2,\n * so a role removed from the CSV leaves no orphan files.\n */\nexport async function d9ToCedar(options?: {\n  permissionPath?: string;\n  sqlPath?: string;\n}): Promise<void> {\n  const manager = new CedarManager(options);\n  await rm(manager.permissionPath, { recursive: true, force: true });\n  await manager.readCsvAndWriteAllFiles();\n}\n"]}

package/lib/cli/commands/cedar/roles-table.d.ts

@@ -0,0 +1,14 @@
+interface Role {
+    id: string;
+    name: string;
+}
+/** Lookup over `directus_roles.csv`, shared by the d9<->cedar managers. */
+export declare class RolesTable {
+    static load(sqlPath: string): Promise<RolesTable>;
+    byId: Map<string, Role>;
+    byName: Map<string, Role>;
+    getNameFromId(id: string): string | undefined;
+    /** Role UUID for a role name; `''` for the implicit `Public` role. */
+    getIdFromName(roleName: string): string | undefined;
+}
+export {};

package/lib/cli/commands/cedar/roles-table.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RolesTable = void 0;
+const utils_1 = require("../save/utils");
+/** Lookup over `directus_roles.csv`, shared by the d9<->cedar managers. */
+class RolesTable {
+    constructor() {
+        this.byId = new Map();
+        this.byName = new Map();
+    }
+    static async load(sqlPath) {
+        const table = new RolesTable();
+        const roles = (await (0, utils_1.readCsvFile)(`${sqlPath}/directus_roles.csv`));
+        for (const role of roles) {
+            table.byId.set(role.id, role);
+            table.byName.set(role.name, role);
+        }
+        return table;
+    }
+    getNameFromId(id) {
+        return this.byId.get(id)?.name;
+    }
+    /** Role UUID for a role name; `''` for the implicit `Public` role. */
+    getIdFromName(roleName) {
+        return roleName === 'Public' ? '' : this.byName.get(roleName)?.id;
+    }
+}
+exports.RolesTable = RolesTable;
+//# sourceMappingURL=data:application/json;base64,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