@syncular/typegen 0.1.2 → 0.2.0

package/src/checksums.ts

@@ -1,257 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import { dirname } from 'node:path';
-import { PGlite } from '@electric-sql/pglite';
-import type {
-  DefinedMigrations,
-  MigrationChecksums,
-  ParsedMigration,
-} from '@syncular/migrations';
-import { Kysely, SqliteDialect } from 'kysely';
-import { PGliteDialect } from 'kysely-pglite-dialect';
-import type {
-  GenerateMigrationChecksumsOptions,
-  GenerateMigrationChecksumsResult,
-  TypegenDialect,
-} from './types';
-
-interface TraceableQuery {
-  sql: string;
-  parameters: readonly unknown[];
-}
-
-interface SqliteDb {
-  close(): void;
-}
-
-type BunAwareGlobals = typeof globalThis & {
-  Bun?: object;
-};
-
-const runtimeGlobals = globalThis as BunAwareGlobals;
-const isBun = typeof runtimeGlobals.Bun !== 'undefined';
-
-function hashString(value: string): string {
-  let hash = 0;
-
-  for (let index = 0; index < value.length; index += 1) {
-    hash = (hash * 31 + value.charCodeAt(index)) >>> 0;
-  }
-
-  return hash.toString(16).padStart(8, '0');
-}
-
-function normalizeParameterValue(value: unknown): unknown {
-  if (typeof value === 'bigint') {
-    return { type: 'bigint', value: value.toString() };
-  }
-  if (value instanceof Date) {
-    return { type: 'date', value: value.toISOString() };
-  }
-  if (value instanceof Uint8Array) {
-    return { type: 'bytes', value: Array.from(value) };
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => normalizeParameterValue(entry));
-  }
-  if (value && typeof value === 'object') {
-    return Object.fromEntries(
-      Object.entries(value)
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([key, entry]) => [key, normalizeParameterValue(entry)])
-    );
-  }
-  return value;
-}
-
-function serializeQuery(query: TraceableQuery): string {
-  return JSON.stringify({
-    sql: query.sql,
-    parameters: query.parameters.map((value) => normalizeParameterValue(value)),
-  });
-}
-
-function hashTrace(entries: string[]): string {
-  return hashString(entries.join('\n'));
-}
-
-function quoteTsString(value: string): string {
-  return `'${value.replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`;
-}
-
-async function createSqliteTraceDb<DB>(traceEntries: string[]): Promise<{
-  db: Kysely<DB>;
-  sqliteDb: SqliteDb;
-}> {
-  if (isBun) {
-    const bunSqliteSpecifier = 'bun:sqlite';
-    const sqliteModule = await import(bunSqliteSpecifier);
-    const dialectModule = await import('kysely-bun-sqlite');
-    const sqliteDb = new sqliteModule.Database(':memory:');
-    const db = new Kysely<DB>({
-      dialect: new dialectModule.BunSqliteDialect({
-        database: sqliteDb as never,
-      }),
-      log(event) {
-        if (event.level === 'query') {
-          traceEntries.push(serializeQuery(event.query));
-        }
-      },
-    });
-
-    return { db, sqliteDb };
-  }
-
-  const { default: Database } = await import('better-sqlite3');
-  const sqliteDb = new Database(':memory:');
-  const db = new Kysely<DB>({
-    dialect: new SqliteDialect({
-      database: sqliteDb as never,
-    }),
-    log(event) {
-      if (event.level === 'query') {
-        traceEntries.push(serializeQuery(event.query));
-      }
-    },
-  });
-
-  return { db, sqliteDb };
-}
-
-async function createPostgresTraceDb<DB>(traceEntries: string[]): Promise<{
-  db: Kysely<DB>;
-  dispose: () => Promise<void>;
-}> {
-  const pglite = await PGlite.create();
-  const db = new Kysely<DB>({
-    dialect: new PGliteDialect(pglite),
-    log(event) {
-      if (event.level === 'query') {
-        traceEntries.push(serializeQuery(event.query));
-      }
-    },
-  });
-
-  return {
-    db,
-    dispose: async () => {
-      if (!pglite.closed) {
-        await pglite.close();
-      }
-    },
-  };
-}
-
-async function createTraceDb<DB>(
-  dialect: TypegenDialect,
-  traceEntries: string[]
-): Promise<{
-  db: Kysely<DB>;
-  dispose: () => Promise<void>;
-}> {
-  if (dialect === 'postgres') {
-    return createPostgresTraceDb<DB>(traceEntries);
-  }
-
-  const { db, sqliteDb } = await createSqliteTraceDb<DB>(traceEntries);
-  return {
-    db,
-    dispose: async () => {
-      sqliteDb.close();
-    },
-  };
-}
-
-async function computeMigrationChecksum<DB>(
-  migrations: DefinedMigrations<DB>,
-  targetMigration: ParsedMigration<DB>,
-  dialect: TypegenDialect
-): Promise<string> {
-  const traceEntries: string[] = [];
-  const { db, dispose } = await createTraceDb<DB>(dialect, traceEntries);
-
-  try {
-    for (const migration of migrations.migrations) {
-      if (migration.version > targetMigration.version) {
-        break;
-      }
-
-      if (migration.version === targetMigration.version) {
-        traceEntries.length = 0;
-      }
-
-      await migration.up(db);
-
-      if (migration.version === targetMigration.version) {
-        break;
-      }
-    }
-
-    return hashTrace(traceEntries);
-  } finally {
-    await db.destroy();
-    await dispose();
-  }
-}
-
-export async function createMigrationChecksums<DB>(
-  migrations: DefinedMigrations<DB>,
-  dialect: TypegenDialect = 'sqlite'
-): Promise<MigrationChecksums> {
-  const checksums: Record<string, string> = {};
-
-  for (const migration of migrations.migrations) {
-    if (migration.checksum === 'disabled') {
-      continue;
-    }
-
-    checksums[String(migration.version)] = await computeMigrationChecksum(
-      migrations,
-      migration,
-      dialect
-    );
-  }
-
-  return checksums;
-}
-
-export function renderMigrationChecksums(
-  checksums: MigrationChecksums
-): string {
-  const entries = Object.entries(checksums)
-    .sort(([left], [right]) => Number(left) - Number(right))
-    .map(
-      ([version, checksum]) =>
-        `  ${quoteTsString(version)}: ${quoteTsString(checksum)},`
-    )
-    .join('\n');
-
-  return [
-    '/**',
-    ' * Generated by @syncular/typegen.',
-    ' * Do not edit by hand.',
-    ' */',
-    '',
-    'export const migrationChecksums = {',
-    entries,
-    '} as const;',
-    '',
-  ].join('\n');
-}
-
-export async function generateMigrationChecksums<DB>(
-  options: GenerateMigrationChecksumsOptions<DB>
-): Promise<GenerateMigrationChecksumsResult> {
-  const { migrations, output, dialect = 'sqlite' } = options;
-  const checksums = await createMigrationChecksums(migrations, dialect);
-  const code = renderMigrationChecksums(checksums);
-
-  await mkdir(dirname(output), { recursive: true });
-  await writeFile(output, code, 'utf-8');
-
-  return {
-    outputPath: output,
-    currentVersion: migrations.currentVersion,
-    checksumCount: Object.keys(checksums).length,
-    code,
-  };
-}

