@db-bridge/core 1.1.7 → 1.2.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 Berke Erdoğan
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2025 Berke Erdoğan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/dist/cli/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { parseArgs } from 'util';
-import { resolve, basename, extname, join } from 'path';
+import { resolve, dirname, basename, extname, join } from 'path';
 import { existsSync } from 'fs';
 import { pathToFileURL } from 'url';
 import { createHash } from 'crypto';
@@ -81,6 +81,11 @@ function applyDefaults(config) {
     seeds: {
       directory: "./src/seeds",
       ...config.seeds
+    },
+    types: {
+      output: "./src/types/database.ts",
+      camelCase: false,
+      ...config.types
     }
   };
 }
@@ -1076,7 +1081,7 @@ var MigrationLock = class {
     }
   }
   sleep(ms) {
-    return new Promise((resolve7) => setTimeout(resolve7, ms));
+    return new Promise((resolve8) => setTimeout(resolve8, ms));
   }
 };
 
@@ -1689,8 +1694,11 @@ var ForeignKeyChain = class {
 var SchemaBuilder = class {
   dialectInstance;
   adapter;
+  collectMode;
+  collectedStatements = [];
   constructor(options) {
     this.adapter = options.adapter;
+    this.collectMode = options.collectMode ?? false;
     switch (options.dialect) {
       case "mysql": {
         this.dialectInstance = new MySQLDialect();
@@ -1796,6 +1804,14 @@ var SchemaBuilder = class {
    * Execute SQL statement
    */
   async execute(sql, params) {
+    if (this.collectMode) {
+      let statement = sql;
+      if (params && params.length > 0) {
+        statement += ` -- params: ${JSON.stringify(params)}`;
+      }
+      this.collectedStatements.push(statement);
+      return;
+    }
     if (this.adapter) {
       await this.adapter.execute(sql, params);
     } else {
@@ -1805,6 +1821,18 @@ var SchemaBuilder = class {
       }
     }
   }
+  /**
+   * Get collected SQL statements (only in collectMode)
+   */
+  getCollectedStatements() {
+    return [...this.collectedStatements];
+  }
+  /**
+   * Clear collected SQL statements
+   */
+  clearCollectedStatements() {
+    this.collectedStatements = [];
+  }
   /**
    * Execute SQL query
    */
@@ -2260,7 +2288,23 @@ var FileMigrationRunner = class {
     const action = direction === "up" ? "Running" : "Rolling back";
     this.options.logger.info(`${action}: ${migration.name}`);
     if (this.options.dryRun) {
-      this.options.logger.info(`DRY RUN: Would ${direction} ${migration.name}`);
+      const schema = new SchemaBuilder({
+        dialect: this.options.dialect,
+        collectMode: true
+      });
+      await migration[direction](schema);
+      const statements = schema.getCollectedStatements();
+      if (statements.length > 0) {
+        this.options.logger.info(`DRY RUN: ${direction.toUpperCase()} ${migration.name}`);
+        this.options.logger.info("SQL statements that would be executed:");
+        for (const sql of statements) {
+          this.options.logger.info(`  ${sql}`);
+        }
+      } else {
+        this.options.logger.info(
+          `DRY RUN: ${direction.toUpperCase()} ${migration.name} (no SQL statements)`
+        );
+      }
       return;
     }
     const transaction = migration.transactional ? await this.adapter.beginTransaction() : null;
@@ -2428,6 +2472,263 @@ async function freshCommand(options = {}) {
   }
 }
 
+// src/types/TypeGenerator.ts
+var SQL_TYPE_MAP = {
+  // Integers
+  tinyint: "number",
+  smallint: "number",
+  mediumint: "number",
+  int: "number",
+  integer: "number",
+  bigint: "number",
+  // Floats
+  float: "number",
+  double: "number",
+  decimal: "number",
+  numeric: "number",
+  real: "number",
+  // Strings
+  char: "string",
+  varchar: "string",
+  tinytext: "string",
+  text: "string",
+  mediumtext: "string",
+  longtext: "string",
+  enum: "string",
+  set: "string",
+  // Binary
+  binary: "Buffer",
+  varbinary: "Buffer",
+  tinyblob: "Buffer",
+  blob: "Buffer",
+  mediumblob: "Buffer",
+  longblob: "Buffer",
+  // Date/Time
+  date: "Date",
+  datetime: "Date",
+  timestamp: "Date",
+  time: "string",
+  year: "number",
+  // Boolean
+  boolean: "boolean",
+  bool: "boolean",
+  // JSON
+  json: "Record<string, unknown>",
+  jsonb: "Record<string, unknown>",
+  // UUID (PostgreSQL)
+  uuid: "string",
+  // Arrays (PostgreSQL)
+  array: "unknown[]"
+};
+var TypeGenerator = class {
+  constructor(adapter, dialect) {
+    this.adapter = adapter;
+    this.dialect = dialect;
+  }
+  /**
+   * Generate TypeScript interfaces from database schema
+   */
+  async generate(options = {}) {
+    const tables = await this.getTables(options);
+    const output = [];
+    if (options.header) {
+      output.push(options.header);
+      output.push("");
+    } else {
+      output.push("/**");
+      output.push(" * Auto-generated TypeScript types from database schema");
+      output.push(` * Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+      output.push(" * DO NOT EDIT - This file is auto-generated");
+      output.push(" */");
+      output.push("");
+    }
+    for (const table of tables) {
+      const tableInfo = await this.getTableInfo(table);
+      const interfaceCode = this.generateInterface(tableInfo, options);
+      output.push(interfaceCode);
+      output.push("");
+    }
+    return output.join("\n");
+  }
+  /**
+   * Get list of tables from database
+   */
+  async getTables(options) {
+    let tables;
+    if (this.dialect === "mysql") {
+      const result = await this.adapter.query(
+        `SELECT table_name FROM information_schema.tables
+         WHERE table_schema = DATABASE() AND table_type = 'BASE TABLE'`
+      );
+      tables = result.rows.map((r) => r["table_name"] || r["TABLE_NAME"]).filter((t) => t !== null && t !== void 0);
+    } else {
+      const result = await this.adapter.query(
+        `SELECT table_name FROM information_schema.tables
+         WHERE table_schema = 'public' AND table_type = 'BASE TABLE'`
+      );
+      tables = result.rows.map((r) => r["table_name"] || r["TABLE_NAME"]).filter((t) => t !== null && t !== void 0);
+    }
+    if (options.tables && options.tables.length > 0) {
+      tables = tables.filter((t) => options.tables.includes(t));
+    }
+    if (options.exclude && options.exclude.length > 0) {
+      tables = tables.filter((t) => !options.exclude.includes(t));
+    }
+    tables = tables.filter((t) => !t.startsWith("db_migrations") && !t.startsWith("db_bridge"));
+    return tables.sort();
+  }
+  /**
+   * Get column information for a table
+   */
+  async getTableInfo(tableName) {
+    let columns;
+    if (this.dialect === "mysql") {
+      columns = await this.getMySQLColumns(tableName);
+    } else {
+      columns = await this.getPostgreSQLColumns(tableName);
+    }
+    return { name: tableName, columns };
+  }
+  /**
+   * Get MySQL column information
+   */
+  async getMySQLColumns(tableName) {
+    const result = await this.adapter.query(`SHOW FULL COLUMNS FROM \`${tableName}\``);
+    return result.rows.map((row) => ({
+      name: row.Field,
+      type: this.parseColumnType(row.Type),
+      nullable: row.Null === "YES",
+      defaultValue: row.Default,
+      isPrimary: row.Key === "PRI",
+      isAutoIncrement: row.Extra.includes("auto_increment"),
+      comment: row.Comment || void 0
+    }));
+  }
+  /**
+   * Get PostgreSQL column information
+   */
+  async getPostgreSQLColumns(tableName) {
+    const result = await this.adapter.query(
+      `
+      SELECT
+        c.column_name,
+        c.data_type,
+        c.is_nullable,
+        c.column_default,
+        c.is_identity,
+        pgd.description
+      FROM information_schema.columns c
+      LEFT JOIN pg_catalog.pg_statio_all_tables st ON c.table_name = st.relname
+      LEFT JOIN pg_catalog.pg_description pgd ON pgd.objoid = st.relid
+        AND pgd.objsubid = c.ordinal_position
+      WHERE c.table_name = $1
+      ORDER BY c.ordinal_position
+    `,
+      [tableName]
+    );
+    return result.rows.map((row) => ({
+      name: row.column_name,
+      type: row.data_type,
+      nullable: row.is_nullable === "YES",
+      defaultValue: row.column_default,
+      isPrimary: false,
+      // Would need additional query
+      isAutoIncrement: row.is_identity === "YES" || (row.column_default?.includes("nextval") ?? false),
+      comment: row.description
+    }));
+  }
+  /**
+   * Parse column type (extract base type from full type string)
+   */
+  parseColumnType(fullType) {
+    const baseType = fullType.toLowerCase().replace(/\(.*\)/, "").trim();
+    return baseType.replace(" unsigned", "");
+  }
+  /**
+   * Map SQL type to TypeScript type
+   */
+  mapType(sqlType, nullable) {
+    const baseType = this.parseColumnType(sqlType);
+    if (sqlType.toLowerCase().includes("tinyint(1)")) {
+      return nullable ? "boolean | null" : "boolean";
+    }
+    const tsType = SQL_TYPE_MAP[baseType] || "unknown";
+    return nullable ? `${tsType} | null` : tsType;
+  }
+  /**
+   * Generate TypeScript interface for a table
+   */
+  generateInterface(table, options) {
+    const lines = [];
+    const interfaceName = this.toInterfaceName(table.name);
+    if (options.includeComments) {
+      lines.push("/**");
+      lines.push(` * ${interfaceName} - ${table.name} table`);
+      lines.push(" */");
+    }
+    lines.push(`export interface ${interfaceName} {`);
+    for (const column of table.columns) {
+      const propertyName = options.camelCase ? this.toCamelCase(column.name) : column.name;
+      const tsType = this.mapType(column.type, column.nullable);
+      const optional = options.optionalNullable && column.nullable ? "?" : "";
+      if (options.includeComments && column.comment) {
+        lines.push(`  /** ${column.comment} */`);
+      }
+      lines.push(`  ${propertyName}${optional}: ${tsType};`);
+    }
+    lines.push("}");
+    return lines.join("\n");
+  }
+  /**
+   * Convert table name to PascalCase interface name
+   */
+  toInterfaceName(tableName) {
+    return tableName.split("_").map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+  }
+  /**
+   * Convert snake_case to camelCase
+   */
+  toCamelCase(name) {
+    return name.replaceAll(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+  }
+};
+
+// src/cli/commands/generate-types.ts
+async function generateTypesCommand(options = {}) {
+  let adapter;
+  try {
+    const config = await loadConfig();
+    adapter = await createAdapterFromConfig(config);
+    info("Generating TypeScript types from database schema...");
+    console.log("");
+    const generator = new TypeGenerator(adapter, config.connection.dialect);
+    const types = await generator.generate({
+      tables: options.tables ? options.tables.split(",").map((t) => t.trim()) : void 0,
+      exclude: options.exclude ? options.exclude.split(",").map((t) => t.trim()) : void 0,
+      camelCase: options.camelCase ?? false,
+      includeComments: options.comments ?? true,
+      optionalNullable: true
+    });
+    const outputPath = resolve(
+      process.cwd(),
+      options.output || config.types?.output || "./src/types/database.ts"
+    );
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, types, "utf8");
+    console.log("");
+    success(`Types generated: ${outputPath}`);
+    const interfaceCount = (types.match(/export interface/g) || []).length;
+    info(`Generated ${interfaceCount} interface(s)`);
+  } catch (error_) {
+    error(error_.message);
+    process.exit(1);
+  } finally {
+    if (adapter) {
+      await adapter.disconnect();
+    }
+  }
+}
+
 // src/cli/commands/latest.ts
 async function latestCommand(options = {}) {
   let adapter;
@@ -2481,20 +2782,61 @@ async function makeCommand(name) {
     process.exit(1);
   }
 }
+var DEFAULT_PRIORITY = 100;
 var SeederLoader = class {
   constructor(directory) {
     this.directory = directory;
   }
   /**
-   * Load all seeder files from directory
+   * Load all seeder files from directory (sorted by priority/dependencies)
    */
   async loadAll() {
     const files = await readdir(this.directory);
-    const seederFiles = files.filter((f) => /\.(ts|js|mjs)$/.test(f) && !f.endsWith(".d.ts")).sort().map((f) => ({
+    const seederPaths = files.filter((f) => /\.(ts|js|mjs)$/.test(f) && !f.endsWith(".d.ts")).map((f) => ({
       name: this.getSeederName(f),
       path: resolve(this.directory, f)
     }));
-    return seederFiles;
+    const seederFiles = [];
+    for (const file of seederPaths) {
+      const seeder = await this.load(file.path);
+      seederFiles.push({
+        name: file.name,
+        path: file.path,
+        priority: seeder.priority ?? DEFAULT_PRIORITY,
+        depends: seeder.depends
+      });
+    }
+    return this.sortByDependencies(seederFiles);
+  }
+  /**
+   * Sort seeders by dependencies (topological sort) then by priority
+   */
+  sortByDependencies(files) {
+    const fileMap = new Map(files.map((f) => [f.name, f]));
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    const visit = (file) => {
+      if (visited.has(file.name)) {
+        return;
+      }
+      visited.add(file.name);
+      if (file.depends) {
+        for (const dep of file.depends) {
+          const depFile = fileMap.get(dep) || fileMap.get(`${dep}_seeder`);
+          if (depFile) {
+            visit(depFile);
+          }
+        }
+      }
+      result.push(file);
+    };
+    const sortedByPriority = [...files].sort(
+      (a, b) => (a.priority ?? DEFAULT_PRIORITY) - (b.priority ?? DEFAULT_PRIORITY)
+    );
+    for (const file of sortedByPriority) {
+      visit(file);
+    }
+    return result;
   }
   /**
    * Load a specific seeder by path
@@ -2536,10 +2878,16 @@ var SeederLoader = class {
 import type { Seeder, DatabaseAdapter } from '@db-bridge/core';
 
 export default {
+  // Priority: lower runs first (default: 100)
+  // priority: 10,
+
+  // Dependencies: seeders that must run before this one
+  // depends: ['users'],
+
   async run(adapter: DatabaseAdapter): Promise<void> {
     // Insert seed data
     // await adapter.execute(\`
-    //   INSERT INTO users (name, email) VALUES
+    //   INSERT INTO ${name} (name, email) VALUES
     //   ('John Doe', 'john@example.com'),
     //   ('Jane Doe', 'jane@example.com')
     // \`);
@@ -2874,12 +3222,20 @@ Seed Commands:
   db:seed                 Run database seeders
   db:seed --class=<name>  Run a specific seeder
 
+Type Generation:
+  generate:types          Generate TypeScript interfaces from schema
+
 Options:
   --help, -h              Show this help message
   --version, -v           Show version number
   --dry-run               Show what would be done without executing
   --step=<n>              Number of batches to rollback (for rollback command)
   --class=<name>          Specific seeder class to run (for db:seed)
+  --output=<path>         Output file path (for generate:types)
+  --tables=<list>         Comma-separated list of tables to include
+  --exclude=<list>        Comma-separated list of tables to exclude
+  --camel-case            Use camelCase for property names
+  --comments              Include JSDoc comments (default: true)
 
 Examples:
   db-bridge migrate:make create_users_table
@@ -2888,6 +3244,8 @@ Examples:
   db-bridge make:seeder users
   db-bridge db:seed
   db-bridge db:seed --class=users
+  db-bridge generate:types
+  db-bridge generate:types --output=./src/types/db.ts --camel-case
 `;
 async function main() {
   const args = process.argv.slice(2);
@@ -2902,7 +3260,12 @@ async function main() {
         version: { type: "boolean", short: "v" },
         "dry-run": { type: "boolean" },
         step: { type: "string" },
-        class: { type: "string" }
+        class: { type: "string" },
+        output: { type: "string" },
+        tables: { type: "string" },
+        exclude: { type: "string" },
+        "camel-case": { type: "boolean" },
+        comments: { type: "boolean" }
       },
       allowPositionals: true
     });
@@ -2911,7 +3274,12 @@ async function main() {
       version: values.version,
       dryRun: values["dry-run"],
       step: values.step ? parseInt(values.step, 10) : void 0,
-      class: values.class
+      class: values.class,
+      output: values.output,
+      tables: values.tables,
+      exclude: values.exclude,
+      camelCase: values["camel-case"],
+      comments: values.comments
     };
     command = positionals[0] || "";
     commandArgs = positionals.slice(1);
@@ -2921,6 +3289,8 @@ async function main() {
     options.help = args.includes("--help") || args.includes("-h");
     options.version = args.includes("--version") || args.includes("-v");
     options.dryRun = args.includes("--dry-run");
+    options.camelCase = args.includes("--camel-case");
+    options.comments = args.includes("--comments");
     const stepArg = args.find((a) => a.startsWith("--step="));
     if (stepArg) {
       options.step = parseInt(stepArg.split("=")[1] || "1", 10);
@@ -2929,6 +3299,18 @@ async function main() {
     if (classArg) {
       options.class = classArg.split("=")[1];
     }
+    const outputArg = args.find((a) => a.startsWith("--output="));
+    if (outputArg) {
+      options.output = outputArg.split("=")[1];
+    }
+    const tablesArg = args.find((a) => a.startsWith("--tables="));
+    if (tablesArg) {
+      options.tables = tablesArg.split("=")[1];
+    }
+    const excludeArg = args.find((a) => a.startsWith("--exclude="));
+    if (excludeArg) {
+      options.exclude = excludeArg.split("=")[1];
+    }
   }
   if (options.help || command === "help") {
     console.log(HELP);
@@ -2990,6 +3372,16 @@ async function main() {
         await seedCommand({ class: options.class });
         break;
       }
+      case "generate:types": {
+        await generateTypesCommand({
+          output: options.output,
+          tables: options.tables,
+          exclude: options.exclude,
+          camelCase: options.camelCase,
+          comments: options.comments
+        });
+        break;
+      }
       default: {
         console.error(`Unknown command: ${command}`);
         console.log('Run "db-bridge --help" for usage information.');