@sequenceholdings/orm 2.1.1 → 2.3.0

package/dist/predicate-v2.d.cts

@@ -1,7 +1,7 @@
 import { ClaimKey, PredIr } from './ir.cjs';
 import { P as PolicyExpression } from './policy-1iZbGnZZ.cjs';
 import 'zod';
-import './constants-YoFGjIBM.cjs';
+import './constants-C6EG6Wq7.cjs';
 
 declare const POLICY_COMPARE_OPS: readonly ["=", "!=", "<", "<=", ">", ">="];
 type PolicyCompareOp = (typeof POLICY_COMPARE_OPS)[number];
@@ -11,7 +11,7 @@ type PolicyOperand =
     kind: 'path';
     segments: readonly string[];
 }
-/** `claim('sub')` / `claim('org')` — the only claim() keys in CLAIMS_CONTRACT. */
+/** `claim('sub')` / `claim('org')` / `claim('ext_subject')` / `claim('ext_email')` — the scalar keys in CLAIMS_CONTRACT. */
  | {
     kind: 'claim';
     key: ClaimKey;
@@ -63,7 +63,7 @@ declare class PolicyParseError extends Error {
     readonly name = "PolicyParseError";
     constructor(message: string, position: number);
 }
-type PolicyCompileErrorCode = 'unknown-table' | 'unknown-column' | 'unknown-link' | 'not-to-one' | 'link-depth-exceeded' | 'unsupported-comparison' | 'invalid-null-comparison' | 'when-not-claims-only';
+type PolicyCompileErrorCode = 'unknown-table' | 'unknown-column' | 'unknown-link' | 'not-to-one' | 'link-depth-exceeded' | 'unsupported-comparison' | 'invalid-null-comparison' | 'when-not-claims-only' | 'claim-type-mismatch';
 /**
  * Compile-time failure — the parsed policy references something the table
  * doesn't declare, or uses a shape the v2.0 IR cannot represent. Carries
@@ -90,6 +90,9 @@ declare function parsePolicy(source: string): ParsedPolicy;
  *  - a comparison must reference exactly ONE column side (column↔column and
  *    claims↔literal comparisons have no PredIr shape in v2.0);
  *  - `col = null` / `col != null` normalize to the isNull operator;
+ *  - verified-borrower claims (`claim('ext_subject')`, `claim('ext_email')`)
+ *    are text: they compare to a text column with `=` only, never under
+ *    not(), so no negation, ordering or pattern can widen a borrower's rows;
  *  - variant `when` guards are claims-only: capability()/role() under
  *    and/or/not. (claim() comparisons in `when` are not representable in the
  *    v2.0 IR — a targeted error says so.)
@@ -99,6 +102,11 @@ declare const POLICY_MAX_LINK_DEPTH = 3;
 interface PolicyColumnInfo {
     readonly name: string;
     readonly columnName: string;
+    /**
+     * The column's IR type when the resolver knows it (TableMetaIr always does).
+     * Required for a verified-borrower claim comparison: unknown is refused.
+     */
+    readonly type?: unknown;
 }
 interface PolicyLinkInfo {
     readonly name: string;

package/dist/predicate-v2.d.ts

@@ -1,7 +1,7 @@
 import { ClaimKey, PredIr } from './ir.js';
 import { P as PolicyExpression } from './policy-1iZbGnZZ.js';
 import 'zod';
-import './constants-YoFGjIBM.js';
+import './constants-C6EG6Wq7.js';
 
 declare const POLICY_COMPARE_OPS: readonly ["=", "!=", "<", "<=", ">", ">="];
 type PolicyCompareOp = (typeof POLICY_COMPARE_OPS)[number];
@@ -11,7 +11,7 @@ type PolicyOperand =
     kind: 'path';
     segments: readonly string[];
 }
