@sequenceholdings/orm 2.2.0 → 2.4.0

package/dist/predicate-v2.cjs

@@ -1058,14 +1058,20 @@ zod.z.object({ irVersion: irVersionSchema });
 var CLAIMS_CONTRACT = {
   sub: "string",
   org: "string?",
+  ext_subject: "string?",
+  ext_email: "string?",
   roles: "string[]",
   capabilities: "string[]"
 };
+var EXTERNAL_POLICY_CLAIM_KEYS = ["ext_subject", "ext_email"];
+function isExternalPolicyClaimKey(key) {
+  return EXTERNAL_POLICY_CLAIM_KEYS.includes(key);
+}
 var scalarLiteral = zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean(), zod.z.null()]);
 var valueIrSchema = zod.z.discriminatedUnion("kind", [
   zod.z.object({ kind: zod.z.literal("literal"), value: zod.z.union([scalarLiteral, zod.z.array(scalarLiteral)]) }),
   zod.z.object({ kind: zod.z.literal("variable"), name: zod.z.string() }),
-  zod.z.object({ kind: zod.z.literal("claim"), key: zod.z.enum(["sub", "org"]) })
+  zod.z.object({ kind: zod.z.literal("claim"), key: zod.z.enum(["sub", "org", ...EXTERNAL_POLICY_CLAIM_KEYS]) })
 ]);
 var CMP_OPS = [
   "eq",
@@ -1636,6 +1642,7 @@ var Parser2 = class {
       return node;
     }
     if (this.peekKeyword("exists")) return this.parseExists();
+    if (this.peekKeyword("visible") && this.tokens[this.index + 1]?.kind === "lparen") return this.parseVisible();
     return this.parseComparison();
   }
   parseBooleanCall(fn) {
@@ -1655,6 +1662,13 @@ var Parser2 = class {
     this.expect("rparen", "')' closing exists(...)");
     return { kind: "exists", path, where };
   }
+  parseVisible() {
+    this.advance();
+    this.expect("lparen", "'(' after visible");
+    const path = this.parsePath("a link path in visible(...)");
+    this.expect("rparen", "')' closing visible(...)");
+    return { kind: "visible", path };
+  }
   parseComparison() {
     const left = this.parseOperand();
     const operator = this.expect("operator", "a comparison operator");
@@ -1770,6 +1784,24 @@ function parsePolicy(source) {
 
 // src/predicate-v2/compile.ts
 var POLICY_MAX_LINK_DEPTH = 3;
+function scopeToNamespace(pred, namespace) {
+  switch (pred.kind) {
+    case "capability":
+    case "role":
+      return pred.namespace ? pred : { ...pred, namespace };
+    case "and":
+    case "or":
+      return { ...pred, operands: pred.operands.map((operand) => scopeToNamespace(operand, namespace)) };
+    case "not":
+      return { ...pred, operand: scopeToNamespace(pred.operand, namespace) };
+    case "exists":
+      return { ...pred, where: scopeToNamespace(pred.where, namespace) };
+    case "aggPredicate":
+      return pred.where ? { ...pred, where: scopeToNamespace(pred.where, namespace) } : pred;
+    default:
+      return pred;
+  }
+}
 var CMP_BY_OP = {
   "=": "eq",
   "!=": "neq",
@@ -1803,7 +1835,7 @@ function resolveLink(info, ref) {
 function columnCandidates(info) {
   return [...info.columns.map((c) => c.name), ...info.links.map((l) => l.name)];
 }
-var PolicyCompiler = class {
+var PolicyCompiler = class _PolicyCompiler {
   constructor(ctx) {
     this.ctx = ctx;
   }
@@ -1815,13 +1847,16 @@ var PolicyCompiler = class {
       case "or":
         return { kind: node.kind, operands: node.operands.map((operand) => this.compile(operand, table, depth)) };
       case "not":
-        return { kind: "not", operand: this.compile(node.operand, table, depth) };
+        assertNoNegatedExternalClaim(node.operand);
+        return { kind: "not", operand: new _PolicyCompiler({ ...this.ctx, negated: true }).compile(node.operand, table, depth) };
       case "capability":
         return { kind: "capability", key: node.key };
       case "role":
         return { kind: "role", key: node.key };
       case "exists":
         return this.compileExists(node.path, node.where, table, depth);
+      case "visible":
+        return this.compileVisible(node.path, table, depth);
       case "compare":
         return this.compileCompare(node, table, depth);
     }
@@ -1835,6 +1870,36 @@ var PolicyCompiler = class {
     }
     return pred;
   }
+  /** `visible(path)` → `exists(path, <final target's read policy>)`. */
+  compileVisible(path, table, depth) {
+    const { links, finalTable } = this.resolveLinkPath(path, table, depth, { toOneOnly: false });
+    const readPolicy = this.ctx.resolver.readPolicy;
+    if (!readPolicy) {
+      throw new PolicyCompileError(
+        `visible(${path.join(".")}) needs the target's read policy, which this compile context does not provide`,
+        "visible-unresolvable"
+      );
+    }
+    if (this.ctx.visiting.includes(finalTable)) {
+      throw new PolicyCompileError(
+        `visible(${path.join(".")}) on '${table}' reaches '${finalTable}' whose read policy is already being expanded (${[...this.ctx.visiting, finalTable].join(" \u2192 ")})`,
+        "visible-cycle"
+      );
+    }
+    const expression = readPolicy(finalTable);
+    let pred = expression === void 0 ? { kind: "const", value: true } : compilePolicyAt({
+      expression,
+      table: finalTable,
+      ctx: { ...this.ctx, visiting: [...this.ctx.visiting, finalTable] },
+      depth: depth + links.length
+    });
+    const owner = this.ctx.resolver.policyNamespace?.(finalTable);
+    if (owner) pred = scopeToNamespace(pred, owner);
+    for (let i = links.length - 1; i >= 0; i -= 1) {
+      pred = { kind: "exists", link: links[i].name, where: pred };
+    }
+    return pred;
+  }
   resolveLinkPath(path, table, depth, { toOneOnly }) {
     const links = [];
     let current = table;
@@ -1894,6 +1959,10 @@ var PolicyCompiler = class {
         columnCandidates(info)
       );
     }
+    if (valueSide.kind === "claim" && isExternalPolicyClaimKey(valueSide.key)) {
+      if (this.ctx.negated) throw negatedExternalClaim(valueSide.key);
+      assertExternalClaimComparison({ op, key: valueSide.key, column: info.columns.find((c) => c.name === column) });
+    }
     let cmp = this.buildCmp(op, column, valueSide);
     for (let i = links.length - 1; i >= 0; i -= 1) {
       cmp = { kind: "exists", link: links[i].name, where: cmp };
@@ -1914,10 +1983,45 @@ var PolicyCompiler = class {
     return { kind: "cmp", op: CMP_BY_OP[op], column, value };
   }
 };
+function assertExternalClaimComparison({ op, key, column }) {
+  if (op !== "=") {
+    throw new PolicyCompileError(
+      `claim('${key}') supports = comparisons only, got '${op}'`,
+      "unsupported-comparison"
+    );
+  }
+  if (column?.type !== "text") {
+    const actual = column?.type === void 0 ? "of unknown type" : typeof column.type === "string" ? column.type : "an enum";
+    throw new PolicyCompileError(
+      `claim('${key}') is text and compares to a text column only \u2014 '${column?.name ?? "?"}' is ${actual}`,
+      "claim-type-mismatch"
+    );
+  }
+}
+function negatedExternalClaim(key) {
+  return new PolicyCompileError(
+    `claim('${key}') cannot appear under not(): a negated borrower comparison admits other borrowers' rows`,
+    "unsupported-comparison"
+  );
+}
+function assertNoNegatedExternalClaim(operand) {
+  walkPolicy(operand, (node) => {
+    if (node.kind !== "compare") return;
+    const claim = [node.left, node.right].find((side) => side.kind === "claim" && isExternalPolicyClaimKey(side.key));
+    if (claim?.kind === "claim") throw negatedExternalClaim(claim.key);
+  });
+}
 function compilePredicateV2({ expression, table, resolver, maxLinkDepth }) {
+  return compilePredicateAt({
+    expression,
+    table,
+    depth: 0,
+    ctx: { resolver, maxLinkDepth: maxLinkDepth ?? POLICY_MAX_LINK_DEPTH, visiting: [table] }
+  });
+}
+function compilePredicateAt({ expression, table, ctx, depth }) {
   const parsed = typeof expression === "string" ? parsePolicy(expression) : expression;
-  const compiler = new PolicyCompiler({ resolver, maxLinkDepth: maxLinkDepth ?? POLICY_MAX_LINK_DEPTH });
-  return compiler.compile(parsed.ast, table, 0);
+  return new PolicyCompiler(ctx).compile(parsed.ast, table, depth);
 }
 function assertClaimsOnlyWhen(parsed) {
   walkPolicy(parsed.ast, (node) => {
@@ -1934,25 +2038,34 @@ function assertClaimsOnlyWhen(parsed) {
         "when-not-claims-only"
       );
     }
-    if (node.kind === "exists") {
+    if (node.kind === "exists" || node.kind === "visible") {
       throw new PolicyCompileError(
-        "variant 'when' guards are claims-only \u2014 exists() is not allowed",
+        `variant 'when' guards are claims-only \u2014 ${node.kind}() is not allowed`,
         "when-not-claims-only"
       );
     }
   });
 }
-function compilePolicy({ expression, table, resolver, maxLinkDepth }) {
-  if (typeof expression === "string") {
-    return compilePredicateV2({ expression, table, resolver, maxLinkDepth });
-  }
-  const defaultPred = compilePredicateV2({ expression: expression.default, table, resolver, maxLinkDepth });
+function initialVisiting({ table, access }) {
+  return (access ?? "read") === "read" ? [table] : [];
+}
+function compilePolicy({ expression, table, resolver, maxLinkDepth, access }) {
+  return compilePolicyAt({
+    expression,
+    table,
+    depth: 0,
+    ctx: { resolver, maxLinkDepth: maxLinkDepth ?? POLICY_MAX_LINK_DEPTH, visiting: initialVisiting({ table, access }) }
+  });
+}
+function compilePolicyAt({ expression, table, ctx, depth }) {
+  if (typeof expression === "string") return compilePredicateAt({ expression, table, ctx, depth });
+  const defaultPred = compilePredicateAt({ expression: expression.default, table, ctx, depth });
   if (expression.variants.length === 0) return defaultPred;
   const branches = expression.variants.map((variant) => {
     const parsedWhen = parsePolicy(variant.when);
     assertClaimsOnlyWhen(parsedWhen);
-    const when = compilePredicateV2({ expression: parsedWhen, table, resolver, maxLinkDepth });
-    const grant = variant.allow === true ? { kind: "const", value: true } : compilePredicateV2({ expression: variant.policy, table, resolver, maxLinkDepth });
+    const when = compilePredicateAt({ expression: parsedWhen, table, ctx, depth });
+    const grant = variant.allow === true ? { kind: "const", value: true } : compilePredicateAt({ expression: variant.policy, table, ctx, depth });
     return { kind: "and", operands: [when, grant] };
   });
   return { kind: "or", operands: [defaultPred, ...branches] };