outlet-orm 4.2.1 → 5.5.1

package/{lib → src}/Schema/Schema.js

@@ -3,6 +3,17 @@
  * Provides a fluent interface for creating and modifying database tables
  */
 
+function quoteIdentifier(identifier) {
+  if (!identifier || typeof identifier !== 'string') {
+    throw new Error('Invalid SQL identifier');
+  }
+  // Strict allowlist: only alphanumeric and underscore — no fallback, no blocklist.
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(identifier)) {
+    throw new Error('Invalid SQL identifier');
+  }
+  return `\`${identifier}\``;
+}
+
 class Schema {
   constructor(connection) {
     this.connection = connection;
@@ -51,16 +62,16 @@ class Schema {
     let sql;
 
     switch (driver) {
-      case 'mysql':
-        sql = `RENAME TABLE ${from} TO ${to}`;
-        break;
-      case 'postgres':
-      case 'postgresql':
-      case 'sqlite':
-        sql = `ALTER TABLE ${from} RENAME TO ${to}`;
-        break;
-      default:
-        throw new Error(`Unsupported driver: ${driver}`);
+    case 'mysql':
+      sql = `RENAME TABLE ${quoteIdentifier(from)} TO ${quoteIdentifier(to)}`;
+      break;
+    case 'postgres':
+    case 'postgresql':
+    case 'sqlite':
+      sql = `ALTER TABLE ${quoteIdentifier(from)} RENAME TO ${quoteIdentifier(to)}`;
+      break;
+    default:
+      throw new Error(`Unsupported driver: ${driver}`);
     }
 
     await this.connection.execute(sql);
@@ -72,7 +83,7 @@ class Schema {
    * @param {string} tableName
    */
   async drop(tableName) {
-    const sql = `DROP TABLE ${tableName}`;
+    const sql = `DROP TABLE ${quoteIdentifier(tableName)}`;
     await this.connection.execute(sql);
     console.log(`✓ Table '${tableName}' dropped successfully`);
   }
@@ -82,7 +93,7 @@ class Schema {
    * @param {string} tableName
    */
   async dropIfExists(tableName) {
-    const sql = `DROP TABLE IF EXISTS ${tableName}`;
+    const sql = `DROP TABLE IF EXISTS ${quoteIdentifier(tableName)}`;
     await this.connection.execute(sql);
     console.log(`✓ Table '${tableName}' dropped if existed`);
   }
@@ -95,26 +106,30 @@ class Schema {
   async hasTable(tableName) {
     const driver = this.connection.config.driver;
     let sql;
+    let params = [];
 
     switch (driver) {
-      case 'mysql':
-        sql = `SELECT COUNT(*) as count FROM information_schema.tables
-               WHERE table_schema = DATABASE() AND table_name = '${tableName}'`;
-        break;
-      case 'postgres':
-      case 'postgresql':
-        sql = `SELECT COUNT(*) as count FROM information_schema.tables
-               WHERE table_schema = 'public' AND table_name = '${tableName}'`;
-        break;
-      case 'sqlite':
-        sql = `SELECT COUNT(*) as count FROM sqlite_master
-               WHERE type='table' AND name='${tableName}'`;
-        break;
-      default:
-        throw new Error(`Unsupported driver: ${driver}`);
+    case 'mysql':
+      sql = `SELECT COUNT(*) as count FROM information_schema.tables
+               WHERE table_schema = DATABASE() AND table_name = ?`;
+      params = [tableName];
+      break;
+    case 'postgres':
+    case 'postgresql':
+      sql = `SELECT COUNT(*) as count FROM information_schema.tables
+               WHERE table_schema = 'public' AND table_name = $1`;
+      params = [tableName];
+      break;
+    case 'sqlite':
+      sql = `SELECT COUNT(*) as count FROM sqlite_master
+               WHERE type='table' AND name=?`;
+      params = [tableName];
+      break;
+    default:
+      throw new Error(`Unsupported driver: ${driver}`);
     }
 
-    const result = await this.connection.execute(sql);
+    const result = await this.connection.execute(sql, params);
     return result[0].count > 0;
   }
 
@@ -127,30 +142,34 @@ class Schema {
   async hasColumn(tableName, columnName) {
     const driver = this.connection.config.driver;
     let sql;
+    let params = [];
 
     switch (driver) {
-      case 'mysql':
-        sql = `SELECT COUNT(*) as count FROM information_schema.columns
+    case 'mysql':
+      sql = `SELECT COUNT(*) as count FROM information_schema.columns
                WHERE table_schema = DATABASE()
-               AND table_name = '${tableName}'
-               AND column_name = '${columnName}'`;
-        break;
-      case 'postgres':
-      case 'postgresql':
-        sql = `SELECT COUNT(*) as count FROM information_schema.columns
+               AND table_name = ?
+               AND column_name = ?`;
+      params = [tableName, columnName];
+      break;
+    case 'postgres':
+    case 'postgresql':
+      sql = `SELECT COUNT(*) as count FROM information_schema.columns
                WHERE table_schema = 'public'
-               AND table_name = '${tableName}'
-               AND column_name = '${columnName}'`;
-        break;
-      case 'sqlite':
-        sql = `SELECT COUNT(*) as count FROM pragma_table_info('${tableName}')
-               WHERE name = '${columnName}'`;
-        break;
-      default:
-        throw new Error(`Unsupported driver: ${driver}`);
+               AND table_name = $1
+               AND column_name = $2`;
+      params = [tableName, columnName];
+      break;
+    case 'sqlite':
+      sql = `SELECT COUNT(*) as count FROM pragma_table_info(?)
+               WHERE name = ?`;
+      params = [tableName, columnName];
+      break;
+    default:
+      throw new Error(`Unsupported driver: ${driver}`);
     }
 
-    const result = await this.connection.execute(sql);
+    const result = await this.connection.execute(sql, params);
     return result[0].count > 0;
   }
 }
@@ -333,6 +352,12 @@ class Blueprint {
     const column = new ColumnDefinition(columnName, 'BIGINT');
     column.unsigned();
     this.columns.push(column);
+
+    column.constrained = (table = null) => {
+      const foreignKey = this.foreign(columnName);
+      return foreignKey.constrained(table);
+    };
+
     return column;
   }
 
@@ -453,7 +478,7 @@ class Blueprint {
     const columnDefinitions = this.columns.map(col => col.toSql(driver)).join(',\n  ');
     const constraints = this.getConstraints();
 
-    let sql = `CREATE TABLE ${this.tableName} (\n  ${columnDefinitions}`;
+    let sql = `CREATE TABLE ${quoteIdentifier(this.tableName)} (\n  ${columnDefinitions}`;
 
     if (constraints) {
       sql += `,\n  ${constraints}`;
@@ -474,61 +499,65 @@ class Blueprint {
     // Add new columns
     const driver = this.connection.config.driver;
     for (const column of this.columns) {
-      let sql = `ALTER TABLE ${this.tableName} ADD COLUMN ${column.toSql(driver)}`;
+      let sql = `ALTER TABLE ${quoteIdentifier(this.tableName)} ADD COLUMN ${column.toSql(driver)}`;
       statements.push(sql);
     }
 
     // Process commands
     for (const command of this.commands) {
       switch (command.type) {
-        case 'dropColumn':
-          for (const col of command.columns) {
-            statements.push(`ALTER TABLE ${this.tableName} DROP COLUMN ${col}`);
-          }
-          break;
-
-        case 'renameColumn':
-          statements.push(`ALTER TABLE ${this.tableName} CHANGE ${command.from} ${command.to}`);
-          break;
-
-        case 'foreign': {
-          const fk = command.foreignKey;
-          statements.push(
-            `ALTER TABLE ${this.tableName} ADD CONSTRAINT ${fk.name} ` +
-            `FOREIGN KEY (${fk.column}) REFERENCES ${fk.references.table}(${fk.references.column})` +
-            (fk.onDelete ? ` ON DELETE ${fk.onDelete}` : '') +
-            (fk.onUpdate ? ` ON UPDATE ${fk.onUpdate}` : '')
-          );
-          break;
+      case 'dropColumn':
+        for (const col of command.columns) {
+          statements.push(`ALTER TABLE ${quoteIdentifier(this.tableName)} DROP COLUMN ${quoteIdentifier(col)}`);
         }
+        break;
 
-        case 'dropForeign': {
-          const fkName = `${this.tableName}_${command.columns.join('_')}_foreign`;
-          statements.push(`ALTER TABLE ${this.tableName} DROP FOREIGN KEY ${fkName}`);
-          break;
+      case 'renameColumn':
+        if (driver === 'mysql') {
+          statements.push(`ALTER TABLE ${quoteIdentifier(this.tableName)} RENAME COLUMN ${quoteIdentifier(command.from)} TO ${quoteIdentifier(command.to)}`);
+        } else {
+          statements.push(`ALTER TABLE ${quoteIdentifier(this.tableName)} RENAME COLUMN ${quoteIdentifier(command.from)} TO ${quoteIdentifier(command.to)}`);
         }
+        break;
+
+      case 'foreign': {
+        const fk = command.foreignKey;
+        statements.push(
+          `ALTER TABLE ${quoteIdentifier(this.tableName)} ADD CONSTRAINT ${quoteIdentifier(fk.name)} ` +
+            `FOREIGN KEY (${quoteIdentifier(fk.column)}) REFERENCES ${quoteIdentifier(fk._ref.table)}(${quoteIdentifier(fk._ref.column)})` +
+            (fk._onDelete ? ` ON DELETE ${fk._onDelete}` : '') +
+            (fk._onUpdate ? ` ON UPDATE ${fk._onUpdate}` : '')
+        );
+        break;
+      }
+
+      case 'dropForeign': {
+        const fkName = `${this.tableName}_${command.columns.join('_')}_foreign`;
+        statements.push(`ALTER TABLE ${quoteIdentifier(this.tableName)} DROP FOREIGN KEY ${quoteIdentifier(fkName)}`);
+        break;
+      }
 
-        case 'index':
-          statements.push(
-            `ALTER TABLE ${this.tableName} ADD INDEX ${command.name} (${command.columns.join(', ')})`
-          );
-          break;
-
-        case 'unique':
-          statements.push(
-            `ALTER TABLE ${this.tableName} ADD UNIQUE ${command.name} (${command.columns.join(', ')})`
-          );
-          break;
-
-        case 'fulltext':
-          statements.push(
-            `ALTER TABLE ${this.tableName} ADD FULLTEXT ${command.name} (${command.columns.join(', ')})`
-          );
-          break;
-
-        case 'dropIndex':
-          statements.push(`ALTER TABLE ${this.tableName} DROP INDEX ${command.name}`);
-          break;
+      case 'index':
+        statements.push(
+          `ALTER TABLE ${quoteIdentifier(this.tableName)} ADD INDEX ${quoteIdentifier(command.name)} (${command.columns.map(c => quoteIdentifier(c)).join(', ')})`
+        );
+        break;
+
+      case 'unique':
+        statements.push(
+          `ALTER TABLE ${quoteIdentifier(this.tableName)} ADD UNIQUE ${quoteIdentifier(command.name)} (${command.columns.map(c => quoteIdentifier(c)).join(', ')})`
+        );
+        break;
+
+      case 'fulltext':
+        statements.push(
+          `ALTER TABLE ${quoteIdentifier(this.tableName)} ADD FULLTEXT ${quoteIdentifier(command.name)} (${command.columns.map(c => quoteIdentifier(c)).join(', ')})`
+        );
+        break;
+
+      case 'dropIndex':
+        statements.push(`ALTER TABLE ${quoteIdentifier(this.tableName)} DROP INDEX ${quoteIdentifier(command.name)}`);
+        break;
       }
     }
 
@@ -548,7 +577,7 @@ class Blueprint {
     // so skip table-level PRIMARY KEY constraints to avoid duplication.
     const hasSqliteAutoInc = driver === 'sqlite' && this.columns.some(col => col.isAutoIncrement);
     if (primaryKeys.length > 0 && !hasSqliteAutoInc) {
-      const pkColumns = primaryKeys.map(col => col.name).join(', ');
+      const pkColumns = primaryKeys.map(col => quoteIdentifier(col.name)).join(', ');
       constraints.push(`PRIMARY KEY (${pkColumns})`);
     }
 
@@ -556,26 +585,26 @@ class Blueprint {
     for (const command of this.commands) {
       if (command.type === 'foreign') {
         const fk = command.foreignKey;
-        let constraint = `CONSTRAINT ${fk.name} FOREIGN KEY (${fk.column}) ` +
-                        `REFERENCES ${fk.references.table}(${fk.references.column})`;
+        let constraint = `CONSTRAINT ${quoteIdentifier(fk.name)} FOREIGN KEY (${quoteIdentifier(fk.column)}) ` +
+                        `REFERENCES ${quoteIdentifier(fk._ref.table)}(${quoteIdentifier(fk._ref.column)})`;
 
-        if (fk.onDelete) {
-          constraint += ` ON DELETE ${fk.onDelete}`;
+        if (fk._onDelete) {
+          constraint += ` ON DELETE ${fk._onDelete}`;
         }
-        if (fk.onUpdate) {
-          constraint += ` ON UPDATE ${fk.onUpdate}`;
+        if (fk._onUpdate) {
+          constraint += ` ON UPDATE ${fk._onUpdate}`;
         }
 
         constraints.push(constraint);
       } else if (command.type === 'unique') {
         if (driver === 'sqlite') {
-          constraints.push(`UNIQUE (${command.columns.join(', ')})`);
+          constraints.push(`UNIQUE (${command.columns.map(c => quoteIdentifier(c)).join(', ')})`);
         } else {
-          constraints.push(`UNIQUE KEY ${command.name} (${command.columns.join(', ')})`);
+          constraints.push(`UNIQUE KEY ${quoteIdentifier(command.name)} (${command.columns.map(c => quoteIdentifier(c)).join(', ')})`);
         }
       } else if (command.type === 'index') {
         if (driver !== 'sqlite') {
-          constraints.push(`KEY ${command.name} (${command.columns.join(', ')})`);
+          constraints.push(`KEY ${quoteIdentifier(command.name)} (${command.columns.map(c => quoteIdentifier(c)).join(', ')})`);
         }
       }
     }
@@ -664,7 +693,7 @@ class ColumnDefinition {
    * Generate SQL for this column
    */
   toSql(driver = 'mysql') {
-    let sql = `${this.name} ${this.getTypeDefinition(driver)}`;
+    let sql = `${quoteIdentifier(this.name)} ${this.getTypeDefinition(driver)}`;
 
     if (this.isUnsigned && ['INT', 'BIGINT', 'TINYINT'].includes(this.type) && driver !== 'sqlite') {
       sql += ' UNSIGNED';
@@ -677,7 +706,7 @@ class ColumnDefinition {
     if (this.isAutoIncrement) {
       if (driver === 'sqlite') {
         // In SQLite, autoincrement must be declared as INTEGER PRIMARY KEY AUTOINCREMENT
-        sql = `${this.name} INTEGER PRIMARY KEY AUTOINCREMENT`;
+        sql = `${quoteIdentifier(this.name)} INTEGER PRIMARY KEY AUTOINCREMENT`;
       } else {
         sql += ' AUTO_INCREMENT';
       }
@@ -698,7 +727,7 @@ class ColumnDefinition {
     }
 
     if (this.commentText) {
-      sql += ` COMMENT '${this.commentText}'`;
+      sql += ` COMMENT '${this.commentText.replace(/'/g, '\'\'')}'`;
     }
 
     return sql;
@@ -718,7 +747,7 @@ class ColumnDefinition {
       return precision ? `FLOAT(${precision}, ${scale})` : 'FLOAT';
     case 'ENUM': {
       if (driver === 'sqlite') return 'TEXT';
-      const enumValues = values.map(v => `'${v}'`).join(', ');
+      const enumValues = values.map(v => `'${v.replace(/'/g, '\'\'')}'`).join(', ');
       return `ENUM(${enumValues})`;
     }
     default:
@@ -728,7 +757,7 @@ class ColumnDefinition {
 
   formatDefaultValue() {
     if (typeof this.defaultValue === 'string') {
-      return `'${this.defaultValue}'`;
+      return `'${this.defaultValue.replace(/'/g, '\'\'')}'`;
     }
     return this.defaultValue;
   }
@@ -740,41 +769,52 @@ class ColumnDefinition {
 class ForeignKeyDefinition {
   constructor(column) {
     this.column = column;
-    this.references = { table: null, column: 'id' };
-    this.onDelete = null;
-    this.onUpdate = null;
+    this._ref = { table: null, column: 'id' };
+    this._onDelete = null;
+    this._onUpdate = null;
     this.name = null;
   }
 
   references(column) {
-    this.references.column = column;
+    this._ref.column = column;
     return this;
   }
 
   on(table) {
-    this.references.table = table;
+    this._ref.table = table;
     this.name = `${table}_${this.column}_foreign`;
     return this;
   }
 
   constrained(table = null) {
     if (table) {
-      this.references.table = table;
+      this._ref.table = table;
     } else {
       // Infer table name from column name (remove _id suffix)
-      this.references.table = this.column.replace(/_id$/, '') + 's';
+      const pluralize = require('pluralize');
+      this._ref.table = pluralize(this.column.replace(/_id$/, ''));
     }
-    this.name = `${this.references.table}_${this.column}_foreign`;
+    this.name = `${this._ref.table}_${this.column}_foreign`;
     return this;
   }
 
   onDelete(action) {
-    this.onDelete = action.toUpperCase();
+    const ALLOWED_FK_ACTIONS = ['CASCADE', 'RESTRICT', 'SET NULL', 'NO ACTION', 'SET DEFAULT'];
+    const normalized = action.toUpperCase();
+    if (!ALLOWED_FK_ACTIONS.includes(normalized)) {
+      throw new Error(`Invalid foreign key action: "${normalized}". Allowed: ${ALLOWED_FK_ACTIONS.join(', ')}`);
+    }
+    this._onDelete = normalized;
     return this;
   }
 
   onUpdate(action) {
-    this.onUpdate = action.toUpperCase();
+    const ALLOWED_FK_ACTIONS = ['CASCADE', 'RESTRICT', 'SET NULL', 'NO ACTION', 'SET DEFAULT'];
+    const normalized = action.toUpperCase();
+    if (!ALLOWED_FK_ACTIONS.includes(normalized)) {
+      throw new Error(`Invalid foreign key action: "${normalized}". Allowed: ${ALLOWED_FK_ACTIONS.join(', ')}`);
+    }
+    this._onUpdate = normalized;
     return this;
   }
 

package/src/Seeders/Seeder.js

@@ -0,0 +1,60 @@
+/**
+ * Base Seeder Class
+ * All seeders should extend this class
+ */
+
+function assertTableName(table) {
+  if (typeof table !== 'string' || !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
+    throw new Error(`Invalid table name: "${table}"`);
+  }
+  return table;
+}
+
+class Seeder {
+  constructor(connection, manager = null) {
+    this.connection = connection;
+    this.manager = manager;
+  }
+
+  async run() {
+    throw new Error('Seeder run() method must be implemented');
+  }
+
+  async call(seeder) {
+    if (!this.manager) {
+      throw new Error('Seeder manager is required to call nested seeders');
+    }
+    await this.manager.runSeeder(seeder);
+  }
+
+  async insert(table, rows) {
+    const safeTable = assertTableName(table);
+
+    if (Array.isArray(rows)) {
+      if (rows.length === 0) return { affectedRows: 0 };
+      return await this.connection.insertMany(safeTable, rows);
+    }
+
+    return await this.connection.insert(safeTable, rows);
+  }
+
+  async truncate(table) {
+    const safeTable = assertTableName(table);
+    const driver = this.connection?.config?.driver;
+
+    switch (driver) {
+    case 'mysql':
+      await this.connection.execute(`TRUNCATE TABLE ${safeTable}`);
+      break;
+    case 'postgres':
+    case 'postgresql':
+    case 'sqlite':
+      await this.connection.execute(`DELETE FROM ${safeTable}`);
+      break;
+    default:
+      throw new Error(`Unsupported driver for truncate: ${driver}`);
+    }
+  }
+}
+
+module.exports = Seeder;

package/src/Seeders/SeederManager.js

@@ -0,0 +1,105 @@
+const fs = require('fs').promises;
+const path = require('path');
+
+class SeederManager {
+  constructor(connection, seedsPath = './database/seeds') {
+    this.connection = connection;
+    this.seedsPath = path.resolve(process.cwd(), seedsPath);
+  }
+
+  async run(target = null) {
+    const files = await this.getSeederFiles();
+
+    if (files.length === 0) {
+      console.log('✓ No seeders found');
+      return;
+    }
+
+    const toRun = this.filterTargetSeeders(files, target);
+
+    if (toRun.length === 0) {
+      throw new Error(`Seeder not found: ${target}`);
+    }
+
+    console.log(`Running ${toRun.length} seeder(s)...\n`);
+
+    for (const file of toRun) {
+      await this.runSeeder(file);
+    }
+
+    console.log('\n✓ Seeding completed successfully');
+  }
+
+  filterTargetSeeders(files, target) {
+    if (!target) {
+      const databaseSeeder = files.find(file => file.toLowerCase() === 'databaseseeder.js');
+      return databaseSeeder ? [databaseSeeder] : files;
+    }
+
+    const normalizedTarget = String(target).toLowerCase();
+
+    return files.filter((file) => {
+      const base = path.basename(file, '.js').toLowerCase();
+      return file.toLowerCase() === normalizedTarget
+        || base === normalizedTarget
+        || `${base}.js` === normalizedTarget;
+    });
+  }
+
+  async runSeeder(seederRef) {
+    const seederPath = this.resolveSeederPath(seederRef);
+
+    try {
+      delete require.cache[require.resolve(seederPath)];
+      const ExportedSeeder = require(seederPath);
+      const SeederClass = ExportedSeeder?.default || ExportedSeeder;
+
+      if (typeof SeederClass !== 'function') {
+        throw new Error('Seeder module must export a class');
+      }
+
+      const seeder = new SeederClass(this.connection, this);
+
+      if (typeof seeder.run !== 'function') {
+        throw new Error('Seeder class must implement run()');
+      }
+
+      await seeder.run();
+      console.log(`✓ ${path.basename(seederPath)}`);
+    } catch (error) {
+      console.error(`✗ Failed to run seeder: ${path.basename(seederPath)}`);
+      console.error(error.message);
+      throw error;
+    }
+  }
+
+  resolveSeederPath(seederRef) {
+    if (typeof seederRef !== 'string') {
+      throw new Error('Seeder reference must be a file path or filename string');
+    }
+
+    if (path.isAbsolute(seederRef)) {
+      return seederRef;
+    }
+
+    const hasExt = path.extname(seederRef) === '.js';
+    const fileName = hasExt ? seederRef : `${seederRef}.js`;
+    return path.join(this.seedsPath, fileName);
+  }
+
+  async getSeederFiles() {
+    try {
+      const files = await fs.readdir(this.seedsPath);
+      return files
+        .filter(file => file.endsWith('.js'))
+        .sort();
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return [];
+      }
+      throw error;
+    }
+  }
+}
+
+module.exports = SeederManager;

package/src/index.js

@@ -14,10 +14,20 @@ const MorphOneRelation = require('./Relations/MorphOneRelation');
 const MorphManyRelation = require('./Relations/MorphManyRelation');
 const MorphToRelation = require('./Relations/MorphToRelation');
 
+// Schema & Migrations (v5.0.0 - moved from lib/)
+const { Schema, Blueprint, ColumnDefinition, ForeignKeyDefinition } = require('./Schema/Schema');
+const Migration = require('./Migrations/Migration');
+const MigrationManager = require('./Migrations/MigrationManager');
+const Seeder = require('./Seeders/Seeder');
+const SeederManager = require('./Seeders/SeederManager');
+
 module.exports = {
+  // Core
   Model,
   QueryBuilder,
   DatabaseConnection,
+
+  // Relations
   Relation,
   HasOneRelation,
   HasManyRelation,
@@ -27,5 +37,19 @@ module.exports = {
   HasOneThroughRelation,
   MorphOneRelation,
   MorphManyRelation,
-  MorphToRelation
+  MorphToRelation,
+
+  // Schema Builder (v5.0.0)
+  Schema,
+  Blueprint,
+  ColumnDefinition,
+  ForeignKeyDefinition,
+
+  // Migrations (v5.0.0)
+  Migration,
+  MigrationManager,
+
+  // Seeders
+  Seeder,
+  SeederManager
 };

package/types/index.d.ts

@@ -657,4 +657,18 @@ declare module 'outlet-orm' {
     static hasTable(name: string): Promise<boolean>;
     static hasColumn(table: string, column: string): Promise<boolean>;
   }
+
+  export class Seeder {
+    constructor(connection: DatabaseConnection, manager?: SeederManager | null);
+    run(): Promise<void>;
+    call(seeder: string): Promise<void>;
+    insert(table: string, rows: Record<string, any> | Record<string, any>[]): Promise<any>;
+    truncate(table: string): Promise<void>;
+  }
+
+  export class SeederManager {
+    constructor(connection: DatabaseConnection, seedsPath?: string);
+    run(target?: string | null): Promise<void>;
+    runSeeder(seederRef: string): Promise<void>;
+  }
 }

package/lib/Database/DatabaseConnection.js

@@ -1,4 +0,0 @@
-// Re-export DatabaseConnection from src for CLI usage (named export for destructuring)
-module.exports = {
-  DatabaseConnection: require('../../src/DatabaseConnection')
-};