@syncular/typegen 0.1.2 → 0.2.0

package/src/map-types.ts

@@ -1,189 +0,0 @@
-/**
- * @syncular/typegen - Type mapping
- *
- * Maps SQL types to TypeScript types for each dialect,
- * with support for column codec type overrides.
- */
-
-import type { ColumnInfo, TypegenDialect, TypeOverride } from './types';
-
-export interface ResolvedType {
-  tsType: string;
-  imports: Array<{ name: string; from: string }>;
-}
-
-function mapSqliteType(sqlType: string): string {
-  const upper = sqlType.toUpperCase();
-
-  if (upper.includes('INT')) return 'number';
-  if (
-    upper.includes('REAL') ||
-    upper.includes('FLOAT') ||
-    upper.includes('DOUBLE')
-  )
-    return 'number';
-  if (upper.includes('BLOB')) return 'Uint8Array';
-  if (upper.includes('BOOL')) return 'number';
-  // TEXT, VARCHAR, CHAR, etc.
-  return 'string';
-}
-
-function mapPostgresType(sqlType: string): string {
-  const lower = sqlType.toLowerCase().replace(/\s+/g, ' ').trim();
-
-  // Array types — strip trailing [] and map the element type
-  if (lower.endsWith('[]')) {
-    const element = mapPostgresType(lower.slice(0, -2));
-    return `${element}[]`;
-  }
-
-  // Integer types
-  if (
-    lower === 'int2' ||
-    lower === 'int4' ||
-    lower === 'integer' ||
-    lower === 'smallint' ||
-    lower === 'serial'
-  )
-    return 'number';
-
-  // 64-bit integers — not safe in JS
-  if (lower === 'int8' || lower === 'bigint' || lower === 'bigserial')
-    return 'string';
-
-  // Floating-point / numeric
-  if (
-    lower === 'float4' ||
-    lower === 'float8' ||
-    lower === 'real' ||
-    lower === 'double precision'
-  )
-    return 'number';
-
-  // Exact numeric types are string by default to match common pg driver behavior.
-  if (lower === 'numeric' || lower === 'decimal') return 'string';
-
-  // Boolean
-  if (lower === 'bool' || lower === 'boolean') return 'boolean';
-
-  // JSON
-  if (lower === 'json' || lower === 'jsonb') return 'unknown';
-
-  // Date/time
-  if (
-    lower === 'timestamp' ||
-    lower === 'timestamptz' ||
-    lower === 'timestamp with time zone' ||
-    lower === 'timestamp without time zone' ||
-    lower === 'date' ||
-    lower === 'time' ||
-    lower === 'timetz' ||
-    lower === 'time with time zone' ||
-    lower === 'time without time zone'
-  )
-    return 'string';
-
-  // Binary
-  if (lower === 'bytea') return 'Uint8Array';
-
-  // Text types
-  if (
-    lower === 'uuid' ||
-    lower === 'text' ||
-    lower === 'varchar' ||
-    lower === 'char' ||
-    lower === 'citext' ||
-    lower.startsWith('character varying') ||
-    lower.startsWith('character(') ||
-    lower.startsWith('varchar(') ||
-    lower.startsWith('char(')
-  )
-    return 'string';
-
-  // Interval
-  if (lower === 'interval') return 'string';
-
-  // Network types
-  if (lower === 'inet' || lower === 'cidr' || lower === 'macaddr')
-    return 'string';
-
-  // Geometric types
-  if (
-    lower === 'point' ||
-    lower === 'line' ||
-    lower === 'box' ||
-    lower === 'path' ||
-    lower === 'polygon' ||
-    lower === 'circle' ||
-    lower === 'lseg'
-  )
-    return 'string';
-
-  // Range types
-  if (
-    lower === 'int4range' ||
-    lower === 'int8range' ||
-    lower === 'tsrange' ||
-    lower === 'tstzrange' ||
-    lower === 'daterange' ||
-    lower === 'numrange'
-  )
-    return 'string';
-
-  // Full-text search
-  if (lower === 'tsvector' || lower === 'tsquery') return 'string';
-
-  // Other
-  if (lower === 'xml') return 'string';
-  if (lower === 'money') return 'string';
-  if (
-    lower === 'bit' ||
-    lower === 'varbit' ||
-    lower.startsWith('bit(') ||
-    lower.startsWith('bit varying')
-  )
-    return 'string';
-
-  return 'string';
-}
-
-function defaultMapper(dialect: TypegenDialect): (sqlType: string) => string {
-  return dialect === 'postgres' ? mapPostgresType : mapSqliteType;
-}
-
-/**
- * Resolve the TypeScript type for a column, applying an optional override
- * first and falling back to the default dialect mapping.
- */
-export function resolveColumnType(
-  col: ColumnInfo,
-  override?: TypeOverride
-): ResolvedType {
-  const imports: Array<{ name: string; from: string }> = [];
-
-  if (override !== undefined) {
-    if (typeof override === 'string') {
-      const baseType = override;
-      return {
-        tsType: col.nullable ? `${baseType} | null` : baseType,
-        imports,
-      };
-    }
-    if (override.import) {
-      imports.push(override.import);
-    }
-    const baseType = override.type;
-    return {
-      tsType: col.nullable ? `${baseType} | null` : baseType,
-      imports,
-    };
-  }
-
-  // Default mapping
-  const mapper = defaultMapper(col.dialect);
-  const baseType = mapper(col.sqlType);
-  return {
-    tsType: col.nullable ? `${baseType} | null` : baseType,
-    imports,
-  };
-}

