@syncular/typegen 0.1.3 → 0.2.0

package/dist/emit-queries.js

@@ -0,0 +1,129 @@
+const TS_TYPE = {
+    string: 'string',
+    integer: 'number',
+    float: 'number',
+    boolean: 'boolean',
+    json: 'string',
+    bytes: 'Uint8Array',
+    blob_ref: 'string',
+    crdt: 'Uint8Array',
+};
+function pascalCase(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function quote(value) {
+    return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function propertyKey(name) {
+    return IDENTIFIER_RE.test(name) ? name : quote(name);
+}
+/** A named-query param value is the SqlValue subset its type maps to. */
+const PARAM_TS_TYPE = TS_TYPE;
+function emitQuery(query) {
+    const Row = `${pascalCase(query.name)}Row`;
+    const Params = `${pascalCase(query.name)}Params`;
+    const lines = [];
+    // Row interface.
+    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' : ''};`);
+    }
+    lines.push('}');
+    lines.push('');
+    // Params interface (only when there are params).
+    const hasParams = query.params.length > 0;
+    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]};`);
+        }
+        lines.push('}');
+        lines.push('');
+    }
+    // Tables dependency set (for useSyncQuery {tables} / useNamedQuery).
+    lines.push(`/** Tables ${quote(query.name)} reads — the exact useSyncQuery \`{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}` : '';
+    const sqlConst = `${query.name}Sql`;
+    const positional = hasParams
+        ? `[${query.params.map((p) => `params.${propertyKey(p.name)}`).join(', ')}]`
+        : '[]';
+    lines.push(`const ${sqlConst} = ${quote(query.positionalSql)};`);
+    lines.push('');
+    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});`);
+    }
+    else {
+        lines.push(`  const rows = await client.query(${sqlConst});`);
+    }
+    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.
+    lines.push(`/** Descriptor for \`useNamedQuery(${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},`);
+    lines.push(`  tables: ${query.name}Tables,`);
+    if (hasParams) {
+        lines.push(`  bind: (params: ${Params}) => ${positional},`);
+    }
+    else {
+        lines.push('  bind: () => [],');
+    }
+    lines.push('};');
+    return lines.join('\n');
+}
+export function emitQueriesModule(queries, hash, irVersion) {
+    const parts = [];
+    parts.push([
+        '// Generated by @syncular/typegen — DO NOT EDIT.',
+        `// irVersion: ${irVersion}`,
+        `// irHash: ${hash}`,
+    ].join('\n'));
+    parts.push([
+        "/** A bindable SQL param/row value (the wrapper's SqlValue subset). */",
+        'export type QueryValue =',
+        '  | string',
+        '  | number',
+        '  | bigint',
+        '  | boolean',
+        '  | Uint8Array',
+        '  | null;',
+        '',
+        "/** Minimal structural client surface — the wrapper's positional",
+        ' *  `query(sql, params?)`. `SyncClient`/`SyncClientHandle`/`SyncClientLike`',
+        ' *  all satisfy it, so this module imports nothing. */',
+        'export interface QueryClient {',
+        '  query(',
+        '    sql: string,',
+        '    params?: readonly QueryValue[],',
+        '  ): unknown[] | Promise<unknown[]>;',
+        '}',
+        '',
+        '/** 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. */',
+        '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 __row?: Row;',
+        '}',
+    ].join('\n'));
+    for (const query of queries) {
+        parts.push(emitQuery(query));
+    }
+    return `${parts.join('\n\n')}\n`;
+}

package/dist/emit-swift.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Swift emitter: neutral IR → one standalone `.swift` file exporting
+ *
+ * - `enum <EnumName> { static let schema: JSONValue }` — the ServerSchema
+ *   object, built from the IR with byte-stable ordering (fed straight into
+ *   `SyncularClient(schema:)`),
+ * - one `struct` per table with typed properties (per the six §2.4 column
+ *   types, plus blob_ref/crdt in their honest Swift shapes) and a
+ *   `init?(row:)` from a `[String: JSONValue]` (the shape `query`/`readRows`
+ *   return),
+ * - a `subscriptions` namespace of typed requested-scope builders.
+ *
+ * The file imports only `Syncular` (for `JSONValue`). The header carries the
+ * IR hash so `--check` verifies freshness byte-exactly, exactly like the TS
+ * emitter.
+ */
+import type { IrDocument } from './ir.js';
+export declare function emitSwiftModule(ir: IrDocument, hash: string, enumName: string): string;

