@syncular/typegen 0.1.2 → 0.2.0

package/dist/emit-kotlin.js

@@ -0,0 +1,201 @@
+/** §2.4 column type → honest Kotlin type. `json`/`blob_ref` are the raw
+ * canonical JSON string; `bytes`/`crdt` are opaque `ByteArray`. */
+const KOTLIN_TYPE = {
+    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) {
+    const type = column.encrypted === true && column.declaredType !== undefined
+        ? column.declaredType
+        : column.type;
+    return KOTLIN_TYPE[type];
+}
+function pascalCase(name) {
+    return name
+        .split(/[_-]+/)
+        .filter((part) => part.length > 0)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+function camelCase(name) {
+    const pascal = pascalCase(name);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function quote(value) {
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\$/g, '\\$')}"`;
+}
+function emitSchemaValue(ir, indent) {
+    const lines = [];
+    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) {
+    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) {
+    const type = pascalCase(table.name);
+    const lines = [];
+    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) {
+    const params = [];
+    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 = [];
+    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, hash, packageName, objectName) {
+    const parts = [];
+    parts.push([
+        '// Generated by @syncular/typegen — DO NOT EDIT.',
+        `// irVersion: ${ir.irVersion}`,
+        `// irHash: ${hash}`,
+        '',
+        `package ${packageName}`,
+        '',
+        'import dev.syncular.JsonValue',
+    ].join('\n'));
+    const schemaLines = [];
+    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/dist/emit-queries-dart.d.ts

@@ -0,0 +1,2 @@
+import type { AnalyzedQuery } from './query.js';
+export declare function emitQueriesDartModule(queries: readonly AnalyzedQuery[], hash: string, irVersion: number): string;

package/dist/emit-queries-dart.js

@@ -0,0 +1,160 @@
+const DART_TYPE = {
+    string: 'String',
+    integer: 'int',
+    float: 'double',
+    boolean: 'bool',
+    json: 'String',
+    bytes: 'List<int>',
+    blob_ref: 'String',
+    crdt: 'List<int>',
+};
+function pascalCase(name) {
+    return name
+        .split(/[_-]+/)
+        .filter((p) => p.length > 0)
+        .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+        .join('');
+}
+function camelCase(name) {
+    const pascal = pascalCase(name);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function typeName(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function quote(value) {
+    return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\$/g, '\\$')}'`;
+}
+function rowAccessor(column) {
+    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, name) {
+    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) {
+    const Row = `${typeName(query.name)}Row`;
+    const lines = [];
+    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) {
+    const Row = `${typeName(query.name)}Row`;
+    const Pascal = pascalCase(query.name);
+    const lines = [];
+    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, hash, irVersion) {
+    const parts = [];
+    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/dist/emit-queries-kotlin.d.ts

@@ -0,0 +1,2 @@
+import type { AnalyzedQuery } from './query.js';
+export declare function emitQueriesKotlinModule(queries: readonly AnalyzedQuery[], hash: string, irVersion: number, packageName: string, objectName: string): string;

package/dist/emit-queries-kotlin.js

@@ -0,0 +1,162 @@
+const KOTLIN_TYPE = {
+    string: 'String',
+    integer: 'Long',
+    float: 'Double',
+    boolean: 'Boolean',
+    json: 'String',
+    bytes: 'ByteArray',
+    blob_ref: 'String',
+    crdt: 'ByteArray',
+};
+function pascalCase(name) {
+    return name
+        .split(/[_-]+/)
+        .filter((p) => p.length > 0)
+        .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+        .join('');
+}
+function camelCase(name) {
+    const pascal = pascalCase(name);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function typeName(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function quote(value) {
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\$/g, '\\$')}"`;
+}
+function rowAccessor(column) {
+    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, name) {
+    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) {
+    const Row = `${typeName(query.name)}Row`;
+    const lines = [];
+    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) {
+    const Row = `${typeName(query.name)}Row`;
+    const lines = [];
+    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, hash, irVersion, packageName, objectName) {
+    const parts = [];
+    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 = [];
+    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`;
+}

package/dist/emit-queries-swift.d.ts

@@ -0,0 +1,2 @@
+import type { AnalyzedQuery } from './query.js';
+export declare function emitQueriesSwiftModule(queries: readonly AnalyzedQuery[], hash: string, irVersion: number, enumName: string): string;

package/dist/emit-queries-swift.js

@@ -0,0 +1,146 @@
+const SWIFT_TYPE = {
+    string: 'String',
+    integer: 'Int',
+    float: 'Double',
+    boolean: 'Bool',
+    json: 'String',
+    bytes: '[UInt8]',
+    blob_ref: 'String',
+    crdt: '[UInt8]',
+};
+function pascalCase(name) {
+    return name
+        .split(/[_-]+/)
+        .filter((p) => p.length > 0)
+        .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+        .join('');
+}
+function camelCase(name) {
+    const pascal = pascalCase(name);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+/** The query function/type name: already camelCase; PascalCase for the type. */
+function typeName(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function quote(value) {
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+function rowAccessor(column) {
+    const key = `row[${quote(column.name)}]`;
+    switch (column.type) {
+        case 'string':
+        case 'json':
+        case 'blob_ref':
+            return `${key}?.stringValue`;
+        case 'integer':
+            return `${key}?.numberValue.map(Int.init)`;
+        case 'float':
+            return `${key}?.numberValue`;
+        case 'boolean':
+            return `SyncularSchemaRow.bool(${key})`;
+        case 'bytes':
+        case 'crdt':
+            return `SyncularSchemaRow.bytes(${key})`;
+    }
+}
+function paramValue(type, name) {
+    switch (type) {
+        case 'integer':
+        case 'float':
+            return `.number(Double(${name}))`;
+        case 'boolean':
+            return `.bool(${name})`;
+        case 'bytes':
+        case 'crdt':
+            return `SyncularSchemaQueryBind.bytes(${name})`;
+        default:
+            return `.string(${name})`;
+    }
+}
+function emitRowStruct(query) {
+    const Row = `${typeName(query.name)}Row`;
+    const lines = [];
+    lines.push(`/// One row of the ${query.name} query (its projection).`);
+    lines.push(`public struct ${Row}: Sendable, Equatable {`);
+    for (const column of query.columns) {
+        const opt = column.nullable ? '?' : '';
+        lines.push(`    public let ${camelCase(column.name)}: ${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 accessor = rowAccessor(column);
+        if (column.nullable) {
+            lines.push(`        self.${name} = ${accessor}`);
+        }
+        else {
+            lines.push(`        guard let ${name} = ${accessor} else { return nil }`);
+            lines.push(`        self.${name} = ${name}`);
+        }
+    }
+    lines.push('    }');
+    lines.push('}');
+    return lines;
+}
+function emitRunner(query) {
+    const Row = `${typeName(query.name)}Row`;
+    const lines = [];
+    lines.push(`    public static let ${query.name}Tables = [${query.tables.map(quote).join(', ')}]`);
+    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 signature = query.params.length > 0
+        ? `client: SyncularClient, ${args}`
+        : 'client: SyncularClient';
+    lines.push(`    public static func ${query.name}(${signature}) throws -> [${Row}] {`);
+    if (query.params.length > 0) {
+        const binds = query.params
+            .map((p) => paramValue(p.type, camelCase(p.name)))
+            .join(', ');
+        lines.push(`        let params: [JSONValue] = [${binds}]`);
+        lines.push(`        return try client.query(${query.name}Sql, params: params).compactMap { row in`);
+    }
+    else {
+        lines.push(`        return try client.query(${query.name}Sql).compactMap { row in`);
+    }
+    lines.push('            guard case let .object(fields) = row else { return nil }');
+    lines.push(`            return ${Row}(row: fields)`);
+    lines.push('        }');
+    lines.push('    }');
+    return lines;
+}
+export function emitQueriesSwiftModule(queries, hash, irVersion, enumName) {
+    const parts = [];
+    parts.push([
+        '// Generated by @syncular/typegen — DO NOT EDIT.',
+        `// irVersion: ${irVersion}`,
+        `// irHash: ${hash}`,
+        '',
+        'import Foundation',
+        'import Syncular',
+    ].join('\n'));
+    parts.push([
+        '/// Param-bind helpers shared by the generated query runners.',
+        'enum SyncularSchemaQueryBind {',
+        '    static func bytes(_ value: [UInt8]) -> JSONValue {',
+        '        let hex = value.map { String(format: "%02x", $0) }.joined()',
+        '        return .object(["$bytes": .string(hex)])',
+        '    }',
+        '}',
+    ].join('\n'));
+    for (const query of queries) {
+        parts.push(emitRowStruct(query).join('\n'));
+    }
+    const enumLines = [];
+    enumLines.push('/// Typed named queries (the sqlc/SQLDelight tier).');
+    enumLines.push(`public enum ${enumName}Queries {`);
+    enumLines.push(queries.map((q) => emitRunner(q).join('\n')).join('\n\n'));
+    enumLines.push('}');
+    parts.push(enumLines.join('\n'));
+    return `${parts.join('\n\n')}\n`;
+}

package/dist/emit-queries.d.ts

@@ -0,0 +1,2 @@
+import type { AnalyzedQuery } from './query.js';
+export declare function emitQueriesModule(queries: readonly AnalyzedQuery[], hash: string, irVersion: number): string;