@syncular/typegen 0.2.1 → 0.3.1

package/src/emit-queries-swift.ts

@@ -13,7 +13,8 @@
  * bytes decode). Header carries the IR hash for byte-exact `--check`.
  */
 import type { IrColumnType } from './ir';
-import type { AnalyzedQuery, QueryColumn } from './query';
+import { snakeToCamel } from './naming';
+import type { AnalyzedQuery, QueryColumn, QueryParam } from './query';
 
 const SWIFT_TYPE: Readonly<Record<IrColumnType, string>> = {
   string: 'String',
@@ -34,9 +35,9 @@ function pascalCase(name: string): string {
     .join('');
 }
 
+/** Language-facing field name — the pinned §12 naming map. */
 function camelCase(name: string): string {
-  const pascal = pascalCase(name);
-  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  return snakeToCamel(name);
 }
 
 /** The query function/type name: already camelCase; PascalCase for the type. */
@@ -49,7 +50,7 @@ function quote(value: string): string {
 }
 
 function rowAccessor(column: QueryColumn): string {
-  const key = `row[${quote(column.name)}]`;
+  const key = `row[${quote(column.langName)}]`;
   switch (column.type) {
     case 'string':
     case 'json':
@@ -82,6 +83,32 @@ function paramValue(type: IrColumnType, name: string): string {
   }
 }
 
+/** Bind for a §4 OPTIONAL param: `nil` rides as JSON null (the §7
+ * neutralization guards make it a no-op). */
+function optionalParamValue(type: IrColumnType, name: string): string {
+  switch (type) {
+    case 'integer':
+      return `${name}.map { JSONValue.number(Double($0)) } ?? .null`;
+    case 'float':
+      return `${name}.map { JSONValue.number($0) } ?? .null`;
+    case 'boolean':
+      return `${name}.map { JSONValue.bool($0) } ?? .null`;
+    case 'bytes':
+    case 'crdt':
+      return `${name}.map { SyncularSchemaQueryBind.bytes($0) } ?? .null`;
+    default:
+      return `${name}.map { JSONValue.string($0) } ?? .null`;
+  }
+}
+
+function isOptionalParam(query: AnalyzedQuery, p: QueryParam): boolean {
+  return (
+    p.optional === true ||
+    p.flag === true ||
+    (query.limit !== undefined && p.name === 'limit')
+  );
+}
+
 function emitRowStruct(query: AnalyzedQuery): string[] {
   const Row = `${typeName(query.name)}Row`;
   const lines: string[] = [];
@@ -90,13 +117,13 @@ function emitRowStruct(query: AnalyzedQuery): string[] {
   for (const column of query.columns) {
     const opt = column.nullable ? '?' : '';
     lines.push(
-      `    public let ${camelCase(column.name)}: ${SWIFT_TYPE[column.type]}${opt}`,
+      `    public let ${camelCase(column.langName)}: ${SWIFT_TYPE[column.type]}${opt}`,
     );
   }
   lines.push('');
   lines.push('    public init?(row: [String: JSONValue]) {');
   for (const column of query.columns) {
-    const name = camelCase(column.name);
+    const name = camelCase(column.langName);
     const accessor = rowAccessor(column);
     if (column.nullable) {
       lines.push(`        self.${name} = ${accessor}`);
@@ -110,38 +137,86 @@ function emitRowStruct(query: AnalyzedQuery): string[] {
   return lines;
 }
 
+/** Per-query orderBy allowlist enum (rawValue = the checked SQL column). */
+function emitOrderByEnum(query: AnalyzedQuery): string[] {
+  if (query.orderBy === undefined) return [];
+  const lines: string[] = [];
+  lines.push(
+    `/// §6 orderBy allowlist for ${query.name} — checked at generate time.`,
+  );
+  lines.push(`public enum ${typeName(query.name)}OrderBy: String, Sendable {`);
+  for (const col of query.orderBy.allowed) {
+    lines.push(`    case ${camelCase(col.langName)} = ${quote(col.name)}`);
+  }
+  lines.push('}');
+  return lines;
+}
+
 function emitRunner(query: AnalyzedQuery): string[] {
   const Row = `${typeName(query.name)}Row`;
   const lines: string[] = [];
   lines.push(
     `    public static let ${query.name}Tables = [${query.tables.map(quote).join(', ')}]`,
   );
-  lines.push(
-    `    private static let ${query.name}Sql = ${quote(query.positionalSql)}`,
-  );
+  if (query.orderBy !== undefined) {
+    lines.push(
+      `    private static let ${query.name}SqlBase = ${quote(query.positionalSqlBase ?? '')}`,
+    );
+  } else {
+    lines.push(
+      `    private static let ${query.name}Sql = ${quote(query.positionalSql)}`,
+    );
+  }
   lines.push('');
   lines.push(`    /// Run the ${query.name} named query (SELECT-only).`);
-  const args = query.params
-    .map((p) => `${camelCase(p.name)}: ${SWIFT_TYPE[p.type]}`)
-    .join(', ');
+  const args: string[] = [];
+  for (const p of query.params) {
+    const name = camelCase(p.langName);
+    if (isOptionalParam(query, p)) {
+      args.push(`${name}: ${SWIFT_TYPE[p.type]}? = nil`);
+    } else {
+      args.push(`${name}: ${SWIFT_TYPE[p.type]}`);
+    }
+  }
+  if (query.orderBy !== undefined) {
+    const defaultCase = camelCase(
+      query.orderBy.allowed.find((c) => c.name === query.orderBy?.defaultColumn)
+        ?.langName ?? query.orderBy.defaultColumn,
+    );
+    args.push(`orderBy: ${typeName(query.name)}OrderBy = .${defaultCase}`);
+    args.push(`dir: SyncularQueryDir = .${query.orderBy.defaultDir}`);
+  }
   const signature =
-    query.params.length > 0
-      ? `client: SyncularClient, ${args}`
+    args.length > 0
+      ? `client: SyncularClient, ${args.join(', ')}`
       : 'client: SyncularClient';
   lines.push(
     `    public static func ${query.name}(${signature}) throws -> [${Row}] {`,
   );
+  const sqlExpr =
+    query.orderBy !== undefined
+      ? `${query.name}SqlBase + " order by " + orderBy.rawValue + " " + dir.rawValue${query.positionalLimitTail !== undefined ? ` + ${quote(query.positionalLimitTail)}` : ''}`
+      : `${query.name}Sql`;
+  if (query.orderBy !== undefined) {
+    lines.push(`        let sql = ${sqlExpr}`);
+  }
+  const sqlRef = query.orderBy !== undefined ? 'sql' : `${query.name}Sql`;
   if (query.params.length > 0) {
     const binds = query.params
-      .map((p) => paramValue(p.type, camelCase(p.name)))
+      .map((p) => {
+        const name = camelCase(p.langName);
+        return isOptionalParam(query, p)
+          ? optionalParamValue(p.type, name)
+          : paramValue(p.type, name);
+      })
       .join(', ');
     lines.push(`        let params: [JSONValue] = [${binds}]`);
     lines.push(
-      `        return try client.query(${query.name}Sql, params: params).compactMap { row in`,
+      `        return try client.query(${sqlRef}, params: params).compactMap { row in`,
     );
   } else {
     lines.push(
-      `        return try client.query(${query.name}Sql).compactMap { row in`,
+      `        return try client.query(${sqlRef}).compactMap { row in`,
     );
   }
   lines.push(
@@ -183,8 +258,22 @@ export function emitQueriesSwiftModule(
     ].join('\n'),
   );
 
+  if (queries.some((q) => q.orderBy !== undefined)) {
+    parts.push(
+      [
+        '/// §6 orderBy direction (shared by every orderBy-knob query).',
+        'public enum SyncularQueryDir: String, Sendable {',
+        '    case asc = "asc"',
+        '    case desc = "desc"',
+        '}',
+      ].join('\n'),
+    );
+  }
+
   for (const query of queries) {
     parts.push(emitRowStruct(query).join('\n'));
+    const orderByEnum = emitOrderByEnum(query);
+    if (orderByEnum.length > 0) parts.push(orderByEnum.join('\n'));
   }
 
   const enumLines: string[] = [];

package/src/emit-queries.ts

@@ -4,12 +4,18 @@
  *
  * - `QRow` — the projection row interface (its OWN type per query — the
  *   drift-kill: the row shape is exactly what the SELECT returns),
- * - `QParams` — the typed params object (when the query has params),
- * - `qTables` — the readonly table-dependency set (feeds useSyncQuery `{tables}`
+ * - `QParams` — the typed params object (when the query has params or
+ *   knobs); §4 optional params are optional keys (`status?: string | null`),
+ *   §6 knobs add `orderBy?/dir?/limit?`,
+ * - `qTables` — the readonly table-dependency set (feeds useRawSql `{tables}`
  *   for EXACT invalidation),
  * - `q(client, params?): Promise<QRow[]>` — runs the query over the wrapper's
  *   positional `query(sql, params[])` surface, reordering the named params
- *   object into the positional array the wire expects.
+ *   object into the positional array the wire expects (optionals bind NULL —
+ *   the §7 neutralization guards make an absent param a no-op),
+ * - for an orderBy knob: a baked column map + a compose function — user
+ *   input only ever SELECTS from the generate-time-checked allowlist (I2);
+ *   it never becomes SQL text.
  *
  * A tiny structural `QueryClient` interface (just `query(sql, params?)`) keeps
  * the module import-free — it structurally accepts `SyncClientLike` /
@@ -17,7 +23,7 @@
  * `--check` gates freshness byte-exactly, like every other emitter.
  */
 import type { IrColumnType } from './ir';
-import type { AnalyzedQuery } from './query';
+import type { AnalyzedQuery, QueryParam } from './query';
 
 const TS_TYPE: Readonly<Record<IrColumnType, string>> = {
   string: 'string',
@@ -46,81 +52,223 @@ function propertyKey(name: string): string {
 /** A named-query param value is the SqlValue subset its type maps to. */
 const PARAM_TS_TYPE: Readonly<Record<IrColumnType, string>> = TS_TYPE;
 
+function isOptional(param: QueryParam): boolean {
+  return param.optional === true || param.flag === true;
+}
+
+/** The positional bind expression for one param. `access` is `params` or
+ * `params?` depending on whether the params object itself may be absent. */
+function bindExpr(
+  query: AnalyzedQuery,
+  param: QueryParam,
+  access: string,
+): string {
+  if (query.limit !== undefined && param.name === 'limit') {
+    // The default + clamp live IN the SQL (`min(coalesce(?, d), m)`).
+    return `${access}.limit ?? null`;
+  }
+  const key = propertyKey(param.langName);
+  return isOptional(param) ? `${access}.${key} ?? null` : `params.${key}`;
+}
+
 function emitQuery(query: AnalyzedQuery): string {
   const Row = `${pascalCase(query.name)}Row`;
   const Params = `${pascalCase(query.name)}Params`;
   const lines: string[] = [];
 
-  // Row interface.
+  // Row interface — keyed by the language-facing names, which ARE the
+  // runtime result keys (§5 projection lowering aliases them in SQL).
   lines.push(
     `/** One row of the ${quote(query.name)} query (its projection). */`,
   );
   lines.push(`export interface ${Row} {`);
   for (const column of query.columns) {
     lines.push(
-      `  ${propertyKey(column.name)}: ${TS_TYPE[column.type]}${column.nullable ? ' | null' : ''};`,
+      `  ${propertyKey(column.langName)}: ${TS_TYPE[column.type]}${column.nullable ? ' | null' : ''};`,
     );
   }
   lines.push('}');
   lines.push('');
 
-  // Params interface (only when there are params).
-  const hasParams = query.params.length > 0;
+  const hasParams = query.params.length > 0 || query.orderBy !== undefined;
+  const requiresParams = query.params.some(
+    (p) => !isOptional(p) && !(query.limit !== undefined && p.name === 'limit'),
+  );
+
+  // Params interface (params and/or knob keys).
   if (hasParams) {
     lines.push(`/** Named parameters for ${quote(query.name)}. */`);
     lines.push(`export interface ${Params} {`);
     for (const param of query.params) {
-      lines.push(`  ${propertyKey(param.name)}: ${PARAM_TS_TYPE[param.type]};`);
+      if (query.limit !== undefined && param.name === 'limit') continue;
+      const opt = isOptional(param);
+      lines.push(
+        `  ${propertyKey(param.langName)}${opt ? '?' : ''}: ${PARAM_TS_TYPE[param.type]}${opt ? ' | null' : ''};`,
+      );
+    }
+    if (query.orderBy !== undefined) {
+      const keys = query.orderBy.allowed
+        .map((c) => quote(c.langName))
+        .join(' | ');
+      lines.push(
+        `  /** §6 orderBy knob — a generate-time-checked allowlist. */`,
+      );
+      lines.push(`  orderBy?: ${keys};`);
+      lines.push(`  dir?: 'asc' | 'desc';`);
+    }
+    if (query.limit !== undefined) {
+      const clamp =
+        query.limit.max !== undefined ? ` (clamped to ${query.limit.max})` : '';
+      lines.push(
+        `  /** §6 limit knob — binds as a value${clamp}; default ${query.limit.default ?? query.limit.max}. */`,
+      );
+      lines.push('  limit?: number;');
     }
     lines.push('}');
     lines.push('');
   }
 
-  // Tables dependency set (for useSyncQuery {tables} / useNamedQuery).
+  // Tables dependency set (for useRawSql {tables} / useQuery).
   lines.push(
-    `/** Tables ${quote(query.name)} reads — the exact useSyncQuery \`{tables}\` set. */`,
+    `/** Tables ${quote(query.name)} reads — the exact useRawSql \`{tables}\` set. */`,
   );
   lines.push(
     `export const ${query.name}Tables = [${query.tables.map(quote).join(', ')}] as const;`,
   );
   lines.push('');
 
-  // The runner. SQL is the positional form; params reorder into the array.
-  const paramArg = hasParams ? `params: ${Params}` : '';
+  // SQL constants: the static default statement, plus (orderBy knob) the
+  // baked base + column map + compose function.
   const sqlConst = `${query.name}Sql`;
+  lines.push(`const ${sqlConst} = ${quote(query.positionalSql)};`);
+  const composeFn = `${query.name}ComposeSql`;
+  if (query.orderBy !== undefined) {
+    const base = `${query.name}SqlBase`;
+    const colsConst = `${query.name}OrderColumns`;
+    const defaultLang =
+      query.orderBy.allowed.find((c) => c.name === query.orderBy?.defaultColumn)
+        ?.langName ?? query.orderBy.defaultColumn;
+    lines.push(`const ${base} = ${quote(query.positionalSqlBase ?? '')};`);
+    lines.push(
+      `const ${colsConst} = { ${query.orderBy.allowed
+        .map((c) => `${propertyKey(c.langName)}: ${quote(c.name)}`)
+        .join(', ')} } as const;`,
+    );
+    lines.push(`function ${composeFn}(params?: ${Params}): string {`);
+    lines.push(
+      `  const column = ${colsConst}[params?.orderBy ?? ${quote(defaultLang)}] ?? ${quote(query.orderBy.defaultColumn)};`,
+    );
+    lines.push(
+      `  const dir = (params?.dir ?? ${quote(query.orderBy.defaultDir)}) === 'desc' ? 'desc' : 'asc';`,
+    );
+    lines.push(
+      `  return \`\${${base}} order by \${column} \${dir}${query.positionalLimitTail ?? ''}\`;`,
+    );
+    lines.push('}');
+  }
+
+  // Positional bind list.
+  const access = requiresParams ? 'params' : 'params?';
   const positional = hasParams
-    ? `[${query.params.map((p) => `params.${propertyKey(p.name)}`).join(', ')}]`
+    ? `[${query.params.map((p) => bindExpr(query, p, access)).join(', ')}]`
     : '[]';
-  lines.push(`const ${sqlConst} = ${quote(query.positionalSql)};`);
+
+  // §7 variant backend: one statement per provided-combination, selected by
+  // a bitmask over the optional groups (bit i = group i provided/true). The
+  // neutralization statement above stays the canonical/default form.
+  const selectFn = `${query.name}SelectVariant`;
+  const paramArgDecl = requiresParams
+    ? `params: ${Params}`
+    : `params?: ${Params}`;
+  if (query.variants !== undefined && query.variantGroups !== undefined) {
+    const variantsConst = `${query.name}Variants`;
+    lines.push(
+      `const ${variantsConst}: { sql: string; bind: (${paramArgDecl}) => QueryValue[] }[] = [`,
+    );
+    for (const variant of query.variants) {
+      const binds = variant.params
+        .map((name) => {
+          const param = query.params.find((p) => p.name === name);
+          if (param === undefined) throw new Error(`unknown param ${name}`);
+          return bindExpr(query, param, access);
+        })
+        .join(', ');
+      lines.push(`  // [${variant.when.join(' + ') || 'no optional filters'}]`);
+      lines.push(
+        `  { sql: ${quote(variant.positionalSql)}, bind: (${requiresParams ? 'params' : 'params?'}) => [${binds}] },`,
+      );
+    }
+    lines.push('];');
+    lines.push(
+      `function ${selectFn}(${paramArgDecl}): { sql: string; bind: QueryValue[] } {`,
+    );
+    lines.push('  let mask = 0;');
+    query.variantGroups.forEach((group, index) => {
+      const langOf = (name: string): string =>
+        query.params.find((p) => p.name === name)?.langName ?? name;
+      const condition = group.flag
+        ? `params?.${propertyKey(langOf(group.params[0] as string))} === true`
+        : group.params
+            .map(
+              (name) =>
+                `(params?.${propertyKey(langOf(name))} ?? null) !== null`,
+            )
+            .join(' && ');
+      lines.push(`  if (${condition}) mask |= ${1 << index};`);
+    });
+    lines.push(
+      `  const variant = ${variantsConst}[mask] as (typeof ${variantsConst})[number];`,
+    );
+    lines.push('  return { sql: variant.sql, bind: variant.bind(params) };');
+    lines.push('}');
+  }
   lines.push('');
+
+  // The runner.
+  const paramArg = !hasParams ? '' : paramArgDecl;
   lines.push(`/** Run the ${quote(query.name)} named query (SELECT-only). */`);
   lines.push(
     `export async function ${query.name}(client: QueryClient${hasParams ? `, ${paramArg}` : ''}): Promise<${Row}[]> {`,
   );
-  if (hasParams) {
-    lines.push(
-      `  const rows = await client.query(${sqlConst}, ${positional});`,
-    );
+  if (query.variants !== undefined) {
+    lines.push(`  const variant = ${selectFn}(params);`);
+    lines.push('  const rows = await client.query(variant.sql, variant.bind);');
   } else {
-    lines.push(`  const rows = await client.query(${sqlConst});`);
+    const sqlExpr =
+      query.orderBy !== undefined ? `${composeFn}(params)` : sqlConst;
+    if (hasParams) {
+      lines.push(
+        `  const rows = await client.query(${sqlExpr}, ${positional});`,
+      );
+    } else {
+      lines.push(`  const rows = await client.query(${sqlExpr});`);
+    }
   }
   lines.push(`  return rows as unknown as ${Row}[];`);
   lines.push('}');
   lines.push('');
 
-  // A descriptor for react's `useNamedQuery` — the SQL, the exact table
-  // dependency set, and a `bind(params)` → positional array. Typed by the
-  // query's own Row/Params so the hook stays fully typed.
+  // A descriptor for react's `useQuery` — the SQL (static, composed from
+  // the baked allowlist, or variant-selected), the exact table dependency
+  // set, and a `bind(params)` → positional array (always paired with the
+  // sqlFor selection). Typed by the query's own Row/Params.
   lines.push(
-    `/** Descriptor for \`useNamedQuery(${query.name}Query${hasParams ? ', params' : ''})\` — sql + tables + row type. */`,
+    `/** Descriptor for \`useQuery(${query.name}Query${hasParams ? ', params' : ''})\` — sql + tables + row type. */`,
   );
   const paramsTypeArg = hasParams ? Params : 'undefined';
   lines.push(
     `export const ${query.name}Query: NamedQuery<${Row}, ${paramsTypeArg}> = {`,
   );
   lines.push(`  sql: ${sqlConst},`);
+  if (query.variants !== undefined) {
+    lines.push(`  sqlFor: (params: ${Params}) => ${selectFn}(params).sql,`);
+  } else if (query.orderBy !== undefined) {
+    lines.push(`  sqlFor: (params: ${Params}) => ${composeFn}(params),`);
+  }
   lines.push(`  tables: ${query.name}Tables,`);
-  if (hasParams) {
+  if (query.variants !== undefined) {
+    lines.push(`  bind: (params: ${Params}) => ${selectFn}(params).bind,`);
+  } else if (hasParams) {
     lines.push(`  bind: (params: ${Params}) => ${positional},`);
   } else {
     lines.push('  bind: () => [],');
@@ -165,13 +313,16 @@ export function emitQueriesModule(
       '',
       '/** A named-query descriptor — sql + its exact table dependency set + a',
       ' *  `bind(params)` → positional args. Consumed by',
-      " *  `@syncular/react`'s `useNamedQuery`. `Row` is the projection row",
-      ' *  type; `Params` is `undefined` for a param-less query. */',
+      " *  `@syncular/react`'s `useQuery`. `Row` is the projection row",
+      ' *  type; `Params` is `undefined` for a param-less query. `sqlFor`',
+      ' *  (present only with an orderBy knob) composes the statement from a',
+      ' *  generate-time-checked column allowlist. */',
       'export interface NamedQuery<Row, Params = undefined> {',
       '  readonly sql: string;',
       '  readonly tables: readonly string[];',
       '  readonly bind: (params: Params) => readonly QueryValue[];',
-      '  /** Phantom — carries the Row type for `useNamedQuery` inference. */',
+      '  readonly sqlFor?: (params: Params) => string;',
+      '  /** Phantom — carries the Row type for `useQuery` inference. */',
       '  readonly __row?: Row;',
       '}',
     ].join('\n'),

package/src/emit-swift.ts

@@ -15,6 +15,7 @@
  * emitter.
  */
 import type { IrColumnType, IrDocument, IrSubscription, IrTable } from './ir';
+import { snakeToCamel } from './naming';
 
 /**
  * §2.4 column type → honest Swift type. `json`/`blob_ref` are the raw
@@ -49,9 +50,9 @@ function pascalCase(name: string): string {
     .join('');
 }
 
+/** Language-facing field name — the pinned §12 naming map. */
 function camelCase(name: string): string {
-  const pascal = pascalCase(name);
-  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  return snakeToCamel(name);
 }
 
 function quote(value: string): string {

package/src/emit.ts

@@ -13,6 +13,7 @@
  * byte-exactly.
  */
 import type { IrColumnType, IrDocument, IrSubscription, IrTable } from './ir';
+import { type NamingMode, snakeToCamel } from './naming';
 
 const TS_TYPE: Readonly<Record<IrColumnType, string>> = {
   string: 'string',
@@ -114,15 +115,20 @@ function emitSchema(ir: IrDocument): string {
   return lines.join('\n');
 }
 
-function emitRowInterfaces(table: IrTable): string {
+function emitRowInterfaces(table: IrTable, naming: NamingMode): string {
   const type = pascalCase(table.name);
+  // §5: mutation-input/row keys are the language-facing names; `mutate`
+  // normalizes them back through the schema naming map (camel or snake both
+  // bind — one map lookup per key).
+  const key = (name: string): string =>
+    propertyKey(naming === 'camel' ? snakeToCamel(name) : name);
   const lines: string[] = [];
   lines.push(`/** One ${table.name} row (§2.4 column order). */`);
   lines.push(`export interface ${type}Row {`);
   for (const column of table.columns) {
     const ts = appTsType(column);
     lines.push(
-      `  ${propertyKey(column.name)}: ${ts}${column.nullable ? ' | null' : ''};`,
+      `  ${key(column.name)}: ${ts}${column.nullable ? ' | null' : ''};`,
     );
   }
   lines.push('}');
@@ -133,8 +139,8 @@ function emitRowInterfaces(table: IrTable): string {
     const ts = appTsType(column);
     lines.push(
       column.nullable
-        ? `  ${propertyKey(column.name)}?: ${ts} | null;`
-        : `  ${propertyKey(column.name)}: ${ts};`,
+        ? `  ${key(column.name)}?: ${ts} | null;`
+        : `  ${key(column.name)}: ${ts};`,
     );
   }
   lines.push('}');
@@ -146,10 +152,10 @@ function emitRowInterfaces(table: IrTable): string {
   for (const column of table.columns) {
     const ts = appTsType(column);
     if (column.name === table.primaryKey) {
-      lines.push(`  ${propertyKey(column.name)}: ${ts};`);
+      lines.push(`  ${key(column.name)}: ${ts};`);
     } else {
       lines.push(
-        `  ${propertyKey(column.name)}?: ${ts}${column.nullable ? ' | null' : ''};`,
+        `  ${key(column.name)}?: ${ts}${column.nullable ? ' | null' : ''};`,
       );
     }
   }
@@ -157,25 +163,6 @@ function emitRowInterfaces(table: IrTable): string {
   return lines.join('\n');
 }
 
-/**
- * A Kysely-compatible `Database` interface: table name → Row type. This is
- * the generic `@syncular/kysely`'s `SyncularDialect` is parameterized by
- * (`new Kysely<Database>({ dialect })`). Additive — the Row interfaces it
- * references are already emitted above. Property keys use the raw table name
- * (quoted when not an identifier) so `db.selectFrom('table-name')` types.
- */
-function emitDatabaseInterface(ir: IrDocument): string {
-  const lines: string[] = [];
-  lines.push('/** Kysely `Database` interface (table → Row); the generic for');
-  lines.push(" *  @syncular/kysely's SyncularDialect. */");
-  lines.push('export interface Database {');
-  for (const table of ir.tables) {
-    lines.push(`  ${propertyKey(table.name)}: ${pascalCase(table.name)}Row;`);
-  }
-  lines.push('}');
-  return lines.join('\n');
-}
-
 function emitSubscription(sub: IrSubscription): string {
   const params: string[] = [];
   for (const scope of sub.scopes) {
@@ -218,7 +205,11 @@ function emitSubscription(sub: IrSubscription): string {
   return lines.join('\n');
 }
 
-export function emitModule(ir: IrDocument, hash: string): string {
+export function emitModule(
+  ir: IrDocument,
+  hash: string,
+  naming: NamingMode = 'camel',
+): string {
   const parts: string[] = [];
   parts.push(
     [
@@ -229,9 +220,8 @@ export function emitModule(ir: IrDocument, hash: string): string {
   );
   parts.push(emitSchema(ir));
   for (const table of ir.tables) {
-    parts.push(emitRowInterfaces(table));
+    parts.push(emitRowInterfaces(table, naming));
   }
-  parts.push(emitDatabaseInterface(ir));
   for (const sub of ir.subscriptions) {
     parts.push(emitSubscription(sub));
   }