@sequenceholdings/orm 2.1.1 → 2.2.0

package/dist/sdl.d.cts

@@ -1,7 +1,7 @@
 export { B as BUCKETABLE_COLUMN_TYPES, C as CELL_TYPENAMES, a as CUSTOM_SCALARS, D as DATE_BUCKET_ENUM, N as NUMERICISH_COLUMN_TYPES, O as ORDER_BY_ENUM, b as ORDER_BY_ENUM_VALUES, P as PLATFORM_USER_TYPENAME, T as TableNames, V as VARIABLE_SCALAR_NAMES, c as camelCase, d as cellsTypename, e as columnTypeForScalar, f as comparisonExpName, g as enumTypeName, h as fieldName, i as graphqlScalarFor, p as pascalCase, t as tableNames, j as typeName } from './naming-CU9ThP_E.cjs';
 import { CanonicalDefinition, CanonicalRelation, CanonicalColumn } from './canonical.cjs';
 import { z } from 'zod';
-import './constants-YoFGjIBM.cjs';
+import './constants-C6EG6Wq7.cjs';
 import './policy-1iZbGnZZ.cjs';
 
 /**
@@ -30,6 +30,13 @@ interface GenerateSdlOptions {
      * Postgres `columnName`.
      */
     pinnedColumns?: Record<string, string[]>;
+    /**
+     * Declare `_like`/`_ilike` on String only, as @sequenceholdings/orm 2.1.x
+     * generated it, before integer and uuid columns took pattern filters. Atlas
+     * regenerates this shape only to recognize a schema.graphql pushed by a
+     * released CLI; operations always compile against the default shape.
+     */
+    stringOnlyPatternOperators?: boolean;
 }
 declare function generateSdl(canonical: CanonicalDefinition, options?: GenerateSdlOptions): string;
 /** Columns a resolved-table mutation may write: authored data columns, never the view's system columns. */

package/dist/sdl.d.ts

@@ -1,7 +1,7 @@
 export { B as BUCKETABLE_COLUMN_TYPES, C as CELL_TYPENAMES, a as CUSTOM_SCALARS, D as DATE_BUCKET_ENUM, N as NUMERICISH_COLUMN_TYPES, O as ORDER_BY_ENUM, b as ORDER_BY_ENUM_VALUES, P as PLATFORM_USER_TYPENAME, T as TableNames, V as VARIABLE_SCALAR_NAMES, c as camelCase, d as cellsTypename, e as columnTypeForScalar, f as comparisonExpName, g as enumTypeName, h as fieldName, i as graphqlScalarFor, p as pascalCase, t as tableNames, j as typeName } from './naming-CPfx7EfF.js';
 import { CanonicalDefinition, CanonicalRelation, CanonicalColumn } from './canonical.js';
 import { z } from 'zod';
-import './constants-YoFGjIBM.js';
+import './constants-C6EG6Wq7.js';
 import './policy-1iZbGnZZ.js';
 
 /**
@@ -30,6 +30,13 @@ interface GenerateSdlOptions {
      * Postgres `columnName`.
      */
     pinnedColumns?: Record<string, string[]>;
+    /**
+     * Declare `_like`/`_ilike` on String only, as @sequenceholdings/orm 2.1.x
+     * generated it, before integer and uuid columns took pattern filters. Atlas
+     * regenerates this shape only to recognize a schema.graphql pushed by a
+     * released CLI; operations always compile against the default shape.
+     */
+    stringOnlyPatternOperators?: boolean;
 }
 declare function generateSdl(canonical: CanonicalDefinition, options?: GenerateSdlOptions): string;
 /** Columns a resolved-table mutation may write: authored data columns, never the view's system columns. */

package/dist/sdl.js

@@ -204,6 +204,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",
@@ -536,6 +537,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`). */
@@ -637,11 +640,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([]),
@@ -794,7 +798,9 @@ function validateCellMetadata(table, index, ctx) {
     }
   }
 }
-var canonicalDefinitionSchema = 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(),
@@ -802,6 +808,8 @@ var canonicalDefinitionSchema = 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(),
@@ -828,7 +836,16 @@ var canonicalDefinitionSchema = 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`),
@@ -998,6 +1015,10 @@ var canonicalDefinitionSchema = 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: z.array(localDefinitionSchema).max(32).optional()
+});
 function canonicalRelations(definition) {
   const views = (definition.views ?? []).map((view) => ({
     table: view.view,
@@ -1041,6 +1062,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;
 }
 
@@ -1171,9 +1197,12 @@ var CELL_TYPENAMES = {
 function cellsTypename(typename) {
   return `${typename}Cells`;
 }
-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 scalarLiteral = z.union([z.string(), z.number(), z.boolean(), z.null()]);
 var valueIrSchema = z.discriminatedUnion("kind", [
@@ -1211,8 +1240,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() })
   ])
@@ -1439,7 +1468,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}$/),
@@ -1451,8 +1504,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) {
@@ -1499,11 +1560,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
@@ -1562,10 +1628,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" });
@@ -1573,6 +1647,70 @@ 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) {
@@ -1593,7 +1731,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) }));
@@ -1666,11 +1804,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) {
@@ -1724,7 +1863,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],
@@ -1736,7 +1877,7 @@ function renderComparisonExp(gqlTypeName) {
     ["_nin", `[${gqlTypeName}!]`],
     ["_isNull", "Boolean"]
   ];
-  if (gqlTypeName === "String") {
+  if (patternTypes.has(gqlTypeName)) {
     fields.push(["_like", "String"], ["_ilike", "String"]);
   }
   if (gqlTypeName === "jsonb") {
@@ -2235,12 +2376,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 {
@@ -2311,7 +2446,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)) {