package/src/render.ts

@@ -1,196 +0,0 @@
-/**
- * @syncular/typegen - TypeScript code generation
- */
-
-import type { ColumnSchema, TableSchema, VersionedSchema } from './types';
-
-/**
- * Convert a snake_case table/column name to PascalCase.
- */
-function toPascalCase(str: string): string {
-  return str
-    .split(/[_-]/)
-    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-    .join('');
-}
-
-/**
- * Render a single column definition.
- */
-function renderColumn(column: ColumnSchema): string {
-  const tsType = column.hasDefault
-    ? `Generated<${column.tsType}>`
-    : column.tsType;
-  return `  ${column.name}: ${tsType};`;
-}
-
-/**
- * Render a table interface.
- */
-function renderTableInterface(
-  table: TableSchema,
-  interfaceName: string
-): string {
-  const columns = table.columns.map(renderColumn).join('\n');
-  return `export interface ${interfaceName} {\n${columns}\n}`;
-}
-
-/**
- * Render a database interface containing all tables.
- */
-function renderDbInterface(
-  schema: VersionedSchema,
-  interfaceName: string,
-  extendsType?: string
-): string {
-  const extendsClause = extendsType ? ` extends ${extendsType}` : '';
-  const tableEntries = schema.tables
-    .map((t) => `  ${t.name}: ${toPascalCase(t.name)}Table;`)
-    .join('\n');
-
-  return `export interface ${interfaceName}${extendsClause} {\n${tableEntries}\n}`;
-}
-
-/**
- * Options for rendering types.
- */
-export interface RenderOptions {
-  /** Schemas at each version (for version history) */
-  schemas: VersionedSchema[];
-  /** Generate versioned interfaces */
-  includeVersionHistory?: boolean;
-  /** Custom imports collected from resolver results */
-  customImports?: Array<{ name: string; from: string }>;
-}
-
-/**
- * Render complete TypeScript type definitions.
- */
-export function renderTypes(options: RenderOptions): string {
-  const { schemas, includeVersionHistory, customImports } = options;
-  const lines: string[] = [];
-
-  // Header
-  lines.push('/**');
-  lines.push(' * Auto-generated database types from migrations.');
-  lines.push(' * DO NOT EDIT - regenerate with @syncular/typegen');
-  lines.push(' */');
-  lines.push('');
-
-  const usesGenerated = schemas.some((schema) =>
-    schema.tables.some((table) =>
-      table.columns.some((column) => column.hasDefault)
-    )
-  );
-  if (usesGenerated) {
-    lines.push("import type { Generated } from 'kysely';");
-    lines.push('');
-  }
-
-  // Render custom imports from resolver
-  if (customImports && customImports.length > 0) {
-    // Group imports by source module
-    const byModule = new Map<string, Set<string>>();
-    for (const imp of customImports) {
-      let names = byModule.get(imp.from);
-      if (!names) {
-        names = new Set();
-        byModule.set(imp.from, names);
-      }
-      names.add(imp.name);
-    }
-    for (const [from, names] of byModule) {
-      const sorted = [...names].sort();
-      lines.push(`import type { ${sorted.join(', ')} } from '${from}';`);
-    }
-    lines.push('');
-  }
-
-  // Get the latest schema
-  const latestSchema = schemas[schemas.length - 1];
-  if (!latestSchema) {
-    lines.push('// No migrations defined');
-    return lines.join('\n');
-  }
-
-  // Generate table interfaces for latest version
-  for (const table of latestSchema.tables) {
-    lines.push(renderTableInterface(table, `${toPascalCase(table.name)}Table`));
-    lines.push('');
-  }
-
-  // Generate versioned DB interfaces if requested
-  if (includeVersionHistory && schemas.length > 0) {
-    for (const schema of schemas) {
-      // For each version, generate table interfaces with version suffix
-      // if they differ from the latest
-      const versionSuffix = `V${schema.version}`;
-
-      // Generate versioned table interfaces
-      for (const table of schema.tables) {
-        const latestTable = latestSchema.tables.find(
-          (t) => t.name === table.name
-        );
-
-        // Only generate versioned interface if different from latest
-        if (latestTable && !tablesEqual(table, latestTable)) {
-          lines.push(
-            renderTableInterface(
-              table,
-              `${toPascalCase(table.name)}Table${versionSuffix}`
-            )
-          );
-          lines.push('');
-        }
-      }
-
-      // Generate versioned DB interface
-      const tableEntries = schema.tables
-        .map((t) => {
-          const latestTable = latestSchema.tables.find(
-            (lt) => lt.name === t.name
-          );
-          const useVersioned = latestTable && !tablesEqual(t, latestTable);
-          const typeName = useVersioned
-            ? `${toPascalCase(t.name)}Table${versionSuffix}`
-            : `${toPascalCase(t.name)}Table`;
-          return `  ${t.name}: ${typeName};`;
-        })
-        .join('\n');
-
-      lines.push(`export interface ClientDb${versionSuffix} {`);
-      lines.push(tableEntries);
-      lines.push('}');
-      lines.push('');
-    }
-  }
-
-  // Generate main DB interface (latest version)
-  lines.push(renderDbInterface(latestSchema, 'ClientDb'));
-  lines.push('');
-
-  return lines.join('\n');
-}
-
-/**
- * Check if two table schemas are equal.
- */
-function tablesEqual(a: TableSchema, b: TableSchema): boolean {
-  if (a.columns.length !== b.columns.length) return false;
-
-  for (let i = 0; i < a.columns.length; i++) {
-    const colA = a.columns[i]!;
-    const colB = b.columns[i]!;
-
-    if (
-      colA.name !== colB.name ||
-      colA.tsType !== colB.tsType ||
-      colA.nullable !== colB.nullable ||
-      colA.hasDefault !== colB.hasDefault
-    ) {
-      return false;
-    }
-  }
-
-  return true;
-}

