@bungres/kit 0.3.0 → 0.4.0

package/src/differ.ts

@@ -1,236 +0,0 @@
-import type { ColumnConfig, TableConfig } from "@bungres/orm";
-import { generateCreateTable, generateAddColumn, generateDropColumn, generateAddConstraint, generateDropConstraint } from "@bungres/orm";
-
-// ---------------------------------------------------------------------------
-// Schema differ — compares two schema snapshots and emits SQL statements
-// that migrate from `prev` to `next`
-// ---------------------------------------------------------------------------
-
-/** Snapshot stored on disk after each generate */
-export type SchemaSnapshot = Record<string, TableConfig>;
-
-export interface DiffResult {
-  statements: string[];
-  summary: string[];
-  warnings: string[];
-}
-
-export function diffSchemas(
-  prev: SchemaSnapshot,
-  next: SchemaSnapshot
-): DiffResult {
-  const statements: string[] = [];
-  const summary: string[] = [];
-  const warnings: string[] = [];
-
-  const prevTables = new Set(Object.keys(prev));
-  const nextTables = new Set(Object.keys(next));
-
-  // ── New tables — topo-sorted so FK deps come first ────────────────────────
-  const newTableConfigs: TableConfig[] = [];
-  for (const tableName of nextTables) {
-    if (!prevTables.has(tableName)) {
-      newTableConfigs.push(next[tableName]!);
-    }
-  }
-
-  for (const config of topoSortConfigs(newTableConfigs)) {
-    statements.push(generateCreateTable(config, true));
-    summary.push(`CREATE TABLE ${config.name}`);
-  }
-
-  // ── Dropped tables ────────────────────────────────────────────────────────
-  for (const tableName of prevTables) {
-    if (!nextTables.has(tableName)) {
-      const config = prev[tableName]!;
-      const tbl = config.schema
-        ? `"${config.schema}"."${tableName}"`
-        : `"${tableName}"`;
-      statements.push(`DROP TABLE IF EXISTS ${tbl};`);
-      summary.push(`DROP TABLE ${tableName}`);
-      warnings.push(`Data loss warning: Table '${tableName}' will be permanently deleted.`);
-    }
-  }
-
-  // ── Modified tables — column-level diff ───────────────────────────────────
-  for (const tableName of nextTables) {
-    if (!prevTables.has(tableName)) continue; // already handled above
-
-    const prevConfig = prev[tableName]!;
-    const nextConfig = next[tableName]!;
-    const prevCols = prevConfig.columns;
-    const nextCols = nextConfig.columns;
-    const prevColNames = new Set(Object.keys(prevCols));
-    const nextColNames = new Set(Object.keys(nextCols));
-
-    // Added columns
-    for (const key of nextColNames) {
-      if (!prevColNames.has(key)) {
-        const col = nextCols[key]!;
-        statements.push(generateAddColumn(tableName, nextConfig.schema, key, col));
-        summary.push(`ALTER TABLE ${tableName} ADD COLUMN ${col.name}`);
-      }
-    }
-
-    // Dropped columns
-    for (const key of prevColNames) {
-      if (!nextColNames.has(key)) {
-        const col = prevCols[key]!;
-        statements.push(generateDropColumn(tableName, prevConfig.schema, col.name));
-        summary.push(`ALTER TABLE ${tableName} DROP COLUMN ${col.name}`);
-        warnings.push(`Data loss warning: Column '${col.name}' in table '${tableName}' will be permanently deleted.`);
-      }
-    }
-
-    // Changed columns
-    for (const key of nextColNames) {
-      if (!prevColNames.has(key)) continue;
-      const changes = diffColumn(prevCols[key]!, nextCols[key]!);
-      if (changes.length > 0) {
-        const tbl = nextConfig.schema
-          ? `"${nextConfig.schema}"."${tableName}"`
-          : `"${tableName}"`;
-        for (const change of changes) {
-          statements.push(`ALTER TABLE ${tbl} ${change};`);
-          summary.push(`ALTER TABLE ${tableName} ALTER COLUMN ${nextCols[key]!.name} (${change})`);
-        }
-      }
-
-      // Foreign Key diffing
-      const prevRef = prevCols[key]!.references;
-      const nextRef = nextCols[key]!.references;
-      if (JSON.stringify(prevRef) !== JSON.stringify(nextRef)) {
-        const constraintName = `${tableName}_${nextCols[key]!.name}_fkey`;
-        if (prevRef) {
-          statements.push(generateDropConstraint(tableName, nextConfig.schema, constraintName));
-          summary.push(`ALTER TABLE ${tableName} DROP CONSTRAINT ${constraintName}`);
-        }
-        if (nextRef) {
-          let fkDef = `FOREIGN KEY ("${nextCols[key]!.name}") REFERENCES "${nextRef.table}"("${nextRef.column}")`;
-          if (nextRef.onDelete) fkDef += ` ON DELETE ${nextRef.onDelete.toUpperCase()}`;
-          if (nextRef.onUpdate) fkDef += ` ON UPDATE ${nextRef.onUpdate.toUpperCase()}`;
-          statements.push(generateAddConstraint(tableName, nextConfig.schema, constraintName, fkDef));
-          summary.push(`ALTER TABLE ${tableName} ADD CONSTRAINT ${constraintName}`);
-        }
-      }
-    }
-
-    // New indexes
-    const prevIdxNames = new Set(
-      (prevConfig.indexes ?? []).map(
-        (i) => i.name ?? `idx_${tableName}_${i.columns.join("_")}`
-      )
-    );
-    for (const idx of nextConfig.indexes ?? []) {
-      const idxName = idx.name ?? `idx_${tableName}_${idx.columns.join("_")}`;
-      if (!prevIdxNames.has(idxName)) {
-        const tbl = nextConfig.schema
-          ? `"${nextConfig.schema}"."${tableName}"`
-          : `"${tableName}"`;
-        const unique = idx.unique ? "UNIQUE " : "";
-        const using = idx.using ? ` USING ${idx.using.toUpperCase()}` : "";
-        const cols = idx.columns.map((c) => `"${c}"`).join(", ");
-        const where = idx.where ? ` WHERE ${idx.where}` : "";
-        statements.push(
-          `CREATE ${unique}INDEX IF NOT EXISTS "${idxName}" ON ${tbl}${using} (${cols})${where};`
-        );
-        summary.push(`CREATE INDEX ${idxName} ON ${tableName}`);
-      }
-    }
-
-    // Dropped indexes
-    const nextIdxNames = new Set(
-      (nextConfig.indexes ?? []).map(
-        (i) => i.name ?? `idx_${tableName}_${i.columns.join("_")}`
-      )
-    );
-    for (const idx of prevConfig.indexes ?? []) {
-      const idxName = idx.name ?? `idx_${tableName}_${idx.columns.join("_")}`;
-      if (!nextIdxNames.has(idxName)) {
-        statements.push(`DROP INDEX IF EXISTS "${idxName}";`);
-        summary.push(`DROP INDEX ${idxName}`);
-      }
-    }
-  }
-
-  return { statements, summary, warnings };
-}
-
-// ---------------------------------------------------------------------------
-// Topological sort for TableConfig objects
-// ---------------------------------------------------------------------------
-
-export function topoSortConfigs(tables: TableConfig[]): TableConfig[] {
-  const byName = new Map<string, TableConfig>(tables.map((t) => [t.name, t]));
-  const visited = new Set<string>();
-  const result: TableConfig[] = [];
-
-  function deps(config: TableConfig): string[] {
-    return Object.values(config.columns)
-      .map((col) => col.references?.table)
-      .filter((t): t is string => t !== undefined && byName.has(t) && t !== config.name);
-  }
-
-  function visit(name: string): void {
-    if (visited.has(name)) return;
-    visited.add(name);
-    const config = byName.get(name);
-    if (!config) return;
-    for (const dep of deps(config)) visit(dep);
-    result.push(config);
-  }
-
-  for (const table of tables) visit(table.name);
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// Column-level diff
-// ---------------------------------------------------------------------------
-
-function diffColumn(prev: ColumnConfig, next: ColumnConfig): string[] {
-  const changes: string[] = [];
-  const col = `"${next.name}"`;
-
-  if (prev.dataType !== next.dataType) {
-    changes.push(
-      `ALTER COLUMN ${col} TYPE ${next.dataType.toUpperCase()} USING ${col}::${next.dataType}`
-    );
-  }
-
-  if (!prev.notNull && next.notNull) {
-    changes.push(`ALTER COLUMN ${col} SET NOT NULL`);
-  }
-  if (prev.notNull && !next.notNull) {
-    changes.push(`ALTER COLUMN ${col} DROP NOT NULL`);
-  }
-
-  const prevDef =
-    prev.defaultFn ??
-    (prev.defaultValue !== undefined ? String(prev.defaultValue) : undefined);
-  const nextDef =
-    next.defaultFn ??
-    (next.defaultValue !== undefined ? String(next.defaultValue) : undefined);
-
-  if (prevDef !== nextDef) {
-    if (nextDef !== undefined) {
-      const val = next.defaultFn ?? formatDefault(next.defaultValue, next.dataType);
-      changes.push(`ALTER COLUMN ${col} SET DEFAULT ${val}`);
-    } else {
-      changes.push(`ALTER COLUMN ${col} DROP DEFAULT`);
-    }
-  }
-
-  return changes;
-}
-
-function formatDefault(value: unknown, dataType: ColumnConfig["dataType"]): string {
-  if (value === null || value === undefined) return "NULL";
-  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
-  if (typeof value === "number") return String(value);
-  if (typeof value === "string") {
-    if (dataType === "boolean") return value;
-    return `'${value.replace(/'/g, "''")}'`;
-  }
-  return `'${JSON.stringify(value)}'`;
-}

package/src/ensure-db.ts

@@ -1,32 +0,0 @@
-export async function ensureDatabase(dbUrl: string): Promise<void> {
-  let sql;
-  try {
-    sql = new Bun.SQL(dbUrl);
-    // Ping to check connection
-    await sql.unsafe('SELECT 1');
-    return;
-  } catch (err: any) {
-    if (err.message && err.message.includes('does not exist')) {
-      try {
-        const parsed = new URL(dbUrl);
-        const dbName = parsed.pathname.slice(1);
-        parsed.pathname = '/postgres';
-        const fallbackUrl = parsed.toString();
-
-        const fallback = new Bun.SQL(fallbackUrl);
-        try {
-          await fallback.unsafe(`CREATE DATABASE "${dbName}"`);
-          console.log(`Created database "${dbName}" automatically.`);
-        } finally {
-          await fallback.end();
-        }
-      } catch (e: any) {
-        // Ignore fallback errors, it will just fail downstream
-      }
-    }
-  } finally {
-    if (sql) {
-      await sql.end();
-    }
-  }
-}

package/src/index.ts

@@ -1,21 +0,0 @@
-// ---------------------------------------------------------------------------
-// @bungres/kit — programmatic API (for use without the CLI)
-// ---------------------------------------------------------------------------
-
-export { loadConfig } from "./config.js";
-export type { BungresKitConfig, ResolvedConfig } from "./config.js";
-
-/** Identity helper for type-safe config — mirrors drizzle-kit's defineConfig */
-export function defineConfig(config: import("./config.js").BungresKitConfig) {
-  return config;
-}
-
-export { loadSchemas } from "./schema-loader.js";
-export type { SchemaEntry } from "./schema-loader.js";
-
-export { runPush } from "./commands/push.js";
-export { runGenerate } from "./commands/generate.js";
-export { runMigrate } from "./commands/migrate.js";
-export { runPull } from "./commands/pull.js";
-export { runStatus } from "./commands/status.js";
-export { runDrop } from "./commands/drop.js";

package/src/schema-loader.ts

@@ -1,50 +0,0 @@
-import { resolve, join } from "node:path";
-import { TableConfigSymbol, type TableConfig } from "@bungres/orm";
-
-// ---------------------------------------------------------------------------
-// Schema loader — imports user schema files and extracts Table definitions
-// ---------------------------------------------------------------------------
-
-export interface SchemaEntry {
-  exportName: string;
-  config: TableConfig;
-  table: any;
-  filePath: string;
-}
-
-export async function loadSchemas(
-  patterns: string | string[],
-  cwd = process.cwd()
-): Promise<SchemaEntry[]> {
-  const globs = Array.isArray(patterns) ? patterns : [patterns];
-  const entries: SchemaEntry[] = [];
-
-  for (const pattern of globs) {
-    const glob = new Bun.Glob(pattern);
-    for await (const file of glob.scan({ cwd, absolute: false })) {
-      const absPath = resolve(join(cwd, file));
-      const mod = await import(absPath);
-
-      for (const [exportName, value] of Object.entries(mod)) {
-        if (isTable(value)) {
-          entries.push({
-            exportName,
-            config: (value as any)[TableConfigSymbol],
-            table: value,
-            filePath: absPath,
-          });
-        }
-      }
-    }
-  }
-
-  return entries;
-}
-
-function isTable(value: unknown): boolean {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    TableConfigSymbol in value
-  );
-}

package/src/utils/colors.ts

@@ -1,4 +0,0 @@
-export function colorize(text: string, color: string): string {
-  const code = Bun.color(color, "ansi");
-  return code ? `${code}${text}\x1b[0m` : text;
-}