@syncular/typegen 0.1.2 → 0.2.0

package/src/emit-kotlin.ts

@@ -0,0 +1,257 @@
+/**
+ * Kotlin emitter: neutral IR → one standalone `.kt` file exporting
+ *
+ * - `object <ObjectName> { val schema: JsonValue }` — the ServerSchema
+ *   object built from the IR (fed straight into `SyncularClient.create(
+ *   schema = …)`),
+ * - one `data class` per table with typed properties (per the six §2.4 column
+ *   types + blob_ref/crdt) and a `fromRow(row: JsonValue)` companion factory,
+ * - a `Subscriptions` object of typed requested-scope builders.
+ *
+ * The row shape is `JsonValue` — the exact type the Kotlin wrapper's
+ * `query`/`readRows` return (each row a `JsonValue.Obj`). The header carries
+ * the IR hash so `--check` verifies freshness byte-exactly.
+ */
+import type { IrColumnType, IrDocument, IrSubscription, IrTable } from './ir';
+
+/** §2.4 column type → honest Kotlin type. `json`/`blob_ref` are the raw
+ * canonical JSON string; `bytes`/`crdt` are opaque `ByteArray`. */
+const KOTLIN_TYPE: Readonly<Record<IrColumnType, string>> = {
+  string: 'String',
+  integer: 'Long',
+  float: 'Double',
+  boolean: 'Boolean',
+  json: 'String',
+  bytes: 'ByteArray',
+  blob_ref: 'String',
+  crdt: 'ByteArray',
+};
+
+/** §5.11: app-side Kotlin type — declaredType for an encrypted column. */
+function appKotlinType(column: IrTable['columns'][number]): string {
+  const type =
+    column.encrypted === true && column.declaredType !== undefined
+      ? column.declaredType
+      : column.type;
+  return KOTLIN_TYPE[type];
+}
+
+function pascalCase(name: string): string {
+  return name
+    .split(/[_-]+/)
+    .filter((part) => part.length > 0)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('');
+}
+
+function camelCase(name: string): string {
+  const pascal = pascalCase(name);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+function quote(value: string): string {
+  return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\$/g, '\\$')}"`;
+}
+
+function emitSchemaValue(ir: IrDocument, indent: string): string[] {
+  const lines: string[] = [];
+  const i = indent;
+  lines.push(`${i}JsonValue.obj(`);
+  lines.push(`${i}  "version" to JsonValue.of(${ir.schemaVersion}),`);
+  lines.push(`${i}  "tables" to JsonValue.arr(listOf(`);
+  for (const table of ir.tables) {
+    lines.push(`${i}    JsonValue.obj(`);
+    lines.push(`${i}      "name" to JsonValue.of(${quote(table.name)}),`);
+    lines.push(
+      `${i}      "primaryKey" to JsonValue.of(${quote(table.primaryKey)}),`,
+    );
+    lines.push(`${i}      "columns" to JsonValue.arr(listOf(`);
+    for (const column of table.columns) {
+      const parts = [
+        `"name" to JsonValue.of(${quote(column.name)})`,
+        `"type" to JsonValue.of(${quote(column.type)})`,
+        `"nullable" to JsonValue.of(${column.nullable})`,
+      ];
+      if (column.crdtType !== undefined) {
+        parts.push(`"crdtType" to JsonValue.of(${quote(column.crdtType)})`);
+      }
+      if (column.encrypted === true) {
+        parts.push('"encrypted" to JsonValue.of(true)');
+        parts.push(
+          `"declaredType" to JsonValue.of(${quote(column.declaredType ?? column.type)})`,
+        );
+      }
+      lines.push(`${i}        JsonValue.obj(${parts.join(', ')}),`);
+    }
+    lines.push(`${i}      )),`);
+    lines.push(`${i}      "scopes" to JsonValue.arr(listOf(`);
+    for (const scope of table.scopes) {
+      lines.push(
+        `${i}        JsonValue.obj("pattern" to JsonValue.of(${quote(scope.pattern)}), "column" to JsonValue.of(${quote(scope.column)})),`,
+      );
+    }
+    lines.push(`${i}      )),`);
+    lines.push(`${i}    ),`);
+  }
+  lines.push(`${i}  )),`);
+  lines.push(`${i})`);
+  return lines;
+}
+
+/** The accessor lifting a §2.4 value out of a row `JsonValue`. */
+function rowAccessor(column: { type: IrColumnType; name: string }): string {
+  const key = `row[${quote(column.name)}]`;
+  switch (column.type) {
+    case 'string':
+    case 'json':
+    case 'blob_ref':
+      return `${key}?.string`;
+    case 'integer':
+      return `${key}?.number?.toLong()`;
+    case 'float':
+      return `${key}?.number`;
+    case 'boolean':
+      return `rowBool(${key})`;
+    case 'bytes':
+    case 'crdt':
+      return `rowBytes(${key})`;
+  }
+}
+
+function emitDataClass(table: IrTable): string[] {
+  const type = pascalCase(table.name);
+  const lines: string[] = [];
+  lines.push(`/** One ${table.name} row (§2.4 column order). */`);
+  lines.push(`data class ${type}(`);
+  for (const column of table.columns) {
+    const kotlin = appKotlinType(column);
+    const opt = column.nullable ? '?' : '';
+    lines.push(`    val ${camelCase(column.name)}: ${kotlin}${opt},`);
+  }
+  lines.push(') {');
+  lines.push('    companion object {');
+  lines.push(
+    `        /** Build from a \`query\`/\`readRows\` row. Null on a missing/mistyped non-nullable column. */`,
+  );
+  lines.push(`        fun fromRow(row: JsonValue): ${type}? {`);
+  for (const column of table.columns) {
+    const name = camelCase(column.name);
+    const accessor = rowAccessor(column);
+    if (column.nullable) {
+      lines.push(`            val ${name} = ${accessor}`);
+    } else {
+      lines.push(`            val ${name} = ${accessor} ?: return null`);
+    }
+  }
+  const args = table.columns.map((c) => camelCase(c.name)).join(', ');
+  lines.push(`            return ${type}(${args})`);
+  lines.push('        }');
+  lines.push('    }');
+  lines.push('}');
+  return lines;
+}
+
+function emitSubscription(sub: IrSubscription): string[] {
+  const params: string[] = [];
+  for (const scope of sub.scopes) {
+    for (const value of scope.values) {
+      if (value.kind === 'parameter' && !params.includes(value.name)) {
+        params.push(value.name);
+      }
+    }
+  }
+  const lines: string[] = [];
+  lines.push(
+    `        /** Requested-scope template for the ${quote(sub.name)} subscription. */`,
+  );
+  lines.push(`        object ${pascalCase(sub.name)} {`);
+  lines.push(`            const val name = ${quote(sub.name)}`);
+  lines.push(`            const val table = ${quote(sub.table)}`);
+  const args = params.map((p) => `${camelCase(p)}: String`).join(', ');
+  lines.push(
+    `            fun scopes(${args}): Map<String, List<String>> = mapOf(`,
+  );
+  for (const scope of sub.scopes) {
+    const values = scope.values
+      .map((value) =>
+        value.kind === 'literal' ? quote(value.value) : camelCase(value.name),
+      )
+      .join(', ');
+    lines.push(
+      `                ${quote(scope.variable)} to listOf(${values}),`,
+    );
+  }
+  lines.push('            )');
+  lines.push('        }');
+  return lines;
+}
+
+export function emitKotlinModule(
+  ir: IrDocument,
+  hash: string,
+  packageName: string,
+  objectName: string,
+): string {
+  const parts: string[] = [];
+  parts.push(
+    [
+      '// Generated by @syncular/typegen — DO NOT EDIT.',
+      `// irVersion: ${ir.irVersion}`,
+      `// irHash: ${hash}`,
+      '',
+      `package ${packageName}`,
+      '',
+      'import dev.syncular.JsonValue',
+    ].join('\n'),
+  );
+
+  const schemaLines: string[] = [];
+  schemaLines.push('/** The generated syncular schema (SPEC §2.4, §3.1). */');
+  schemaLines.push(`object ${objectName} {`);
+  schemaLines.push(
+    `    /** ServerSchema-compatible schema — pass to \`SyncularClient.create(schema = …)\`. */`,
+  );
+  schemaLines.push('    val schema: JsonValue =');
+  for (const line of emitSchemaValue(ir, '        ')) schemaLines.push(line);
+  schemaLines.push('');
+  schemaLines.push(
+    '    /** Typed requested-scope builders per subscription. */',
+  );
+  schemaLines.push('    object Subscriptions {');
+  if (ir.subscriptions.length === 0) {
+    schemaLines.push('        // (no subscriptions declared)');
+  }
+  for (const sub of ir.subscriptions) {
+    for (const line of emitSubscription(sub)) schemaLines.push(line);
+  }
+  schemaLines.push('    }');
+  schemaLines.push('}');
+  parts.push(schemaLines.join('\n'));
+
+  // Shared row-decode helpers.
+  parts.push(
+    [
+      '/** Lift a SQLite boolean: a real JSON bool, or 0/1 as a number. */',
+      'private fun rowBool(value: JsonValue?): Boolean? {',
+      '    value?.bool?.let { return it }',
+      '    value?.number?.let { return it != 0.0 }',
+      '    return null',
+      '}',
+      '',
+      '/** Decode the core\'s `{"$bytes":"<hex>"}` marshaling into a ByteArray. */',
+      'private fun rowBytes(value: JsonValue?): ByteArray? {',
+      '    val hex = value?.get("\\$bytes")?.string ?: return null',
+      '    if (hex.length % 2 != 0) return null',
+      '    return ByteArray(hex.length / 2) { i ->',
+      '        hex.substring(i * 2, i * 2 + 2).toInt(16).toByte()',
+      '    }',
+      '}',
+    ].join('\n'),
+  );
+
+  for (const table of ir.tables) {
+    parts.push(emitDataClass(table).join('\n'));
+  }
+
+  return `${parts.join('\n\n')}\n`;
+}