-/** `claim('sub')` / `claim('org')` — the only claim() keys in CLAIMS_CONTRACT. */
+/** `claim('sub')` / `claim('org')` / `claim('ext_subject')` / `claim('ext_email')` — the scalar keys in CLAIMS_CONTRACT. */
  | {
     kind: 'claim';
     key: ClaimKey;
@@ -63,7 +63,7 @@ declare class PolicyParseError extends Error {
     readonly name = "PolicyParseError";
     constructor(message: string, position: number);
 }
-type PolicyCompileErrorCode = 'unknown-table' | 'unknown-column' | 'unknown-link' | 'not-to-one' | 'link-depth-exceeded' | 'unsupported-comparison' | 'invalid-null-comparison' | 'when-not-claims-only';
+type PolicyCompileErrorCode = 'unknown-table' | 'unknown-column' | 'unknown-link' | 'not-to-one' | 'link-depth-exceeded' | 'unsupported-comparison' | 'invalid-null-comparison' | 'when-not-claims-only' | 'claim-type-mismatch';
 /**
  * Compile-time failure — the parsed policy references something the table
  * doesn't declare, or uses a shape the v2.0 IR cannot represent. Carries
@@ -90,6 +90,9 @@ declare function parsePolicy(source: string): ParsedPolicy;
  *  - a comparison must reference exactly ONE column side (column↔column and
  *    claims↔literal comparisons have no PredIr shape in v2.0);
  *  - `col = null` / `col != null` normalize to the isNull operator;
+ *  - verified-borrower claims (`claim('ext_subject')`, `claim('ext_email')`)
+ *    are text: they compare to a text column with `=` only, never under
+ *    not(), so no negation, ordering or pattern can widen a borrower's rows;
  *  - variant `when` guards are claims-only: capability()/role() under
  *    and/or/not. (claim() comparisons in `when` are not representable in the
  *    v2.0 IR — a targeted error says so.)
@@ -99,6 +102,11 @@ declare const POLICY_MAX_LINK_DEPTH = 3;
 interface PolicyColumnInfo {
     readonly name: string;
     readonly columnName: string;
+    /**
+     * The column's IR type when the resolver knows it (TableMetaIr always does).
+     * Required for a verified-borrower claim comparison: unknown is refused.
+     */
+    readonly type?: unknown;
 }
 interface PolicyLinkInfo {
     readonly name: string;

package/dist/predicate-v2.js

@@ -32,6 +32,7 @@ var PolicyCompileError = class extends Error {
 var COLUMN_IDENTIFIER_PATTERN = /^_?[a-z][a-z0-9_]*$/;
 var MAX_IDENTIFIER_LENGTH = 63;
 var CAPABILITY_KEY_PATTERN = /^(?:org\/|app\/[a-z][a-z0-9-]{0,63}\/)?[a-z0-9-]{1,64}$/;
+var QUALIFIED_TABLE_PATTERN = /^[a-z][a-z0-9_]{0,62}\.[a-z][a-z0-9_]{0,62}$/;
 var CELL_PARTS = ["at", "by", "rev", "source", "conflicts"];
 var CELL_PART_SUFFIX = {
   at: "__at",
@@ -561,6 +562,8 @@ var canonicalLinkSchema = z.object({
   kind: z.enum(["toOne", "toMany", "toPlatformUser"]),
   /** Target table name (namespace-local). Absent for toPlatformUser. */
   target: identifier2.optional(),
+  /** Owning namespace of an imported target; omitted for local links. */
+  namespace: identifier2.max(41).optional(),
   /** FK column on the owning side (toOne/toPlatformUser: on this table; toMany: on the target). */
   on: columnIdentifier,
   /** Referenced column on the target (default: target's PK / platform user `sub`). */
@@ -662,11 +665,12 @@ var canonicalForeignKeySchema = z.object({
 }).strict();
 var canonicalTableSchema = z.object({
   table: identifier2,
+  displayName: z.string().trim().min(1).max(120).optional(),
   description: z.string().max(2e3).optional(),
   /** Table-level rename hint (new in v2). */
   renamedFrom: identifier2.optional(),
-  /** Synced/reflected read-only tables (`source: gold.*`) — v1 semantics. */
-  source: z.string().regex(/^gold\.[a-z][a-z0-9_]*$/).optional(),
+  /** Synced/reflected read-only tables (`source: schema.table`) — v1 semantics. */
+  source: z.string().regex(QUALIFIED_TABLE_PATTERN).optional(),
   columns: z.array(canonicalColumnSchema).default([]),
   primaryKey: z.array(columnIdentifier).min(1).max(8).optional(),
   links: z.array(canonicalLinkSchema).default([]),
@@ -819,7 +823,9 @@ function validateCellMetadata(table, index, ctx) {
     }
   }
 }
-z.object({
+var exportGateSchema = z.union([z.literal(true), z.object({ capability: z.string().min(1) }).strict(), z.object({ role: z.string().min(1) }).strict()]);
+var relationExportSchema = z.object({ read: exportGateSchema, write: exportGateSchema.optional() }).strict();
+var localDefinitionSchema = z.object({
   definition_format: z.literal(CANONICAL_FORMAT),
   namespace: identifier2.max(41),
   description: z.string().max(2e3).optional(),
@@ -827,6 +833,8 @@ z.object({
   tables: z.array(canonicalTableSchema).min(0).max(500),
   /** Optional to preserve byte-identical hashes for pre-view canonical v2 documents. */
   views: z.array(canonicalViewSchema).max(500).optional(),
+  /** Target-owned cross-namespace access contract, using existing namespace grants. */
+  exports: z.record(identifier2, relationExportSchema).optional(),
   /** Verbatim custom-roles grammar (@sequenceholdings/custom-roles-manifest). */
   capabilities: z.object({
     roles: z.unknown().optional(),
@@ -853,7 +861,16 @@ z.object({
     }
   }
   const fkTables = new Map(definition.tables.map((table) => [table.table, table]));
+  const relations = /* @__PURE__ */ new Set([...fkTables.keys(), ...(definition.views ?? []).map((view) => view.view)]);
+  for (const name of Object.keys(definition.exports ?? {})) {
+    if (!relations.has(name)) ctx.addIssue({ code: "custom", path: ["exports", name], message: `export '${name}' is not a local object` });
+  }
   for (const [tableIndex, table] of definition.tables.entries()) {
+    for (const [linkIndex, link] of table.links.entries()) {
+      if (link.enforce && link.namespace !== void 0 && link.namespace !== definition.namespace) {
+        ctx.addIssue({ code: "custom", path: ["tables", tableIndex, "links", linkIndex], message: "physical foreign keys require a local target; use an ORM link without enforce" });
+      }
+    }
     const names = /* @__PURE__ */ new Set([
       ...table.primaryKey?.length ? [`${table.table}_pkey`] : [],
       ...table.columns.filter((column) => column.unique && !(table.primaryKey?.length === 1 && table.primaryKey[0] === column.columnName)).map((column) => `${table.table}_${column.columnName}_unique`),
@@ -1023,23 +1040,36 @@ z.object({
   };
   for (const view of views) visit(view.view, []);
 });
+localDefinitionSchema.safeExtend({
+  /** Flattened, pinned snapshots. Imported relations never participate in this namespace's DDL. */
+  imports: z.array(localDefinitionSchema).max(32).optional()
+});
 
 // src/ir/index.ts
-var IR_VERSION = 2;
 var LEGACY_IR_VERSION = 1;
-var irVersionSchema = z.union([z.literal(LEGACY_IR_VERSION), z.literal(IR_VERSION)]);
+var GUARDED_IR_VERSION = 2;
+var COMPOSED_IR_VERSION = 3;
+var SQL_IR_VERSION = 4;
+var RUNTIME_SQL_IR_VERSION = 5;
+var irVersionSchema = z.union([z.literal(LEGACY_IR_VERSION), z.literal(GUARDED_IR_VERSION), z.literal(COMPOSED_IR_VERSION), z.literal(SQL_IR_VERSION), z.literal(RUNTIME_SQL_IR_VERSION)]);
 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 = z.union([z.string(), z.number(), z.boolean(), z.null()]);
 var valueIrSchema = z.discriminatedUnion("kind", [
   z.object({ kind: z.literal("literal"), value: z.union([scalarLiteral, z.array(scalarLiteral)]) }),
   z.object({ kind: z.literal("variable"), name: z.string() }),
-  z.object({ kind: z.literal("claim"), key: z.enum(["sub", "org"]) })
+  z.object({ kind: z.literal("claim"), key: z.enum(["sub", "org", ...EXTERNAL_POLICY_CLAIM_KEYS]) })
 ]);
 var CMP_OPS = [
   "eq",
@@ -1071,8 +1101,8 @@ var predIrSchema = z.lazy(
       value: z.number(),
       where: predIrSchema.optional()
     }),
-    z.object({ kind: z.literal("capability"), key: z.string() }),
-    z.object({ kind: z.literal("role"), key: z.string() }),
+    z.object({ kind: z.literal("capability"), key: z.string(), namespace: z.string().optional() }),
+    z.object({ kind: z.literal("role"), key: z.string(), namespace: z.string().optional() }),
     z.object({ kind: z.literal("dynamicFilter"), slot: z.string() }),
     z.object({ kind: z.literal("const"), value: z.boolean() })
   ])
@@ -1299,7 +1329,31 @@ var variableIrSchema = z.object({
   /** Absent = no default declared; see {@link variableDefaultIrSchema}. */
   defaultValue: variableDefaultIrSchema.optional()
 });
+var sqlColumnSchema = z.object({ name: z.string(), type: z.enum(["text", "boolean", "integer", "bigint", "numeric", "double", "uuid", "date", "timestamptz"]), nullable: z.boolean() });
 var compiledOperationSchema = z.object({
+  language: z.literal("sql").optional(),
+  /** Server-compiled object catalog and permission ceiling, never caller SQL. */
+  sqlQuery: z.object({
+    catalog: z.object({
+      identity: z.string(),
+      objects: z.array(z.object({
+        ref: z.string(),
+        table: z.string(),
+        columns: z.array(sqlColumnSchema.extend({ type: z.string() })).min(1),
+        scan: z.string().min(1),
+        read: z.array(z.string()).min(1)
+      }).strict()).min(1).max(256)
+    }).strict(),
+    read: z.array(z.string()).min(1).max(256),
+    maxRows: z.number().int().min(1).max(1e4)
+  }).strict().optional(),
+  sql: z.object({
+    text: z.string().min(1).max(1048576),
+    columns: z.array(sqlColumnSchema).min(1).max(256),
+    parameters: z.array(z.string()).max(128),
+    read: z.array(z.string()).min(1).max(256),
+    maxRows: z.number().int().min(1).max(1e4)
+  }).strict().optional(),
   irVersion: irVersionSchema,
   name: z.string(),
   opHash: z.string().regex(/^sha256:[0-9a-f]{64}$/),
@@ -1311,8 +1365,16 @@ var compiledOperationSchema = z.object({
   variables: z.array(variableIrSchema),
   /** Every table the op touches — data-token scoping + audit. */
   tableSet: z.array(z.string()).min(1),
-  roots: z.array(rootIrSchema).min(1)
+  roots: z.array(rootIrSchema)
 }).superRefine((operation, ctx) => {
+  if (operation.language === "sql") {
+    const validPlan = operation.sqlQuery ? !operation.sql && operation.irVersion === RUNTIME_SQL_IR_VERSION : !!operation.sql && operation.irVersion === SQL_IR_VERSION;
+    if (!validPlan || operation.kind !== "query" || operation.roots.length !== 0 || !operation.requires?.capability) {
+      ctx.addIssue({ code: "custom", message: "SQL operations require a query-only v4 plan or v5 runtime contract, capability, and no GraphQL roots" });
+    }
+  } else if (operation.sql || operation.sqlQuery || operation.roots.length === 0) {
+    ctx.addIssue({ code: "custom", message: "GraphQL operations require roots and cannot carry SQL" });
+  }
   for (const [index, root] of operation.roots.entries()) {
     if (root.kind !== "mutation" || root.assertAffectedRows === void 0) continue;
     if (operation.irVersion < 2 || operation.kind !== "mutation" || root.includeIf !== void 0) {
@@ -1359,11 +1421,16 @@ var resolvedMetaIrSchema = z.object({
 });
 var tableMetaIrSchema = z.object({
   table: z.string(),
+  namespace: z.string().optional(),
+  dependencies: z.array(z.string()).optional(),
+  foreignReferences: z.array(z.object({ column: z.string(), target: z.string(), targetColumn: z.string() })).optional(),
+  exportRead: z.union([z.literal(true), z.object({ capability: z.string() }), z.object({ role: z.string() })]).optional(),
+  exportWrite: z.union([z.literal(true), z.object({ capability: z.string() }), z.object({ role: z.string() })]).optional(),
   schema: z.string(),
   typename: z.string(),
   /**
    * True when statements over this relation evaluate a claims-gated synced
-   * view: synced twins (`source: gold.*`) materialize as views whose baked
+   * view: synced twins (`source: schema.table`) materialize as views whose baked
    * policy reads `current_setting('request.jwt.claims')`, and namespace views
    * inherit the gate transitively through their declared dependencies. The
    * executor must stamp that GUC (transaction-scoped) before any statement
@@ -1422,10 +1489,18 @@ z.object({
   irVersion: irVersionSchema,
   namespace: z.string(),
   schemaHash: z.string(),
+  ownSchemaHash: z.string().optional(),
+  dependencies: z.record(z.string(), z.string()).optional(),
+  readPolicies: z.record(z.string(), predIrSchema).optional(),
   opsHash: z.string(),
+  /** Apply-observed synced objects without a serving backing; not part of the authored schema hash. */
+  unbackedTables: z.array(z.string()).optional(),
   tables: z.record(z.string(), tableMetaIrSchema),
   operations: z.record(z.string(), compiledOperationSchema)
 }).superRefine((artifact, ctx) => {
+  if (Object.keys(artifact.dependencies ?? {}).length > 0 && artifact.irVersion < COMPOSED_IR_VERSION) {
+    ctx.addIssue({ code: "custom", path: ["irVersion"], message: "cross-namespace dependencies require IR v3" });
+  }
   for (const [name, operation] of Object.entries(artifact.operations)) {
     if (operation.irVersion > artifact.irVersion) {
       ctx.addIssue({ code: "custom", path: ["operations", name, "irVersion"], message: "operation requires a newer IR version than its artifact" });
@@ -1744,6 +1819,7 @@ var PolicyCompiler = class {
       case "or":
         return { kind: node.kind, operands: node.operands.map((operand) => this.compile(operand, table, depth)) };
       case "not":
+        assertNoNegatedExternalClaim(node.operand);
         return { kind: "not", operand: this.compile(node.operand, table, depth) };
       case "capability":
         return { kind: "capability", key: node.key };
@@ -1823,6 +1899,9 @@ var PolicyCompiler = class {
         columnCandidates(info)
       );
     }
+    if (valueSide.kind === "claim" && isExternalPolicyClaimKey(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 };
@@ -1843,6 +1922,33 @@ 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 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 new PolicyCompileError(
+        `claim('${claim.key}') cannot appear under not(): a negated borrower comparison admits other borrowers' rows`,
+        "unsupported-comparison"
+      );
+    }
+  });
+}
 function compilePredicateV2({ expression, table, resolver, maxLinkDepth }) {
   const parsed = typeof expression === "string" ? parsePolicy(expression) : expression;
   const compiler = new PolicyCompiler({ resolver, maxLinkDepth: maxLinkDepth ?? POLICY_MAX_LINK_DEPTH });