package/dist/emit-swift.js

@@ -0,0 +1,235 @@
+/**
+ * §2.4 column type → honest Swift type. `json`/`blob_ref` are the raw
+ * canonical JSON string (the client's blob API parses blob_ref); `bytes`/
+ * `crdt` are opaque `[UInt8]`.
+ */
+const SWIFT_TYPE = {
+    string: 'String',
+    integer: 'Int',
+    float: 'Double',
+    boolean: 'Bool',
+    json: 'String',
+    bytes: '[UInt8]',
+    blob_ref: 'String',
+    crdt: '[UInt8]',
+};
+/** §5.11: app-side Swift type — declaredType for an encrypted column. */
+function appSwiftType(column) {
+    const type = column.encrypted === true && column.declaredType !== undefined
+        ? column.declaredType
+        : column.type;
+    return SWIFT_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, '\\"')}"`;
+}
+/** Emit a `JSONValue` literal for the schema object (built from the IR). */
+function emitSchemaValue(ir, indent) {
+    const lines = [];
+    const i = indent;
+    lines.push(`${i}.object([`);
+    lines.push(`${i}  "version": .number(${ir.schemaVersion}),`);
+    lines.push(`${i}  "tables": .array([`);
+    for (const table of ir.tables) {
+        lines.push(`${i}    .object([`);
+        lines.push(`${i}      "name": .string(${quote(table.name)}),`);
+        lines.push(`${i}      "primaryKey": .string(${quote(table.primaryKey)}),`);
+        lines.push(`${i}      "columns": .array([`);
+        for (const column of table.columns) {
+            const parts = [
+                `"name": .string(${quote(column.name)})`,
+                `"type": .string(${quote(column.type)})`,
+                `"nullable": .bool(${column.nullable})`,
+            ];
+            if (column.crdtType !== undefined) {
+                parts.push(`"crdtType": .string(${quote(column.crdtType)})`);
+            }
+            if (column.encrypted === true) {
+                parts.push('"encrypted": .bool(true)');
+                parts.push(`"declaredType": .string(${quote(column.declaredType ?? column.type)})`);
+            }
+            lines.push(`${i}        .object([${parts.join(', ')}]),`);
+        }
+        lines.push(`${i}      ]),`);
+        lines.push(`${i}      "scopes": .array([`);
+        for (const scope of table.scopes) {
+            lines.push(`${i}        .object(["pattern": .string(${quote(scope.pattern)}), "column": .string(${quote(scope.column)})]),`);
+        }
+        lines.push(`${i}      ]),`);
+        lines.push(`${i}    ]),`);
+    }
+    lines.push(`${i}  ]),`);
+    lines.push(`${i}])`);
+    return lines;
+}
+/** The accessor that lifts a §2.4 value out of a `[String: JSONValue]` row. */
+function rowAccessor(column) {
+    const key = `row[${quote(column.name)}]`;
+    switch (column.type) {
+        case 'string':
+        case 'json':
+        case 'blob_ref':
+            return `${key}?.stringValue`;
+        case 'integer':
+            // SQLite integers ride as JSON numbers; round to Int. Uses `.map(Int.init)`
+            // (not a trailing closure) so it parses inside a `guard let … else`.
+            return `${key}?.numberValue.map(Int.init)`;
+        case 'float':
+            return `${key}?.numberValue`;
+        case 'boolean':
+            // SQLite has no bool: it stores 0/1. Accept a real JSON bool OR 0/1.
+            return `SyncularSchemaRow.bool(${key})`;
+        case 'bytes':
+        case 'crdt':
+            // The core marshals bytes as {"$bytes":"<hex>"}; decode to [UInt8].
+            return `SyncularSchemaRow.bytes(${key})`;
+    }
+}
+function emitStruct(table) {
+    const type = pascalCase(table.name);
+    const lines = [];
+    lines.push(`/// One ${table.name} row (§2.4 column order).`);
+    lines.push(`public struct ${type}: Sendable, Equatable {`);
+    for (const column of table.columns) {
+        const swift = appSwiftType(column);
+        const opt = column.nullable ? '?' : '';
+        lines.push(`    public let ${camelCase(column.name)}: ${swift}${opt}`);
+    }
+    lines.push('');
+    // Memberwise init (public, so app code can build rows too).
+    const params = table.columns
+        .map((c) => {
+        const swift = SWIFT_TYPE[c.type];
+        const opt = c.nullable ? '? = nil' : '';
+        return `${camelCase(c.name)}: ${swift}${opt}`;
+    })
+        .join(', ');
+    lines.push(`    public init(${params}) {`);
+    for (const column of table.columns) {
+        const name = camelCase(column.name);
+        lines.push(`        self.${name} = ${name}`);
+    }
+    lines.push('    }');
+    lines.push('');
+    lines.push(`    /// Build from a \`query\`/\`readRows\` row (\`[String: JSONValue]\`).`);
+    lines.push(`    /// Returns nil when a non-nullable column is missing or mistyped.`);
+    lines.push('    public init?(row: [String: JSONValue]) {');
+    for (const column of table.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 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(`        public enum ${pascalCase(sub.name)} {`);
+    lines.push(`            public static let name = ${quote(sub.name)}`);
+    lines.push(`            public static let table = ${quote(sub.table)}`);
+    const args = params.map((p) => `${camelCase(p)}: String`).join(', ');
+    lines.push(`            public static func scopes(${args}) -> [String: [String]] {`);
+    lines.push('                [');
+    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)}: [${values}],`);
+    }
+    lines.push('                ]');
+    lines.push('            }');
+    lines.push('        }');
+    return lines;
+}
+export function emitSwiftModule(ir, hash, enumName) {
+    const parts = [];
+    parts.push([
+        '// Generated by @syncular/typegen — DO NOT EDIT.',
+        `// irVersion: ${ir.irVersion}`,
+        `// irHash: ${hash}`,
+        '',
+        'import Foundation',
+        'import Syncular',
+    ].join('\n'));
+    // The schema namespace.
+    const schemaLines = [];
+    schemaLines.push(`/// The generated syncular schema (SPEC §2.4, §3.1) + typed rows.`);
+    schemaLines.push(`public enum ${enumName} {`);
+    schemaLines.push(`    /// ServerSchema-compatible schema — pass to \`SyncularClient(schema:)\`.`);
+    schemaLines.push('    public static let schema: JSONValue =');
+    for (const line of emitSchemaValue(ir, '        ')) {
+        schemaLines.push(line);
+    }
+    schemaLines.push('');
+    // Subscriptions namespace nested in the schema enum.
+    schemaLines.push('    /// Typed requested-scope builders per subscription.');
+    schemaLines.push('    public enum 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 (0/1 booleans, {$bytes} decode).
+    parts.push([
+        '/// Row-decode helpers shared by the generated structs.',
+        'enum SyncularSchemaRow {',
+        '    /// Lift a SQLite boolean: a real JSON bool, or 0/1 as a number.',
+        '    static func bool(_ value: JSONValue?) -> Bool? {',
+        '        if let b = value?.boolValue { return b }',
+        '        if let n = value?.numberValue { return n != 0 }',
+        '        return nil',
+        '    }',
+        '',
+        '    /// Decode the core\'s `{"$bytes":"<hex>"}` marshaling into bytes.',
+        '    static func bytes(_ value: JSONValue?) -> [UInt8]? {',
+        '        guard let hex = value?["$bytes"]?.stringValue else { return nil }',
+        '        var out: [UInt8] = []',
+        '        out.reserveCapacity(hex.count / 2)',
+        '        var index = hex.startIndex',
+        '        while index < hex.endIndex {',
+        '            let next = hex.index(index, offsetBy: 2, limitedBy: hex.endIndex) ?? hex.endIndex',
+        '            guard let byte = UInt8(hex[index..<next], radix: 16) else { return nil }',
+        '            out.append(byte)',
+        '            index = next',
+        '        }',
+        '        return out',
+        '    }',
+        '}',
+    ].join('\n'));
+    for (const table of ir.tables) {
+        parts.push(emitStruct(table).join('\n'));
+    }
+    return `${parts.join('\n\n')}\n`;
+}