package/src/emit-queries-dart.ts

@@ -0,0 +1,203 @@
+/**
+ * Dart named-query emitter: analyzed queries → a standalone
+ * `syncular.queries.dart` file. Per query `q` it emits a `class QRow` +
+ * `fromRow` factory, and a top-level `syncular<Q>Query(client, …)` function
+ * returning `List<QRow>` plus a `syncular<Q>QueryTables` const. The runner
+ * binds named params positionally into `query(sql, params: […])`.
+ *
+ * Header carries the IR hash for byte-exact `--check`.
+ */
+import type { IrColumnType } from './ir';
+import type { AnalyzedQuery, QueryColumn } from './query';
+
+const DART_TYPE: Readonly<Record<IrColumnType, string>> = {
+  string: 'String',
+  integer: 'int',
+  float: 'double',
+  boolean: 'bool',
+  json: 'String',
+  bytes: 'List<int>',
+  blob_ref: 'String',
+  crdt: 'List<int>',
+};
+
+function pascalCase(name: string): string {
+  return name
+    .split(/[_-]+/)
+    .filter((p) => p.length > 0)
+    .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+    .join('');
+}
+
+function camelCase(name: string): string {
+  const pascal = pascalCase(name);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+function typeName(name: string): string {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+function quote(value: string): string {
+  return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\$/g, '\\$')}'`;
+}
+
+function rowAccessor(column: QueryColumn): string {
+  const key = `row[${quote(column.name)}]`;
+  switch (column.type) {
+    case 'string':
+    case 'json':
+    case 'blob_ref':
+      return `${key} as String?`;
+    case 'integer':
+      return `(${key} as num?)?.toInt()`;
+    case 'float':
+      return `(${key} as num?)?.toDouble()`;
+    case 'boolean':
+      return `_queryRowBool(${key})`;
+    case 'bytes':
+    case 'crdt':
+      return `_queryRowBytes(${key})`;
+  }
+}
+
+function paramValue(type: IrColumnType, name: string): string {
+  switch (type) {
+    case 'bytes':
+    case 'crdt':
+      return `_queryBindBytes(${name})`;
+    default:
+      // String/int/double/bool ride as-is in the params list.
+      return name;
+  }
+}
+
+function emitClass(query: AnalyzedQuery): string[] {
+  const Row = `${typeName(query.name)}Row`;
+  const lines: string[] = [];
+  lines.push(`/// One row of the ${query.name} query (its projection).`);
+  lines.push(`class ${Row} {`);
+  for (const column of query.columns) {
+    const opt = column.nullable ? '?' : '';
+    lines.push(
+      `  final ${DART_TYPE[column.type]}${opt} ${camelCase(column.name)};`,
+    );
+  }
+  lines.push('');
+  const ctorParams = query.columns
+    .map((c) => `${c.nullable ? '' : 'required '}this.${camelCase(c.name)}`)
+    .join(', ');
+  lines.push(`  const ${Row}({${ctorParams}});`);
+  lines.push('');
+  lines.push(`  static ${Row}? fromRow(Map<String, Object?> row) {`);
+  for (const column of query.columns) {
+    if (!column.nullable) {
+      const name = camelCase(column.name);
+      lines.push(`    final ${name} = ${rowAccessor(column)};`);
+      lines.push(`    if (${name} == null) return null;`);
+    }
+  }
+  const args = query.columns
+    .map((c) => {
+      const name = camelCase(c.name);
+      return c.nullable ? `${name}: ${rowAccessor(c)}` : `${name}: ${name}`;
+    })
+    .join(', ');
+  lines.push(`    return ${Row}(${args});`);
+  lines.push('  }');
+  lines.push('}');
+  return lines;
+}
+
+function emitRunner(query: AnalyzedQuery): string[] {
+  const Row = `${typeName(query.name)}Row`;
+  const Pascal = pascalCase(query.name);
+  const lines: string[] = [];
+  lines.push(
+    `/// Tables the ${query.name} query reads (exact invalidation set).`,
+  );
+  lines.push(
+    `const List<String> syncular${Pascal}QueryTables = [${query.tables.map(quote).join(', ')}];`,
+  );
+  lines.push('');
+  lines.push(`const String _${query.name}Sql = ${quote(query.positionalSql)};`);
+  lines.push('');
+  lines.push(`/// Run the ${query.name} named query (SELECT-only).`);
+  const args = query.params
+    .map((p) => `required ${DART_TYPE[p.type]} ${camelCase(p.name)}`)
+    .join(', ');
+  const argsClause = query.params.length > 0 ? `, {${args}}` : '';
+  lines.push(
+    `List<${Row}> syncular${Pascal}Query(SyncularClient client${argsClause}) {`,
+  );
+  if (query.params.length > 0) {
+    const binds = query.params
+      .map((p) => paramValue(p.type, camelCase(p.name)))
+      .join(', ');
+    lines.push(`  final params = <Object?>[${binds}];`);
+    lines.push(
+      `  return client.query(_${query.name}Sql, params: params).map(${Row}.fromRow).whereType<${Row}>().toList();`,
+    );
+  } else {
+    lines.push(
+      `  return client.query(_${query.name}Sql).map(${Row}.fromRow).whereType<${Row}>().toList();`,
+    );
+  }
+  lines.push('}');
+  return lines;
+}
+
+export function emitQueriesDartModule(
+  queries: readonly AnalyzedQuery[],
+  hash: string,
+  irVersion: number,
+): string {
+  const parts: string[] = [];
+  parts.push(
+    [
+      '// Generated by @syncular/typegen — DO NOT EDIT.',
+      `// irVersion: ${irVersion}`,
+      `// irHash: ${hash}`,
+      '// ignore_for_file: type=lint',
+      '',
+      "import 'package:syncular/syncular.dart';",
+    ].join('\n'),
+  );
+
+  parts.push(
+    [
+      '/// Lift a SQLite boolean: a real bool, or 0/1 as a number.',
+      'bool? _queryRowBool(Object? value) {',
+      '  if (value is bool) return value;',
+      '  if (value is num) return value != 0;',
+      '  return null;',
+      '}',
+      '',
+      "/// Decode the core's {'\\$bytes': '<hex>'} marshaling (bytes as hex).",
+      'List<int>? _queryRowBytes(Object? value) {',
+      '  if (value is! Map) return null;',
+      "  final hex = value[r'$bytes'];",
+      '  if (hex is! String || hex.length % 2 != 0) return null;',
+      '  return [',
+      '    for (var i = 0; i < hex.length; i += 2)',
+      '      int.parse(hex.substring(i, i + 2), radix: 16),',
+      '  ];',
+      '}',
+      '',
+      "/// Encode bytes as the core's {'\\$bytes': '<hex>'} marshaling for binding.",
+      'Map<String, Object?> _queryBindBytes(List<int> value) {',
+      "  final hex = value.map((b) => b.toRadixString(16).padLeft(2, '0')).join();",
+      "  return {r'$bytes': hex};",
+      '}',
+    ].join('\n'),
+  );
+
+  for (const query of queries) {
+    parts.push(emitClass(query).join('\n'));
+  }
+  for (const query of queries) {
+    parts.push(emitRunner(query).join('\n'));
+  }
+
+  return `${parts.join('\n\n')}\n`;
+}