package/src/types.ts

@@ -1,137 +0,0 @@
-/**
- * @syncular/typegen - Type definitions
- */
-
-import type { DefinedMigrations } from '@syncular/migrations';
-
-export type TypegenDialect = 'sqlite' | 'postgres';
-
-/**
- * Column information for a schema column.
- */
-export interface ColumnInfo {
-  table: string;
-  column: string;
-  sqlType: string;
-  nullable: boolean;
-  isPrimaryKey: boolean;
-  hasDefault: boolean;
-  dialect: TypegenDialect;
-}
-
-/**
- * Return type from a resolver function.
- */
-export type TypeOverride =
-  | string
-  | { type: string; import?: { name: string; from: string } };
-
-/**
- * Column codec definition shared across runtime and typegen.
- * Typegen only consumes the `ts` field, but a full codec object can be
- * provided as a single source of truth.
- */
-export interface ColumnCodec<App, Db> {
-  ts: TypeOverride;
-  toDb(value: App): Db;
-  fromDb(value: Db): App;
-  dialects?: Partial<
-    Record<
-      TypegenDialect,
-      {
-        toDb?(value: App): Db;
-        fromDb?(value: Db): App;
-      }
-    >
-  >;
-}
-
-/**
- * Column codec resolver for a column.
- */
-export type ColumnCodecResolver = (
-  column: ColumnInfo
-) => ColumnCodec<unknown, unknown> | undefined;
-
-/**
- * Parsed table schema.
- */
-export interface TableSchema {
-  name: string;
-  columns: ColumnSchema[];
-}
-
-/**
- * Parsed column schema.
- */
-export interface ColumnSchema {
-  name: string;
-  sqlType: string;
-  tsType: string;
-  nullable: boolean;
-  isPrimaryKey: boolean;
-  hasDefault: boolean;
-}
-
-/**
- * Schema snapshot at a specific version.
- */
-export interface VersionedSchema {
-  version: number;
-  tables: TableSchema[];
-}
-
-/**
- * Options for generateTypes().
- */
-export interface GenerateTypesOptions<DB = unknown> {
-  /** Defined migrations from defineMigrations() */
-  migrations: DefinedMigrations<DB>;
-  /** Output file path for generated types */
-  output: string;
-  /** Database dialect to use for introspection (default: 'sqlite') */
-  dialect?: TypegenDialect;
-  /** Generate versioned interfaces (ClientDbV1, ClientDbV2, etc.) */
-  includeVersionHistory?: boolean;
-  /** Only generate types for these tables (default: all tables) */
-  tables?: string[];
-  /**
-   * Optional column codec resolver for per-column type overrides.
-   * Receives full column metadata (table, column, sqlType, dialect, etc.).
-   */
-  codecs?: ColumnCodecResolver;
-}
-
-/**
- * Result of type generation.
- */
-export interface GenerateTypesResult {
-  /** Path to the generated file */
-  outputPath: string;
-  /** Current schema version */
-  currentVersion: number;
-  /** Number of tables generated */
-  tableCount: number;
-  /** Generated TypeScript code */
-  code: string;
-}
-
-export interface GenerateMigrationChecksumsOptions<DB = unknown> {
-  /** Defined migrations from defineMigrations() */
-  migrations: DefinedMigrations<DB>;
-  /** Output file path for generated checksums */
-  output: string;
-  /** Database dialect to use for replay (default: 'sqlite') */
-  dialect?: TypegenDialect;
-}
-
-export interface GenerateMigrationChecksumsResult {
-  /** Path to the generated file */
-  outputPath: string;
-  /** Current schema version */
-  currentVersion: number;
-  /** Number of checksums generated */
-  checksumCount: number;
-  /** Generated TypeScript code */
-  code: string;
-}