package/dist/emit.d.ts

@@ -0,0 +1,16 @@
+/**
+ * TS emitter: neutral IR → one standalone generated module exporting
+ *
+ * - `schema` — a ServerSchema-compatible object (structurally typed; the
+ *   generated file imports nothing),
+ * - a `<Table>Row` interface per table,
+ * - `<Table>Insert` / `<Table>Update` mutation-input shapes honoring
+ *   nullability,
+ * - a `<name>Subscription` helper constant per manifest subscription with
+ *   a typed requested-scopes builder.
+ *
+ * The header carries the IR hash so `--check` verifies freshness
+ * byte-exactly.
+ */
+import type { IrDocument } from './ir.js';
+export declare function emitModule(ir: IrDocument, hash: string): string;

package/dist/emit.js

@@ -0,0 +1,191 @@
+const TS_TYPE = {
+    string: 'string',
+    integer: 'number',
+    float: 'number',
+    boolean: 'boolean',
+    json: 'string',
+    bytes: 'Uint8Array',
+    // §5.9: a blob_ref value is the raw canonical BlobRef JSON string
+    // (like `json`); the client's blob API parses it into a BlobRef object.
+    blob_ref: 'string',
+    // §5.10: a crdt value is opaque bytes (like `bytes`); the Y.Doc accessor
+    // is an app-level helper in @syncular/crdt-yjs, not generated code.
+    crdt: 'Uint8Array',
+};
+/**
+ * §5.11: the app-side TS type of a column. An encrypted column's wire type is
+ * `bytes`, but the app sees its declared type (the local mirror is plaintext).
+ */
+function appTsType(column) {
+    const type = column.encrypted === true && column.declaredType !== undefined
+        ? column.declaredType
+        : column.type;
+    return TS_TYPE[type];
+}
+function pascalCase(name) {
+    return name
+        .split(/[_-]+/)
+        .filter((part) => part.length > 0)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+function quote(value) {
+    return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function propertyKey(name) {
+    return IDENTIFIER_RE.test(name) ? name : quote(name);
+}
+function emitSchema(ir) {
+    const lines = [];
+    lines.push('/** ServerSchema-compatible schema object (SPEC §2.4, §3.1). */');
+    lines.push('export const schema = {');
+    lines.push(`  version: ${ir.schemaVersion},`);
+    lines.push('  tables: [');
+    for (const table of ir.tables) {
+        lines.push('    {');
+        lines.push(`      name: ${quote(table.name)},`);
+        lines.push('      columns: [');
+        for (const column of table.columns) {
+            // §5.10.1: emit crdtType on crdt columns so a generated server schema
+            // can select the merger; omitted (and thus unchanged) for others.
+            const crdtType = column.crdtType !== undefined
+                ? `, crdtType: ${quote(column.crdtType)}`
+                : '';
+            // §5.11: emit encrypted/declaredType on encrypted columns so the client
+            // codec encrypts/decrypts them; omitted for others.
+            const encrypted = column.encrypted === true
+                ? `, encrypted: true, declaredType: ${quote(column.declaredType ?? column.type)}`
+                : '';
+            lines.push(`        { name: ${quote(column.name)}, type: ${quote(column.type)}, nullable: ${column.nullable}${crdtType}${encrypted} },`);
+        }
+        lines.push('      ],');
+        lines.push(`      primaryKey: ${quote(table.primaryKey)},`);
+        lines.push('      scopes: [');
+        for (const scope of table.scopes) {
+            lines.push(`        { pattern: ${quote(scope.pattern)}, column: ${quote(scope.column)} },`);
+        }
+        lines.push('      ],');
+        // Local secondary indexes — emitted only when the table declares any, so
+        // index-free tables keep their exact pre-index generated bytes.
+        if (table.indexes.length > 0) {
+            lines.push('      indexes: [');
+            for (const index of table.indexes) {
+                const cols = index.columns.map((c) => quote(c)).join(', ');
+                lines.push(`        { name: ${quote(index.name)}, columns: [${cols}], unique: ${index.unique} },`);
+            }
+            lines.push('      ],');
+        }
+        lines.push('    },');
+    }
+    lines.push('  ],');
+    lines.push('} as const;');
+    return lines.join('\n');
+}
+function emitRowInterfaces(table) {
+    const type = pascalCase(table.name);
+    const lines = [];
+    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' : ''};`);
+    }
+    lines.push('}');
+    lines.push('');
+    lines.push(`/** Insert shape: nullable columns may be omitted. */`);
+    lines.push(`export interface ${type}Insert {`);
+    for (const column of table.columns) {
+        const ts = appTsType(column);
+        lines.push(column.nullable
+            ? `  ${propertyKey(column.name)}?: ${ts} | null;`
+            : `  ${propertyKey(column.name)}: ${ts};`);
+    }
+    lines.push('}');
+    lines.push('');
+    lines.push(`/** Update shape: primary key required, all other columns optional. */`);
+    lines.push(`export interface ${type}Update {`);
+    for (const column of table.columns) {
+        const ts = appTsType(column);
+        if (column.name === table.primaryKey) {
+            lines.push(`  ${propertyKey(column.name)}: ${ts};`);
+        }
+        else {
+            lines.push(`  ${propertyKey(column.name)}?: ${ts}${column.nullable ? ' | null' : ''};`);
+        }
+    }
+    lines.push('}');
+    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) {
+    const lines = [];
+    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) {
+    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 = [];
+    const paramsType = `${pascalCase(sub.name)}Params`;
+    if (params.length > 0) {
+        lines.push(`export interface ${paramsType} {`);
+        for (const param of params) {
+            lines.push(`  ${propertyKey(param)}: string;`);
+        }
+        lines.push('}');
+        lines.push('');
+    }
+    lines.push(`/** Requested-scope template for the ${quote(sub.name)} subscription. */`);
+    lines.push(`export const ${sub.name}Subscription = {`);
+    lines.push(`  name: ${quote(sub.name)},`);
+    lines.push(`  table: ${quote(sub.table)},`);
+    const args = params.length > 0 ? `params: ${paramsType}` : '';
+    lines.push(`  scopes: (${args}): Record<string, string[]> => ({`);
+    for (const scope of sub.scopes) {
+        const values = scope.values
+            .map((value) => value.kind === 'literal'
+            ? quote(value.value)
+            : `params.${propertyKey(value.name)}`)
+            .join(', ');
+        lines.push(`    ${propertyKey(scope.variable)}: [${values}],`);
+    }
+    lines.push('  }),');
+    lines.push('} as const;');
+    return lines.join('\n');
+}
+export function emitModule(ir, hash) {
+    const parts = [];
+    parts.push([
+        '// Generated by @syncular/typegen — DO NOT EDIT.',
+        `// irVersion: ${ir.irVersion}`,
+        `// irHash: ${hash}`,
+    ].join('\n'));
+    parts.push(emitSchema(ir));
+    for (const table of ir.tables) {
+        parts.push(emitRowInterfaces(table));
+    }
+    parts.push(emitDatabaseInterface(ir));
+    for (const sub of ir.subscriptions) {
+        parts.push(emitSubscription(sub));
+    }
+    return `${parts.join('\n\n')}\n`;
+}

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+/** Fail-loud codegen error: every message names the offending construct. */
+export declare class TypegenError extends Error {
+    /** Input the error came from (a migration file, the manifest, …). */
+    readonly source: string;
+    constructor(source: string, message: string);
+}

package/dist/errors.js

@@ -0,0 +1,10 @@
+/** Fail-loud codegen error: every message names the offending construct. */
+export class TypegenError extends Error {
+    /** Input the error came from (a migration file, the manifest, …). */
+    source;
+    constructor(source, message) {
+        super(`${source}: ${message}`);
+        this.name = 'TypegenError';
+        this.source = source;
+    }
+}