package/src/emit-queries-kotlin.ts

@@ -0,0 +1,209 @@
+/**
+ * Kotlin named-query emitter: analyzed queries → a standalone
+ * `Syncular.queries.kt` file. Per query `q` it emits a `data class QRow` +
+ * `fromRow` companion, and an `object <ObjectName>Queries` with a
+ * `q(client, …): List<QRow>` runner + `qTables` constant. The runner binds
+ * named params positionally into the wrapper's `query(sql, params)`.
+ *
+ * Reuses the schema file's `rowBool`/`rowBytes` helpers (they are top-level
+ * private in the schema module; queries live in the same package so re-declare
+ * package-private copies here to stay self-contained — the query file is a
+ * separate output). Header carries the IR hash for byte-exact `--check`.
+ */
+import type { IrColumnType } from './ir';
+import type { AnalyzedQuery, QueryColumn } from './query';
+
+const KOTLIN_TYPE: Readonly<Record<IrColumnType, string>> = {
+  string: 'String',
+  integer: 'Long',
+  float: 'Double',
+  boolean: 'Boolean',
+  json: 'String',
+  bytes: 'ByteArray',
+  blob_ref: 'String',
+  crdt: 'ByteArray',
+};
+
+function pascalCase(name: string): string {
+  return name
+    .split(/[_-]+/)
+    .filter((p) => p.length > 0)
+    .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+    .join('');
+}
+
+function camelCase(name: string): string {
+  const pascal = pascalCase(name);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+function typeName(name: string): string {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+function quote(value: string): string {
+  return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\$/g, '\\$')}"`;
+}
+
+function rowAccessor(column: QueryColumn): string {
+  const key = `row[${quote(column.name)}]`;
+  switch (column.type) {
+    case 'string':
+    case 'json':
+    case 'blob_ref':
+      return `${key}?.string`;
+    case 'integer':
+      return `${key}?.number?.toLong()`;
+    case 'float':
+      return `${key}?.number`;
+    case 'boolean':
+      return `queryRowBool(${key})`;
+    case 'bytes':
+    case 'crdt':
+      return `queryRowBytes(${key})`;
+  }
+}
+
+function paramValue(type: IrColumnType, name: string): string {
+  switch (type) {
+    case 'integer':
+      // JsonValue.of has no Long overload; widen to Double (SQLite numbers).
+      return `JsonValue.of(${name}.toDouble())`;
+    case 'float':
+      return `JsonValue.of(${name})`;
+    case 'boolean':
+      return `JsonValue.of(${name})`;
+    case 'bytes':
+    case 'crdt':
+      return `queryBindBytes(${name})`;
+    default:
+      return `JsonValue.of(${name})`;
+  }
+}
+
+function emitDataClass(query: AnalyzedQuery): string[] {
+  const Row = `${typeName(query.name)}Row`;
+  const lines: string[] = [];
+  lines.push(`/** One row of the ${query.name} query (its projection). */`);
+  lines.push(`data class ${Row}(`);
+  for (const column of query.columns) {
+    const opt = column.nullable ? '?' : '';
+    lines.push(
+      `    val ${camelCase(column.name)}: ${KOTLIN_TYPE[column.type]}${opt},`,
+    );
+  }
+  lines.push(') {');
+  lines.push('    companion object {');
+  lines.push(`        fun fromRow(row: JsonValue): ${Row}? {`);
+  for (const column of query.columns) {
+    const name = camelCase(column.name);
+    const accessor = rowAccessor(column);
+    if (column.nullable) {
+      lines.push(`            val ${name} = ${accessor}`);
+    } else {
+      lines.push(`            val ${name} = ${accessor} ?: return null`);
+    }
+  }
+  const args = query.columns.map((c) => camelCase(c.name)).join(', ');
+  lines.push(`            return ${Row}(${args})`);
+  lines.push('        }');
+  lines.push('    }');
+  lines.push('}');
+  return lines;
+}
+
+function emitRunner(query: AnalyzedQuery): string[] {
+  const Row = `${typeName(query.name)}Row`;
+  const lines: string[] = [];
+  lines.push(
+    `        val ${query.name}Tables = listOf(${query.tables.map(quote).join(', ')})`,
+  );
+  lines.push(
+    `        private const val ${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)}: ${KOTLIN_TYPE[p.type]}`)
+    .join(', ');
+  const signature =
+    query.params.length > 0
+      ? `client: SyncularClient, ${args}`
+      : 'client: SyncularClient';
+  lines.push(`        fun ${query.name}(${signature}): List<${Row}> {`);
+  if (query.params.length > 0) {
+    const binds = query.params
+      .map((p) => paramValue(p.type, camelCase(p.name)))
+      .join(', ');
+    lines.push(`            val params = listOf(${binds})`);
+    lines.push(
+      `            return client.query(${query.name}Sql, params).mapNotNull { ${Row}.fromRow(it) }`,
+    );
+  } else {
+    lines.push(
+      `            return client.query(${query.name}Sql).mapNotNull { ${Row}.fromRow(it) }`,
+    );
+  }
+  lines.push('        }');
+  return lines;
+}
+
+export function emitQueriesKotlinModule(
+  queries: readonly AnalyzedQuery[],
+  hash: string,
+  irVersion: number,
+  packageName: string,
+  objectName: string,
+): string {
+  const parts: string[] = [];
+  parts.push(
+    [
+      '// Generated by @syncular/typegen — DO NOT EDIT.',
+      `// irVersion: ${irVersion}`,
+      `// irHash: ${hash}`,
+      '',
+      `package ${packageName}`,
+      '',
+      'import dev.syncular.JsonValue',
+      'import dev.syncular.SyncularClient',
+    ].join('\n'),
+  );
+
+  // Row-decode + bind helpers (package-private; distinct names so they don't
+  // clash with the schema file's rowBool/rowBytes in the same package).
+  parts.push(
+    [
+      'private fun queryRowBool(value: JsonValue?): Boolean? {',
+      '    value?.bool?.let { return it }',
+      '    value?.number?.let { return it != 0.0 }',
+      '    return null',
+      '}',
+      '',
+      'private fun queryRowBytes(value: JsonValue?): ByteArray? {',
+      '    val hex = value?.get("\\$bytes")?.string ?: return null',
+      '    if (hex.length % 2 != 0) return null',
+      '    return ByteArray(hex.length / 2) { i ->',
+      '        hex.substring(i * 2, i * 2 + 2).toInt(16).toByte()',
+      '    }',
+      '}',
+      '',
+      'private fun queryBindBytes(value: ByteArray): JsonValue {',
+      '    val hex = value.joinToString("") { "%02x".format(it) }',
+      '    return JsonValue.obj("\\$bytes" to JsonValue.of(hex))',
+      '}',
+    ].join('\n'),
+  );
+
+  for (const query of queries) {
+    parts.push(emitDataClass(query).join('\n'));
+  }
+
+  const objLines: string[] = [];
+  objLines.push('/** Typed named queries (the sqlc/SQLDelight tier). */');
+  objLines.push(`object ${objectName}Queries {`);
+  objLines.push(queries.map((q) => emitRunner(q).join('\n')).join('\n\n'));
+  objLines.push('}');
+  parts.push(objLines.join('\n'));
+
+  return `${parts.join('\n\n')}\n`;
+}