@sequenceholdings/orm 2.7.1 → 2.8.1

package/dist/compiler.cjs

@@ -1841,9 +1841,15 @@ function typeName(table) {
   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(name2) {
   return pascalCase(name2);
 }
+function comparisonExpName(gqlTypeName) {
+  return `${capitalizeFirst(gqlTypeName)}ComparisonExp`;
+}
 var SCALAR_FOR_COLUMN_TYPE = {
   uuid: "uuid",
   text: "String",
@@ -1867,7 +1873,19 @@ 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";
+var DATE_BUCKET_ENUM = "DateBucket";
 function tableNames(table) {
   const root = camelCase(table);
   const rootPascal = pascalCase(table);
@@ -3480,8 +3498,8 @@ var COMPILER_MAJOR = 1;
 var OP_HASH_DOMAIN = "sequence-orm-op\0";
 var OPS_HASH_DOMAIN = "sequence-orm-opset\0";
 function canonicalOperationText(definition) {
-  const document = { kind: graphql.Kind.DOCUMENT, definitions: [definition] };
-  return graphql.print(document);
+  const document2 = { kind: graphql.Kind.DOCUMENT, definitions: [definition] };
+  return graphql.print(document2);
 }
 function computeOpHash({
   definition,
@@ -4729,9 +4747,9 @@ function parseDocuments({
   const parsed = [];
   const diagnostics = [];
   for (const source of documents) {
-    let document;
+    let document2;
     try {
-      document = graphql.parse(source.contents);
+      document2 = graphql.parse(source.contents);
     } catch (error) {
       diagnostics.push({
         severity: "error",
@@ -4741,7 +4759,7 @@ function parseDocuments({
       });
       continue;
     }
-    const validationErrors = graphql.validate(schema, document);
+    const validationErrors = graphql.validate(schema, document2);
     if (validationErrors.length > 0) {
       for (const validationError of validationErrors) {
         diagnostics.push({
@@ -4755,11 +4773,11 @@ function parseDocuments({
     }
     const operations = [];
     const fragments = /* @__PURE__ */ new Map();
-    for (const definition of document.definitions) {
+    for (const definition of document2.definitions) {
       if (definition.kind === graphql.Kind.OPERATION_DEFINITION) operations.push(definition);
       if (definition.kind === graphql.Kind.FRAGMENT_DEFINITION) fragments.set(definition.name.value, definition);
     }
-    parsed.push({ path: source.path, document, operations, fragments });
+    parsed.push({ path: source.path, document: document2, operations, fragments });
   }
   return { documents: parsed, diagnostics };
 }
@@ -4957,12 +4975,12 @@ function compileNamespace({ canonical, sdl, documents }) {
   diagnostics.push(...parsed.diagnostics);
   const operations = {};
   const operationSources = /* @__PURE__ */ new Map();
-  for (const document of parsed.documents) {
-    for (const operationNode of document.operations) {
+  for (const document2 of parsed.documents) {
+    for (const operationNode of document2.operations) {
       const operationName = operationNode.name?.value;
       try {
         const restricted = restrictOperation({ operation: operationNode, ctx });
-        const flattened = flattenOperation({ operation: restricted.definition, fragments: document.fragments });
+        const flattened = flattenOperation({ operation: restricted.definition, fragments: document2.fragments });
         const previousSource = operationSources.get(restricted.name);
         if (previousSource !== void 0) {
           throw new DocumentCompileError(
@@ -4994,14 +5012,14 @@ function compileNamespace({ canonical, sdl, documents }) {
           tableSet,
           roots
         };
-        operationSources.set(restricted.name, document.path);
+        operationSources.set(restricted.name, document2.path);
       } catch (error) {
         if (error instanceof DocumentCompileError) {
           diagnostics.push({
             severity: "error",
             code: error.code,
             message: error.message,
-            document: document.path,
+            document: document2.path,
             ...operationName !== void 0 ? { operation: operationName } : {}
           });
           continue;
@@ -5429,6 +5447,815 @@ function validateOnConflictInput({
   return finish(collector, { constraint, updateColumns });
 }
 
+// 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 = composeNamespace(normalizeCanonical(canonicalDefinitionSchema.parse(canonical))).definition;
+  const exposed = canonicalRelations(def).filter((table) => table.internal !== true && (table.source === void 0 || options.includeSyncedReads === true && (table.primaryKey?.length ?? 0) > 0));
+  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) }));
+  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'
+  );
+  if (!options.omitReadBudgetDirective) blocks.push(
+    '"""Sets a document-authored ceiling of 1\u201350001 rows for one flat select root. Runtime variables cannot raise it."""\ndirective @readBudget(maxRows: Int!) on QUERY'
+  );
+  blocks.push("directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT");
+  blocks.push(
+    '"""Abort the entire mutation unless this root affects exactly the document-authored number of rows. Mutation roots only; cannot be conditional."""\ndirective @assertAffectedRows(exactly: Int!) on FIELD'
+  );
+  if (tables.some((table) => table.resolved !== void 0)) blocks.push(...RESOLVED_DIRECTIVE_BLOCKS);
+  for (const scalar of CUSTOM_SCALARS) blocks.push(`scalar ${scalar}`);
+  blocks.push(...renderSharedCellTypes([...cellsByTable.values()]));
+  blocks.push(renderEnum(ORDER_BY_ENUM, [...ORDER_BY_ENUM_VALUES]));
+  blocks.push(renderEnum(DATE_BUCKET_ENUM, DATE_BUCKETS.map((bucket) => bucket.toUpperCase())));
+  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));
+  }
+  const patternTypes = options.stringOnlyPatternOperators ? STRING_PATTERN_COMPARISON_TYPES : PATTERN_COMPARISON_TYPES;
+  for (const scalar of [...usedComparisonScalars].sort()) {
+    blocks.push(renderComparisonExp({ gqlTypeName: scalar, patternTypes }));
+  }
+  for (const enumName of [...usedEnums].sort()) {
+    blocks.push(renderComparisonExp({ gqlTypeName: enumTypeName(enumName), patternTypes }));
+  }
+  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] ?? [],
+        cells: cellsByTable.get(table.table) ?? null
+      })
+    );
+  }
+  blocks.push(renderQueryRoot(tables, namesByTable));
+  const mutationRoot = renderMutationRoot(tables, namesByTable);
+  if (mutationRoot !== null) blocks.push(mutationRoot);
+  assertNoDuplicateTypeNames(blocks);
+  return `${blocks.join("\n\n")}
+`;
+}
+var TYPE_DECLARATION_RE = /^(?:type|input|enum|scalar|interface|union)\s+([_A-Za-z][_0-9A-Za-z]*)/;
+function assertNoDuplicateTypeNames(blocks) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    const declared = TYPE_DECLARATION_RE.exec(block)?.[1];
+    if (declared === void 0) continue;
+    if (seen.has(declared)) {
+      throw new SdlGenerationError(
+        `Generated schema declares "${declared}" twice. A canonical enum or table name is PascalCased into this GraphQL type name and collides with another declaration (for example an enum named "date_bucket" renders as "DateBucket", the shared bucket enum). Rename the offending enum or table.`
+      );
+    }
+    seen.add(declared);
+  }
+}
+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(name2, values) {
+  return `enum ${name2} {
+${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}"""`];
+}
+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],
+    ["_gt", gqlTypeName],
+    ["_gte", gqlTypeName],
+    ["_lt", gqlTypeName],
+    ["_lte", gqlTypeName],
+    ["_in", `[${gqlTypeName}!]`],
+    ["_nin", `[${gqlTypeName}!]`],
+    ["_isNull", "Boolean"]
+  ];
+  if (patternTypes.has(gqlTypeName)) {
+    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}
+}`
+  ];
+}
+var RESOLVED_DIRECTIVE_BLOCKS = [
+  '"""Refresh this resolved-table root from a prefetch source before reading. Key-addressed roots only; the source must support the root shape."""\ndirective @prefetch(source: String!, maxStaleness: String) repeatable on FIELD',
+  renderEnum("WritebackMode", ["SYNC", "ASYNC"]),
+  '"""Write this resolved-table mutation back to a prefetch source (SYNC rolls back on failure; ASYNC queues)."""\ndirective @writeback(source: String!, mode: WritebackMode) repeatable on FIELD',
+  '"""Declare that this mutation deliberately keeps writeback columns local to the named source."""\ndirective @localOnly(source: String!) repeatable on FIELD'
+];
+function trackedCells(table) {
+  const columns = [...new Set(table.columns.flatMap((column) => column.cell ? [column.cell.of] : []))];
+  if (columns.length === 0) return null;
+  return { resolved: table.columns.some((column) => column.cell?.part === "source"), columns };
+}
+function renderSharedCellTypes(all) {
+  const present = all.filter((cells) => cells !== null);
+  const blocks = [];
+  if (present.some((cells) => !cells.resolved)) {
+    blocks.push(`"""When, and by whom, a cell was last written."""
+type ${CELL_TYPENAMES.stamp} {
+  at: timestamptz!
+  by: String
+}`);
+  }
+  if (present.some((cells) => cells.resolved)) {
+    blocks.push(`"""A newer candidate value that lost to the column's resolve rule."""
+type ${CELL_TYPENAMES.conflict} {
+  source: String!
+  at: timestamptz
+  value: jsonb
+}`);
+    blocks.push(`"""How a resolved cell was decided: the winning source, its time and actor, and newer losers."""
+type ${CELL_TYPENAMES.resolved} {
+  source: String!
+  at: timestamptz
+  by: String
+  conflicts: [${CELL_TYPENAMES.conflict}!]!
+}`);
+  }
+  return blocks;
+}
+function renderCellsType(ctx) {
+  if (!ctx.cells) return [];
+  const cellType = ctx.cells.resolved ? CELL_TYPENAMES.resolved : CELL_TYPENAMES.stamp;
+  const lines = ctx.cells.columns.map((column) => `  ${fieldName(column)}: ${cellType}`);
+  return [`type ${cellsTypename(ctx.names.typename)} {
+${lines.join("\n")}
+}`];
+}
+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((identifier3) => {
+    const column = table.columns.find((c) => c.columnName === identifier3 || c.name === identifier3);
+    if (!column) {
+      throw new SdlGenerationError(`Primary key column "${identifier3}" not found on table "${table.table}".`);
+    }
+    return column;
+  });
+}
+function renderTableBlocks(ctx) {
+  const { table, names } = ctx;
+  const blocks = [
+    renderObjectType(ctx),
+    ...renderCellsType(ctx),
+    renderSelectColumnEnum(ctx),
+    renderOrderByInput(ctx),
+    renderBoolExp(ctx),
+    ...renderAggregateTypes(ctx),
+    ...renderGroupByTypes(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 (ctx.table.resolved !== void 0) {
+    blocks.push(...renderResolvedWriteBlocks(ctx));
+  } else if (allowsInsert(table) || allowsUpdate(table)) {
+    blocks.push(...renderWriteBlocks(ctx, { insert: allowsInsert(table), update: allowsUpdate(table) }));
+  }
+  return blocks;
+}
+function resolvedWritableColumns(table) {
+  const system = new Set(Object.values(RESOLVED_VIEW_SYSTEM_COLUMNS).map((column) => column.name));
+  return table.columns.filter((column) => !system.has(column.name));
+}
+function renderResolvedWriteBlocks(ctx) {
+  const { table, names } = ctx;
+  const writable = resolvedWritableColumns(table);
+  const pk = new Set(table.primaryKey ?? []);
+  const settable = writable.filter((column) => !pk.has(column.columnName));
+  const line = (column) => `  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}`;
+  const blocks = [];
+  if (allowsInsert(table)) blocks.push(`input ${names.insertInput} {
+${writable.map(line).join("\n")}
+}`);
+  if (allowsUpdate(table)) {
+    blocks.push(`input ${names.setInput} {
+${settable.map(line).join("\n")}
+}`);
+    blocks.push(renderEnum(names.updateColumnEnum, settable.map((column) => fieldName(column.name))));
+  }
+  return blocks;
+}
+function renderResolvedMutationFields(table, names) {
+  const lines = [];
+  const pk = primaryKeyColumns(table);
+  if (allowsInsert(table)) lines.push(`  ${names.insertOneRoot}(object: ${names.insertInput}!): ${names.typename}`);
+  if (allowsUpdate(table) && pk.length > 0) {
+    lines.push(`  ${names.updateByPkRoot}(pkColumns: ${names.pkColumnsInput}!, _set: ${names.setInput}!): ${names.typename}`);
+    lines.push(`  ${names.revertByPkRoot}(pkColumns: ${names.pkColumnsInput}!, columns: [${names.updateColumnEnum}!]!): ${names.typename}`);
+    if ((table.resolved?.deletedBy.length ?? 0) > 0) {
+      const args = pk.map((column) => `${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}!`).join(", ");
+      lines.push(`  ${names.deleteByPkRoot}(${args}): ${names.typename}`);
+    }
+  }
+  return lines;
+}
+function allowsInsert(table) {
+  return table.source === void 0 && (table.policies.write !== void 0 || table.policies.insert !== void 0);
+}
+function allowsUpdate(table) {
+  return table.source === void 0 && (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}`);
+  }
+  if (ctx.cells) {
+    lines.push('  """Per-cell metadata: when each field was last written, and by whom."""');
+    lines.push(`  ${CELLS_FIELD}: ${cellsTypename(names.typename)}!`);
+  }
+  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 clientWritableColumns(table).filter((column) => column.type === "jsonb");
+}
+function clientWritableColumns(table) {
+  return table.columns;
+}
+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 groupableColumns(table) {
+  return table.columns.filter((column) => column.type !== "jsonb");
+}
+function renderGroupByTypes(ctx) {
+  const { table, names } = ctx;
+  const groupable = groupableColumns(table);
+  if (groupable.length === 0) return [];
+  const keyLines = groupable.map((column) => `  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}`);
+  return [
+    renderEnum(names.groupByColumnEnum, groupable.map((column) => fieldName(column.name))),
+    `input ${names.groupByInput} {
+  column: ${names.groupByColumnEnum}!
+  bucket: ${DATE_BUCKET_ENUM}
+}`,
+    `type ${names.groupKey} {
+${keyLines.join("\n")}
+}`,
+    `type ${names.aggregateGroup} {
+  key: ${names.groupKey}!
+  aggregate: ${names.aggregateFields}
+}`
+  ];
+}
+function groupRootArgs(names) {
+  return `where: ${names.boolExp}, groupBy: [${names.groupByInput}!]!, limit: Int, offset: Int`;
+}
+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 clientSettableColumns(table) {
+  return clientWritableColumns(table).filter((column) => column.onUpdateFn === void 0);
+}
+function renderWriteBlocks(ctx, access) {
+  const { table, names, pinned } = ctx;
+  const blocks = [];
+  if (access.insert) {
+    const pinnedSet = new Set(pinned);
+    const insertable = clientWritableColumns(table).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 = clientSettableColumns(table).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 = clientSettableColumns(table).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}!`);
+    if (groupableColumns(table).length > 0) {
+      lines.push(`  ${names.aggregateGroupsRoot}(${groupRootArgs(names)}): [${names.aggregateGroup}!]!`);
+    }
+  }
+  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;
+    if (table.resolved !== void 0) {
+      lines.push(...renderResolvedMutationFields(table, 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;
+}
+
+// src/compiler-gql/default-operations.ts
+var DEFAULT_LIST_LIMIT = 100;
+function typeReference(type, nonNull = false) {
+  if (type instanceof graphql.GraphQLNonNull) return `${typeReference(type.ofType, true)}`;
+  const inner = type instanceof graphql.GraphQLList ? `[${typeReference(type.ofType)}]` : graphql.getNamedType(type).name;
+  return `${inner}${nonNull ? "!" : ""}`;
+}
+function objectScalarFields(type) {
+  return Object.entries(type.getFields()).filter(([, field]) => {
+    const named = graphql.getNamedType(field.type);
+    return named instanceof graphql.GraphQLScalarType || named instanceof graphql.GraphQLEnumType;
+  }).map(([name2]) => name2);
+}
+function argumentInputFields(arg) {
+  if (arg.name !== "pkColumns") return void 0;
+  const input = graphql.getNamedType(arg.type);
+  if (!(input instanceof graphql.GraphQLInputObjectType)) return void 0;
+  return Object.values(input.getFields()).map((field) => ({
+    name: field.name,
+    type: field.type,
+    variable: field.name
+  }));
+}
+function inputFieldsTouchWriteback(root, writebackColumns) {
+  if (!root) return false;
+  const input = graphql.getNamedType(root.type);
+  return input instanceof graphql.GraphQLInputObjectType && Object.keys(input.getFields()).some((field) => writebackColumns.has(field));
+}
+function variableDefinitions(args, defaults = {}) {
+  return args.flatMap((arg) => {
+    const inputFields = argumentInputFields(arg);
+    if (inputFields) {
+      return inputFields.map((field) => `$${field.variable}: ${typeReference(field.type)}`);
+    }
+    const defaultValue = defaults[arg.name];
+    return [`$${arg.name}: ${typeReference(arg.type)}${defaultValue === void 0 ? "" : ` = ${defaultValue}`}`];
+  }).join(", ");
+}
+function argumentUses(args) {
+  return args.map((arg) => {
+    const inputFields = argumentInputFields(arg);
+    if (inputFields) {
+      const values = inputFields.map((field) => `${field.name}: $${field.variable}`);
+      return `${arg.name}: { ${values.join(", ")} }`;
+    }
+    return `${arg.name}: $${arg.name}`;
+  }).join(", ");
+}
+function callArguments(args) {
+  const uses = argumentUses(args);
+  return uses ? `(${uses})` : "";
+}
+function listOperationName(table) {
+  const raw = pascalCase(table);
+  if (raw !== typeName(table)) return `List${raw}`;
+  if (raw.endsWith("y") && !/[aeiou]y$/.test(raw)) return `List${raw.slice(0, -1)}ies`;
+  if (/(s|x|ch|sh)$/.test(raw)) return `List${raw}es`;
+  return `List${raw}s`;
+}
+function document(path, operation) {
+  return { path: `graphql/__generated__/${path}.graphql`, contents: `${operation.trim()}
+` };
+}
+function generateDefaultOperations(canonical, sdl, existingOperationNames = []) {
+  const definition = canonicalDefinitionSchema.parse(canonical);
+  const composed = composeNamespace(definition).definition;
+  const schema = parseSdl(sdl);
+  const query = schema.getQueryType();
+  const mutation = schema.getMutationType();
+  if (!query) return [];
+  const owned = /* @__PURE__ */ new Set([
+    ...definition.tables.map((table) => table.table),
+    ...(definition.views ?? []).map((view) => view.view)
+  ]);
+  const occupied = new Set(existingOperationNames);
+  const generatedNames = /* @__PURE__ */ new Map();
+  const results = [];
+  const claimName = (name2, relation) => {
+    if (occupied.has(name2)) return false;
+    const previous = generatedNames.get(name2);
+    if (previous !== void 0) throw new Error(`default operation name collision '${name2}' for '${previous}' and '${relation}'`);
+    generatedNames.set(name2, relation);
+    return true;
+  };
+  for (const relation of canonicalRelations(composed).filter((item) => owned.has(item.table) && item.internal !== true)) {
+    const names = tableNames(relation.table);
+    const fields = query.getFields();
+    const objectType = schema.getType(names.typename);
+    const scalarSelection = objectType instanceof graphql.GraphQLObjectType ? objectScalarFields(objectType) : [];
+    const selection = scalarSelection.length > 0 ? `{ ${scalarSelection.join(" ")} }` : "";
+    const byPk = fields[names.byPkRoot];
+    const getName = `Get${names.typename}`;
+    if (byPk && selection && claimName(getName, relation.table)) {
+      const vars = variableDefinitions(byPk.args);
+      results.push(document(getName, `query ${getName}${vars ? `(${vars})` : ""} { record: ${names.byPkRoot}${callArguments(byPk.args)} ${selection} }`));
+    }
+    const list2 = fields[names.selectRoot];
+    const listName = listOperationName(relation.table);
+    if (list2 && selection && claimName(listName, relation.table)) {
+      const listArgs = list2.args.filter((arg) => ["where", "orderBy", "limit", "offset"].includes(arg.name));
+      const defaults = { limit: String(DEFAULT_LIST_LIMIT), offset: "0" };
+      const vars = variableDefinitions(listArgs, defaults);
+      results.push(document(listName, `query ${listName}${vars ? `(${vars})` : ""} { records: ${names.selectRoot}${callArguments(listArgs)} ${selection} }`));
+    }
+    if (!mutation || !selection) continue;
+    const mutationFields = mutation.getFields();
+    const mutationOps = [
+      { root: names.insertOneRoot, name: `Create${names.typename}`, args: ["object"], writeArg: "object" },
+      { root: names.updateByPkRoot, name: `Update${names.typename}`, args: ["pkColumns", "_set"], writeArg: "_set" },
+      { root: names.deleteByPkRoot, name: `Delete${names.typename}` }
+    ];
+    const writebackColumns = new Set((relation.resolved?.sources.flatMap((source) => source.writeback?.columns ?? []) ?? []).map(fieldName));
+    for (const item of mutationOps) {
+      const root = mutationFields[item.root];
+      if (root && item.writeArg && inputFieldsTouchWriteback(root.args.find((arg) => arg.name === item.writeArg), writebackColumns)) continue;
+      if (!root || !claimName(item.name, relation.table)) continue;
+      const args = item.args ? root.args.filter((arg) => item.args?.includes(arg.name)) : root.args;
+      const vars = variableDefinitions(args);
+      results.push(document(item.name, `mutation ${item.name}${vars ? `(${vars})` : ""} { record: ${item.root}${callArguments(args)} ${selection} }`));
+    }
+  }
+  return results.map((source) => {
+    try {
+      return { ...source, contents: `${graphql.print(graphql.parse(source.contents)).trim()}
+` };
+    } catch (error) {
+      throw new Error(`${error instanceof Error ? error.message : String(error)}
+${source.contents}`);
+    }
+  });
+}
+function compileDefaultOperations(canonical, existingOperationNames = []) {
+  const pinnedColumns = Object.fromEntries(
+    Object.entries(computePinnedColumnsByTable(canonical)).map(([table, pins]) => [table, pins.map((pin) => pin.column)])
+  );
+  const sdl = generateSdl(canonical, { pinnedColumns, includeSyncedReads: true });
+  const documents = generateDefaultOperations(canonical, sdl, existingOperationNames);
+  return compileNamespaceOrThrow({ canonical, sdl, documents }).artifact;
+}
+
 // src/engine/types.ts
 var SQL_TYPE_NAMES = {
   double: "double precision",
@@ -6159,9 +6986,9 @@ async function compileOperationDocuments(input) {
   return compileSqlDocuments({ input, result, sqlDocuments });
 }
 async function compileSqlDocuments({ input, result, sqlDocuments }) {
-  for (const document of sqlDocuments) {
+  for (const document2 of sqlDocuments) {
     try {
-      const definition = defineOperation(JSON.parse(document.contents));
+      const definition = defineOperation(JSON.parse(document2.contents));
       if (definition.namespace !== input.canonical.namespace) throw new Error("SQL operation namespace does not match its owner");
       if (result.artifact.operations[definition.name]) throw new Error("duplicate operation name");
       const roles = input.canonical.capabilities.roles;
@@ -6241,7 +7068,7 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
       return { ok: false, diagnostics: [...result.diagnostics, {
         severity: "error",
         code: "invalid-sql-operation",
-        document: document.path,
+        document: document2.path,
         message: error instanceof Error ? error.message : "invalid SQL operation"
       }] };
     }
@@ -6449,6 +7276,7 @@ exports.classifyInputType = classifyInputType;
 exports.collectPinnedColumns = collectPinnedColumns;
 exports.compileBuiltinSqlArtifact = compileBuiltinSqlArtifact;
 exports.compileDatasetPreviews = compileDatasetPreviews;
+exports.compileDefaultOperations = compileDefaultOperations;
 exports.compileNamespace = compileNamespace;
 exports.compileNamespaceOrThrow = compileNamespaceOrThrow;
 exports.compileOperationDocuments = compileOperationDocuments;
@@ -6462,6 +7290,7 @@ exports.computeSchemaHash = computeSchemaHash;
 exports.defineOperation = defineOperation;
 exports.enumTypeName = enumTypeName;
 exports.flattenOperation = flattenOperation;
+exports.generateDefaultOperations = generateDefaultOperations;
 exports.injectPolicies = injectPolicies;
 exports.inputTypeName = inputTypeName;
 exports.isSqlOperationDocument = isSqlOperationDocument;