@sequenceholdings/orm 0.1.1 → 0.1.3

package/dist/sdl.cjs

@@ -0,0 +1,1122 @@
+'use strict';
+
+var zod = require('zod');
+var crypto = require('crypto');
+
+// src/canonical/v2.ts
+var CANONICAL_FORMAT = 2;
+var IDENTIFIER_RE = /^[a-z][a-z0-9_]*$/;
+var identifier = zod.z.string().min(1).max(63).regex(IDENTIFIER_RE);
+var COLUMN_TYPES = [
+  "uuid",
+  "text",
+  "integer",
+  "bigint",
+  "numeric",
+  "double",
+  "boolean",
+  "timestamptz",
+  "date",
+  "jsonb"
+];
+var columnTypeSchema = zod.z.enum(COLUMN_TYPES);
+var canonicalEnumSchema = zod.z.object({
+  name: identifier,
+  values: zod.z.array(zod.z.string().min(1).max(63)).min(1).max(100)
+});
+var canonicalColumnSchema = zod.z.object({
+  /** Property name in TS (camelCase); columnName is the Postgres name. */
+  name: zod.z.string().min(1).max(63),
+  columnName: identifier,
+  type: zod.z.union([columnTypeSchema, zod.z.object({ enum: identifier })]),
+  nullable: zod.z.boolean().default(true),
+  unique: zod.z.boolean().default(false),
+  /** Literal default, or one of the allowlisted SQL functions. */
+  default: zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean(), zod.z.null()]).optional(),
+  defaultFn: zod.z.enum(["gen_random_uuid()", "now()"]).optional(),
+  description: zod.z.string().max(500).optional(),
+  /** Migration hints — same semantics as v1. */
+  renamedFrom: identifier.optional(),
+  cast: zod.z.string().max(200).optional(),
+  deprecated: zod.z.boolean().default(false)
+});
+var canonicalLinkSchema = zod.z.object({
+  name: zod.z.string().min(1).max(63),
+  kind: zod.z.enum(["toOne", "toMany", "toPlatformUser"]),
+  /** Target table name (namespace-local). Absent for toPlatformUser. */
+  target: identifier.optional(),
+  /** FK column on the owning side (toOne/toPlatformUser: on this table; toMany: on the target). */
+  on: identifier,
+  /** Referenced column on the target (default: target's PK / platform user `sub`). */
+  references: identifier.optional(),
+  /** enforce: true emits a real FK constraint (same-namespace toOne only). */
+  enforce: zod.z.boolean().default(false),
+  description: zod.z.string().max(500).optional()
+});
+var canonicalIndexSchema = zod.z.object({
+  columns: zod.z.array(identifier).min(1),
+  unique: zod.z.boolean().default(false),
+  name: identifier.optional()
+});
+var policyVariantSchema = zod.z.object({
+  /** Claims-only guard (capability()/role()/claim() comparisons — no columns). */
+  when: zod.z.string().min(1).max(1e3),
+  /** Exactly one of: allow-all bypass, or a row predicate. */
+  allow: zod.z.literal(true).optional(),
+  policy: zod.z.string().min(1).max(2e3).optional()
+}).refine((v) => v.allow === true !== (typeof v.policy === "string"), {
+  message: "A variant declares exactly one of allow: true or policy"
+});
+var policyExpressionSchema = zod.z.union([
+  zod.z.string().min(1).max(2e3),
+  zod.z.object({
+    default: zod.z.string().min(1).max(2e3),
+    variants: zod.z.array(policyVariantSchema).max(10).default([])
+  })
+]);
+var canonicalPoliciesSchema = zod.z.object({
+  read: 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(),
+  params: zod.z.record(zod.z.string(), zod.z.object({
+    type: columnTypeSchema,
+    nullable: zod.z.boolean().default(false)
+  })).default({}),
+  executes: zod.z.string().min(1).max(1e4),
+  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(),
+  /** Table-level rename hint (new in v2). */
+  renamedFrom: identifier.optional(),
+  /** Synced/reflected read-only tables (`source: gold.*`) — v1 semantics. */
+  source: zod.z.string().regex(/^gold\.[a-z][a-z0-9_]*$/).optional(),
+  columns: zod.z.array(canonicalColumnSchema).default([]),
+  primaryKey: zod.z.array(identifier).min(1).max(8).optional(),
+  links: zod.z.array(canonicalLinkSchema).default([]),
+  indexes: zod.z.array(canonicalIndexSchema).default([]),
+  policies: canonicalPoliciesSchema.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),
+  namespace: identifier.max(41),
+  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));
+  const normalized = {
+    ...definition,
+    enums: sortByName(definition.enums),
+    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
+function camelCase(name) {
+  const segments = name.split("_").filter((segment) => segment.length > 0);
+  const first = segments[0];
+  if (first === void 0) return name;
+  const head = first.charAt(0).toLowerCase() + first.slice(1);
+  return head + segments.slice(1).map(capitalizeFirst).join("");
+}
+function pascalCase(name) {
+  return capitalizeFirst(camelCase(name));
+}
+function capitalizeFirst(segment) {
+  return segment.charAt(0).toUpperCase() + segment.slice(1);
+}
+function singularizeWord(word) {
+  if (word.endsWith("ies") && word.length > 3) return `${word.slice(0, -3)}y`;
+  for (const suffix of ["sses", "xes", "ches", "shes"]) {
+    if (word.endsWith(suffix)) return word.slice(0, -2);
+  }
+  if (word.endsWith("ss")) return word;
+  if (word.endsWith("s") && word.length > 1) return word.slice(0, -1);
+  return word;
+}
+function typeName(table) {
+  const segments = table.split("_").filter((segment) => segment.length > 0);
+  const last = segments[segments.length - 1];
+  if (last === void 0) return pascalCase(table);
+  return [...segments.slice(0, -1), singularizeWord(last)].map(capitalizeFirst).join("");
+}
+function fieldName(column) {
+  return camelCase(column);
+}
+function enumTypeName(name) {
+  return pascalCase(name);
+}
+function comparisonExpName(gqlTypeName) {
+  return `${capitalizeFirst(gqlTypeName)}ComparisonExp`;
+}
+var SCALAR_FOR_COLUMN_TYPE = {
+  uuid: "uuid",
+  text: "String",
+  integer: "Int",
+  bigint: "bigint",
+  numeric: "numeric",
+  double: "Float",
+  boolean: "Boolean",
+  timestamptz: "timestamptz",
+  date: "date",
+  jsonb: "jsonb"
+};
+function graphqlScalarFor(type) {
+  return SCALAR_FOR_COLUMN_TYPE[type];
+}
+var COLUMN_TYPE_BY_SCALAR = new Map([
+  ["ID", "text"],
+  ...COLUMN_TYPES.map((type) => [graphqlScalarFor(type), type])
+]);
+function columnTypeForScalar(scalarName) {
+  return COLUMN_TYPE_BY_SCALAR.get(scalarName);
+}
+var VARIABLE_SCALAR_NAMES = [...COLUMN_TYPE_BY_SCALAR.keys()];
+var CUSTOM_SCALARS = ["bigint", "date", "jsonb", "numeric", "timestamptz", "uuid"];
+var NUMERICISH_COLUMN_TYPES = ["integer", "bigint", "numeric", "double"];
+var ORDER_BY_ENUM = "OrderBy";
+var ORDER_BY_ENUM_VALUES = [
+  "ASC",
+  "ASC_NULLS_FIRST",
+  "ASC_NULLS_LAST",
+  "DESC",
+  "DESC_NULLS_FIRST",
+  "DESC_NULLS_LAST"
+];
+var PLATFORM_USER_TYPENAME = "PlatformUser";
+function tableNames(table) {
+  const root = camelCase(table);
+  const rootPascal = pascalCase(table);
+  const type = typeName(table);
+  return {
+    typename: type,
+    selectRoot: root,
+    byPkRoot: `${root}ByPk`,
+    aggregateRoot: `${root}Aggregate`,
+    insertRoot: `insert${rootPascal}`,
+    insertOneRoot: `insert${rootPascal}One`,
+    updateRoot: `update${rootPascal}`,
+    updateByPkRoot: `update${rootPascal}ByPk`,
+    deleteRoot: `delete${rootPascal}`,
+    deleteByPkRoot: `delete${rootPascal}ByPk`,
+    boolExp: `${type}BoolExp`,
+    orderBy: `${type}OrderBy`,
+    selectColumn: `${type}SelectColumn`,
+    insertInput: `${type}InsertInput`,
+    setInput: `${type}SetInput`,
+    appendInput: `${type}AppendInput`,
+    incInput: `${type}IncInput`,
+    onConflict: `${type}OnConflict`,
+    pkColumnsInput: `${type}PkColumnsInput`,
+    constraintEnum: `${type}Constraint`,
+    updateColumnEnum: `${type}UpdateColumn`,
+    mutationResponse: `${type}MutationResponse`,
+    aggregate: `${type}Aggregate`,
+    aggregateFields: `${type}AggregateFields`,
+    sumFields: `${type}SumFields`,
+    avgFields: `${type}AvgFields`,
+    aggregateBoolExp: `${type}AggregateBoolExp`,
+    aggregateBoolExpCount: `${type}AggregateBoolExpCount`
+  };
+}
+
+// src/sdl/generate.ts
+var SdlGenerationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SdlGenerationError";
+  }
+};
+var GRAPHQL_NAME_RE = /^[_A-Za-z][_0-9A-Za-z]*$/;
+var RESERVED_ENUM_VALUES = /* @__PURE__ */ new Set(["true", "false", "null"]);
+var NUMERICISH = new Set(NUMERICISH_COLUMN_TYPES);
+var PLATFORM_USER_FIELDS = [
+  { name: "sub", gqlType: "String", nullable: false },
+  { name: "email", gqlType: "String", nullable: true },
+  { name: "name", gqlType: "String", nullable: true },
+  { name: "organization", gqlType: "String", nullable: true },
+  { name: "role", gqlType: "String", nullable: true },
+  { name: "managerId", gqlType: "String", nullable: true },
+  { name: "accountEnabled", gqlType: "Boolean", nullable: false }
+];
+function generateSdl(canonical, options = {}) {
+  const def = normalizeCanonical(canonicalDefinitionSchema.parse(canonical));
+  const tables = canonicalRelations(def).filter((table) => table.source === void 0);
+  if (tables.length === 0) {
+    throw new SdlGenerationError(
+      `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(`Relation "${table.table}" has no columns \u2014 cannot generate an object type.`);
+    }
+  }
+  const namesByTable = new Map(tables.map((table) => [table.table, tableNames(table.table)]));
+  const enumByName = new Map(def.enums.map((entry) => [entry.name, entry]));
+  const hasPlatformUser = tables.some((table) => table.links.some((link) => link.kind === "toPlatformUser"));
+  const usedEnums = /* @__PURE__ */ new Set();
+  for (const table of tables) {
+    for (const column of table.columns) {
+      if (typeof column.type === "object") {
+        if (!enumByName.has(column.type.enum)) {
+          throw new SdlGenerationError(
+            `Column "${table.table}.${column.columnName}" references undeclared enum "${column.type.enum}".`
+          );
+        }
+        usedEnums.add(column.type.enum);
+      }
+    }
+  }
+  const aggregateBoolExpTargets = /* @__PURE__ */ new Set();
+  for (const table of tables) {
+    for (const link of table.links) {
+      if (link.kind === "toMany" && link.target !== void 0 && namesByTable.has(link.target)) {
+        aggregateBoolExpTargets.add(link.target);
+      }
+    }
+  }
+  const usedComparisonScalars = /* @__PURE__ */ new Set();
+  for (const table of tables) {
+    for (const column of table.columns) {
+      if (typeof column.type !== "object") usedComparisonScalars.add(graphqlScalarFor(column.type));
+    }
+  }
+  if (hasPlatformUser) {
+    usedComparisonScalars.add("String");
+    usedComparisonScalars.add("Boolean");
+  }
+  if (aggregateBoolExpTargets.size > 0) usedComparisonScalars.add("Int");
+  const blocks = [];
+  blocks.push(
+    `# Generated by @sequenceholdings/orm \u2014 GraphQL SDL for namespace "${def.namespace}".
+# Do not edit: regenerate with \`seq-studio orm generate\`.`
+  );
+  blocks.push("directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT");
+  blocks.push(
+    '"""Gates an operation behind a platform capability or custom role \u2014 checked by the data plane before execution."""\ndirective @requires(capability: String, role: String) on QUERY | MUTATION'
+  );
+  blocks.push("directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT");
+  for (const scalar of CUSTOM_SCALARS) blocks.push(`scalar ${scalar}`);
+  blocks.push(renderEnum(ORDER_BY_ENUM, [...ORDER_BY_ENUM_VALUES]));
+  for (const enumName of [...usedEnums].sort()) {
+    const entry = enumByName.get(enumName);
+    if (!entry) continue;
+    for (const value of entry.values) assertEnumValue(value, `enum "${enumName}"`);
+    blocks.push(renderEnum(enumTypeName(enumName), entry.values));
+  }
+  for (const scalar of [...usedComparisonScalars].sort()) {
+    blocks.push(renderComparisonExp(scalar));
+  }
+  for (const enumName of [...usedEnums].sort()) {
+    blocks.push(renderComparisonExp(enumTypeName(enumName)));
+  }
+  if (hasPlatformUser) blocks.push(...renderPlatformUserBlocks());
+  for (const table of tables) {
+    const names = namesByTable.get(table.table);
+    if (!names) continue;
+    blocks.push(
+      ...renderTableBlocks({
+        table,
+        names,
+        namesByTable,
+        emitAggregateBoolExp: aggregateBoolExpTargets.has(table.table),
+        pinned: options.pinnedColumns?.[table.table] ?? []
+      })
+    );
+  }
+  blocks.push(renderQueryRoot(tables, namesByTable));
+  const mutationRoot = renderMutationRoot(tables, namesByTable);
+  if (mutationRoot !== null) blocks.push(mutationRoot);
+  return `${blocks.join("\n\n")}
+`;
+}
+function assertEnumValue(value, context) {
+  if (!GRAPHQL_NAME_RE.test(value) || RESERVED_ENUM_VALUES.has(value)) {
+    throw new SdlGenerationError(
+      `Value "${value}" in ${context} is not a valid GraphQL enum value (must match ${GRAPHQL_NAME_RE} and not be true/false/null).`
+    );
+  }
+}
+function renderEnum(name, values) {
+  return `enum ${name} {
+${values.map((value) => `  ${value}`).join("\n")}
+}`;
+}
+function descriptionLines(text, indent) {
+  const escaped = text.replace(/"""/g, '\\"""');
+  return [`${indent}"""`, ...escaped.split("\n").map((line) => `${indent}${line}`), `${indent}"""`];
+}
+function renderComparisonExp(gqlTypeName) {
+  const fields = [
+    ["_eq", gqlTypeName],
+    ["_neq", gqlTypeName],
+    ["_gt", gqlTypeName],
+    ["_gte", gqlTypeName],
+    ["_lt", gqlTypeName],
+    ["_lte", gqlTypeName],
+    ["_in", `[${gqlTypeName}!]`],
+    ["_nin", `[${gqlTypeName}!]`],
+    ["_isNull", "Boolean"]
+  ];
+  if (gqlTypeName === "String") {
+    fields.push(["_like", "String"], ["_ilike", "String"]);
+  }
+  if (gqlTypeName === "jsonb") {
+    fields.push(["_contains", "jsonb"], ["_hasKey", "String"]);
+  }
+  fields.sort(([a], [b]) => a.localeCompare(b));
+  const body = fields.map(([field, type]) => `  ${field}: ${type}`).join("\n");
+  return `input ${comparisonExpName(gqlTypeName)} {
+${body}
+}`;
+}
+function renderPlatformUserBlocks() {
+  const typeFields = PLATFORM_USER_FIELDS.map(
+    (field) => `  ${field.name}: ${field.gqlType}${field.nullable ? "" : "!"}`
+  ).join("\n");
+  const boolExpName = `${PLATFORM_USER_TYPENAME}BoolExp`;
+  const boolFields = [
+    `  _and: [${boolExpName}!]`,
+    `  _not: ${boolExpName}`,
+    `  _or: [${boolExpName}!]`,
+    ...PLATFORM_USER_FIELDS.map((field) => `  ${field.name}: ${comparisonExpName(field.gqlType)}`)
+  ].join("\n");
+  const orderFields = PLATFORM_USER_FIELDS.map((field) => `  ${field.name}: ${ORDER_BY_ENUM}`).join("\n");
+  return [
+    `"""Curated read-only view over platform users (plan \xA74b) \u2014 reachable only through \`toPlatformUser\` links."""
+type ${PLATFORM_USER_TYPENAME} {
+${typeFields}
+}`,
+    `input ${boolExpName} {
+${boolFields}
+}`,
+    `input ${PLATFORM_USER_TYPENAME}OrderBy {
+${orderFields}
+}`
+  ];
+}
+function relationArgs(target) {
+  return `where: ${target.boolExp}, orderBy: [${target.orderBy}!], limit: Int, offset: Int`;
+}
+function rootArgs(names) {
+  return `where: ${names.boolExp}, orderBy: [${names.orderBy}!], distinctOn: [${names.selectColumn}!], limit: Int, offset: Int`;
+}
+function primaryKeyColumns(table) {
+  if (!table.primaryKey || table.primaryKey.length === 0) return [];
+  return table.primaryKey.map((identifier2) => {
+    const column = table.columns.find((c) => c.columnName === identifier2 || c.name === identifier2);
+    if (!column) {
+      throw new SdlGenerationError(`Primary key column "${identifier2}" not found on table "${table.table}".`);
+    }
+    return column;
+  });
+}
+function renderTableBlocks(ctx) {
+  const { table, names } = ctx;
+  const blocks = [
+    renderObjectType(ctx),
+    renderSelectColumnEnum(ctx),
+    renderOrderByInput(ctx),
+    renderBoolExp(ctx),
+    ...renderAggregateTypes(ctx)
+  ];
+  if (ctx.emitAggregateBoolExp) blocks.push(...renderAggregateBoolExp(ctx));
+  const pk = primaryKeyColumns(table);
+  if (pk.length > 0) {
+    const fields = pk.map((column) => `  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}!`).join("\n");
+    blocks.push(`input ${names.pkColumnsInput} {
+${fields}
+}`);
+  }
+  if (allowsInsert(table) || allowsUpdate(table)) {
+    blocks.push(...renderWriteBlocks(ctx, { insert: allowsInsert(table), update: allowsUpdate(table) }));
+  }
+  return blocks;
+}
+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) {
+  const { table, names } = ctx;
+  const lines = [];
+  if (table.description !== void 0) lines.push(...descriptionLines(table.description, ""));
+  lines.push(`type ${names.typename} {`);
+  for (const column of table.columns) {
+    if (column.description !== void 0) lines.push(...descriptionLines(column.description, "  "));
+    const bang = column.nullable ? "" : "!";
+    const deprecated = column.deprecated ? " @deprecated" : "";
+    lines.push(`  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}${bang}${deprecated}`);
+  }
+  for (const link of table.links) {
+    if (link.description !== void 0) lines.push(...descriptionLines(link.description, "  "));
+    if (link.kind === "toPlatformUser") {
+      lines.push(`  ${fieldName(link.name)}: ${PLATFORM_USER_TYPENAME}`);
+      continue;
+    }
+    const target = link.target !== void 0 ? ctx.namesByTable.get(link.target) : void 0;
+    if (!target) continue;
+    if (link.kind === "toOne") {
+      lines.push(`  ${fieldName(link.name)}: ${target.typename}`);
+    } else {
+      lines.push(`  ${fieldName(link.name)}(${relationArgs(target)}): [${target.typename}!]!`);
+      lines.push(`  ${fieldName(link.name)}Aggregate(${relationArgs(target)}): ${target.aggregate}!`);
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function renderSelectColumnEnum(ctx) {
+  const values = ctx.table.columns.map((column) => fieldName(column.name));
+  for (const value of values) assertEnumValue(value, `select-column enum for table "${ctx.table.table}"`);
+  return renderEnum(ctx.names.selectColumn, values);
+}
+function renderOrderByInput(ctx) {
+  const { table, names } = ctx;
+  const lines = table.columns.map((column) => `  ${fieldName(column.name)}: ${ORDER_BY_ENUM}`);
+  for (const link of table.links) {
+    if (link.kind === "toPlatformUser") {
+      lines.push(`  ${fieldName(link.name)}: ${PLATFORM_USER_TYPENAME}OrderBy`);
+    } else if (link.kind === "toOne" && link.target !== void 0) {
+      const target = ctx.namesByTable.get(link.target);
+      if (target) lines.push(`  ${fieldName(link.name)}: ${target.orderBy}`);
+    }
+  }
+  return `input ${names.orderBy} {
+${lines.join("\n")}
+}`;
+}
+function renderBoolExp(ctx) {
+  const { table, names } = ctx;
+  const lines = [
+    `  _and: [${names.boolExp}!]`,
+    `  _not: ${names.boolExp}`,
+    `  _or: [${names.boolExp}!]`
+  ];
+  for (const column of table.columns) {
+    lines.push(`  ${fieldName(column.name)}: ${comparisonExpName(columnGqlTypeOf(table, column))}`);
+  }
+  for (const link of table.links) {
+    if (link.kind === "toPlatformUser") {
+      lines.push(`  ${fieldName(link.name)}: ${PLATFORM_USER_TYPENAME}BoolExp`);
+      continue;
+    }
+    const target = link.target !== void 0 ? ctx.namesByTable.get(link.target) : void 0;
+    if (!target) continue;
+    lines.push(`  ${fieldName(link.name)}: ${target.boolExp}`);
+    if (link.kind === "toMany") {
+      lines.push(`  ${fieldName(link.name)}Aggregate: ${target.aggregateBoolExp}`);
+    }
+  }
+  return `input ${names.boolExp} {
+${lines.join("\n")}
+}`;
+}
+function numericishColumns(table) {
+  return table.columns.filter((column) => typeof column.type !== "object" && NUMERICISH.has(column.type));
+}
+function jsonbColumns(table) {
+  return table.columns.filter((column) => column.type === "jsonb");
+}
+function renderAggregateTypes(ctx) {
+  const { table, names } = ctx;
+  const numericish = numericishColumns(table);
+  const blocks = [];
+  blocks.push(
+    `type ${names.aggregate} {
+  aggregate: ${names.aggregateFields}
+  nodes: [${names.typename}!]!
+}`
+  );
+  const fieldLines = [`  count(columns: [${names.selectColumn}!], distinct: Boolean): Int!`];
+  if (numericish.length > 0) {
+    fieldLines.push(`  avg: ${names.avgFields}`);
+    fieldLines.push(`  sum: ${names.sumFields}`);
+  }
+  blocks.push(`type ${names.aggregateFields} {
+${fieldLines.join("\n")}
+}`);
+  if (numericish.length > 0) {
+    const avgLines = numericish.map((column) => `  ${fieldName(column.name)}: Float`);
+    blocks.push(`type ${names.avgFields} {
+${avgLines.join("\n")}
+}`);
+    const sumLines = numericish.map((column) => `  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}`);
+    blocks.push(`type ${names.sumFields} {
+${sumLines.join("\n")}
+}`);
+  }
+  return blocks;
+}
+function renderAggregateBoolExp(ctx) {
+  const { names } = ctx;
+  return [
+    `input ${names.aggregateBoolExp} {
+  count: ${names.aggregateBoolExpCount}
+}`,
+    `input ${names.aggregateBoolExpCount} {
+  arguments: [${names.selectColumn}!]
+  distinct: Boolean
+  filter: ${names.boolExp}
+  predicate: IntComparisonExp!
+}`
+  ];
+}
+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}_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, access) {
+  const { table, names, pinned } = ctx;
+  const blocks = [];
+  if (access.insert) {
+    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(", ")}].`
+      );
+    }
+    const insertLines = insertable.map(
+      (column) => `  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}`
+    );
+    blocks.push(`input ${names.insertInput} {
+${insertLines.join("\n")}
+}`);
+  }
+  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 (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 (access.update && numericish.length > 0) {
+    const incLines = numericish.map(
+      (column) => `  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}`
+    );
+    blocks.push(`input ${names.incInput} {
+${incLines.join("\n")}
+}`);
+  }
+  const constraints = constraintValues(table);
+  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));
+    blocks.push(renderEnum(names.updateColumnEnum, updateColumns));
+    blocks.push(
+      `input ${names.onConflict} {
+  constraint: ${names.constraintEnum}!
+  updateColumns: [${names.updateColumnEnum}!]! = []
+  where: ${names.boolExp}
+}`
+    );
+  }
+  if (access.insert || access.update) {
+    blocks.push(
+      `type ${names.mutationResponse} {
+  affectedRows: Int!
+  returning: [${names.typename}!]!
+}`
+    );
+  }
+  return blocks;
+}
+function renderQueryRoot(tables, namesByTable) {
+  const lines = ["type Query {"];
+  for (const table of tables) {
+    const names = namesByTable.get(table.table);
+    if (!names) continue;
+    lines.push(`  ${names.selectRoot}(${rootArgs(names)}): [${names.typename}!]!`);
+    const pk = primaryKeyColumns(table);
+    if (pk.length > 0) {
+      const args = pk.map((column) => `${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}!`).join(", ");
+      lines.push(`  ${names.byPkRoot}(${args}): ${names.typename}`);
+    }
+    lines.push(`  ${names.aggregateRoot}(${rootArgs(names)}): ${names.aggregate}!`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function columnGqlTypeOf(table, column) {
+  return typeof column.type === "object" ? enumTypeName(column.type.enum) : graphqlScalarFor(column.type);
+}
+function renderMutationRoot(tables, namesByTable) {
+  const lines = [];
+  for (const table of tables) {
+    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 = 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(", ");
+    if (canInsert) {
+      lines.push(`  ${names.insertRoot}(objects: [${names.insertInput}!]!${onConflictArg}): ${names.mutationResponse}`);
+      lines.push(`  ${names.insertOneRoot}(object: ${names.insertInput}!${onConflictArg}): ${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(",")}]`;
+  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 {
+  constructor(message) {
+    super(message);
+    this.name = "CodegenGqlError";
+  }
+};
+
+// src/codegen-gql/manifest.ts
+var MANIFEST_VERSION = 1;
+var OP_HASH_RE = /^sha256:[0-9a-f]{64}$/;
+var GRAPHQL_NAME_RE2 = /^[_A-Za-z][_0-9A-Za-z]*$/;
+var manifestRequiresSchema = zod.z.object({
+  capability: zod.z.string().min(1).optional(),
+  role: zod.z.string().min(1).optional()
+}).nullable();
+var manifestOperationSchema = zod.z.object({
+  hash: zod.z.string().regex(OP_HASH_RE),
+  kind: zod.z.enum(["query", "mutation"]),
+  requires: manifestRequiresSchema
+});
+var operationsManifestSchema = zod.z.object({
+  manifestVersion: zod.z.literal(MANIFEST_VERSION),
+  schemaHash: zod.z.string().min(1),
+  opsHash: zod.z.string().regex(OP_HASH_RE),
+  operations: zod.z.record(zod.z.string().regex(GRAPHQL_NAME_RE2), manifestOperationSchema)
+});
+function buildOperationsManifest({
+  schemaHash,
+  operations
+}) {
+  if (schemaHash.length === 0) throw new CodegenGqlError("schemaHash must be a non-empty string.");
+  const sorted = [...operations].sort((a, b) => a.name.localeCompare(b.name));
+  const seen = /* @__PURE__ */ new Set();
+  const entries = sorted.map((op) => {
+    if (!GRAPHQL_NAME_RE2.test(op.name)) {
+      throw new CodegenGqlError(`Operation name "${op.name}" is not a valid GraphQL name.`);
+    }
+    if (seen.has(op.name)) {
+      throw new CodegenGqlError(`Duplicate operation name "${op.name}" \u2014 operation names must be unique per namespace.`);
+    }
+    seen.add(op.name);
+    if (!OP_HASH_RE.test(op.hash)) {
+      throw new CodegenGqlError(`Operation "${op.name}" has malformed hash "${op.hash}" (expected sha256:<64 hex>).`);
+    }
+    return { name: op.name, hash: op.hash, kind: op.kind, requires: normalizeRequires(op.requires) };
+  });
+  const opsHash = `sha256:${crypto.createHash("sha256").update(stableJson(entries)).digest("hex")}`;
+  const operationsRecord = {};
+  for (const entry of entries) {
+    operationsRecord[entry.name] = { hash: entry.hash, kind: entry.kind, requires: entry.requires };
+  }
+  return {
+    manifestVersion: MANIFEST_VERSION,
+    schemaHash,
+    opsHash,
+    operations: operationsRecord
+  };
+}
+function normalizeRequires(requires) {
+  if (requires === void 0 || requires === null) return null;
+  const normalized = {};
+  if (requires.capability !== void 0) normalized.capability = requires.capability;
+  if (requires.role !== void 0) normalized.role = requires.role;
+  return normalized.capability === void 0 && normalized.role === void 0 ? null : normalized;
+}
+
+// src/codegen-gql/type-policies.ts
+function generateTypePolicies(canonical) {
+  const def = normalizeCanonical(canonicalDefinitionSchema.parse(canonical));
+  const entries = [];
+  let hasPlatformUser = false;
+  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 relation "${table.table}".`);
+      }
+      return fieldName(column.name);
+    });
+    entries.push({ typename: tableNames(table.table).typename, keyFields });
+  }
+  if (hasPlatformUser) entries.push({ typename: PLATFORM_USER_TYPENAME, keyFields: ["sub"] });
+  entries.sort((a, b) => a.typename.localeCompare(b.typename));
+  const body = entries.map((entry) => `  ${entry.typename}: { keyFields: [${entry.keyFields.map((key) => `'${key}'`).join(", ")}] },`).join("\n");
+  return `/* Generated by @sequenceholdings/orm \u2014 Apollo cache type policies. Do not edit. */
+import type { TypePolicies } from '@apollo/client'
+
+export const typePolicies: TypePolicies = {
+${body}
+}
+`;
+}
+
+exports.CUSTOM_SCALARS = CUSTOM_SCALARS;
+exports.MANIFEST_VERSION = MANIFEST_VERSION;
+exports.NUMERICISH_COLUMN_TYPES = NUMERICISH_COLUMN_TYPES;
+exports.ORDER_BY_ENUM = ORDER_BY_ENUM;
+exports.ORDER_BY_ENUM_VALUES = ORDER_BY_ENUM_VALUES;
+exports.PLATFORM_USER_TYPENAME = PLATFORM_USER_TYPENAME;
+exports.SdlGenerationError = SdlGenerationError;
+exports.VARIABLE_SCALAR_NAMES = VARIABLE_SCALAR_NAMES;
+exports.buildOperationsManifest = buildOperationsManifest;
+exports.camelCase = camelCase;
+exports.columnTypeForScalar = columnTypeForScalar;
+exports.comparisonExpName = comparisonExpName;
+exports.enumTypeName = enumTypeName;
+exports.fieldName = fieldName;
+exports.generateSdl = generateSdl;
+exports.generateTypePolicies = generateTypePolicies;
+exports.graphqlScalarFor = graphqlScalarFor;
+exports.manifestOperationSchema = manifestOperationSchema;
+exports.manifestRequiresSchema = manifestRequiresSchema;
+exports.operationsManifestSchema = operationsManifestSchema;
+exports.pascalCase = pascalCase;
+exports.tableNames = tableNames;
+exports.typeName = typeName;
+//# sourceMappingURL=sdl.cjs.map
+//# sourceMappingURL=sdl.cjs.map