nexusql 0.1.0

package/dist/index.js

@@ -0,0 +1,909 @@
+// src/lib/database.ts
+import pg from "pg";
+
+// src/lib/db-url.ts
+function parseAndEncodeDbUrl(rawUrl) {
+  const match = rawUrl.match(
+    /^(postgres(?:ql)?):\/\/([^:]+):(.+)@([^:]+):(\d+)\/([^?]+)(\?.*)?$/
+  );
+  if (!match) {
+    throw new Error(
+      "Invalid DATABASE_URL format. Expected: postgres://user:password@host:port/database"
+    );
+  }
+  const [, protocol, user, password, host, port, database, params = ""] = match;
+  const encodedPassword = encodeURIComponent(password);
+  return {
+    url: `${protocol}://${user}:${encodedPassword}@${host}:${port}/${database}${params}`,
+    protocol,
+    user,
+    password: encodedPassword,
+    host,
+    port,
+    database,
+    params
+  };
+}
+function buildDbUrl(parts, database) {
+  return `${parts.protocol}://${parts.user}:${parts.password}@${parts.host}:${parts.port}/${database}${parts.params}`;
+}
+
+// src/lib/database.ts
+var { Client } = pg;
+var Database = class _Database {
+  connectionString;
+  dbParts;
+  constructor(connectionString) {
+    this.dbParts = parseAndEncodeDbUrl(connectionString);
+    this.connectionString = this.dbParts.url;
+  }
+  /**
+   * Execute a query and return results.
+   */
+  async query(sql) {
+    const client = new Client({ connectionString: this.connectionString });
+    try {
+      await client.connect();
+      const result = await client.query(sql);
+      return {
+        rows: result.rows,
+        rowCount: result.rowCount ?? 0
+      };
+    } finally {
+      await client.end();
+    }
+  }
+  /**
+   * Execute a parameterized query and return results.
+   */
+  async queryParams(sql, params) {
+    const client = new Client({ connectionString: this.connectionString });
+    try {
+      await client.connect();
+      const result = await client.query(sql, params);
+      return {
+        rows: result.rows,
+        rowCount: result.rowCount ?? 0
+      };
+    } finally {
+      await client.end();
+    }
+  }
+  /**
+   * Execute a parameterized query without returning results.
+   */
+  async execParams(sql, params) {
+    const client = new Client({ connectionString: this.connectionString });
+    try {
+      await client.connect();
+      await client.query(sql, params);
+    } finally {
+      await client.end();
+    }
+  }
+  /**
+   * Execute a query without returning results (for DDL/DML).
+   */
+  async exec(sql) {
+    const client = new Client({ connectionString: this.connectionString });
+    try {
+      await client.connect();
+      await client.query(sql);
+    } finally {
+      await client.end();
+    }
+  }
+  /**
+   * Execute operations within a transaction.
+   * Automatically commits on success, rolls back on error.
+   */
+  async withTransaction(fn) {
+    const client = new Client({ connectionString: this.connectionString });
+    try {
+      await client.connect();
+      await client.query("BEGIN");
+      const result = await fn(client);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      await client.end();
+    }
+  }
+  /**
+   * Create a new database.
+   */
+  async createDatabase(name) {
+    await this.exec(`CREATE DATABASE "${name}";`);
+  }
+  /**
+   * Drop a database if it exists.
+   */
+  async dropDatabase(name) {
+    await this.exec(`DROP DATABASE IF EXISTS "${name}";`);
+  }
+  /**
+   * Create a Database instance connected to a different database.
+   */
+  withDatabase(name) {
+    const newUrl = buildDbUrl(this.dbParts, name);
+    return new _Database(newUrl);
+  }
+  /**
+   * Get connection URL for external tools (like migra).
+   */
+  getConnectionUrl() {
+    return this.connectionString;
+  }
+  /**
+   * Get parsed database URL parts.
+   */
+  getParts() {
+    return this.dbParts;
+  }
+  /**
+   * Install PostgreSQL extensions.
+   */
+  async installExtensions(extensions) {
+    for (const ext of extensions) {
+      try {
+        await this.exec(`CREATE EXTENSION IF NOT EXISTS "${ext}";`);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Get column information for a table.
+   */
+  async getTableColumns(tableName) {
+    const result = await this.query(`
+      SELECT column_name, ordinal_position
+      FROM information_schema.columns
+      WHERE table_name = '${tableName}'
+      ORDER BY ordinal_position;
+    `);
+    return result.rows;
+  }
+  /**
+   * List all tables in the public schema.
+   */
+  async listTables() {
+    const result = await this.query(`
+      SELECT tablename FROM pg_tables WHERE schemaname = 'public';
+    `);
+    return result.rows.map((row) => row.tablename);
+  }
+};
+
+// src/lib/migrations.ts
+import { readdirSync, statSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+// src/lib/reverse.ts
+function generateReverseSql(upSql) {
+  if (!upSql) return "";
+  const downStatements = [];
+  const lines = upSql.split(";").map((l) => l.trim()).filter((l) => l);
+  for (const line of lines) {
+    const createTableMatch = line.match(
+      /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([^\s(]+)/i
+    );
+    if (createTableMatch) {
+      const tableName = createTableMatch[1];
+      downStatements.push(`DROP TABLE ${tableName};`);
+      continue;
+    }
+    const dropTableMatch = line.match(
+      /DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?([^\s;]+)/i
+    );
+    if (dropTableMatch) {
+      const tableName = dropTableMatch[1];
+      downStatements.push(`-- Manual: Recreate table ${tableName}`);
+      continue;
+    }
+    const addColumnMatch = line.match(
+      /ALTER\s+TABLE\s+([^\s]+)\s+ADD\s+(?:COLUMN\s+)?([^\s;]+)/i
+    );
+    if (addColumnMatch) {
+      const [, tableName, colName] = addColumnMatch;
+      downStatements.push(`ALTER TABLE ${tableName} DROP COLUMN ${colName};`);
+      continue;
+    }
+    const dropColumnMatch = line.match(
+      /ALTER\s+TABLE\s+([^\s]+)\s+DROP\s+(?:COLUMN\s+)?([^\s;]+)/i
+    );
+    if (dropColumnMatch) {
+      const [, tableName, colName] = dropColumnMatch;
+      downStatements.push(
+        `-- Manual: Add column ${colName} back to table ${tableName}`
+      );
+      continue;
+    }
+    const createIndexMatch = line.match(
+      /CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?([^\s]+)\s+ON/i
+    );
+    if (createIndexMatch) {
+      const indexName = createIndexMatch[1];
+      downStatements.push(`DROP INDEX ${indexName};`);
+      continue;
+    }
+    const dropIndexMatch = line.match(
+      /DROP\s+INDEX\s+(?:IF\s+EXISTS\s+)?([^\s;]+)/i
+    );
+    if (dropIndexMatch) {
+      const indexName = dropIndexMatch[1];
+      downStatements.push(`-- Manual: Recreate index ${indexName}`);
+      continue;
+    }
+    downStatements.push(`-- Manual: Revert ${line.substring(0, 50)}...`);
+  }
+  return downStatements.reverse().join("\n");
+}
+
+// src/lib/migrations.ts
+function listMigrations(migrationsDir) {
+  try {
+    const files = readdirSync(migrationsDir);
+    return files.filter((f) => f.endsWith(".sql")).map((f) => {
+      const path = join(migrationsDir, f);
+      const match = f.match(/^(\d+)/);
+      return {
+        name: f,
+        path,
+        version: match ? match[1] : f,
+        mtime: statSync(path).mtime.getTime()
+      };
+    }).sort((a, b) => a.version.localeCompare(b.version));
+  } catch {
+    return [];
+  }
+}
+function getMostRecentMigration(migrationsDir) {
+  const migrations = listMigrations(migrationsDir);
+  if (migrations.length === 0) return null;
+  return migrations.reduce(
+    (most, current) => current.mtime > most.mtime ? current : most
+  );
+}
+function generateMigrationFilename(name) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, "").slice(0, 14);
+  const sanitized = name.replace(/\s+/g, "_").toLowerCase();
+  return `${timestamp}_${sanitized}.sql`;
+}
+function createMigrationFile(migrationsDir, name, upSql = "", downSql = "") {
+  const filename = generateMigrationFilename(name);
+  const filepath = join(migrationsDir, filename);
+  if (!downSql && upSql) {
+    downSql = generateReverseSql(upSql);
+  }
+  const content = `-- migrate:up
+${upSql}
+
+-- migrate:down
+${downSql}
+`;
+  writeFileSync(filepath, content, "utf-8");
+  return filepath;
+}
+function updateMigrationFile(filepath, upSql) {
+  const content = readFileSync(filepath, "utf-8");
+  const updated = content.replace(
+    /-- migrate:up\n/,
+    `-- migrate:up
+${upSql}
+
+`
+  );
+  writeFileSync(filepath, updated, "utf-8");
+}
+function parseMigrationFile(filepath) {
+  const content = readFileSync(filepath, "utf-8");
+  const upMatch = content.match(
+    /-- migrate:up\n([\s\S]*?)(?=-- migrate:down|$)/
+  );
+  const downMatch = content.match(/-- migrate:down\n([\s\S]*?)$/);
+  return {
+    up: upMatch ? upMatch[1].trim() : "",
+    down: downMatch ? downMatch[1].trim() : ""
+  };
+}
+
+// src/lib/runner.ts
+var SCHEMA_MIGRATIONS_TABLE = "schema_migrations";
+var MigrationRunner = class {
+  db;
+  migrationsDir;
+  constructor(db, migrationsDir) {
+    this.db = db;
+    this.migrationsDir = migrationsDir;
+  }
+  /**
+   * Ensure schema_migrations table exists.
+   */
+  async ensureTable() {
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${SCHEMA_MIGRATIONS_TABLE} (
+        version VARCHAR(255) PRIMARY KEY
+      );
+    `);
+  }
+  /**
+   * Get list of applied migration versions.
+   */
+  async getAppliedVersions() {
+    await this.ensureTable();
+    const result = await this.db.query(
+      `SELECT version FROM ${SCHEMA_MIGRATIONS_TABLE};`
+    );
+    return new Set(result.rows.map((row) => row.version));
+  }
+  /**
+   * Mark a migration as applied.
+   */
+  async markApplied(version, client) {
+    await this.ensureTable();
+    const sql = `
+      INSERT INTO ${SCHEMA_MIGRATIONS_TABLE} (version)
+      VALUES ($1)
+      ON CONFLICT DO NOTHING;
+    `;
+    if (client) {
+      await client.query(sql, [version]);
+    } else {
+      await this.db.execParams(sql, [version]);
+    }
+  }
+  /**
+   * Mark a migration as not applied (for rollback).
+   */
+  async markUnapplied(version, client) {
+    const sql = `
+      DELETE FROM ${SCHEMA_MIGRATIONS_TABLE}
+      WHERE version = $1;
+    `;
+    if (client) {
+      await client.query(sql, [version]);
+    } else {
+      await this.db.execParams(sql, [version]);
+    }
+  }
+  /**
+   * Get pending migrations (not yet applied).
+   */
+  async getPendingMigrations() {
+    const all = listMigrations(this.migrationsDir);
+    const applied = await this.getAppliedVersions();
+    return all.filter((m) => !applied.has(m.version));
+  }
+  /**
+   * Apply a single migration.
+   */
+  async applyMigration(migration) {
+    const { up: up2 } = parseMigrationFile(migration.path);
+    await this.db.withTransaction(async (client) => {
+      if (up2) {
+        await client.query(up2);
+      }
+      await this.markApplied(migration.version, client);
+    });
+  }
+  /**
+   * Roll back a single migration.
+   */
+  async rollbackMigration(migration) {
+    const { down } = parseMigrationFile(migration.path);
+    await this.db.withTransaction(async (client) => {
+      if (down) {
+        await client.query(down);
+      }
+      await this.markUnapplied(migration.version, client);
+    });
+  }
+  /**
+   * Apply all pending migrations.
+   */
+  async migrateUp() {
+    const pending = await this.getPendingMigrations();
+    for (const migration of pending) {
+      await this.applyMigration(migration);
+    }
+    return pending;
+  }
+  /**
+   * Get migration status.
+   */
+  async status() {
+    const all = listMigrations(this.migrationsDir);
+    const appliedVersions = await this.getAppliedVersions();
+    return {
+      applied: all.filter((m) => appliedVersions.has(m.version)),
+      pending: all.filter((m) => !appliedVersions.has(m.version))
+    };
+  }
+};
+
+// src/lib/dbml.ts
+import { Parser, ModelExporter } from "@dbml/core";
+function dbmlToSql(dbmlContent) {
+  const database = new Parser().parse(dbmlContent, "dbml");
+  const sql = ModelExporter.export(database, "postgres");
+  return { sql };
+}
+
+// src/lib/migra.ts
+import { execFileSync } from "child_process";
+function runMigra(fromUrl, toUrl, options = {}) {
+  const args = [fromUrl, toUrl];
+  if (options.unsafe) {
+    args.push("--unsafe");
+  }
+  try {
+    const output = execFileSync("migra", args, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { sql: output || "", hasChanges: false };
+  } catch (error) {
+    const err = error;
+    if (err.status === 2 && err.stdout) {
+      return { sql: err.stdout, hasChanges: true };
+    }
+    if (err.status === 1) {
+      throw new Error(`migra error: ${err.stderr || "Unknown error"}`);
+    }
+    return { sql: err.stdout || "", hasChanges: Boolean(err.stdout) };
+  }
+}
+function filterSchemaMigrations(sql) {
+  return sql.split("\n").filter((line) => !line.includes("schema_migrations")).join("\n").trim();
+}
+
+// src/lib/config.ts
+import { existsSync } from "fs";
+import { join as join2 } from "path";
+import { pathToFileURL } from "url";
+import { config as loadDotenv } from "dotenv";
+var DEFAULT_CONFIG = {
+  schema: "./schema.dbml",
+  migrations: "./db/migrations",
+  extensions: ["uuid-ossp"]
+};
+async function loadConfig(cwd = process.cwd()) {
+  loadDotenv();
+  const configPath = join2(cwd, "nexusql.config.js");
+  let userConfig = {};
+  if (existsSync(configPath)) {
+    try {
+      const configUrl = pathToFileURL(configPath).href;
+      const module = await import(configUrl);
+      userConfig = module.default || module;
+    } catch {
+    }
+  }
+  return {
+    ...DEFAULT_CONFIG,
+    ...userConfig,
+    databaseUrl: process.env.DATABASE_URL || userConfig.databaseUrl
+  };
+}
+function getDatabaseUrl(config) {
+  const url = config.databaseUrl || process.env.DATABASE_URL;
+  if (!url) {
+    throw new Error("DATABASE_URL not set. Set it in .env or nexusql.config.js");
+  }
+  return url;
+}
+function generateConfigTemplate() {
+  return `/** @type {import('nexusql').NexusqlConfig} */
+export default {
+  // Path to your DBML schema file
+  schema: './schema.dbml',
+
+  // Directory for migration files
+  migrations: './db/migrations',
+
+  // PostgreSQL extensions to install in temp database
+  extensions: ['uuid-ossp'],
+};
+`;
+}
+
+// src/commands/gen.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { resolve } from "path";
+import ora from "ora";
+import chalk from "chalk";
+async function gen(options = {}) {
+  const config = await loadConfig();
+  const databaseUrl = getDatabaseUrl(config);
+  const db = new Database(databaseUrl);
+  const spinner = ora();
+  spinner.start("Reading DBML schema...");
+  const schemaPath = resolve(config.schema);
+  let dbmlContent;
+  try {
+    dbmlContent = readFileSync2(schemaPath, "utf-8");
+    spinner.succeed("Read DBML schema");
+  } catch {
+    spinner.fail(`Failed to read schema: ${schemaPath}`);
+    throw new Error(`Schema file not found: ${schemaPath}`);
+  }
+  spinner.start("Converting DBML to SQL...");
+  const { sql: targetSql } = dbmlToSql(dbmlContent);
+  spinner.succeed("Converted DBML to SQL");
+  const tempDbName = `nexusql_temp_${Date.now()}`;
+  spinner.start(`Creating temp database: ${tempDbName}`);
+  try {
+    await db.createDatabase(tempDbName);
+    spinner.succeed(`Created temp database: ${tempDbName}`);
+  } catch (error) {
+    spinner.fail("Failed to create temp database");
+    throw error;
+  }
+  const tempDb = db.withDatabase(tempDbName);
+  let migrationSql = "";
+  try {
+    spinner.start("Installing extensions...");
+    await tempDb.installExtensions(config.extensions);
+    spinner.succeed("Installed extensions");
+    spinner.start("Loading schema into temp database...");
+    await tempDb.exec(targetSql);
+    spinner.succeed("Loaded schema into temp database");
+    if (options.verbose) {
+      const tables = await tempDb.listTables();
+      console.log(chalk.dim(`
+Tables in temp database: ${tables.join(", ")}`));
+    }
+    spinner.start("Generating migration diff...");
+    const migraResult = runMigra(
+      db.getConnectionUrl(),
+      tempDb.getConnectionUrl(),
+      { unsafe: true }
+    );
+    migrationSql = filterSchemaMigrations(migraResult.sql);
+    if (migraResult.hasChanges) {
+      spinner.succeed("Generated migration diff");
+    } else {
+      spinner.info("No schema changes detected");
+    }
+    spinner.start("Checking comment changes...");
+    const commentSql = await getCommentChanges(db, tempDb);
+    if (commentSql) {
+      migrationSql = migrationSql ? `${migrationSql}
+
+-- Comment changes
+${commentSql}` : `-- Comment changes
+${commentSql}`;
+    }
+    spinner.succeed("Checked comment changes");
+  } finally {
+    spinner.start("Cleaning up temp database...");
+    try {
+      await db.dropDatabase(tempDbName);
+      spinner.succeed("Cleaned up temp database");
+    } catch {
+      spinner.warn("Failed to cleanup temp database");
+    }
+  }
+  const finalSql = migrationSql || "-- No changes detected";
+  if (options.output) {
+    writeFileSync2(options.output, finalSql, "utf-8");
+    console.log(chalk.green(`
+Migration SQL written to: ${options.output}`));
+  } else {
+    console.log(chalk.cyan("\n=== Migration SQL ===\n"));
+    console.log(finalSql);
+  }
+  return finalSql;
+}
+async function getCommentChanges(currentDb, targetDb) {
+  const commentQuery = `
+    SELECT
+      format('COMMENT ON COLUMN %I.%I IS %L;',
+        c.table_name,
+        c.column_name,
+        pgd.description
+      ) as comment_sql,
+      c.table_name,
+      c.column_name,
+      pgd.description
+    FROM information_schema.columns c
+    JOIN pg_catalog.pg_class pc ON pc.relname = c.table_name
+    JOIN pg_catalog.pg_namespace pn ON pn.oid = pc.relnamespace AND pn.nspname = c.table_schema
+    LEFT JOIN pg_catalog.pg_description pgd ON pgd.objoid = pc.oid AND pgd.objsubid = c.ordinal_position
+    WHERE c.table_schema = 'public'
+      AND c.table_name != 'schema_migrations'
+    ORDER BY c.table_name, c.ordinal_position;
+  `;
+  const [currentComments, targetComments] = await Promise.all([
+    currentDb.query(commentQuery),
+    targetDb.query(commentQuery)
+  ]);
+  const currentMap = /* @__PURE__ */ new Map();
+  const targetMap = /* @__PURE__ */ new Map();
+  for (const row of currentComments.rows) {
+    const key = `${row.table_name}.${row.column_name}`;
+    currentMap.set(key, row.description);
+  }
+  for (const row of targetComments.rows) {
+    const key = `${row.table_name}.${row.column_name}`;
+    targetMap.set(key, {
+      sql: row.comment_sql,
+      description: row.description
+    });
+  }
+  const commentDiffs = [];
+  for (const [key, target] of targetMap) {
+    const current = currentMap.get(key);
+    if (current !== target.description && target.sql) {
+      commentDiffs.push(target.sql);
+    }
+  }
+  return commentDiffs.join("\n");
+}
+
+// src/commands/migrate.ts
+import { mkdirSync, existsSync as existsSync2 } from "fs";
+import chalk2 from "chalk";
+import ora2 from "ora";
+
+// src/utils/prompts.ts
+import * as readline from "readline";
+var rl = null;
+function getReadline() {
+  if (!rl) {
+    rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+  }
+  return rl;
+}
+function closePrompts() {
+  if (rl) {
+    rl.close();
+    rl = null;
+  }
+}
+function question(query) {
+  return new Promise((resolve2) => {
+    getReadline().question(query, (answer) => {
+      resolve2(answer);
+    });
+  });
+}
+async function confirm(query) {
+  const answer = await question(`${query} (yes/no): `);
+  return answer.toLowerCase() === "yes" || answer.toLowerCase() === "y";
+}
+
+// src/commands/migrate.ts
+async function migrate(options = {}) {
+  const config = await loadConfig();
+  const databaseUrl = getDatabaseUrl(config);
+  const db = new Database(databaseUrl);
+  const runner = new MigrationRunner(db, config.migrations);
+  console.log(chalk2.bold("\nInteractive Database Migration\n"));
+  console.log("This will:");
+  console.log("  1. Generate migration diff from DBML");
+  console.log("  2. Create a new migration file");
+  console.log("  3. Optionally apply the migration\n");
+  try {
+    console.log(chalk2.cyan("Step 1: Generating migration diff...\n"));
+    const migrationSql = await gen({ verbose: false });
+    const noChanges = !migrationSql || migrationSql === "-- No changes detected";
+    if (noChanges) {
+      console.log(chalk2.yellow("\nNo schema changes detected.\n"));
+      if (!options.yes) {
+        const proceed = await confirm(
+          "Do you still want to create an empty migration?"
+        );
+        if (!proceed) {
+          console.log(chalk2.red("\nMigration cancelled."));
+          return;
+        }
+      }
+    }
+    console.log(chalk2.cyan("\n--- Step 2: Create Migration File ---\n"));
+    let migrationName = options.name;
+    if (!migrationName) {
+      migrationName = await question(
+        'Enter migration name (e.g., "add_users_table"): '
+      );
+    }
+    if (!migrationName || migrationName.trim() === "") {
+      console.log(chalk2.red("\nMigration name cannot be empty. Exiting..."));
+      return;
+    }
+    const sanitizedName = migrationName.trim().replace(/\s+/g, "_");
+    console.log(chalk2.green(`
+Using migration name: ${sanitizedName}`));
+    if (!options.yes) {
+      const proceed = await confirm("\nCreate this migration?");
+      if (!proceed) {
+        console.log(chalk2.red("\nMigration cancelled."));
+        return;
+      }
+    }
+    if (!existsSync2(config.migrations)) {
+      mkdirSync(config.migrations, { recursive: true });
+    }
+    const spinner = ora2("Creating migration file...").start();
+    const filepath = createMigrationFile(
+      config.migrations,
+      sanitizedName,
+      noChanges ? "" : migrationSql
+    );
+    spinner.succeed(`Created migration file: ${filepath}`);
+    console.log(chalk2.cyan("\n--- Step 3: Apply Migration ---\n"));
+    let shouldApply = options.apply;
+    if (shouldApply === void 0 && !options.yes) {
+      shouldApply = await confirm("Apply this migration now?");
+    }
+    if (shouldApply) {
+      const applySpinner = ora2("Applying migration...").start();
+      try {
+        const applied = await runner.migrateUp();
+        if (applied.length > 0) {
+          applySpinner.succeed(
+            `Applied ${applied.length} migration(s) successfully`
+          );
+        } else {
+          applySpinner.info("No pending migrations to apply");
+        }
+      } catch (error) {
+        applySpinner.fail("Failed to apply migration");
+        throw error;
+      }
+    } else {
+      console.log(chalk2.dim("\nMigration created but not applied."));
+      console.log(chalk2.dim(`Run "nexusql up" to apply pending migrations.`));
+    }
+    console.log(chalk2.green(`
+Migration file: ${filepath}
+`));
+  } finally {
+    closePrompts();
+  }
+}
+async function up(options = {}) {
+  const config = await loadConfig();
+  const databaseUrl = getDatabaseUrl(config);
+  const db = new Database(databaseUrl);
+  const runner = new MigrationRunner(db, config.migrations);
+  const spinner = ora2("Checking migrations...").start();
+  try {
+    const pending = await runner.getPendingMigrations();
+    if (pending.length === 0) {
+      spinner.info("No pending migrations");
+      return;
+    }
+    if (options.dryRun) {
+      spinner.info(`found ${pending.length} pending migration(s):`);
+      for (const m of pending) {
+        console.log(chalk2.cyan(`  \u25CB ${m.name}`));
+      }
+      return;
+    }
+    spinner.text = "Applying migrations...";
+    for (const migration of pending) {
+      await runner.applyMigration(migration);
+      console.log(chalk2.green(`  \u2713 ${migration.name}`));
+    }
+    spinner.succeed(`Applied ${pending.length} migration(s)`);
+  } catch (error) {
+    spinner.fail("Migration failed");
+    throw error;
+  }
+}
+async function status() {
+  const config = await loadConfig();
+  const databaseUrl = getDatabaseUrl(config);
+  const db = new Database(databaseUrl);
+  const runner = new MigrationRunner(db, config.migrations);
+  const spinner = ora2("Checking migration status...").start();
+  const { applied, pending } = await runner.status();
+  spinner.stop();
+  console.log(chalk2.bold("\nMigration Status\n"));
+  if (applied.length > 0) {
+    console.log(chalk2.green("Applied:"));
+    for (const m of applied) {
+      console.log(chalk2.green(`  \u2713 ${m.name}`));
+    }
+  }
+  if (pending.length > 0) {
+    console.log(chalk2.yellow("\nPending:"));
+    for (const m of pending) {
+      console.log(chalk2.yellow(`  \u25CB ${m.name}`));
+    }
+  }
+  if (applied.length === 0 && pending.length === 0) {
+    console.log(chalk2.dim("No migrations found."));
+  }
+  console.log();
+}
+
+// src/commands/mark-applied.ts
+import chalk3 from "chalk";
+import ora3 from "ora";
+async function markApplied(version) {
+  if (!version) {
+    console.error(chalk3.red("Error: Migration version is required"));
+    console.log(chalk3.dim("\nUsage: nexusql mark-applied <version>"));
+    console.log(chalk3.dim("Example: nexusql mark-applied 20251209153535"));
+    process.exit(1);
+  }
+  const config = await loadConfig();
+  const databaseUrl = getDatabaseUrl(config);
+  const db = new Database(databaseUrl);
+  const runner = new MigrationRunner(db, config.migrations);
+  const spinner = ora3(`Marking migration ${version} as applied...`).start();
+  try {
+    await runner.markApplied(version);
+    spinner.succeed(`Migration ${version} marked as applied`);
+  } catch (error) {
+    spinner.fail("Failed to mark migration as applied");
+    throw error;
+  }
+}
+
+// src/commands/init.ts
+import { writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3 } from "path";
+import chalk4 from "chalk";
+async function init(options = {}) {
+  const cwd = process.cwd();
+  const configPath = join3(cwd, "nexusql.config.js");
+  if (existsSync3(configPath) && !options.force) {
+    console.log(chalk4.yellow("nexusql.config.js already exists."));
+    console.log(chalk4.dim("Use --force to overwrite."));
+    return;
+  }
+  writeFileSync3(configPath, generateConfigTemplate(), "utf-8");
+  console.log(chalk4.green("Created nexusql.config.js"));
+  const migrationsDir = join3(cwd, "db", "migrations");
+  if (!existsSync3(migrationsDir)) {
+    mkdirSync2(migrationsDir, { recursive: true });
+    console.log(chalk4.green("Created db/migrations/"));
+  }
+  const envExamplePath = join3(cwd, ".env.example");
+  if (!existsSync3(envExamplePath)) {
+    writeFileSync3(
+      envExamplePath,
+      "DATABASE_URL=postgres://user:password@localhost:5432/database\n",
+      "utf-8"
+    );
+    console.log(chalk4.green("Created .env.example"));
+  }
+  console.log(chalk4.bold("\nNext steps:"));
+  console.log("  1. Copy .env.example to .env and set your DATABASE_URL");
+  console.log("  2. Create your schema.dbml file");
+  console.log('  3. Run "nexusql gen" to generate migration SQL');
+  console.log('  4. Run "nexusql migrate" to create and apply migrations\n');
+}
+export {
+  Database,
+  MigrationRunner,
+  buildDbUrl,
+  createMigrationFile,
+  dbmlToSql,
+  filterSchemaMigrations,
+  gen,
+  generateConfigTemplate,
+  getDatabaseUrl,
+  getMostRecentMigration,
+  init,
+  listMigrations,
+  loadConfig,
+  markApplied,
+  migrate,
+  parseAndEncodeDbUrl,
+  parseMigrationFile,
+  runMigra,
+  status,
+  up,
+  updateMigrationFile
+};
+//# sourceMappingURL=index.js.map