@wbce/projen-d9 0.0.28 → 0.1.1

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":"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","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;
+};

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":";;AA4CA,wCAqIC;AAED,4CAwFC;AAxQD,0FAA0F;AAC1F,SAAS,aAAa,CAAC,KAAU;IAC/B,IAAI,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,iBAAiB;QAAE,OAAO,KAAK,CAAC;IAC9E,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAC3C,OAAO,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,MAAM,CAAC,SAAS,CAAC;AACtD,CAAC;AAED,SAAS,YAAY,CACnB,GAAW,EACX,KAA0B;IAE1B,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QAC5E,OAAO,EAAE,QAAQ,EAAE,GAAa,EAAE,KAAK,EAAE,CAAC;IAC5C,CAAC;SAAM,IAAI,aAAa,CAAC,KAAK,CAAC,KAAK,KAAK,EAAE,CAAC;QAC1C,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;IACpC,CAAC;IAED,OAAO,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAE,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACvE,CAAC;AAED,SAAS,aAAa,CAAC,GAAW,EAAE,KAA0B;IAC5D,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;IACnB,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAE,CAAC;IAExC,IACE,OAAO,QAAQ,KAAK,QAAQ;QAC5B,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,IAAI;QACjC,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,EACtC,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,IAAI,CAAC,IAAI,CAAC,GAAG,aAAa,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACjE,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAID,SAAgB,cAAc,CAC5B,MAAc,EACd,UAA4B,UAAU;IAEtC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACvC,IAAI,CAAC,OAAO,CAAC,MAAM;QAAE,OAAO;IAC5B,MAAM,GAAG,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1B,MAAM,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAE5B,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,MAAM,EAAE,CAAC;QACpC,IACE,GAAG,KAAK,KAAK;YACb,KAAK,CAAC,IAAI,CACR,CAAC,SAA8B,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,KAAK,CAAC,CACxE,EACD,CAAC;YACD,OAAO;QACT,CAAC;QACD,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACtB,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QAC1B,MAAM,QAAQ,GAAG,GAAG,KAAK,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;QAC7C,IAAI,QAAQ,EAAE,CAAC;YACb,OAAO;gBACL,CAAC,QAAQ,CAAC,EAAE;oBACV,IAAI,EAAE,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC;oBACnC,KAAK,EAAE,cAAc,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,OAAO,CAAC;iBAC1D;aACF,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,OAAO,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QACvC,CAAC;IACH,CAAC;IAED,MAAM,UAAU,GAAG,aAAa,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAC7C,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,KAAK,EAAE,WAAW,EAAE,GAAG,YAAY,CACnE,GAAG,EACH,KAAK,CACN,CAAC;IAEF,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;QACnB,OAAO;YACL,IAAI,EAAE;gBACJ,IAAI,EAAE,kBAAkB,CAAC,UAAU,EAAE,cAAc,EAAE,WAAW,EAAE,OAAO,CAAC;gBAC1E,KAAK,EAAE,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC;aACvC;SACF,CAAC;IACJ,CAAC;SAAM,CAAC;QACN,OAAO,kBAAkB,CAAC,UAAU,EAAE,cAAc,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;IAC9E,CAAC;IAED,SAAS,kBAAkB,CACzB,IAAc,EACd,QAAgB,EAChB,YAAiB,EACjB,aAA+B,UAAU;QAEzC,SAAS,SAAS,CAAC,YAAsB,EAAE,IAAsB;YAC/D,IAAI,IAAI,GACN,IAAI,KAAK,kBAAkB;gBACzB,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,SAAkB,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE;gBAClE,CAAC,CAAC,EAAE,GAAG,EAAE,UAAmB,EAAE,CAAC;YACnC,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;gBAChC,IAAI,GAAG,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC;YACvC,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,UAAU,GAAG,CAAC,CAAM,EAAE,EAAE,CAC5B,CAAC,KAAK,eAAe,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,WAAoB,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;QAEvE,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QACzC,MAAM,KAAK,GAAG,UAAU,CAAC,YAAY,CAAC,CAAC;QAEvC,IAAI,IAAI,GAAQ,IAAI,CAAC;QAErB,MAAM,aAAa,GACjB,IAAI,CAAC,MAAM,IAAI,CAAC;YACd,CAAC,CAAC,UAAU,KAAK,kBAAkB;gBACjC,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,SAAkB,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE;gBAClE,CAAC,CAAC,EAAE,GAAG,EAAE,UAAmB,EAAE;YAChC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;QAE/C,IACE,QAAQ,KAAK,OAAO;YACpB,CAAC,QAAQ,KAAK,QAAQ,IAAI,YAAY,KAAK,KAAK,CAAC,EACjD,CAAC;YACD,IAAI,GAAG;gBACL,GAAG,EAAE;oBACH,GAAG,EAAE,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,EAAE,EAAE;iBACpE;aACF,CAAC;QACJ,CAAC;QACD,IACE,QAAQ,KAAK,QAAQ;YACrB,CAAC,QAAQ,KAAK,OAAO,IAAI,YAAY,KAAK,KAAK,CAAC,EAChD,CAAC;YACD,IAAI,GAAG,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,EAAE,EAAE,CAAC;QACxE,CAAC;QAED,IAAI,YAAY,KAAK,SAAS,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAChD,IAAI,QAAQ,KAAK,KAAK;gBAAE,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YACzD,IAAI,QAAQ,KAAK,MAAM;gBAAE,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YAC1D,IAAI,QAAQ,KAAK,KAAK;gBAAE,IAAI,GAAG,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YACxD,IAAI,QAAQ,KAAK,MAAM;gBAAE,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YAC1D,IAAI,QAAQ,KAAK,KAAK;gBAAE,IAAI,GAAG,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YACxD,IAAI,QAAQ,KAAK,MAAM;gBAAE,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YAC1D,IAAI,QAAQ,KAAK,YAAY,EAAE,CAAC;gBAC9B,4EAA4E;gBAC5E,sFAAsF;gBACtF,MAAM,IAAI,KAAK,CACb,8GAA8G,CAC/G,CAAC;YACJ,CAAC;YACD,IAAI,QAAQ,KAAK,WAAW,EAAE,CAAC;gBAC7B,IAAI,GAAG;oBACL,IAAI,EAAE;wBACJ,IAAI;wBACJ,OAAO,EAAE,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,UAAU,CAAC;qBAC7D;iBACF,CAAC;YACJ,CAAC;YACD,IAAI,QAAQ,KAAK,cAAc,EAAE,CAAC;gBAChC,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,UAAU,CAAC,EAAE,EAAE,CAAC;YAC9E,CAAC;YACD,IAAI,QAAQ,KAAK,YAAY,EAAE,CAAC;gBAC9B,IAAI,GAAG,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9E,CAAC;QACH,CAAC;QAED,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,SAAgB,gBAAgB,CAAC,UAAwB;IAKvD,MAAM,mBAAmB,GAAG;QAC1B,EAAE,EAAE,IAAI;QACR,MAAM,EAAE;YACN,IAAI,EAAE,eAAe;YACrB,EAAE,EAAE,UAAU,CAAC,QAAQ;SACxB;KACF,CAAC;IAEF,MAAM,MAAM,GAAG;QACb,EAAE,EAAE,IAAI;QACR,MAAM,EAAE;YACN,IAAI,EAAE,OAAO,UAAU,CAAC,UAAU,UAAU;YAC5C,EAAE,EAAE,UAAU,CAAC,MAAM;SACtB;KACF,CAAC;IAEF,MAAM,iBAAiB,GAAG,cAAc,CAAC,UAAU,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC;IAEvE,MAAM,cAAc,GAAG,iBAAiB;QACtC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC;QACtD,CAAC,CAAC,EAAE,CAAC;IAEP,MAAM,UAAU,GAAe;QAC7B,MAAM,EAAE,QAAQ;QAChB,SAAS,EAAE,mBAA0B;QACrC,MAAM,EAAE,MAAa;QACrB,QAAQ,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE;QACvB,UAAU,EAAE,cAAqB;KAClC,CAAC;IAEF,+EAA+E;IAC/E,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,IAAI,EAAE,CAAC;IACvC,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;IACpC,MAAM,iBAAiB,GACrB,UAAU,CAAC,UAAU,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;IAE5E,IAAI,WAAmC,CAAC;IACxC,IAAI,gBAAwC,CAAC;IAC7C,IAAI,SAAS,EAAE,CAAC;QACd,MAAM,eAAe,GAAuC,EAAE,CAAC;QAE/D,eAAe,CAAC,IAAI,CAAC;YACnB,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE;gBACJ,WAAW,EAAE;oBACX,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE;oBACvB,KAAK,EAAE;wBACL,GAAG,EAAE;4BACH,IAAI,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE;4BACxB,IAAI,EAAE,iBAAiB;yBACxB;qBACF;iBACF;aACF;SACF,CAAC,CAAC;QACH,WAAW,GAAG;YACZ,MAAM,EAAE,QAAQ;YAChB,SAAS,EAAE,mBAA0B;YACrC,MAAM,EAAE,MAAa;YACrB,QAAQ,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE;YACvB,UAAU,EAAE,eAAe;SAC5B,CAAC;IACJ,CAAC;IAED,IAAI,iBAAiB,EAAE,CAAC;QACtB,MAAM,oBAAoB,GAAuC,EAAE,CAAC;QAEpE,MAAM,cAAc,GAAG,cAAc,CACnC,UAAU,CAAC,UAAU,IAAI,EAAE,EAC3B,kBAAkB,CACnB,CAAC;QACF,oBAAoB,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC,CAAC;QAElE,gBAAgB,GAAG;YACjB,MAAM,EAAE,QAAQ;YAChB,SAAS,EAAE,mBAA0B;YACrC,MAAM,EAAE,MAAa;YACrB,QAAQ,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE;YACvB,UAAU,EAAE,oBAA2B;SACxC,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,gBAAgB,EAAE,CAAC;AACvD,CAAC","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>;