package/src/introspect-postgres.ts

@@ -1,149 +0,0 @@
-/**
- * @syncular/typegen - PostgreSQL schema introspection via PGlite
- */
-
-import { PGlite } from '@electric-sql/pglite';
-import type { DefinedMigrations } from '@syncular/migrations';
-import { Kysely } from 'kysely';
-import { PGliteDialect } from 'kysely-pglite-dialect';
-import type { TableSchema, VersionedSchema } from './types';
-
-interface PgColumn {
-  table_name: string;
-  column_name: string;
-  data_type: string;
-  udt_name: string;
-  is_nullable: string;
-  column_default: string | null;
-  ordinal_position: number;
-}
-
-interface PgPrimaryKey {
-  table_name: string;
-  column_name: string;
-}
-
-async function introspectPg(pglite: PGlite): Promise<TableSchema[]> {
-  const colResult = await pglite.query<PgColumn>(
-    `SELECT table_name, column_name, data_type, udt_name,
-            is_nullable, column_default, ordinal_position
-     FROM information_schema.columns
-     WHERE table_schema = 'public'
-     ORDER BY table_name, ordinal_position`
-  );
-
-  const pkResult = await pglite.query<PgPrimaryKey>(
-    `SELECT kcu.column_name, tc.table_name
-     FROM information_schema.table_constraints tc
-     JOIN information_schema.key_column_usage kcu
-       ON tc.constraint_name = kcu.constraint_name
-          AND tc.table_schema = kcu.table_schema
-     WHERE tc.constraint_type = 'PRIMARY KEY' AND tc.table_schema = 'public'`
-  );
-
-  const pkSet = new Set(
-    pkResult.rows.map((r) => `${r.table_name}.${r.column_name}`)
-  );
-
-  const tableMap = new Map<string, TableSchema>();
-
-  for (const col of colResult.rows) {
-    let table = tableMap.get(col.table_name);
-    if (!table) {
-      table = { name: col.table_name, columns: [] };
-      tableMap.set(col.table_name, table);
-    }
-
-    const isPrimaryKey = pkSet.has(`${col.table_name}.${col.column_name}`);
-    const nullable = col.is_nullable === 'YES' && !isPrimaryKey;
-    const hasDefault = col.column_default !== null;
-
-    // Use udt_name for more precise type info (e.g. int4 instead of "integer")
-    // For arrays, data_type is "ARRAY" and udt_name starts with "_"
-    let sqlType: string;
-    if (col.data_type === 'ARRAY' && col.udt_name.startsWith('_')) {
-      // Convert _int4 → int4[], _text → text[], etc.
-      sqlType = `${col.udt_name.slice(1)}[]`;
-    } else if (col.data_type === 'USER-DEFINED') {
-      sqlType = col.udt_name;
-    } else {
-      sqlType = col.udt_name;
-    }
-
-    table.columns.push({
-      name: col.column_name,
-      sqlType,
-      tsType: '', // resolved later by map-types
-      nullable,
-      isPrimaryKey,
-      hasDefault,
-    });
-  }
-
-  // Sort tables by name for deterministic output
-  return [...tableMap.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-
-async function introspectAtVersion<DB = unknown>(
-  migrations: DefinedMigrations<DB>,
-  targetVersion: number,
-  filterTables?: string[]
-): Promise<VersionedSchema> {
-  const pglite = await PGlite.create();
-  const db = new Kysely<DB>({
-    dialect: new PGliteDialect(pglite),
-  });
-
-  try {
-    for (const migration of migrations.migrations) {
-      if (migration.version > targetVersion) break;
-      await migration.up(db);
-    }
-
-    let tables = await introspectPg(pglite);
-
-    if (filterTables && filterTables.length > 0) {
-      const filterSet = new Set(filterTables);
-      tables = tables.filter((t) => filterSet.has(t.name));
-    }
-
-    return {
-      version: targetVersion,
-      tables,
-    };
-  } finally {
-    await db.destroy();
-    if (!pglite.closed) {
-      await pglite.close();
-    }
-  }
-}
-
-export async function introspectPostgresAllVersions<DB = unknown>(
-  migrations: DefinedMigrations<DB>,
-  filterTables?: string[]
-): Promise<VersionedSchema[]> {
-  const schemas: VersionedSchema[] = [];
-
-  for (const migration of migrations.migrations) {
-    const schema = await introspectAtVersion(
-      migrations,
-      migration.version,
-      filterTables
-    );
-    schemas.push(schema);
-  }
-
-  return schemas;
-}
-
-export async function introspectPostgresCurrentSchema<DB = unknown>(
-  migrations: DefinedMigrations<DB>,
-  filterTables?: string[]
-): Promise<VersionedSchema> {
-  return introspectAtVersion(
-    migrations,
-    migrations.currentVersion,
-    filterTables
-  );
-}

package/src/introspect-sqlite.ts

@@ -1,156 +0,0 @@
-/**
- * @syncular/typegen - SQLite schema introspection
- *
- * Works with both better-sqlite3 (Node.js) and bun:sqlite (Bun runtime).
- */
-
-import type { DefinedMigrations } from '@syncular/migrations';
-import { Kysely, SqliteDialect } from 'kysely';
-import type { TableSchema, VersionedSchema } from './types';
-
-interface SqliteColumnInfo {
-  cid: number;
-  name: string;
-  type: string;
-  notnull: 0 | 1;
-  dflt_value: string | null;
-  pk: 0 | 1;
-}
-
-/** Minimal interface shared by better-sqlite3 and bun:sqlite */
-interface SqliteDb {
-  prepare(sql: string): { all(...params: unknown[]): unknown[] };
-  close(): void;
-}
-
-type BunAwareGlobals = typeof globalThis & {
-  Bun?: object;
-};
-
-const runtimeGlobals = globalThis as BunAwareGlobals;
-const isBun = typeof runtimeGlobals.Bun !== 'undefined';
-
-async function createSqliteDb(): Promise<SqliteDb> {
-  if (isBun) {
-    const { Database } = await import('bun:sqlite');
-    return new Database(':memory:');
-  }
-  const { default: Database } = await import('better-sqlite3');
-  return new Database(':memory:');
-}
-
-async function createKysely<DB>(sqliteDb: SqliteDb): Promise<Kysely<DB>> {
-  if (isBun) {
-    const { BunSqliteDialect } = await import('kysely-bun-sqlite');
-    return new Kysely<DB>({
-      dialect: new BunSqliteDialect({
-        database: sqliteDb as never,
-      }),
-    });
-  }
-
-  return new Kysely<DB>({
-    dialect: new SqliteDialect({
-      database: sqliteDb as never,
-    }),
-  });
-}
-
-function introspectTable(sqliteDb: SqliteDb, tableName: string): TableSchema {
-  const columns = sqliteDb
-    .prepare(`PRAGMA table_info("${tableName}")`)
-    .all() as SqliteColumnInfo[];
-
-  return {
-    name: tableName,
-    columns: columns.map((col) => {
-      const nullable = col.notnull === 0 && col.pk === 0;
-      const hasDefault = col.dflt_value !== null;
-      return {
-        name: col.name,
-        sqlType: col.type,
-        tsType: '', // resolved later by map-types
-        nullable,
-        isPrimaryKey: col.pk === 1,
-        hasDefault,
-      };
-    }),
-  };
-}
-
-function getAllTables(sqliteDb: SqliteDb): string[] {
-  const rows = sqliteDb
-    .prepare(
-      `SELECT name FROM sqlite_master
-       WHERE type='table'
-       AND name NOT LIKE 'sqlite_%'
-       ORDER BY name`
-    )
-    .all() as { name: string }[];
-
-  return rows.map((r) => r.name);
-}
-
-async function introspectAtVersion<DB = unknown>(
-  migrations: DefinedMigrations<DB>,
-  targetVersion: number,
-  filterTables?: string[]
-): Promise<VersionedSchema> {
-  const sqliteDb = await createSqliteDb();
-
-  try {
-    const db = await createKysely<DB>(sqliteDb);
-
-    for (const migration of migrations.migrations) {
-      if (migration.version > targetVersion) break;
-      await migration.up(db);
-    }
-
-    let tableNames = getAllTables(sqliteDb);
-
-    if (filterTables && filterTables.length > 0) {
-      const filterSet = new Set(filterTables);
-      tableNames = tableNames.filter((t) => filterSet.has(t));
-    }
-
-    const tables = tableNames.map((name) => introspectTable(sqliteDb, name));
-
-    await db.destroy();
-
-    return {
-      version: targetVersion,
-      tables,
-    };
-  } finally {
-    sqliteDb.close();
-  }
-}
-
-export async function introspectSqliteAllVersions<DB = unknown>(
-  migrations: DefinedMigrations<DB>,
-  filterTables?: string[]
-): Promise<VersionedSchema[]> {
-  const schemas: VersionedSchema[] = [];
-
-  for (const migration of migrations.migrations) {
-    const schema = await introspectAtVersion(
-      migrations,
-      migration.version,
-      filterTables
-    );
-    schemas.push(schema);
-  }
-
-  return schemas;
-}
-
-export async function introspectSqliteCurrentSchema<DB = unknown>(
-  migrations: DefinedMigrations<DB>,
-  filterTables?: string[]
-): Promise<VersionedSchema> {
-  return introspectAtVersion(
-    migrations,
-    migrations.currentVersion,
-    filterTables
-  );
-}

package/src/introspect.ts

@@ -1,36 +0,0 @@
-/**
- * @syncular/typegen - Schema introspection dispatcher
- */
-
-import type { DefinedMigrations } from '@syncular/migrations';
-import {
-  introspectPostgresAllVersions,
-  introspectPostgresCurrentSchema,
-} from './introspect-postgres';
-import {
-  introspectSqliteAllVersions,
-  introspectSqliteCurrentSchema,
-} from './introspect-sqlite';
-import type { TypegenDialect, VersionedSchema } from './types';
-
-export async function introspectAllVersions<DB = unknown>(
-  migrations: DefinedMigrations<DB>,
-  dialect: TypegenDialect,
-  filterTables?: string[]
-): Promise<VersionedSchema[]> {
-  if (dialect === 'postgres') {
-    return introspectPostgresAllVersions(migrations, filterTables);
-  }
-  return introspectSqliteAllVersions(migrations, filterTables);
-}
-
-export async function introspectCurrentSchema<DB = unknown>(
-  migrations: DefinedMigrations<DB>,
-  dialect: TypegenDialect,
-  filterTables?: string[]
-): Promise<VersionedSchema> {
-  if (dialect === 'postgres') {
-    return introspectPostgresCurrentSchema(migrations, filterTables);
-  }
-  return introspectSqliteCurrentSchema(migrations, filterTables);
-}