@bungres/kit 0.3.0 → 0.5.0

package/src/commands/pull.ts

@@ -1,339 +0,0 @@
-import { resolve, join } from "node:path";
-import type { ResolvedConfig } from "../config.js";
-
-// ---------------------------------------------------------------------------
-// pull — introspect a live Postgres database and generate schema TypeScript
-// Reads information_schema + pg_indexes to reconstruct table definitions
-// ---------------------------------------------------------------------------
-
-interface PgColumn {
-  table_name: string;
-  column_name: string;
-  data_type: string;
-  udt_name: string;
-  is_nullable: string;
-  column_default: string | null;
-  character_maximum_length: number | null;
-}
-
-interface PgConstraint {
-  table_name: string;
-  column_name: string;
-  constraint_type: string;
-  foreign_table: string | null;
-  foreign_column: string | null;
-  delete_rule: string | null;
-  update_rule: string | null;
-}
-
-interface PgIndex {
-  tablename: string;
-  indexname: string;
-  indexdef: string;
-}
-
-export async function introspectDb(
-  sql: any, // Bun.SQL
-  dbSchema: string
-): Promise<Map<string, TableInfo>> {
-  // Fetch columns
-  const columns = await sql.unsafe(
-    `SELECT
-      c.table_name,
-      c.column_name,
-      c.data_type,
-      c.udt_name,
-      c.is_nullable,
-      c.column_default,
-      c.character_maximum_length
-    FROM information_schema.columns c
-    WHERE c.table_schema = $1
-      AND c.table_name NOT IN ('__bungres_migrations', '__bungres_push')
-    ORDER BY c.table_name, c.ordinal_position`,
-    [dbSchema]
-  ) as unknown as PgColumn[];
-
-  // Fetch constraints (PK, FK, UNIQUE)
-  const constraints = await sql.unsafe(
-    `SELECT
-      tc.table_name,
-      kcu.column_name,
-      tc.constraint_type,
-      ccu.table_name  AS foreign_table,
-      ccu.column_name AS foreign_column,
-      rc.delete_rule,
-      rc.update_rule
-    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
-    LEFT JOIN information_schema.constraint_column_usage ccu
-      ON tc.constraint_name = ccu.constraint_name
-      AND tc.table_schema = ccu.table_schema
-    LEFT JOIN information_schema.referential_constraints rc
-      ON tc.constraint_name = rc.constraint_name
-      AND tc.table_schema = rc.constraint_schema
-    WHERE tc.table_schema = $1`,
-    [dbSchema]
-  ) as unknown as PgConstraint[];
-
-  // Fetch indexes
-  const indexes = await sql.unsafe(
-    `SELECT tablename, indexname, indexdef
-     FROM pg_indexes
-     WHERE schemaname = $1`,
-    [dbSchema]
-  ) as unknown as PgIndex[];
-
-  // Group by table
-  return groupByTable(columns, constraints, indexes);
-}
-
-export async function runPull(config: ResolvedConfig): Promise<void> {
-  console.log("@bungres/kit pull: introspecting database...");
-
-  const sql = new Bun.SQL(config.dbUrl);
-
-  try {
-    const dbSchema = config.dbSchema;
-    const tableMap = await introspectDb(sql, dbSchema);
-
-    if (tableMap.size === 0) {
-      console.log("No tables found in schema:", dbSchema);
-      return;
-    }
-
-    // Generate TypeScript
-    const outDir = resolve(config.outDir);
-    await Bun.$`mkdir -p ${outDir}`.quiet();
-
-    const outPath = join(outDir, "schema.ts");
-    const code = generateSchemaTS(tableMap, dbSchema);
-
-    await Bun.write(outPath, code);
-    console.log(`Generated schema: ${outPath}`);
-    console.log(`  Tables: ${[...tableMap.keys()].join(", ")}`);
-  } finally {
-    await sql.end();
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Internals
-// ---------------------------------------------------------------------------
-
-export interface TableInfo {
-  tableName: string;
-  columns: Array<{
-    name: string;
-    dataType: string;
-    udtName: string;
-    isNullable: boolean;
-    columnDefault: string | null;
-    maxLength: number | null;
-    isPrimary: boolean;
-    isUnique: boolean;
-    foreignTable: string | undefined;
-    foreignColumn: string | undefined;
-    deleteRule: string | undefined;
-    updateRule: string | undefined;
-  }>;
-  indexes: PgIndex[];
-}
-
-function groupByTable(
-  columns: PgColumn[],
-  constraints: PgConstraint[],
-  indexes: PgIndex[]
-): Map<string, TableInfo> {
-  const map = new Map<string, TableInfo>();
-
-  for (const col of columns) {
-    if (!map.has(col.table_name)) {
-      map.set(col.table_name, {
-        tableName: col.table_name,
-        columns: [],
-        indexes: indexes.filter((i) => i.tablename === col.table_name),
-      });
-    }
-
-    const tableConstraints = constraints.filter(
-      (c) => c.table_name === col.table_name && c.column_name === col.column_name
-    );
-
-    const pkConstraint = tableConstraints.find((c) => c.constraint_type === "PRIMARY KEY");
-    const uniqueConstraint = tableConstraints.find((c) => c.constraint_type === "UNIQUE");
-    const fkConstraint = tableConstraints.find((c) => c.constraint_type === "FOREIGN KEY");
-
-    map.get(col.table_name)!.columns.push({
-      name: col.column_name,
-      dataType: col.data_type,
-      udtName: col.udt_name,
-      isNullable: col.is_nullable === "YES",
-      columnDefault: col.column_default,
-      maxLength: col.character_maximum_length,
-      isPrimary: !!pkConstraint,
-      isUnique: !!uniqueConstraint,
-      foreignTable: fkConstraint?.foreign_table ?? undefined,
-      foreignColumn: fkConstraint?.foreign_column ?? undefined,
-      deleteRule: fkConstraint?.delete_rule ?? undefined,
-      updateRule: fkConstraint?.update_rule ?? undefined,
-    });
-  }
-
-  return map;
-}
-
-function generateSchemaTS(
-  tableMap: Map<string, TableInfo>,
-  dbSchema: string
-): string {
-  const lines: string[] = [
-    `// Generated by @bungres/kit pull`,
-    `// Do not edit manually — re-run \`bungres pull\` to regenerate`,
-    `// Generated at: ${new Date().toISOString()}`,
-    ``,
-    `import {`,
-    `  snakeCase,`,
-    `  text, varchar, char, integer, bigint, smallint,`,
-    `  serial, bigserial, boolean, real, doublePrecision,`,
-    `  numeric, decimal, json, jsonb,`,
-    `  timestamp, timestamptz, date, time, uuid,`,
-    `  bytea, inet,`,
-    `  textArray, integerArray, varcharArray, uuidArray,`,
-    `} from "@bungres/orm";`,
-    ``,
-  ];
-
-  for (const [, table] of tableMap) {
-    const varName = toCamelCase(table.tableName);
-    lines.push(`export const ${varName} = snakeCase.table("${table.tableName}", {`);
-
-    for (const col of table.columns) {
-      const colExpr = buildColumnExpression(col);
-      lines.push(`  ${toCamelCase(col.name)}: ${colExpr},`);
-    }
-
-    // Third argument: Table options (schema, indexes)
-    const options: string[] = [];
-    if (dbSchema !== "public") {
-      options.push(`schema: "${dbSchema}"`);
-    }
-
-    if (table.indexes.length > 0) {
-      const idxLines: string[] = [];
-      for (const idx of table.indexes) {
-        // Simple regex to parse `indexdef`
-        // e.g. CREATE UNIQUE INDEX my_idx ON users USING btree (col1, col2) WHERE col3 = 1
-        const m = idx.indexdef.match(/CREATE (UNIQUE )?INDEX (.+) ON (.+) USING (\w+) \((.+)\)(?: WHERE (.+))?/i);
-        if (m) {
-          const isUnique = !!m[1];
-          const name = m[2]!.trim().replace(/^"|"$/g, "");
-          // Skip auto-generated PK and UNIQUE constraint indexes which are already attached to columns
-          if (name.endsWith("_pkey") || name.endsWith("_key")) continue;
-          
-          const using = m[4]!.toLowerCase();
-          const cols = m[5]!.split(",").map(c => `"${c.trim().replace(/^"|"$/g, "")}"`);
-          let idxStr = `{ name: "${name}", columns: [${cols.join(", ")}], using: "${using}"`;
-          if (isUnique) idxStr += `, unique: true`;
-          if (m[6]) idxStr += `, where: \`${m[6].trim()}\``;
-          idxStr += ` }`;
-          idxLines.push(idxStr);
-        }
-      }
-      if (idxLines.length > 0) {
-        options.push(`indexes: [\n    ${idxLines.join(",\n    ")}\n  ]`);
-      }
-    }
-
-    if (options.length > 0) {
-      lines.push(`}, {`);
-      lines.push(`  ${options.join(",\n  ")}`);
-      lines.push(`});`);
-    } else {
-      lines.push(`});`);
-    }
-
-    lines.push(``);
-  }
-
-  return lines.join("\n");
-}
-
-function buildColumnExpression(col: TableInfo["columns"][number]): string {
-  const opts: string[] = [];
-
-  if (col.dataType === "character varying" || col.dataType === "character") {
-    if (col.maxLength) opts.push(`length: ${col.maxLength}`);
-  }
-
-  if (col.isPrimary) opts.push(`primaryKey: true`);
-  else if (!col.isNullable) opts.push(`notNull: true`);
-
-  if (col.isUnique && !col.isPrimary) opts.push(`unique: true`);
-
-  if (col.columnDefault !== null && !col.isPrimary) {
-    if (col.columnDefault.includes("(")) {
-      opts.push(`defaultRaw: "${col.columnDefault}"`);
-    } else if (col.dataType === "boolean" || col.dataType.includes("int") || col.dataType.includes("numeric") || col.dataType.includes("real") || col.dataType.includes("double")) {
-      opts.push(`default: ${col.columnDefault}`);
-    } else {
-      const cleaned = col.columnDefault.replace(/^'(.*)'::.*$/, "$1");
-      opts.push(`default: "${cleaned}"`);
-    }
-  }
-
-  if (col.foreignTable && col.foreignColumn) {
-    const deleteRule = col.deleteRule?.toLowerCase().replace(" ", " ");
-    const updateRule = col.updateRule?.toLowerCase().replace(" ", " ");
-    let refOpts = `table: "${col.foreignTable}", column: "${col.foreignColumn}"`;
-    if (deleteRule && deleteRule !== "no action") refOpts += `, onDelete: "${deleteRule}"`;
-    if (updateRule && updateRule !== "no action") refOpts += `, onUpdate: "${updateRule}"`;
-    opts.push(`references: { ${refOpts} }`);
-  }
-
-  let builderName = pgTypeToBungresBuilderName(col);
-  
-  if (opts.length > 0) {
-    return `${builderName}({ ${opts.join(", ")} })`;
-  }
-  return `${builderName}()`;
-}
-
-function pgTypeToBungresBuilderName(col: TableInfo["columns"][number]): string {
-  const dt = col.dataType;
-
-  if (dt === "uuid") return "uuid";
-  if (dt === "text") return "text";
-  if (dt === "character varying") return "varchar";
-  if (dt === "character") return "char";
-  if (dt === "integer") return "integer";
-  if (dt === "bigint") return "bigint";
-  if (dt === "smallint") return "smallint";
-  if (dt === "boolean") return "boolean";
-  if (dt === "real") return "real";
-  if (dt === "double precision") return "doublePrecision";
-  if (dt === "numeric" || dt === "decimal") return "numeric";
-  if (dt === "json") return "json";
-  if (dt === "jsonb") return "jsonb";
-  if (dt === "timestamp without time zone") return "timestamp";
-  if (dt === "timestamp with time zone") return "timestamptz";
-  if (dt === "date") return "date";
-  if (dt === "time without time zone") return "time";
-  if (dt === "bytea") return "bytea";
-  if (dt === "inet") return "inet";
-  if (dt === "USER-DEFINED" && col.udtName === "citext") return "text";
-  if (dt === "ARRAY") {
-    if (col.udtName === "_text") return "textArray";
-    if (col.udtName === "_int4" || col.udtName === "_int8") return "integerArray";
-    if (col.udtName === "_varchar") return "varcharArray";
-    if (col.udtName === "_uuid") return "uuidArray";
-    return "textArray";
-  }
-  // Fallback
-  return "text";
-}
-
-function toCamelCase(str: string): string {
-  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
-}

package/src/commands/push.ts

@@ -1,105 +0,0 @@
-import * as fs from "node:fs";
-import type { ResolvedConfig } from "../config.js";
-import { diffSchemas, type SchemaSnapshot } from "../differ.js";
-import { loadSchemas } from "../schema-loader.js";
-
-// ---------------------------------------------------------------------------
-// push — apply schema directly to the database (no migration files)
-// Uses a hidden table __bungres_push to track the previous schema state
-// and perform an exact diff.
-// ---------------------------------------------------------------------------
-
-export async function runPush(
-  config: ResolvedConfig,
-  opts: { force?: boolean } = {}
-): Promise<void> {
-  console.log("@bungres/kit push: loading schemas...");
-
-  const schemas = await loadSchemas(config.schema);
-
-  if (schemas.length === 0) {
-    console.warn("No table definitions found. Check your schema glob pattern.");
-    return;
-  }
-
-  const sql = new Bun.SQL(config.dbUrl);
-
-  try {
-    // Ensure our tracking table exists
-    await sql.unsafe(`
-      CREATE TABLE IF NOT EXISTS public.__bungres_push (
-        id SERIAL PRIMARY KEY,
-        snapshot JSONB NOT NULL
-      );
-    `);
-
-    // Load previous snapshot from DB
-    const rows = await sql.unsafe(`SELECT snapshot FROM public.__bungres_push ORDER BY id DESC LIMIT 1;`) as any[];
-    let prevSnapshot: SchemaSnapshot = {};
-    if (rows.length > 0) {
-      prevSnapshot = typeof rows[0].snapshot === "string"
-        ? JSON.parse(rows[0].snapshot)
-        : rows[0].snapshot;
-    }
-
-    // Current snapshot from TypeScript
-    const currentSnapshot: SchemaSnapshot = Object.fromEntries(
-      schemas.map((s) => [s.config.name, s.config])
-    );
-
-    // Diff
-    const diff = diffSchemas(prevSnapshot, currentSnapshot);
-
-    if (diff.statements.length === 0) {
-      console.log("\nNo schema changes detected. Database is up to date.");
-      return;
-    }
-
-    console.log(`\nChanges to apply:`);
-    for (const s of diff.summary) console.log(`  + ${s}`);
-
-    if (diff.warnings && diff.warnings.length > 0) {
-      console.warn(`\n  ⚠️  WARNING: Data Loss Detected!`);
-      for (const w of diff.warnings) console.warn(`    ! ${w}`);
-      console.warn(`\n  These changes will be immediately executed against the database!`);
-    }
-
-    if (!opts.force) {
-      process.stdout.write("\nAre you sure you want to push these changes? Type YES to continue: ");
-      const answer = await readLine();
-      if (answer.trim().toLowerCase() !== "yes") {
-        console.log("Aborted.");
-        return;
-      }
-    }
-
-    console.log(`\nPushing changes...`);
-
-    // We must run extension first if needed
-    await sql.unsafe(`CREATE EXTENSION IF NOT EXISTS "pgcrypto";`);
-
-    // Execute diff statements
-    for (const stmt of diff.statements) {
-      if (config.verbose) {
-        console.log(`-- ${stmt}`);
-      }
-      await sql.unsafe(stmt);
-    }
-
-    // Save new snapshot
-    await sql.unsafe(
-      `INSERT INTO public.__bungres_push (snapshot) VALUES ($1);`,
-      [JSON.stringify(currentSnapshot)]
-    );
-
-    console.log("\nPush complete.");
-  } finally {
-    await sql.end();
-  }
-}
-
-async function readLine(): Promise<string> {
-  const buf = Buffer.alloc(256);
-  const n = fs.readSync(0, buf, 0, 256, null);
-  return buf.subarray(0, n).toString().trim();
-}

package/src/commands/refresh.ts

@@ -1,37 +0,0 @@
-import type { ResolvedConfig } from "../config.js";
-import { loadSchemas } from "../schema-loader.js";
-import { colorize } from "../utils/colors.js";
-
-// ---------------------------------------------------------------------------
-// refresh — truncate all tables to reset data without dropping schema
-// ---------------------------------------------------------------------------
-
-export async function runRefresh(config: ResolvedConfig): Promise<void> {
-  const schemas = await loadSchemas(config.schema);
-
-  if (schemas.length === 0) {
-    console.warn("No table definitions found in schema files.");
-    return;
-  }
-
-  const sql = new Bun.SQL(config.dbUrl);
-
-  try {
-    const tableNames = schemas.map(
-      (s) => `"${s.config.schema ? s.config.schema + '"."' : ""}${s.config.name}"`
-    );
-
-    console.log(`Truncating ${tableNames.length} tables...`);
-    
-    // We use CASCADE to handle foreign key constraints automatically
-    for (const entry of schemas) {
-      const ddl = `TRUNCATE TABLE "${entry.config.name}" CASCADE;`;
-      await sql.unsafe(ddl);
-      console.log(colorize(`  ✓ truncated ${entry.config.name}`, "green"));
-    }
-
-    console.log(colorize("\nRefresh complete. All tables are now empty.", "green"));
-  } finally {
-    await sql.end();
-  }
-}

package/src/commands/seed.ts

@@ -1,41 +0,0 @@
-import { resolve } from "node:path";
-import type { ResolvedConfig } from "../config.js";
-import { colorize } from "../utils/colors.js";
-
-// ---------------------------------------------------------------------------
-// seed — execute a seed script to populate the database
-// ---------------------------------------------------------------------------
-
-export async function runSeed(config: ResolvedConfig): Promise<void> {
-  if (!config.seed) {
-    console.log(colorize(`No seed file configured in bungres.config.ts`, "yellow"));
-    return;
-  }
-
-  const seedPath = resolve(process.cwd(), config.seed);
-  
-  const file = Bun.file(seedPath);
-  if (!(await file.exists())) {
-    console.error(colorize(`Seed file not found at ${seedPath}`, "red"));
-    process.exit(1);
-  }
-
-  console.log(colorize(`\nRunning seeder: ${config.seed}...`, "cyan"));
-
-  // Run the seed script in a new process to ensure a clean state
-  const proc = Bun.spawn(["bun", "run", seedPath], {
-    cwd: process.cwd(),
-    stdout: "inherit",
-    stderr: "inherit",
-    env: { ...process.env, DATABASE_URL: config.dbUrl } // Pass dbUrl implicitly just in case
-  });
-
-  const exitCode = await proc.exited;
-
-  if (exitCode === 0) {
-    console.log("\nSeed complete.");
-  } else {
-    console.error(`\nSeed failed with exit code ${exitCode}.`);
-    process.exit(exitCode);
-  }
-}

package/src/commands/status.ts

@@ -1,64 +0,0 @@
-import { resolve, join } from "node:path";
-import type { ResolvedConfig } from "../config.js";
-import { colorize } from "../utils/colors.js";
-
-// ---------------------------------------------------------------------------
-// status — show which migrations have been applied vs. pending
-// ---------------------------------------------------------------------------
-
-const MIGRATIONS_TABLE = "__bungres_migrations";
-
-export async function runStatus(config: ResolvedConfig): Promise<void> {
-  const migrationsDir = resolve(config.migrationsDir);
-  const sql = new Bun.SQL(config.dbUrl);
-
-  try {
-    // Check if migrations table exists
-    const tableCheck = await sql.unsafe(
-      `SELECT EXISTS (
-        SELECT 1 FROM information_schema.tables
-        WHERE table_name = $1
-      ) AS exists`,
-      [MIGRATIONS_TABLE]
-    ) as Array<{ exists: boolean }>;
-
-    const trackingExists = tableCheck[0]?.exists ?? false;
-
-    // Discover migration files
-    const glob = new Bun.Glob("*.sql");
-    const files: string[] = [];
-    for await (const file of glob.scan({ cwd: migrationsDir, absolute: false })) {
-      files.push(file);
-    }
-    files.sort();
-
-    if (files.length === 0) {
-      console.log(colorize("No migration files found. Run `bungres generate` first.", "yellow"));
-      return;
-    }
-
-    let appliedSet = new Set<string>();
-    if (trackingExists) {
-      const applied = await sql.unsafe(
-        `SELECT name FROM "${MIGRATIONS_TABLE}" ORDER BY applied_at`
-      ) as Array<{ name: string }>;
-      appliedSet = new Set(applied.map((r) => r.name));
-    }
-
-    console.log(colorize("\nMigration status:\n", "cyan"));
-    let pendingCount = 0;
-
-    for (const file of files) {
-      const isApplied = appliedSet.has(file);
-      const status = isApplied ? colorize("✓ applied ", "green") : colorize("✗ pending ", "yellow");
-      if (!isApplied) pendingCount++;
-      console.log(`  ${status}  ${file}`);
-    }
-
-    console.log(
-      `\n${colorize(appliedSet.size.toString(), "green")} applied, ${colorize(pendingCount.toString(), "yellow")} pending.\n`
-    );
-  } finally {
-    await sql.end();
-  }
-}