@plyaz/db 0.1.1 → 0.2.0

package/dist/cli/index.js

@@ -193,6 +193,10 @@ function failure(error) {
   return { success: false, error };
 }
 __name(failure, "failure");
+var DESCRIPTION_MAX_LENGTH = 60;
+var FALLBACK_DESCRIPTION_LENGTH = 50;
+var PROGRESS_LOG_INTERVAL = 10;
+var ERROR_MESSAGE_MAX_LENGTH = 300;
 var MigrationManager = class {
   static {
     __name(this, "MigrationManager");
@@ -302,6 +306,116 @@ var MigrationManager = class {
     }
     return { upSQL: sql2.trim(), downSQL: null };
   }
+  /**
+   * Process dollar-quoted string delimiters ($$ or $tag$)
+   * Returns updated state for tracking if we're inside a dollar block
+   */
+  processDollarDelimiters(line, inDollarBlock, dollarTag) {
+    const dollarMatch = line.match(/\$([a-zA-Z_]*)\$/g);
+    if (!dollarMatch) return { inDollarBlock, dollarTag };
+    let currentInBlock = inDollarBlock;
+    let currentTag = dollarTag;
+    for (const match of dollarMatch) {
+      if (!currentInBlock) {
+        currentInBlock = true;
+        currentTag = match;
+      } else if (match === currentTag) {
+        currentInBlock = false;
+        currentTag = "";
+      }
+    }
+    return { inDollarBlock: currentInBlock, dollarTag: currentTag };
+  }
+  /**
+   * Filter out comment-only statements
+   */
+  isNonCommentStatement(statement) {
+    const withoutComments = statement.replace(/--.*$/gm, "").trim();
+    return withoutComments.length > 0;
+  }
+  /**
+   * Split SQL into individual statements for better error reporting
+   * Handles $$ delimited blocks (functions, triggers) correctly
+   */
+  splitSqlStatements(sql2) {
+    const statements = [];
+    let current = "";
+    let inDollarBlock = false;
+    let dollarTag = "";
+    for (const line of sql2.split("\n")) {
+      const trimmedLine = line.trim();
+      const isEmptyOrComment = trimmedLine === "" || trimmedLine.startsWith("--");
+      current += line + "\n";
+      if (isEmptyOrComment) continue;
+      const dollarState = this.processDollarDelimiters(line, inDollarBlock, dollarTag);
+      inDollarBlock = dollarState.inDollarBlock;
+      dollarTag = dollarState.dollarTag;
+      const isEndOfStatement = !inDollarBlock && trimmedLine.endsWith(";");
+      if (isEndOfStatement && current.trim()) {
+        statements.push(current.trim());
+        current = "";
+      }
+    }
+    if (current.trim()) {
+      statements.push(current.trim());
+    }
+    return statements.filter((s) => this.isNonCommentStatement(s));
+  }
+  /**
+   * Extract a short description from a SQL statement for logging
+   */
+  getStatementDescription(statement) {
+    const firstLine = statement.split("\n").find((l) => l.trim() && !l.trim().startsWith("--"))?.trim() ?? "";
+    const patterns = [
+      /^(CREATE\s+(?:OR\s+REPLACE\s+)?(?:TABLE|INDEX|UNIQUE\s+INDEX|TYPE|FUNCTION|TRIGGER|EXTENSION|SCHEMA|VIEW|POLICY))\s+(?:IF\s+NOT\s+EXISTS\s+)?([^\s(]+)/i,
+      /^(ALTER\s+TABLE)\s+([^\s]+)/i,
+      /^(DROP\s+(?:TABLE|INDEX|TYPE|FUNCTION|TRIGGER|EXTENSION|SCHEMA|VIEW|POLICY))\s+(?:IF\s+EXISTS\s+)?([^\s(;]+)/i,
+      /^(INSERT\s+INTO)\s+([^\s(]+)/i,
+      /^(COMMENT\s+ON\s+(?:TABLE|COLUMN|INDEX|FUNCTION|TYPE))\s+([^\s]+)/i,
+      /^(GRANT|REVOKE)\s+.+\s+ON\s+([^\s]+)/i
+    ];
+    for (const pattern of patterns) {
+      const match = firstLine.match(pattern);
+      if (match) {
+        return `${match[1]} ${match[2]}`.slice(0, DESCRIPTION_MAX_LENGTH);
+      }
+    }
+    const truncated = firstLine.slice(0, FALLBACK_DESCRIPTION_LENGTH);
+    const suffix = firstLine.length > FALLBACK_DESCRIPTION_LENGTH ? "..." : "";
+    return truncated + suffix;
+  }
+  /**
+   * Execute SQL statements individually with better error reporting
+   */
+  async executeSqlStatements(adapter, sql2, migrationVersion) {
+    const statements = this.splitSqlStatements(sql2);
+    const total = statements.length;
+    console.log(`  → ${total} statements to execute`);
+    for (let i = 0; i < statements.length; i++) {
+      const statement = statements[i];
+      const description = this.getStatementDescription(statement);
+      try {
+        await adapter.query(statement);
+        const isInterval = (i + 1) % PROGRESS_LOG_INTERVAL === 0;
+        const isLast = i === total - 1;
+        const isSignificant = Boolean(description.match(/^(CREATE TABLE|CREATE FUNCTION|CREATE TRIGGER)/i));
+        if (isInterval || isLast || isSignificant) {
+          console.log(`  ✓ [${i + 1}/${total}] ${description}`);
+        }
+      } catch (error) {
+        console.log(`  ✗ [${i + 1}/${total}] ${description}`);
+        const rawMessage = error.message;
+        const errorMessage = rawMessage.replace(/^SQL Error:\s*/i, "").replace(/^Failed to execute query:.*?-\s*/i, "").slice(0, ERROR_MESSAGE_MAX_LENGTH);
+        throw new DatabaseError(
+          `Migration ${migrationVersion} failed at statement ${i + 1}/${total}:
+  Statement: ${description}
+  Error: ${errorMessage}`,
+          DATABASE_ERROR_CODES.QUERY_FAILED,
+          { cause: error }
+        );
+      }
+    }
+  }
   /**
    * Load SQL migration from file
    */
@@ -313,12 +427,20 @@ var MigrationManager = class {
       name: migrationFile.name,
       up: /* @__PURE__ */ __name(async (adapter) => {
         if (typeof adapter.query === "function") {
-          await adapter.query(upSQL);
+          await this.executeSqlStatements(
+            adapter,
+            upSQL,
+            migrationFile.version
+          );
         }
       }, "up"),
       down: /* @__PURE__ */ __name(async (adapter) => {
         if (downSQL && typeof adapter.query === "function") {
-          await adapter.query(downSQL);
+          await this.executeSqlStatements(
+            adapter,
+            downSQL,
+            migrationFile.version
+          );
         } else {
           console.warn(
             `[Migrations] No DOWN migration for ${migrationFile.version}`
@@ -425,6 +547,7 @@ var MigrationManager = class {
   /**
    * Run all pending migrations
    */
+  /* eslint-disable max-depth, complexity */
   async up(targetVersion) {
     try {
       await this.initialize();
@@ -445,9 +568,15 @@ var MigrationManager = class {
         const migration = await this.loadMigration(migrationFile);
         const startTime = Date.now();
         if (typeof this.adapter.transaction === "function") {
-          await this.adapter.transaction(async () => {
+          const txResult = await this.adapter.transaction(async () => {
             await migration.up(this.adapter);
           });
+          if (!txResult.success) {
+            throw txResult.error ?? new DatabaseError(
+              `Migration ${migration.version} failed`,
+              DATABASE_ERROR_CODES.QUERY_FAILED
+            );
+          }
         } else {
           await migration.up(this.adapter);
         }
@@ -502,9 +631,15 @@ var MigrationManager = class {
         const migration = await this.loadMigration(migrationFile);
         const startTime = Date.now();
         if (typeof this.adapter.transaction === "function") {
-          await this.adapter.transaction(async () => {
+          const txResult = await this.adapter.transaction(async () => {
             await migration.down(this.adapter);
           });
+          if (!txResult.success) {
+            throw txResult.error ?? new DatabaseError(
+              `Rollback ${appliedMigration.version} failed`,
+              DATABASE_ERROR_CODES.QUERY_FAILED
+            );
+          }
         } else {
           await migration.down(this.adapter);
         }
@@ -563,6 +698,10 @@ var MigrationManager = class {
     }
   }
 };
+var DESCRIPTION_MAX_LENGTH2 = 60;
+var FALLBACK_DESCRIPTION_LENGTH2 = 50;
+var PROGRESS_LOG_INTERVAL2 = 10;
+var ERROR_MESSAGE_MAX_LENGTH2 = 300;
 var SeedManager = class {
   static {
     __name(this, "SeedManager");
@@ -631,7 +770,7 @@ var SeedManager = class {
     const files = fs3.readdirSync(this.seedsPath);
     const seeds = [];
     for (const file of files) {
-      const match = file.match(/^(\d+)_(.+)\.(ts|js)$/);
+      const match = file.match(/^(\d+)_(.+)\.(ts|js|sql)$/);
       if (match) {
         const [, order, name] = match;
         seeds.push({
@@ -644,9 +783,137 @@ var SeedManager = class {
     return seeds.sort((a, b) => a.order - b.order);
   }
   /**
-   * Load seed from file
+   * Process dollar-quoted string delimiters ($$ or $tag$)
+   */
+  processDollarDelimiters(line, inDollarBlock, dollarTag) {
+    const dollarMatch = line.match(/\$([a-zA-Z_]*)\$/g);
+    if (!dollarMatch) return { inDollarBlock, dollarTag };
+    let currentInBlock = inDollarBlock;
+    let currentTag = dollarTag;
+    for (const match of dollarMatch) {
+      if (!currentInBlock) {
+        currentInBlock = true;
+        currentTag = match;
+      } else if (match === currentTag) {
+        currentInBlock = false;
+        currentTag = "";
+      }
+    }
+    return { inDollarBlock: currentInBlock, dollarTag: currentTag };
+  }
+  /**
+   * Filter out comment-only statements
+   */
+  isNonCommentStatement(statement) {
+    const withoutComments = statement.replace(/--.*$/gm, "").trim();
+    return withoutComments.length > 0;
+  }
+  /**
+   * Split SQL into individual statements for better error reporting
+   */
+  splitSqlStatements(sql2) {
+    const statements = [];
+    let current = "";
+    let inDollarBlock = false;
+    let dollarTag = "";
+    for (const line of sql2.split("\n")) {
+      const trimmedLine = line.trim();
+      const isEmptyOrComment = trimmedLine === "" || trimmedLine.startsWith("--");
+      current += line + "\n";
+      if (isEmptyOrComment) continue;
+      const dollarState = this.processDollarDelimiters(line, inDollarBlock, dollarTag);
+      inDollarBlock = dollarState.inDollarBlock;
+      dollarTag = dollarState.dollarTag;
+      if (!inDollarBlock && trimmedLine.endsWith(";") && current.trim()) {
+        statements.push(current.trim());
+        current = "";
+      }
+    }
+    if (current.trim()) {
+      statements.push(current.trim());
+    }
+    return statements.filter((s) => this.isNonCommentStatement(s));
+  }
+  /**
+   * Extract a short description from a SQL statement for logging
    */
+  getStatementDescription(statement) {
+    const firstLine = statement.split("\n").find((l) => l.trim() && !l.trim().startsWith("--"))?.trim() ?? "";
+    const patterns = [
+      /^(CREATE\s+(?:OR\s+REPLACE\s+)?(?:TABLE|INDEX|UNIQUE\s+INDEX|TYPE|FUNCTION|TRIGGER|EXTENSION|SCHEMA|VIEW|POLICY))\s+(?:IF\s+NOT\s+EXISTS\s+)?([^\s(]+)/i,
+      /^(ALTER\s+TABLE)\s+([^\s]+)/i,
+      /^(DROP\s+(?:TABLE|INDEX|TYPE|FUNCTION|TRIGGER|EXTENSION|SCHEMA|VIEW|POLICY))\s+(?:IF\s+EXISTS\s+)?([^\s(;]+)/i,
+      /^(INSERT\s+INTO)\s+([^\s(]+)/i,
+      /^(COMMENT\s+ON\s+(?:TABLE|COLUMN|INDEX|FUNCTION|TYPE))\s+([^\s]+)/i,
+      /^(GRANT|REVOKE)\s+.+\s+ON\s+([^\s]+)/i
+    ];
+    for (const pattern of patterns) {
+      const match = firstLine.match(pattern);
+      if (match) {
+        return `${match[1]} ${match[2]}`.slice(0, DESCRIPTION_MAX_LENGTH2);
+      }
+    }
+    const truncated = firstLine.slice(0, FALLBACK_DESCRIPTION_LENGTH2);
+    const suffix = firstLine.length > FALLBACK_DESCRIPTION_LENGTH2 ? "..." : "";
+    return truncated + suffix;
+  }
+  /**
+   * Execute SQL statements individually with better error reporting
+   */
+  async executeSqlStatements(sql2, seedName) {
+    const statements = this.splitSqlStatements(sql2);
+    const total = statements.length;
+    console.log(`  → ${total} statements to execute`);
+    for (let i = 0; i < statements.length; i++) {
+      const statement = statements[i];
+      const description = this.getStatementDescription(statement);
+      try {
+        await this.adapter.query(statement);
+        const isInterval = (i + 1) % PROGRESS_LOG_INTERVAL2 === 0;
+        const isLast = i === total - 1;
+        const isSignificant = Boolean(description.match(/^(INSERT INTO)/i));
+        if (isInterval || isLast || isSignificant) {
+          console.log(`  ✓ [${i + 1}/${total}] ${description}`);
+        }
+      } catch (error) {
+        console.log(`  ✗ [${i + 1}/${total}] ${description}`);
+        const rawMessage = error.message;
+        const errorMessage = rawMessage.replace(/^SQL Error:\s*/i, "").replace(/^Failed to execute query:.*?-\s*/i, "").slice(0, ERROR_MESSAGE_MAX_LENGTH2);
+        throw new DatabaseError(
+          `Seed "${seedName}" failed at statement ${i + 1}/${total}:
+  Statement: ${description}
+  Error: ${errorMessage}`,
+          DATABASE_ERROR_CODES.QUERY_FAILED,
+          { cause: error }
+        );
+      }
+    }
+  }
+  /**
+   * Load SQL seed from file
+   */
+  loadSqlSeed(seedFile) {
+    const sql2 = fs3.readFileSync(seedFile.filePath, "utf-8");
+    return {
+      name: seedFile.name,
+      run: /* @__PURE__ */ __name(async () => {
+        if (typeof this.adapter.query === "function") {
+          await this.executeSqlStatements(sql2, seedFile.name);
+        }
+      }, "run"),
+      // SQL seeds don't have cleanup by default
+      cleanup: void 0
+    };
+  }
+  /**
+   * Load seed from file (supports .ts, .js, and .sql)
+   */
+  // eslint-disable-next-line complexity
   async loadSeed(seedFile) {
+    const ext = path4.extname(seedFile.filePath);
+    if (ext === ".sql") {
+      return this.loadSqlSeed(seedFile);
+    }
     const importPath = seedFile.filePath.startsWith("/") ? seedFile.filePath : new URL(`file:///${seedFile.filePath.replace(/\\/g, "/")}`).href;
     const seedModule = await import(importPath);
     return {
@@ -700,9 +967,15 @@ var SeedManager = class {
    */
   async executeSeed(seed) {
     if (typeof this.adapter.transaction === "function") {
-      await this.adapter.transaction(async () => {
+      const txResult = await this.adapter.transaction(async () => {
         await seed.run(this.adapter);
       });
+      if (!txResult.success) {
+        throw txResult.error ?? new DatabaseError(
+          `Seed ${seed.name} failed`,
+          DATABASE_ERROR_CODES.QUERY_FAILED
+        );
+      }
     } else {
       await seed.run(this.adapter);
     }
@@ -759,9 +1032,15 @@ var SeedManager = class {
   async executeCleanup(seed) {
     if (!seed.cleanup) return;
     if (typeof this.adapter.transaction === "function") {
-      await this.adapter.transaction(async () => {
+      const txResult = await this.adapter.transaction(async () => {
         await seed.cleanup(this.adapter);
       });
+      if (!txResult.success) {
+        throw txResult.error ?? new DatabaseError(
+          `Seed cleanup for ${seed.name} failed`,
+          DATABASE_ERROR_CODES.QUERY_FAILED
+        );
+      }
     } else {
       await seed.cleanup(this.adapter);
     }
@@ -4395,6 +4674,7 @@ var SupabaseAdapter = class {
     return ops[operator]();
   }
 };
+var SQL_ERROR_TRUNCATE_LENGTH = 500;
 var SQLAdapter = class {
   static {
     __name(this, "SQLAdapter");
@@ -4405,6 +4685,7 @@ var SQLAdapter = class {
   idColumnMap = /* @__PURE__ */ new Map();
   configIdColumns;
   defaultSchema;
+  showSqlInErrors;
   /**
    * Creates a new SQLAdapter instance.
    * @param {SQLAdapterConfig} config - Configuration for the SQL adapter.
@@ -4418,6 +4699,7 @@ var SQLAdapter = class {
   constructor(config) {
     this.config = config;
     this.defaultSchema = config.schema ?? "public";
+    this.showSqlInErrors = config.showSqlInErrors ?? true;
     this.pool = new Pool({
       connectionString: config.connectionString,
       ...config.pool
@@ -4536,16 +4818,16 @@ var SQLAdapter = class {
       const result = await this.pool.query(sql2, params);
       return result.rows;
     } catch (error) {
-      throw new DatabaseError(
-        `Failed to execute query: ${sql2} - ${error.message}`,
-        DATABASE_ERROR_CODES.QUERY_FAILED,
-        {
-          context: {
-            source: "SQLAdapter.query"
-          },
-          cause: error
-        }
-      );
+      const truncatedSql = sql2.slice(0, SQL_ERROR_TRUNCATE_LENGTH);
+      const sqlSuffix = sql2.length > SQL_ERROR_TRUNCATE_LENGTH ? "..." : "";
+      const errorMessage = this.showSqlInErrors ? `SQL Error: ${error.message}
+  Query: ${truncatedSql}${sqlSuffix}` : `SQL Error: ${error.message}`;
+      throw new DatabaseError(errorMessage, DATABASE_ERROR_CODES.QUERY_FAILED, {
+        context: {
+          source: "SQLAdapter.query"
+        },
+        cause: error
+      });
     }
   }
   /**
@@ -7975,20 +8257,48 @@ async function createDatabaseService(config) {
 }
 __name(createDatabaseService, "createDatabaseService");
 var JSON_INDENT_SPACES = 2;
-async function getPublicTables(adapter) {
+async function getUserSchemas(adapter) {
   const result = await adapter.query?.(`
-    SELECT tablename FROM pg_tables
-    WHERE schemaname = 'public'
-    AND tablename NOT IN ('schema_migrations', 'seed_history')
+    SELECT schema_name FROM information_schema.schemata
+    WHERE schema_name NOT IN ('pg_catalog', 'information_schema', 'pg_toast', 'mysql', 'sys', 'performance_schema')
+      AND schema_name NOT LIKE 'pg_%'
+      AND schema_name NOT LIKE 'pg_temp_%'
+      AND schema_name NOT LIKE 'pg_toast_temp_%'
   `);
-  const tables = Array.isArray(result) ? result : result.rows || [];
-  return tables.map((t) => t.tablename);
+  const schemas = Array.isArray(result) ? result : result.rows || [];
+  return schemas.map((s) => s.schema_name);
+}
+__name(getUserSchemas, "getUserSchemas");
+async function getTablesFromSchemas(adapter, schemas) {
+  const tables = [];
+  for (const schema of schemas) {
+    const result = await adapter.query?.(
+      `
+      SELECT table_name FROM information_schema.tables
+      WHERE table_schema = $1
+        AND table_type = 'BASE TABLE'
+        AND table_name NOT IN ('schema_migrations', 'seed_history')
+    `,
+      [schema]
+    );
+    const schemaResult = Array.isArray(result) ? result : result.rows || [];
+    for (const row of schemaResult) {
+      tables.push({ schema, table: row.table_name });
+    }
+  }
+  return tables;
 }
-__name(getPublicTables, "getPublicTables");
+__name(getTablesFromSchemas, "getTablesFromSchemas");
 async function clearTables(adapter, tables) {
-  for (const table of tables) {
-    await adapter.query?.(`TRUNCATE TABLE ${table} CASCADE`);
-    console.log(`   ✓ Cleared ${table}`);
+  let currentSchema = "";
+  for (const { schema, table } of tables) {
+    if (schema !== currentSchema) {
+      console.log(`
+📁 Schema: ${schema}`);
+      currentSchema = schema;
+    }
+    await adapter.query?.(`TRUNCATE TABLE "${schema}"."${table}" CASCADE`);
+    console.log(`   ✓ Cleared ${schema}.${table}`);
   }
 }
 __name(clearTables, "clearTables");
@@ -8335,7 +8645,13 @@ seedCommand.command("reset").description("Reset seeds (run cleanup functions)").
     process.exit(1);
   }
 });
-program.command("clear").description("Clear all data from database (keep schema)").option("--confirm", "Confirm clear operation").option("-t, --tables <tables>", "Comma-separated list of tables to clear").action(async (options) => {
+program.command("clear").description("Clear all data from database (keep schema)").option("--confirm", "Confirm clear operation").option(
+  "-t, --tables <tables>",
+  "Comma-separated list of tables to clear (format: schema.table or just table for public)"
+).option(
+  "-s, --schemas <schemas>",
+  "Comma-separated list of schemas to clear (default: all user schemas)"
+).action(async (options) => {
   if (!options.confirm) {
     console.error("❌ Please use --confirm flag to confirm clear operation");
     process.exit(1);
@@ -8347,16 +8663,36 @@ program.command("clear").description("Clear all data from database (keep schema)
       console.error("❌ Clear operation not supported by this adapter");
       process.exit(1);
     }
-    const tablesToClear = options.tables ? options.tables.split(",").map((t) => t.trim()) : await getPublicTables(adapter);
+    let tablesToClear;
+    if (options.tables) {
+      tablesToClear = options.tables.split(",").map((t) => {
+        const trimmed = t.trim();
+        if (trimmed.includes(".")) {
+          const [schema, table] = trimmed.split(".");
+          return { schema, table };
+        }
+        return { schema: "public", table: trimmed };
+      });
+    } else {
+      const schemas = options.schemas ? options.schemas.split(",").map((s) => s.trim()) : await getUserSchemas(adapter);
+      tablesToClear = await getTablesFromSchemas(adapter, schemas);
+    }
     await clearTables(adapter, tablesToClear);
-    console.log("✅ Database cleared");
+    console.log(`
+✅ Cleared ${tablesToClear.length} tables`);
     process.exit(0);
   } catch (error) {
     console.error("❌ Error:", error.message);
     process.exit(1);
   }
 });
-program.command("drop").description("Drop all tables from database").option("--confirm", "Confirm drop operation").action(async (options) => {
+program.command("drop").description("Drop all tables from database (all schemas)").option("--confirm", "Confirm drop operation").option(
+  "-s, --schemas <schemas>",
+  "Comma-separated list of schemas to drop from (default: all user schemas)"
+).option(
+  "--all",
+  "Drop everything: tables, types, functions, views (not just tables)"
+).option("--drop-schemas", "Also drop the schemas themselves (except public)").action(async (options) => {
   if (!options.confirm) {
     console.error("❌ Please use --confirm flag to confirm drop operation");
     process.exit(1);
@@ -8364,22 +8700,226 @@ program.command("drop").description("Drop all tables from database").option("--c
   try {
     const { adapter } = await initDatabase();
     console.log("🔄 Dropping all tables...");
-    if (typeof adapter.query === "function") {
-      const result = await adapter.query(`
-          SELECT tablename FROM pg_tables
-          WHERE schemaname = 'public'
-        `);
-      const tables = Array.isArray(result) ? result : result.rows || [];
-      for (const { tablename } of tables) {
-        await adapter.query(`DROP TABLE IF EXISTS ${tablename} CASCADE`);
-        console.log(`   ✓ Dropped ${tablename}`);
-      }
-      console.log("✅ All tables dropped");
-      process.exit(0);
-    } else {
+    if (typeof adapter.query !== "function") {
       console.error("❌ Drop operation not supported by this adapter");
       process.exit(1);
     }
+    const schemas = options.schemas ? options.schemas.split(",").map((s) => s.trim()) : await getUserSchemas(adapter);
+    let totalDropped = 0;
+    for (const schema of schemas) {
+      const result = await adapter.query(
+        `
+          SELECT table_name FROM information_schema.tables
+          WHERE table_schema = $1
+            AND table_type = 'BASE TABLE'
+        `,
+        [schema]
+      );
+      const tables = Array.isArray(result) ? result : result.rows || [];
+      if (tables.length === 0) continue;
+      console.log(`
+📁 Schema: ${schema}`);
+      for (const { table_name } of tables) {
+        await adapter.query(
+          `DROP TABLE IF EXISTS "${schema}"."${table_name}" CASCADE`
+        );
+        console.log(`   ✓ Dropped ${schema}.${table_name}`);
+        totalDropped++;
+      }
+    }
+    if (options.all) {
+      console.log("\n🗑️  Dropping views...");
+      for (const schema of schemas) {
+        const viewResult = await adapter.query(
+          `
+            SELECT table_name FROM information_schema.views
+            WHERE table_schema = $1
+          `,
+          [schema]
+        );
+        const views = Array.isArray(viewResult) ? viewResult : viewResult.rows || [];
+        for (const { table_name } of views) {
+          try {
+            await adapter.query(
+              `DROP VIEW IF EXISTS "${schema}"."${table_name}" CASCADE`
+            );
+            console.log(`   ✓ Dropped view ${schema}.${table_name}`);
+          } catch {
+          }
+        }
+      }
+      console.log("\n🗑️  Dropping triggers...");
+      for (const schema of schemas) {
+        try {
+          const triggerResult = await adapter.query(
+            `
+              SELECT DISTINCT trigger_name, event_object_table
+              FROM information_schema.triggers
+              WHERE trigger_schema = $1
+            `,
+            [schema]
+          );
+          const triggers = Array.isArray(triggerResult) ? triggerResult : triggerResult.rows || [];
+          for (const { trigger_name, event_object_table } of triggers) {
+            try {
+              await adapter.query(
+                `DROP TRIGGER IF EXISTS "${trigger_name}" ON "${schema}"."${event_object_table}" CASCADE`
+              );
+              console.log(`   ✓ Dropped trigger ${schema}.${trigger_name}`);
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+      console.log("\n🗑️  Dropping functions...");
+      for (const schema of schemas) {
+        try {
+          const funcResult = await adapter.query(
+            `
+              SELECT p.proname, pg_get_function_identity_arguments(p.oid) as args
+              FROM pg_proc p
+              JOIN pg_namespace n ON p.pronamespace = n.oid
+              WHERE n.nspname = $1
+                AND p.prokind = 'f'
+            `,
+            [schema]
+          );
+          const funcs = Array.isArray(funcResult) ? funcResult : funcResult.rows || [];
+          for (const { proname, args } of funcs) {
+            try {
+              await adapter.query(
+                `DROP FUNCTION IF EXISTS "${schema}"."${proname}"(${args}) CASCADE`
+              );
+              console.log(`   ✓ Dropped function ${schema}.${proname}`);
+            } catch {
+            }
+          }
+        } catch {
+          console.log(
+            `   ⚠ Function dropping not supported for this database`
+          );
+          break;
+        }
+      }
+      console.log("\n🗑️  Dropping procedures...");
+      for (const schema of schemas) {
+        try {
+          const procResult = await adapter.query(
+            `
+              SELECT p.proname, pg_get_function_identity_arguments(p.oid) as args
+              FROM pg_proc p
+              JOIN pg_namespace n ON p.pronamespace = n.oid
+              WHERE n.nspname = $1
+                AND p.prokind = 'p'
+            `,
+            [schema]
+          );
+          const procs = Array.isArray(procResult) ? procResult : procResult.rows || [];
+          for (const { proname, args } of procs) {
+            try {
+              await adapter.query(
+                `DROP PROCEDURE IF EXISTS "${schema}"."${proname}"(${args}) CASCADE`
+              );
+              console.log(`   ✓ Dropped procedure ${schema}.${proname}`);
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+      console.log("\n🗑️  Dropping sequences...");
+      for (const schema of schemas) {
+        try {
+          const seqResult = await adapter.query(
+            `
+              SELECT sequence_name FROM information_schema.sequences
+              WHERE sequence_schema = $1
+            `,
+            [schema]
+          );
+          const sequences = Array.isArray(seqResult) ? seqResult : seqResult.rows || [];
+          for (const { sequence_name } of sequences) {
+            try {
+              await adapter.query(
+                `DROP SEQUENCE IF EXISTS "${schema}"."${sequence_name}" CASCADE`
+              );
+              console.log(`   ✓ Dropped sequence ${schema}.${sequence_name}`);
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+      console.log("\n🗑️  Dropping types...");
+      for (const schema of schemas) {
+        try {
+          const typeResult = await adapter.query(
+            `
+              SELECT t.typname
+              FROM pg_type t
+              JOIN pg_namespace n ON t.typnamespace = n.oid
+              WHERE n.nspname = $1
+                AND t.typtype = 'e'
+            `,
+            [schema]
+          );
+          const types = Array.isArray(typeResult) ? typeResult : typeResult.rows || [];
+          for (const { typname } of types) {
+            try {
+              await adapter.query(
+                `DROP TYPE IF EXISTS "${schema}"."${typname}" CASCADE`
+              );
+              console.log(`   ✓ Dropped type ${schema}.${typname}`);
+            } catch {
+            }
+          }
+        } catch {
+          console.log(`   ⚠ Type dropping not supported for this database`);
+          break;
+        }
+      }
+      console.log("\n🗑️  Dropping domains...");
+      for (const schema of schemas) {
+        try {
+          const domainResult = await adapter.query(
+            `
+              SELECT domain_name FROM information_schema.domains
+              WHERE domain_schema = $1
+            `,
+            [schema]
+          );
+          const domains = Array.isArray(domainResult) ? domainResult : domainResult.rows || [];
+          for (const { domain_name } of domains) {
+            try {
+              await adapter.query(
+                `DROP DOMAIN IF EXISTS "${schema}"."${domain_name}" CASCADE`
+              );
+              console.log(`   ✓ Dropped domain ${schema}.${domain_name}`);
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    if (options.dropSchemas) {
+      console.log("\n🗑️  Dropping schemas...");
+      for (const schema of schemas) {
+        if (schema === "public") continue;
+        try {
+          await adapter.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
+          console.log(`   ✓ Dropped schema ${schema}`);
+        } catch {
+          console.log(`   ⚠ Could not drop schema ${schema}`);
+        }
+      }
+    }
+    console.log(
+      `
+✅ Dropped ${totalDropped} tables${options.all ? " + types, functions, views" : ""}`
+    );
+    process.exit(0);
   } catch (error) {
     console.error("❌ Error:", error.message);
     process.exit(1);
@@ -8415,6 +8955,247 @@ program.command("health").description("Check database health").action(async () =
     process.exit(1);
   }
 });
+async function dropAllObjects(adapter, schemas, dropSchemas) {
+  let totalTables = 0;
+  let totalObjects = 0;
+  console.log("\n🗑️  Dropping tables...");
+  for (const schema of schemas) {
+    const result = await adapter.query(
+      `
+      SELECT table_name FROM information_schema.tables
+      WHERE table_schema = $1
+        AND table_type = 'BASE TABLE'
+    `,
+      [schema]
+    );
+    const tables = Array.isArray(result) ? result : result.rows || [];
+    if (tables.length === 0) continue;
+    console.log(`
+📁 Schema: ${schema}`);
+    for (const { table_name } of tables) {
+      await adapter.query(
+        `DROP TABLE IF EXISTS "${schema}"."${table_name}" CASCADE`
+      );
+      console.log(`   ✓ Dropped table ${schema}.${table_name}`);
+      totalTables++;
+    }
+  }
+  console.log("\n🗑️  Dropping views...");
+  for (const schema of schemas) {
+    const viewResult = await adapter.query(
+      `SELECT table_name FROM information_schema.views WHERE table_schema = $1`,
+      [schema]
+    );
+    const views = Array.isArray(viewResult) ? viewResult : viewResult.rows || [];
+    for (const { table_name } of views) {
+      try {
+        await adapter.query(
+          `DROP VIEW IF EXISTS "${schema}"."${table_name}" CASCADE`
+        );
+        console.log(`   ✓ Dropped view ${schema}.${table_name}`);
+        totalObjects++;
+      } catch {
+      }
+    }
+  }
+  console.log("\n🗑️  Dropping triggers...");
+  for (const schema of schemas) {
+    try {
+      const triggerResult = await adapter.query(
+        `SELECT DISTINCT trigger_name, event_object_table FROM information_schema.triggers WHERE trigger_schema = $1`,
+        [schema]
+      );
+      const triggers = Array.isArray(triggerResult) ? triggerResult : triggerResult.rows || [];
+      for (const { trigger_name, event_object_table } of triggers) {
+        try {
+          await adapter.query(
+            `DROP TRIGGER IF EXISTS "${trigger_name}" ON "${schema}"."${event_object_table}" CASCADE`
+          );
+          console.log(`   ✓ Dropped trigger ${schema}.${trigger_name}`);
+          totalObjects++;
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  console.log("\n🗑️  Dropping functions...");
+  for (const schema of schemas) {
+    try {
+      const funcResult = await adapter.query(
+        `SELECT p.proname, pg_get_function_identity_arguments(p.oid) as args
+         FROM pg_proc p JOIN pg_namespace n ON p.pronamespace = n.oid
+         WHERE n.nspname = $1 AND p.prokind = 'f'`,
+        [schema]
+      );
+      const funcs = Array.isArray(funcResult) ? funcResult : funcResult.rows || [];
+      for (const { proname, args } of funcs) {
+        try {
+          await adapter.query(
+            `DROP FUNCTION IF EXISTS "${schema}"."${proname}"(${args}) CASCADE`
+          );
+          console.log(`   ✓ Dropped function ${schema}.${proname}`);
+          totalObjects++;
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  console.log("\n🗑️  Dropping procedures...");
+  for (const schema of schemas) {
+    try {
+      const procResult = await adapter.query(
+        `SELECT p.proname, pg_get_function_identity_arguments(p.oid) as args
+         FROM pg_proc p JOIN pg_namespace n ON p.pronamespace = n.oid
+         WHERE n.nspname = $1 AND p.prokind = 'p'`,
+        [schema]
+      );
+      const procs = Array.isArray(procResult) ? procResult : procResult.rows || [];
+      for (const { proname, args } of procs) {
+        try {
+          await adapter.query(
+            `DROP PROCEDURE IF EXISTS "${schema}"."${proname}"(${args}) CASCADE`
+          );
+          console.log(`   ✓ Dropped procedure ${schema}.${proname}`);
+          totalObjects++;
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  console.log("\n🗑️  Dropping sequences...");
+  for (const schema of schemas) {
+    try {
+      const seqResult = await adapter.query(
+        `SELECT sequence_name FROM information_schema.sequences WHERE sequence_schema = $1`,
+        [schema]
+      );
+      const sequences = Array.isArray(seqResult) ? seqResult : seqResult.rows || [];
+      for (const { sequence_name } of sequences) {
+        try {
+          await adapter.query(
+            `DROP SEQUENCE IF EXISTS "${schema}"."${sequence_name}" CASCADE`
+          );
+          console.log(`   ✓ Dropped sequence ${schema}.${sequence_name}`);
+          totalObjects++;
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  console.log("\n🗑️  Dropping types...");
+  for (const schema of schemas) {
+    try {
+      const typeResult = await adapter.query(
+        `SELECT t.typname FROM pg_type t
+         JOIN pg_namespace n ON t.typnamespace = n.oid
+         WHERE n.nspname = $1 AND t.typtype = 'e'`,
+        [schema]
+      );
+      const types = Array.isArray(typeResult) ? typeResult : typeResult.rows || [];
+      for (const { typname } of types) {
+        try {
+          await adapter.query(
+            `DROP TYPE IF EXISTS "${schema}"."${typname}" CASCADE`
+          );
+          console.log(`   ✓ Dropped type ${schema}.${typname}`);
+          totalObjects++;
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  console.log("\n🗑️  Dropping domains...");
+  for (const schema of schemas) {
+    try {
+      const domainResult = await adapter.query(
+        `SELECT domain_name FROM information_schema.domains WHERE domain_schema = $1`,
+        [schema]
+      );
+      const domains = Array.isArray(domainResult) ? domainResult : domainResult.rows || [];
+      for (const { domain_name } of domains) {
+        try {
+          await adapter.query(
+            `DROP DOMAIN IF EXISTS "${schema}"."${domain_name}" CASCADE`
+          );
+          console.log(`   ✓ Dropped domain ${schema}.${domain_name}`);
+          totalObjects++;
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  if (dropSchemas) {
+    console.log("\n🗑️  Dropping schemas...");
+    for (const schema of schemas) {
+      if (schema === "public") continue;
+      try {
+        await adapter.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
+        console.log(`   ✓ Dropped schema ${schema}`);
+      } catch {
+        console.log(`   ⚠ Could not drop schema ${schema}`);
+      }
+    }
+  }
+  return { tables: totalTables, objects: totalObjects };
+}
+__name(dropAllObjects, "dropAllObjects");
+program.command("reset").description(
+  "Full database reset: drop all objects from all schemas, optionally run migrations"
+).option("--confirm", "Confirm reset operation").option(
+  "-s, --schemas <schemas>",
+  "Comma-separated list of schemas (default: all user schemas)"
+).option("--drop-schemas", "Also drop schemas themselves (except public)").option("--migrate", "Run migrations after reset").action(async (options) => {
+  if (!options.confirm) {
+    console.error("❌ Please use --confirm flag to confirm reset operation");
+    console.error(
+      "   This will DROP ALL database objects (tables, types, functions, etc.)"
+    );
+    process.exit(1);
+  }
+  try {
+    const { adapter, config } = await initDatabase();
+    if (typeof adapter.query !== "function") {
+      console.error("❌ Reset operation not supported by this adapter");
+      process.exit(1);
+    }
+    console.log("🔄 Resetting database (dropping all objects)...");
+    const schemas = options.schemas ? options.schemas.split(",").map((s) => s.trim()) : await getUserSchemas(adapter);
+    const { tables, objects } = await dropAllObjects(
+      adapter,
+      schemas,
+      options.dropSchemas ?? false
+    );
+    console.log(
+      `
+✅ Reset complete: dropped ${tables} tables, ${objects} other objects`
+    );
+    if (options.migrate) {
+      console.log("\n🔄 Running migrations...");
+      const migrationManager = new MigrationManager({
+        adapter,
+        migrationsPath: config.migrationsPath ?? "./migrations",
+        tableName: config.migrationsTable ?? "schema_migrations"
+      });
+      const result = await migrationManager.up();
+      if (result.success) {
+        console.log(`✅ Applied ${result.value} migration(s)`);
+      } else {
+        console.error("❌ Migration failed:", result.error?.message);
+        process.exit(1);
+      }
+    }
+    process.exit(0);
+  } catch (error) {
+    console.error("❌ Error:", error.message);
+    process.exit(1);
+  }
+});
 program.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map