@sequenceholdings/orm 2.1.1 → 2.2.0

package/dist/sdl.cjs

@@ -206,6 +206,7 @@ function compileCheckExpression(source, columns) {
 // src/constants.ts
 var COLUMN_IDENTIFIER_PATTERN = /^_?[a-z][a-z0-9_]*$/;
 var MAX_IDENTIFIER_LENGTH = 63;
+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",
@@ -538,6 +539,8 @@ var canonicalLinkSchema = zod.z.object({
   kind: zod.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`). */
@@ -639,11 +642,12 @@ var canonicalForeignKeySchema = zod.z.object({
 }).strict();
 var canonicalTableSchema = zod.z.object({
   table: identifier2,
+  displayName: zod.z.string().trim().min(1).max(120).optional(),
   description: zod.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: zod.z.string().regex(/^gold\.[a-z][a-z0-9_]*$/).optional(),
+  /** Synced/reflected read-only tables (`source: schema.table`) — v1 semantics. */
+  source: zod.z.string().regex(QUALIFIED_TABLE_PATTERN).optional(),
   columns: zod.z.array(canonicalColumnSchema).default([]),
   primaryKey: zod.z.array(columnIdentifier).min(1).max(8).optional(),
   links: zod.z.array(canonicalLinkSchema).default([]),
@@ -796,7 +800,9 @@ function validateCellMetadata(table, index, ctx) {
     }
   }
 }
-var canonicalDefinitionSchema = zod.z.object({
+var exportGateSchema = zod.z.union([zod.z.literal(true), zod.z.object({ capability: zod.z.string().min(1) }).strict(), zod.z.object({ role: zod.z.string().min(1) }).strict()]);
+var relationExportSchema = zod.z.object({ read: exportGateSchema, write: exportGateSchema.optional() }).strict();
+var localDefinitionSchema = zod.z.object({
   definition_format: zod.z.literal(CANONICAL_FORMAT),
   namespace: identifier2.max(41),
   description: zod.z.string().max(2e3).optional(),
@@ -804,6 +810,8 @@ var canonicalDefinitionSchema = zod.z.object({
   tables: zod.z.array(canonicalTableSchema).min(0).max(500),
   /** Optional to preserve byte-identical hashes for pre-view canonical v2 documents. */
   views: zod.z.array(canonicalViewSchema).max(500).optional(),
+  /** Target-owned cross-namespace access contract, using existing namespace grants. */
+  exports: zod.z.record(identifier2, relationExportSchema).optional(),
   /** Verbatim custom-roles grammar (@sequenceholdings/custom-roles-manifest). */
   capabilities: zod.z.object({
     roles: zod.z.unknown().optional(),
@@ -830,7 +838,16 @@ var canonicalDefinitionSchema = zod.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`),
@@ -1000,6 +1017,10 @@ var canonicalDefinitionSchema = zod.z.object({
   };
   for (const view of views) visit(view.view, []);
 });
+var canonicalDefinitionSchema = localDefinitionSchema.safeExtend({
+  /** Flattened, pinned snapshots. Imported relations never participate in this namespace's DDL. */
+  imports: zod.z.array(localDefinitionSchema).max(32).optional()
+});
 function canonicalRelations(definition) {
   const views = (definition.views ?? []).map((view) => ({
     table: view.view,
@@ -1043,6 +1064,11 @@ function normalizeCanonical(definition) {
       dependencies: [...view.dependencies].sort()
     }));
   }
+  if (definition.imports?.length) {
+    normalized.imports = definition.imports.map(normalizeCanonical).sort((a, b) => a.namespace.localeCompare(b.namespace));
+  } else {
+    delete normalized.imports;
+  }
   return normalized;
 }
 
@@ -1173,9 +1199,12 @@ var CELL_TYPENAMES = {
 function cellsTypename(typename) {
   return `${typename}Cells`;
 }
-var IR_VERSION = 2;
 var LEGACY_IR_VERSION = 1;
-var irVersionSchema = zod.z.union([zod.z.literal(LEGACY_IR_VERSION), zod.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 = zod.z.union([zod.z.literal(LEGACY_IR_VERSION), zod.z.literal(GUARDED_IR_VERSION), zod.z.literal(COMPOSED_IR_VERSION), zod.z.literal(SQL_IR_VERSION), zod.z.literal(RUNTIME_SQL_IR_VERSION)]);
 zod.z.object({ irVersion: irVersionSchema });
 var scalarLiteral = zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean(), zod.z.null()]);
 var valueIrSchema = zod.z.discriminatedUnion("kind", [
@@ -1213,8 +1242,8 @@ var predIrSchema = zod.z.lazy(
       value: zod.z.number(),
       where: predIrSchema.optional()
     }),
-    zod.z.object({ kind: zod.z.literal("capability"), key: zod.z.string() }),
-    zod.z.object({ kind: zod.z.literal("role"), key: zod.z.string() }),
+    zod.z.object({ kind: zod.z.literal("capability"), key: zod.z.string(), namespace: zod.z.string().optional() }),
+    zod.z.object({ kind: zod.z.literal("role"), key: zod.z.string(), namespace: zod.z.string().optional() }),
     zod.z.object({ kind: zod.z.literal("dynamicFilter"), slot: zod.z.string() }),
     zod.z.object({ kind: zod.z.literal("const"), value: zod.z.boolean() })
   ])
@@ -1441,7 +1470,31 @@ var variableIrSchema = zod.z.object({
   /** Absent = no default declared; see {@link variableDefaultIrSchema}. */
   defaultValue: variableDefaultIrSchema.optional()
 });
+var sqlColumnSchema = zod.z.object({ name: zod.z.string(), type: zod.z.enum(["text", "boolean", "integer", "bigint", "numeric", "double", "uuid", "date", "timestamptz"]), nullable: zod.z.boolean() });
 var compiledOperationSchema = zod.z.object({
+  language: zod.z.literal("sql").optional(),
+  /** Server-compiled object catalog and permission ceiling, never caller SQL. */
+  sqlQuery: zod.z.object({
+    catalog: zod.z.object({
+      identity: zod.z.string(),
+      objects: zod.z.array(zod.z.object({
+        ref: zod.z.string(),
+        table: zod.z.string(),
+        columns: zod.z.array(sqlColumnSchema.extend({ type: zod.z.string() })).min(1),
+        scan: zod.z.string().min(1),
+        read: zod.z.array(zod.z.string()).min(1)
+      }).strict()).min(1).max(256)
+    }).strict(),
+    read: zod.z.array(zod.z.string()).min(1).max(256),
+    maxRows: zod.z.number().int().min(1).max(1e4)
+  }).strict().optional(),
+  sql: zod.z.object({
+    text: zod.z.string().min(1).max(1048576),
+    columns: zod.z.array(sqlColumnSchema).min(1).max(256),
+    parameters: zod.z.array(zod.z.string()).max(128),
+    read: zod.z.array(zod.z.string()).min(1).max(256),
+    maxRows: zod.z.number().int().min(1).max(1e4)
+  }).strict().optional(),
   irVersion: irVersionSchema,
   name: zod.z.string(),
   opHash: zod.z.string().regex(/^sha256:[0-9a-f]{64}$/),
@@ -1453,8 +1506,16 @@ var compiledOperationSchema = zod.z.object({
   variables: zod.z.array(variableIrSchema),
   /** Every table the op touches — data-token scoping + audit. */
   tableSet: zod.z.array(zod.z.string()).min(1),
-  roots: zod.z.array(rootIrSchema).min(1)
+  roots: zod.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) {
@@ -1501,11 +1562,16 @@ var resolvedMetaIrSchema = zod.z.object({
 });
 var tableMetaIrSchema = zod.z.object({
   table: zod.z.string(),
+  namespace: zod.z.string().optional(),
+  dependencies: zod.z.array(zod.z.string()).optional(),
+  foreignReferences: zod.z.array(zod.z.object({ column: zod.z.string(), target: zod.z.string(), targetColumn: zod.z.string() })).optional(),
+  exportRead: zod.z.union([zod.z.literal(true), zod.z.object({ capability: zod.z.string() }), zod.z.object({ role: zod.z.string() })]).optional(),
+  exportWrite: zod.z.union([zod.z.literal(true), zod.z.object({ capability: zod.z.string() }), zod.z.object({ role: zod.z.string() })]).optional(),
   schema: zod.z.string(),
   typename: zod.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
@@ -1564,10 +1630,18 @@ zod.z.object({
   irVersion: irVersionSchema,
   namespace: zod.z.string(),
   schemaHash: zod.z.string(),
+  ownSchemaHash: zod.z.string().optional(),
+  dependencies: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+  readPolicies: zod.z.record(zod.z.string(), predIrSchema).optional(),
   opsHash: zod.z.string(),
+  /** Apply-observed synced objects without a serving backing; not part of the authored schema hash. */
+  unbackedTables: zod.z.array(zod.z.string()).optional(),
   tables: zod.z.record(zod.z.string(), tableMetaIrSchema),
   operations: zod.z.record(zod.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" });
@@ -1575,6 +1649,70 @@ zod.z.object({
   }
 });
 
+// src/errors.ts
+var OrmDefinitionError = class extends Error {
+  constructor(message, file) {
+    super(file ? `${file}: ${message}` : message);
+    this.file = file;
+  }
+  name = "OrmDefinitionError";
+};
+function stableJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  const entries = Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([a], [b]) => a < b ? -1 : 1).map(([key, entryValue]) => `${JSON.stringify(key)}:${stableJson(entryValue)}`);
+  return `{${entries.join(",")}}`;
+}
+
+// src/canonical/composition.ts
+function localContract(definition) {
+  return normalizeCanonical(localDefinitionSchema.parse(definition));
+}
+function composeNamespace(definition) {
+  const all = [localContract(definition), ...definition.imports ?? []];
+  const owners = /* @__PURE__ */ new Map();
+  const namespaces = /* @__PURE__ */ new Set();
+  const enums = /* @__PURE__ */ new Map();
+  for (const owner of all) {
+    if (namespaces.has(owner.namespace)) throw new OrmDefinitionError(`duplicate imported namespace '${owner.namespace}'`);
+    namespaces.add(owner.namespace);
+    for (const value of owner.enums) {
+      const previous = enums.get(value.name);
+      if (previous && stableJson(previous) !== stableJson(value)) {
+        throw new OrmDefinitionError(`conflicting imported enum '${value.name}'`);
+      }
+      enums.set(value.name, value);
+    }
+    for (const relation of canonicalRelations(owner)) {
+      if (owners.has(relation.table)) throw new OrmDefinitionError(`ambiguous imported relation '${relation.table}'`);
+      owners.set(relation.table, owner);
+    }
+  }
+  for (const owner of definition.imports?.length ? all : []) {
+    for (const relation of canonicalRelations(owner)) {
+      for (const link of relation.links) {
+        if (link.kind === "toPlatformUser") continue;
+        const target = owners.get(link.target ?? "");
+        if (!target || target.namespace !== (link.namespace ?? owner.namespace)) {
+          throw new OrmDefinitionError(`link '${owner.namespace}/${relation.table}.${link.name}' has no matching imported target`);
+        }
+        if (target.namespace !== owner.namespace && !target.exports?.[link.target ?? ""]) {
+          throw new OrmDefinitionError(`target '${target.namespace}/${link.target}' is not exported`);
+        }
+      }
+    }
+  }
+  return {
+    owners,
+    definition: {
+      ...localContract(definition),
+      tables: all.flatMap((item) => item.tables),
+      views: all.flatMap((item) => item.views ?? []),
+      enums: [...enums.values()]
+    }
+  };
+}
+
 // src/sdl/generate.ts
 var SdlGenerationError = class extends Error {
   constructor(message) {
@@ -1595,7 +1733,7 @@ var PLATFORM_USER_FIELDS = [
   { name: "accountEnabled", gqlType: "Boolean", nullable: false }
 ];
 function generateSdl(canonical, options = {}) {
-  const def = normalizeCanonical(canonicalDefinitionSchema.parse(canonical));
+  const def = composeNamespace(normalizeCanonical(canonicalDefinitionSchema.parse(canonical))).definition;
   const exposed = canonicalRelations(def).filter((table) => table.source === void 0 && table.internal !== true);
   const cellsByTable = new Map(exposed.map((table) => [table.table, trackedCells(table)]));
   const tables = exposed.map((table) => ({ ...table, columns: table.columns.filter((column) => column.cell === void 0) }));
@@ -1668,11 +1806,12 @@ function generateSdl(canonical, options = {}) {
     for (const value of entry.values) assertEnumValue(value, `enum "${enumName}"`);
     blocks.push(renderEnum(enumTypeName(enumName), entry.values));
   }
+  const patternTypes = options.stringOnlyPatternOperators ? STRING_PATTERN_COMPARISON_TYPES : PATTERN_COMPARISON_TYPES;
   for (const scalar of [...usedComparisonScalars].sort()) {
-    blocks.push(renderComparisonExp(scalar));
+    blocks.push(renderComparisonExp({ gqlTypeName: scalar, patternTypes }));
   }
   for (const enumName of [...usedEnums].sort()) {
-    blocks.push(renderComparisonExp(enumTypeName(enumName)));
+    blocks.push(renderComparisonExp({ gqlTypeName: enumTypeName(enumName), patternTypes }));
   }
   if (hasPlatformUser) blocks.push(...renderPlatformUserBlocks());
   for (const table of tables) {
@@ -1726,7 +1865,9 @@ function descriptionLines(text, indent) {
   const escaped = text.replace(/"""/g, '\\"""');
   return [`${indent}"""`, ...escaped.split("\n").map((line) => `${indent}${line}`), `${indent}"""`];
 }
-function renderComparisonExp(gqlTypeName) {
+var PATTERN_COMPARISON_TYPES = /* @__PURE__ */ new Set(["String", "Int", "bigint", "uuid"]);
+var STRING_PATTERN_COMPARISON_TYPES = /* @__PURE__ */ new Set(["String"]);
+function renderComparisonExp({ gqlTypeName, patternTypes }) {
   const fields = [
     ["_eq", gqlTypeName],
     ["_neq", gqlTypeName],
@@ -1738,7 +1879,7 @@ function renderComparisonExp(gqlTypeName) {
     ["_nin", `[${gqlTypeName}!]`],
     ["_isNull", "Boolean"]
   ];
-  if (gqlTypeName === "String") {
+  if (patternTypes.has(gqlTypeName)) {
     fields.push(["_like", "String"], ["_ilike", "String"]);
   }
   if (gqlTypeName === "jsonb") {
@@ -2237,12 +2378,6 @@ function renderCowMutationFields(table, names) {
   }
   return lines;
 }
-function stableJson(value) {
-  if (value === null || typeof value !== "object") return JSON.stringify(value);
-  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
-  const entries = Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([a], [b]) => a < b ? -1 : 1).map(([key, entryValue]) => `${JSON.stringify(key)}:${stableJson(entryValue)}`);
-  return `{${entries.join(",")}}`;
-}
 
 // src/codegen-gql/errors.ts
 var CodegenGqlError = class extends Error {
@@ -2313,7 +2448,7 @@ function normalizeRequires(requires) {
 
 // src/codegen-gql/type-policies.ts
 function generateTypePolicies(canonical) {
-  const def = normalizeCanonical(canonicalDefinitionSchema.parse(canonical));
+  const def = composeNamespace(normalizeCanonical(canonicalDefinitionSchema.parse(canonical))).definition;
   const entries = [];
   let hasPlatformUser = false;
   for (const table of canonicalRelations(def)) {