@sequenceholdings/orm 0.1.2 → 0.1.3

package/dist/sdl.cjs

@@ -76,8 +76,33 @@ var policyExpressionSchema = zod.z.union([
 ]);
 var canonicalPoliciesSchema = zod.z.object({
   read: policyExpressionSchema.optional(),
-  write: policyExpressionSchema.optional()
+  write: policyExpressionSchema.optional(),
+  insert: policyExpressionSchema.optional(),
+  update: policyExpressionSchema.optional()
 });
+function isSingleViewQuerySql(value) {
+  const query = value.trim();
+  if (!/^\(*(?:select|with)\b/i.test(query) || query.includes("\0")) return false;
+  let state = "normal";
+  for (let index = 0; index < query.length; index += 1) {
+    const char = query[index];
+    const next = query[index + 1];
+    if (state === "single") {
+      if (char === "'" && next === "'") index += 1;
+      else if (char === "'") state = "normal";
+      continue;
+    }
+    if (state === "double") {
+      if (char === '"' && next === '"') index += 1;
+      else if (char === '"') state = "normal";
+      continue;
+    }
+    if (char === "'") state = "single";
+    else if (char === '"') state = "double";
+    else if (char === ";" || char === "-" && next === "-" || char === "/" && next === "*") return false;
+  }
+  return state === "normal" && !/\$[a-z_0-9]*\$/i.test(query);
+}
 var canonicalActionSchema = zod.z.object({
   name: identifier,
   requires: zod.z.string().max(1e3).optional(),
@@ -89,6 +114,37 @@ var canonicalActionSchema = zod.z.object({
   returns: zod.z.enum(["rows", "rowsAffected", "scalar"]).default("rowsAffected"),
   audit: zod.z.object({ action: zod.z.string(), resource: zod.z.string() }).optional()
 });
+var canonicalCowMutationSchema = zod.z.object({
+  kind: zod.z.enum(["override", "revert"]),
+  name: identifier,
+  /** Synced table (same namespace) the overlay copies from / falls back to. */
+  synced: identifier,
+  /** Single-column primary key PROPERTY (TS camelCase, like column `name`) shared by overlay and synced. */
+  pk: zod.z.string().min(1).max(63),
+  /** Override: contract properties copied INSERT…SELECT from synced (pk included). Empty for revert. */
+  copy: zod.z.array(zod.z.string().min(1).max(63)).default([]),
+  /** Override: overlay properties written by the UPDATE (never the pk). Empty for revert. */
+  set: zod.z.array(zod.z.string().min(1).max(63)).default([])
+}).superRefine((mutation, ctx) => {
+  if (mutation.kind === "override") {
+    if (mutation.set.length === 0) {
+      ctx.addIssue({ code: "custom", path: ["set"], message: "override mutations must set at least one column" });
+    }
+    if (!mutation.copy.includes(mutation.pk)) {
+      ctx.addIssue({ code: "custom", path: ["copy"], message: "override copy list must include the pk" });
+    }
+  } else if (mutation.set.length > 0 || mutation.copy.length > 0) {
+    ctx.addIssue({ code: "custom", path: ["set"], message: "revert mutations take no copy/set columns" });
+  }
+  if (mutation.set.includes(mutation.pk)) {
+    ctx.addIssue({ code: "custom", path: ["set"], message: "set must not include the pk \u2014 identity columns are pinned" });
+  }
+  for (const [field, values] of [["copy", mutation.copy], ["set", mutation.set]]) {
+    if (new Set(values).size !== values.length) {
+      ctx.addIssue({ code: "custom", path: [field], message: `${field} must not contain duplicate columns` });
+    }
+  }
+});
 var canonicalTableSchema = zod.z.object({
   table: identifier,
   description: zod.z.string().max(2e3).optional(),
@@ -101,7 +157,45 @@ var canonicalTableSchema = zod.z.object({
   links: zod.z.array(canonicalLinkSchema).default([]),
   indexes: zod.z.array(canonicalIndexSchema).default([]),
   policies: canonicalPoliciesSchema.default({}),
-  actions: zod.z.array(canonicalActionSchema).default([])
+  /**
+   * v1-conversion carry-over only. v2 has no action surface — the runtime
+   * neither compiles nor executes these; writes are mutations. Kept parseable
+   * so stored definitions and their content hashes stay stable.
+   */
+  actions: zod.z.array(canonicalActionSchema).default([]),
+  /** Optional (not defaulted) so pre-CoW canonical documents keep byte-identical hashes. */
+  cowMutations: zod.z.array(canonicalCowMutationSchema).optional()
+});
+var canonicalViewSchema = zod.z.object({
+  view: identifier,
+  description: zod.z.string().max(2e3).optional(),
+  columns: zod.z.array(canonicalColumnSchema).min(1),
+  /** Logical identity for GraphQL only; PostgreSQL views have no PK constraint. */
+  primaryKey: zod.z.array(identifier).min(1).max(8).optional(),
+  links: zod.z.array(canonicalLinkSchema).default([]),
+  policies: zod.z.object({ read: policyExpressionSchema }).strict(),
+  query: zod.z.string().min(1).max(1e5).refine(isSingleViewQuerySql, {
+    message: "view query must be one SELECT/WITH statement without comments or dollar-quoted bodies"
+  }),
+  /** Namespace-local logical relation names, sorted for deterministic hashing. */
+  dependencies: zod.z.array(identifier).max(500)
+}).superRefine((view, ctx) => {
+  for (const [index, column] of view.columns.entries()) {
+    if (column.default !== void 0 || column.defaultFn !== void 0) {
+      ctx.addIssue({ code: "custom", path: ["columns", index], message: `view column '${column.name}' cannot declare a default` });
+    }
+    if (column.unique) {
+      ctx.addIssue({ code: "custom", path: ["columns", index], message: `view column '${column.name}' cannot declare unique` });
+    }
+    if (column.renamedFrom !== void 0 || column.cast !== void 0) {
+      ctx.addIssue({ code: "custom", path: ["columns", index], message: `view column '${column.name}' cannot declare migration hints` });
+    }
+  }
+  for (const [index, link] of view.links.entries()) {
+    if (link.enforce) {
+      ctx.addIssue({ code: "custom", path: ["links", index, "enforce"], message: `view link '${link.name}' cannot enforce a foreign key` });
+    }
+  }
 });
 var canonicalDefinitionSchema = zod.z.object({
   definition_format: zod.z.literal(CANONICAL_FORMAT),
@@ -109,24 +203,174 @@ var canonicalDefinitionSchema = zod.z.object({
   description: zod.z.string().max(2e3).optional(),
   enums: zod.z.array(canonicalEnumSchema).default([]),
   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(),
   /** Verbatim custom-roles grammar (@sequenceholdings/custom-roles-manifest). */
   capabilities: zod.z.object({
     roles: zod.z.unknown().optional(),
     uses: zod.z.array(zod.z.string()).default([])
   }).default({ uses: [] })
+}).superRefine((definition, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, table] of definition.tables.entries()) {
+    if (seen.has(table.table)) {
+      ctx.addIssue({ code: "custom", path: ["tables", index, "table"], message: `duplicate relation '${table.table}'` });
+    }
+    seen.add(table.table);
+  }
+  const tableByName = new Map(definition.tables.map((table) => [table.table, table]));
+  for (const [tableIndex, table] of definition.tables.entries()) {
+    const cowMutations = table.cowMutations ?? [];
+    if (cowMutations.length === 0) continue;
+    const path = (index, ...rest) => ["tables", tableIndex, "cowMutations", index, ...rest];
+    if (table.source !== void 0) {
+      ctx.addIssue({ code: "custom", path: path(0), message: `synced table '${table.table}' cannot declare cow mutations \u2014 it is read-only` });
+      continue;
+    }
+    for (const [index, mutation] of cowMutations.entries()) {
+      const synced = tableByName.get(mutation.synced);
+      if (!synced || synced.source === void 0) {
+        ctx.addIssue({
+          code: "custom",
+          path: path(index, "synced"),
+          message: `cow mutation '${mutation.name}' references '${mutation.synced}', which is not a synced table in this namespace`
+        });
+        continue;
+      }
+      const overlayColumnsByName = new Map(table.columns.map((column) => [column.name, column]));
+      const syncedColumnsByName = new Map(synced.columns.map((column) => [column.name, column]));
+      let columnsExist = true;
+      for (const property of [mutation.pk, ...mutation.copy, ...mutation.set]) {
+        if (!overlayColumnsByName.has(property)) {
+          columnsExist = false;
+          ctx.addIssue({ code: "custom", path: path(index), message: `cow mutation '${mutation.name}': column '${property}' does not exist on overlay '${table.table}'` });
+        }
+      }
+      for (const property of [mutation.pk, ...mutation.copy]) {
+        if (!syncedColumnsByName.has(property)) {
+          columnsExist = false;
+          ctx.addIssue({ code: "custom", path: path(index), message: `cow mutation '${mutation.name}': column '${property}' does not exist on synced '${mutation.synced}'` });
+        }
+      }
+      if (!columnsExist) continue;
+      const overlayPk = table.primaryKey ?? [];
+      const syncedPk = synced.primaryKey ?? [];
+      if (overlayPk.length !== 1 || overlayPk[0] !== mutation.pk || syncedPk.length !== 1 || syncedPk[0] !== mutation.pk) {
+        ctx.addIssue({
+          code: "custom",
+          path: path(index, "pk"),
+          message: `cow mutation '${mutation.name}': pk '${mutation.pk}' must be the single-column primary key on both '${table.table}' and '${mutation.synced}'`
+        });
+      }
+      for (const property of [mutation.pk, ...mutation.copy]) {
+        const overlayColumn = overlayColumnsByName.get(property);
+        const syncedColumn = syncedColumnsByName.get(property);
+        if (!overlayColumn || !syncedColumn) continue;
+        if (JSON.stringify(overlayColumn.type) !== JSON.stringify(syncedColumn.type)) {
+          ctx.addIssue({
+            code: "custom",
+            path: path(index),
+            message: `cow mutation '${mutation.name}': column '${property}' must have the same type on overlay and synced`
+          });
+        }
+        if (overlayColumn.columnName !== syncedColumn.columnName) {
+          ctx.addIssue({
+            code: "custom",
+            path: path(index),
+            message: `cow mutation '${mutation.name}': column '${property}' maps to different Postgres names on overlay ('${overlayColumn.columnName}') and synced ('${syncedColumn.columnName}')`
+          });
+        }
+        if (syncedColumn.nullable !== false && overlayColumn.nullable === false) {
+          ctx.addIssue({
+            code: "custom",
+            path: path(index),
+            message: `cow mutation '${mutation.name}': column '${property}' is nullable on synced but NOT NULL on overlay \u2014 a NULL synced value would fail the copy`
+          });
+        }
+      }
+    }
+  }
+  for (const [index, view] of (definition.views ?? []).entries()) {
+    if (seen.has(view.view)) {
+      ctx.addIssue({ code: "custom", path: ["views", index, "view"], message: `duplicate relation '${view.view}'` });
+    }
+    seen.add(view.view);
+  }
+  const views = definition.views ?? [];
+  const viewByName = new Map(views.map((view) => [view.view, view]));
+  for (const [viewIndex, view] of views.entries()) {
+    for (const [dependencyIndex, dependency] of view.dependencies.entries()) {
+      if (!seen.has(dependency)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["views", viewIndex, "dependencies", dependencyIndex],
+          message: `view '${view.view}' depends on unknown relation '${dependency}'`
+        });
+      }
+    }
+  }
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  let cycleReported = false;
+  const visit = (name, path) => {
+    if (visited.has(name) || cycleReported) return;
+    if (visiting.has(name)) {
+      cycleReported = true;
+      ctx.addIssue({
+        code: "custom",
+        path: ["views"],
+        message: `view dependencies form a cycle: ${[...path, name].join(" -> ")}`
+      });
+      return;
+    }
+    visiting.add(name);
+    const view = viewByName.get(name);
+    for (const dependency of view?.dependencies ?? []) {
+      if (viewByName.has(dependency)) visit(dependency, [...path, name]);
+    }
+    visiting.delete(name);
+    visited.add(name);
+  };
+  for (const view of views) visit(view.view, []);
 });
+function canonicalRelations(definition) {
+  const views = (definition.views ?? []).map((view) => ({
+    table: view.view,
+    ...view.description !== void 0 ? { description: view.description } : {},
+    columns: view.columns,
+    ...view.primaryKey !== void 0 ? { primaryKey: view.primaryKey } : {},
+    links: view.links,
+    indexes: [],
+    policies: { read: view.policies.read },
+    actions: []
+  }));
+  return [...definition.tables, ...views].sort((a, b) => a.table.localeCompare(b.table));
+}
 function normalizeCanonical(definition) {
   const sortByName = (items) => [...items].sort((a, b) => a.name.localeCompare(b.name));
-  return {
+  const normalized = {
     ...definition,
     enums: sortByName(definition.enums),
-    tables: [...definition.tables].sort((a, b) => a.table.localeCompare(b.table)).map((t) => ({
-      ...t,
-      links: sortByName(t.links),
-      indexes: [...t.indexes].sort((a, b) => (a.name ?? a.columns.join("_")).localeCompare(b.name ?? b.columns.join("_"))),
-      actions: sortByName(t.actions)
-    }))
+    tables: [...definition.tables].sort((a, b) => a.table.localeCompare(b.table)).map((t) => {
+      const { cowMutations, ...rest } = t;
+      return {
+        ...rest,
+        links: sortByName(t.links),
+        indexes: [...t.indexes].sort((a, b) => (a.name ?? a.columns.join("_")).localeCompare(b.name ?? b.columns.join("_"))),
+        actions: sortByName(t.actions),
+        // Omitted entirely when absent/empty so pre-CoW documents hash unchanged.
+        ...cowMutations !== void 0 && cowMutations.length > 0 ? { cowMutations: sortByName(cowMutations) } : {}
+      };
+    })
   };
+  if (definition.views !== void 0) {
+    normalized.views = [...definition.views].sort((a, b) => a.view.localeCompare(b.view)).map((view) => ({
+      ...view,
+      links: sortByName(view.links),
+      dependencies: [...view.dependencies].sort()
+    }));
+  }
+  return normalized;
 }
 
 // src/sdl/naming.ts
@@ -259,15 +503,15 @@ var PLATFORM_USER_FIELDS = [
 ];
 function generateSdl(canonical, options = {}) {
   const def = normalizeCanonical(canonicalDefinitionSchema.parse(canonical));
-  const tables = def.tables.filter((table) => table.source === void 0);
+  const tables = canonicalRelations(def).filter((table) => table.source === void 0);
   if (tables.length === 0) {
     throw new SdlGenerationError(
-      `Namespace "${def.namespace}" exposes no tables (synced tables are excluded from SDL in v2.0) \u2014 nothing to generate.`
+      `Namespace "${def.namespace}" exposes no relations (synced tables are excluded from SDL in v2.0) \u2014 nothing to generate.`
     );
   }
   for (const table of tables) {
     if (table.columns.length === 0) {
-      throw new SdlGenerationError(`Table "${table.table}" has no columns \u2014 cannot generate an object type.`);
+      throw new SdlGenerationError(`Relation "${table.table}" has no columns \u2014 cannot generate an object type.`);
     }
   }
   const namesByTable = new Map(tables.map((table) => [table.table, tableNames(table.table)]));
@@ -447,10 +691,20 @@ function renderTableBlocks(ctx) {
 ${fields}
 }`);
   }
-  if (isWritable(table)) blocks.push(...renderWriteBlocks(ctx));
+  if (allowsInsert(table) || allowsUpdate(table)) {
+    blocks.push(...renderWriteBlocks(ctx, { insert: allowsInsert(table), update: allowsUpdate(table) }));
+  }
   return blocks;
 }
-function isWritable(table) {
+function allowsInsert(table) {
+  return table.policies.write !== void 0 || table.policies.insert !== void 0;
+}
+function allowsUpdate(table) {
+  return table.policies.write !== void 0 || table.policies.update !== void 0;
+}
+function allowsOnConflict(table) {
+  if (!allowsInsert(table) || !allowsUpdate(table)) return false;
+  if (table.policies.insert !== void 0 || table.policies.update !== void 0) return false;
   return table.policies.write !== void 0;
 }
 function renderObjectType(ctx) {
@@ -582,46 +836,50 @@ function constraintValues(table) {
   const values = /* @__PURE__ */ new Set();
   if (table.primaryKey && table.primaryKey.length > 0) values.add(`${table.table}_pkey`);
   for (const column of table.columns) {
-    if (column.unique) values.add(`${table.table}_${column.columnName}_key`);
+    if (column.unique) values.add(`${table.table}_${column.columnName}_unique`);
   }
   for (const index of table.indexes) {
     if (index.unique) values.add(index.name ?? `${table.table}_${index.columns.join("_")}_key`);
   }
   return [...values].sort();
 }
-function renderWriteBlocks(ctx) {
+function renderWriteBlocks(ctx, access) {
   const { table, names, pinned } = ctx;
   const blocks = [];
-  const pinnedSet = new Set(pinned);
-  const insertable = table.columns.filter(
-    (column) => !pinnedSet.has(column.name) && !pinnedSet.has(column.columnName)
-  );
-  if (insertable.length === 0) {
-    throw new SdlGenerationError(
-      `Table "${table.table}" has no insertable columns after excluding pinned columns [${pinned.join(", ")}].`
+  if (access.insert) {
+    const pinnedSet = new Set(pinned);
+    const insertable = table.columns.filter(
+      (column) => !pinnedSet.has(column.name) && !pinnedSet.has(column.columnName)
     );
-  }
-  const insertLines = insertable.map(
-    (column) => `  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}`
-  );
-  blocks.push(`input ${names.insertInput} {
+    if (insertable.length === 0) {
+      throw new SdlGenerationError(
+        `Table "${table.table}" has no insertable columns after excluding pinned columns [${pinned.join(", ")}].`
+      );
+    }
+    const insertLines = insertable.map(
+      (column) => `  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}`
+    );
+    blocks.push(`input ${names.insertInput} {
 ${insertLines.join("\n")}
 }`);
-  const setLines = table.columns.map(
-    (column) => `  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}`
-  );
-  blocks.push(`input ${names.setInput} {
+  }
+  if (access.update) {
+    const setLines = table.columns.map(
+      (column) => `  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}`
+    );
+    blocks.push(`input ${names.setInput} {
 ${setLines.join("\n")}
 }`);
+  }
   const jsonb = jsonbColumns(table);
-  if (jsonb.length > 0) {
+  if (access.update && jsonb.length > 0) {
     const appendLines = jsonb.map((column) => `  ${fieldName(column.name)}: jsonb`);
     blocks.push(`input ${names.appendInput} {
 ${appendLines.join("\n")}
 }`);
   }
   const numericish = numericishColumns(table);
-  if (numericish.length > 0) {
+  if (access.update && numericish.length > 0) {
     const incLines = numericish.map(
       (column) => `  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}`
     );
@@ -630,7 +888,7 @@ ${incLines.join("\n")}
 }`);
   }
   const constraints = constraintValues(table);
-  if (constraints.length > 0) {
+  if (access.insert && allowsOnConflict(table) && constraints.length > 0) {
     for (const value of constraints) assertEnumValue(value, `constraint enum for table "${table.table}"`);
     blocks.push(renderEnum(names.constraintEnum, constraints));
     const updateColumns = table.columns.map((column) => fieldName(column.name));
@@ -643,12 +901,14 @@ ${incLines.join("\n")}
 }`
     );
   }
-  blocks.push(
-    `type ${names.mutationResponse} {
+  if (access.insert || access.update) {
+    blocks.push(
+      `type ${names.mutationResponse} {
   affectedRows: Int!
   returning: [${names.typename}!]!
 }`
-  );
+    );
+  }
   return blocks;
 }
 function renderQueryRoot(tables, namesByTable) {
@@ -673,35 +933,64 @@ function columnGqlTypeOf(table, column) {
 function renderMutationRoot(tables, namesByTable) {
   const lines = [];
   for (const table of tables) {
-    if (!isWritable(table)) continue;
+    const canInsert = allowsInsert(table);
+    const canUpdate = allowsUpdate(table);
+    if (!canInsert && !canUpdate) continue;
     const names = namesByTable.get(table.table);
     if (!names) continue;
     const constraints = constraintValues(table);
-    const onConflictArg = constraints.length > 0 ? `, onConflict: ${names.onConflict}` : "";
+    const onConflictArg = canInsert && allowsOnConflict(table) && constraints.length > 0 ? `, onConflict: ${names.onConflict}` : "";
     const updateArgs = [`_set: ${names.setInput}`];
     if (jsonbColumns(table).length > 0) updateArgs.push(`_append: ${names.appendInput}`);
     if (numericishColumns(table).length > 0) updateArgs.push(`_inc: ${names.incInput}`);
     const updateArgList = updateArgs.join(", ");
-    lines.push(`  ${names.insertRoot}(objects: [${names.insertInput}!]!${onConflictArg}): ${names.mutationResponse}`);
-    lines.push(`  ${names.insertOneRoot}(object: ${names.insertInput}!${onConflictArg}): ${names.typename}`);
-    lines.push(`  ${names.updateRoot}(where: ${names.boolExp}!, ${updateArgList}): ${names.mutationResponse}`);
-    const pk = primaryKeyColumns(table);
-    if (pk.length > 0) {
-      lines.push(
-        `  ${names.updateByPkRoot}(pkColumns: ${names.pkColumnsInput}!, ${updateArgList}): ${names.typename}`
-      );
+    if (canInsert) {
+      lines.push(`  ${names.insertRoot}(objects: [${names.insertInput}!]!${onConflictArg}): ${names.mutationResponse}`);
+      lines.push(`  ${names.insertOneRoot}(object: ${names.insertInput}!${onConflictArg}): ${names.typename}`);
     }
-    lines.push(`  ${names.deleteRoot}(where: ${names.boolExp}!): ${names.mutationResponse}`);
-    if (pk.length > 0) {
-      const args = pk.map((column) => `${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}!`).join(", ");
-      lines.push(`  ${names.deleteByPkRoot}(${args}): ${names.typename}`);
+    if (canUpdate) {
+      lines.push(`  ${names.updateRoot}(where: ${names.boolExp}!, ${updateArgList}): ${names.mutationResponse}`);
+      const pk = primaryKeyColumns(table);
+      if (pk.length > 0) {
+        lines.push(
+          `  ${names.updateByPkRoot}(pkColumns: ${names.pkColumnsInput}!, ${updateArgList}): ${names.typename}`
+        );
+      }
+      lines.push(`  ${names.deleteRoot}(where: ${names.boolExp}!): ${names.mutationResponse}`);
+      if (pk.length > 0) {
+        const args = pk.map((column) => `${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}!`).join(", ");
+        lines.push(`  ${names.deleteByPkRoot}(${args}): ${names.typename}`);
+      }
     }
+    lines.push(...renderCowMutationFields(table, names));
   }
   if (lines.length === 0) return null;
   return `type Mutation {
 ${lines.join("\n")}
 }`;
 }
+function renderCowMutationFields(table, names) {
+  const lines = [];
+  const columnByName = new Map(table.columns.map((column) => [column.name, column]));
+  for (const mutation of table.cowMutations ?? []) {
+    const pkColumn = columnByName.get(mutation.pk);
+    if (!pkColumn) continue;
+    const pkArg = `${fieldName(mutation.pk)}: ${columnGqlTypeOf(table, pkColumn)}!`;
+    if (mutation.kind === "revert") {
+      lines.push(`  ${fieldName(mutation.name)}(${pkArg}): ${names.typename}`);
+      continue;
+    }
+    const setArgs = mutation.set.map((property) => {
+      const column = columnByName.get(property);
+      if (!column) return null;
+      const bang = column.nullable === false ? "!" : "";
+      return `${fieldName(property)}: ${columnGqlTypeOf(table, column)}${bang}`;
+    });
+    if (setArgs.some((arg) => arg === null)) continue;
+    lines.push(`  ${fieldName(mutation.name)}(${pkArg}, ${setArgs.join(", ")}): ${names.typename}`);
+  }
+  return lines;
+}
 function stableJson(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value);
   if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
@@ -727,7 +1016,7 @@ var manifestRequiresSchema = zod.z.object({
 }).nullable();
 var manifestOperationSchema = zod.z.object({
   hash: zod.z.string().regex(OP_HASH_RE),
-  kind: zod.z.enum(["query", "mutation", "action"]),
+  kind: zod.z.enum(["query", "mutation"]),
   requires: manifestRequiresSchema
 });
 var operationsManifestSchema = zod.z.object({
@@ -781,14 +1070,14 @@ function generateTypePolicies(canonical) {
   const def = normalizeCanonical(canonicalDefinitionSchema.parse(canonical));
   const entries = [];
   let hasPlatformUser = false;
-  for (const table of def.tables) {
+  for (const table of canonicalRelations(def)) {
     if (table.source !== void 0) continue;
     if (table.links.some((link) => link.kind === "toPlatformUser")) hasPlatformUser = true;
     if (!table.primaryKey || table.primaryKey.length === 0) continue;
     const keyFields = table.primaryKey.map((identifier2) => {
       const column = table.columns.find((c) => c.columnName === identifier2 || c.name === identifier2);
       if (!column) {
-        throw new CodegenGqlError(`Primary key column "${identifier2}" not found on table "${table.table}".`);
+        throw new CodegenGqlError(`Primary key column "${identifier2}" not found on relation "${table.table}".`);
       }
       return fieldName(column.name);
     });