outlet-orm 2.5.0

package/bin/init.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+/**
+ * Script d'initialisation pour le package ORM
+ * Ce script aide à configurer rapidement un projet avec l'ORM
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+const question = (query) => new Promise((resolve) => rl.question(query, resolve));
+
+async function init() {
+  console.log('\n🚀 Bienvenue dans l\'assistant de configuration Outlet ORM!\n');
+
+  try {
+    // Database driver
+    console.log('Quel driver de base de données souhaitez-vous utiliser?');
+    console.log('1. MySQL');
+    console.log('2. PostgreSQL');
+    console.log('3. SQLite');
+    const driverChoice = await question('\nVotre choix (1-3): ');
+
+    const drivers = {
+      '1': { name: 'mysql', package: 'mysql2', defaultPort: 3306 },
+      '2': { name: 'postgres', package: 'pg', defaultPort: 5432 },
+      '3': { name: 'sqlite', package: 'sqlite3', defaultPort: null }
+    };
+
+    const selectedDriver = drivers[driverChoice];
+    if (!selectedDriver) {
+      console.error('❌ Choix invalide!');
+      process.exit(1);
+    }
+
+    // Database configuration
+    let config = {
+      driver: selectedDriver.name
+    };
+
+    if (selectedDriver.name !== 'sqlite') {
+      config.host = await question('Host (localhost): ') || 'localhost';
+      config.port = await question(`Port (${selectedDriver.defaultPort}): `) || selectedDriver.defaultPort;
+      config.database = await question('Nom de la base de données: ');
+      config.user = await question('Utilisateur: ');
+      config.password = await question('Mot de passe: ');
+    } else {
+      config.database = await question('Chemin du fichier SQLite (./database.sqlite): ') || './database.sqlite';
+    }
+
+    // Ask to generate a .env file
+    const generateEnv = (await question('\nSouhaitez-vous générer un fichier .env avec ces paramètres ? (oui/non) [oui]: ')).trim().toLowerCase();
+    const wantEnv = generateEnv === '' || generateEnv === 'oui' || generateEnv === 'o' || generateEnv === 'yes' || generateEnv === 'y';
+
+    if (wantEnv) {
+      const envLines = [];
+      envLines.push(`DB_DRIVER=${config.driver}`);
+      if (config.driver !== 'sqlite') {
+        envLines.push(`DB_HOST=${config.host || 'localhost'}`);
+        envLines.push(`DB_PORT=${config.port || selectedDriver.defaultPort || ''}`);
+        envLines.push(`DB_USER=${config.user || ''}`);
+        envLines.push(`DB_PASSWORD=${config.password || ''}`);
+        envLines.push(`DB_DATABASE=${config.database || ''}`);
+      } else {
+        envLines.push(`DB_FILE=${config.database}`);
+      }
+
+      const envPath = path.join(process.cwd(), '.env');
+      if (fs.existsSync(envPath)) {
+        console.log('ℹ️  .env existe déjà, génération ignorée.');
+      } else {
+        fs.writeFileSync(envPath, envLines.join('\n') + '\n');
+        console.log(`✅ Fichier .env créé: ${envPath}`);
+      }
+    }
+
+    // Generate config file
+    const configContent = `const { DatabaseConnection } = require('outlet-orm');
+
+// Configuration de la base de données
+const db = new DatabaseConnection(${JSON.stringify(config, null, 2)});
+
+module.exports = db;
+`;
+
+    const configPath = path.join(process.cwd(), 'database.js');
+    fs.writeFileSync(configPath, configContent);
+    console.log(`\n✅ Fichier de configuration créé: ${configPath}`);
+
+    // Generate example model
+    const modelContent = `const { Model } = require('outlet-orm');
+const db = require('./database');
+
+class User extends Model {
+  static table = 'users';
+  static fillable = ['name', 'email', 'password'];
+  static hidden = ['password'];
+  static casts = {
+    id: 'int',
+    email_verified: 'boolean'
+  };
+  static connection = db;
+
+  // Définissez vos relations ici
+  // posts() {
+  //   return this.hasMany(Post, 'user_id');
+  // }
+}
+
+module.exports = User;
+`;
+
+    const modelPath = path.join(process.cwd(), 'User.js');
+    fs.writeFileSync(modelPath, modelContent);
+    console.log(`✅ Modèle exemple créé: ${modelPath}`);
+
+    // Generate usage example
+    const usageContent = `const User = require('./User');
+
+async function main() {
+  try {
+    // Exemple: Créer un utilisateur
+    const user = await User.create({
+      name: 'John Doe',
+      email: 'john@example.com',
+      password: 'secret123'
+    });
+    console.log('Utilisateur créé:', user.toJSON());
+
+    // Exemple: Rechercher des utilisateurs
+    const users = await User.all();
+    console.log('Tous les utilisateurs:', users.length);
+
+    // Exemple: Requête avec conditions
+    const activeUsers = await User
+      .where('status', 'active')
+      .orderBy('name')
+      .get();
+    console.log('Utilisateurs actifs:', activeUsers.length);
+
+  } catch (error) {
+    console.error('Erreur:', error.message);
+  }
+}
+
+main();
+`;
+
+    const usagePath = path.join(process.cwd(), 'example.js');
+    fs.writeFileSync(usagePath, usageContent);
+    console.log(`✅ Exemple d'utilisation créé: ${usagePath}`);
+
+    // Optionally skip package init/install in non-interactive or test context
+    const skipInstall = process.env.OUTLET_INIT_NO_INSTALL === '1';
+    if (!skipInstall) {
+      // Check if package needs to be installed
+      const packageJsonPath = path.join(process.cwd(), 'package.json');
+      if (!fs.existsSync(packageJsonPath)) {
+        console.log('\n⚠️  Aucun package.json trouvé. Initialisation...');
+        require('child_process').execSync('npm init -y', { stdio: 'inherit' });
+      }
+
+      console.log(`\n📦 Installation du driver ${selectedDriver.package}...`);
+      require('child_process').execSync(`npm install ${selectedDriver.package}`, { stdio: 'inherit' });
+    } else {
+      console.log('\n⏭️  Installation du driver ignorée (OUTLET_INIT_NO_INSTALL=1).');
+    }
+
+    console.log('\n✨ Configuration terminée!\n');
+    console.log('Prochaines étapes:');
+    console.log('1. Créez votre schéma de base de données');
+    console.log('2. Modifiez User.js selon vos besoins');
+    console.log('3. Exécutez example.js: node example.js');
+    console.log('\n📚 Documentation: https://github.com/yourusername/outlet-orm');
+
+  } catch (error) {
+    console.error('\n❌ Erreur:', error.message);
+    process.exit(1);
+  } finally {
+    rl.close();
+  }
+}
+
+init();

package/bin/migrate.js

@@ -0,0 +1,442 @@
+#!/usr/bin/env node
+
+/**
+ * outlet-migrate CLI
+ * Migration management tool for outlet-orm
+ */
+
+const readline = require('readline');
+const fs = require('fs').promises;
+const path = require('path');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+function question(query) {
+  return new Promise(resolve => rl.question(query, resolve));
+}
+
+async function main() {
+  console.log('\n╔═══════════════════════════════════════╗');
+  console.log('║   Outlet ORM - Migration Manager     ║');
+  console.log('╚═══════════════════════════════════════╝\n');
+
+  const command = process.argv[2];
+
+  if (command === 'make') {
+    await makeMigration();
+    rl.close();
+    return;
+  }
+
+  // Support non-interactive commands for automation and CI
+  const nonInteractive = new Set(['migrate', 'up', 'rollback', 'reset', 'refresh', 'fresh', 'status']);
+  if (nonInteractive.has(command)) {
+    const flags = parseFlags(process.argv.slice(3));
+    await runNonInteractive(command, flags);
+    rl.close();
+    return;
+  }
+
+  // Fallback to interactive menu
+  await runMigrationCommands();
+
+  rl.close();
+}
+
+/**
+ * Create a new migration file
+ */
+async function makeMigration() {
+  const migrationName = process.argv[3];
+
+  if (!migrationName) {
+    console.error('✗ Error: Migration name is required');
+    console.log('Usage: outlet-migrate make <migration_name>');
+    console.log('Example: outlet-migrate make create_users_table');
+    return;
+  }
+
+  const migrationsDir = path.join(process.cwd(), 'database', 'migrations');
+
+  // Create migrations directory if it doesn't exist
+  try {
+    await fs.mkdir(migrationsDir, { recursive: true });
+  } catch (error) {
+    // Directory already exists - ignore error as recursive: true handles this
+    if (error.code !== 'EEXIST') {
+      throw error;
+    }
+  }
+
+  // Generate timestamp
+  const timestamp = new Date().toISOString()
+    .replace(/[-:]/g, '')
+    .replace(/T/, '_')
+    .replace(/\..+/, '');
+
+  const fileName = `${timestamp}_${migrationName}.js`;
+  const filePath = path.join(migrationsDir, fileName);
+
+  // Determine if it's a create or alter migration
+  const isCreate = migrationName.includes('create_');
+  const tableName = extractTableName(migrationName);
+
+  const template = isCreate
+    ? getCreateMigrationTemplate(tableName)
+    : getAlterMigrationTemplate(tableName);
+
+  await fs.writeFile(filePath, template);
+
+  console.log(`✓ Migration created: ${fileName}`);
+  console.log(`  Location: ${filePath}`);
+}
+
+/**
+ * Extract table name from migration name
+ */
+function extractTableName(migrationName) {
+  // Extract table name from patterns like:
+  // create_users_table -> users
+  // add_email_to_users_table -> users
+  // alter_users_table -> users
+
+  const patterns = [
+    /create_(\w+)_table/,
+    /to_(\w+)_table/,
+    /alter_(\w+)_table/,
+    /(\w+)_table/
+  ];
+
+  for (const pattern of patterns) {
+    const match = migrationName.match(pattern);
+    if (match) {
+      return match[1];
+    }
+  }
+
+  return 'table_name';
+}
+
+/**
+ * Get migration template for creating a table
+ */
+function getCreateMigrationTemplate(tableName) {
+  return `/**
+ * Migration: Create ${tableName} table
+ */
+
+const Migration = require('../../lib/Migrations/Migration');
+
+class Create${capitalize(tableName)}Table extends Migration {
+  /**
+   * Run the migrations
+   */
+  async up() {
+    const schema = this.getSchema();
+
+    await schema.create('${tableName}', (table) => {
+      table.id();
+      table.string('name');
+      table.timestamps();
+    });
+  }
+
+  /**
+   * Reverse the migrations
+   */
+  async down() {
+    const schema = this.getSchema();
+    await schema.dropIfExists('${tableName}');
+  }
+}
+
+module.exports = Create${capitalize(tableName)}Table;
+`;
+}
+
+/**
+ * Get migration template for altering a table
+ */
+function getAlterMigrationTemplate(tableName) {
+  return `/**
+ * Migration: Alter ${tableName} table
+ */
+
+const Migration = require('../../lib/Migrations/Migration');
+
+class Alter${capitalize(tableName)}Table extends Migration {
+  /**
+   * Run the migrations
+   */
+  async up() {
+    const schema = this.getSchema();
+
+    await schema.table('${tableName}', (table) => {
+      // Add your column modifications here
+      // table.string('new_column');
+    });
+  }
+
+  /**
+   * Reverse the migrations
+   */
+  async down() {
+    const schema = this.getSchema();
+
+    await schema.table('${tableName}', (table) => {
+      // Reverse your column modifications here
+      // table.dropColumn('new_column');
+    });
+  }
+}
+
+module.exports = Alter${capitalize(tableName)}Table;
+`;
+}
+
+/**
+ * Capitalize first letter
+ */
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+/**
+ * Simple flag parser for CLI args
+ * Supports formats:
+ * --key=value, --key value, -k value, and boolean flags like --yes/-y
+ */
+function parseFlags(argv) {
+  const text = ` ${argv.join(' ')} `;
+  const flags = {};
+  // Booleans
+  if (/(^|\s)(--yes|-y)(\s|$)/.test(text)) flags.yes = true;
+  if (/(^|\s)(--force|-f)(\s|$)/.test(text)) flags.force = true;
+  // Steps with value: supports "--steps N", "--steps=N", "-s N"
+  const stepsRe = /(?:--steps(?:=|\s+)|-s\s+)(\S+)/;
+  const stepsMatch = stepsRe.exec(text);
+  if (stepsMatch) flags.steps = coerce(stepsMatch[1]);
+  return flags;
+}
+
+function coerce(val) {
+  if (val === 'true') return true;
+  if (val === 'false') return false;
+  const n = Number(val);
+  return Number.isNaN(n) ? val : n;
+}
+
+/**
+ * Run migration commands non-interactively
+ */
+async function runNonInteractive(cmd, flags) {
+  // Load database configuration
+  const dbConfigPath = path.join(process.cwd(), 'database', 'config.js');
+
+  // Prefer database/config.js; if missing, allow env-based config via .env
+  let dbConfig;
+  try {
+    dbConfig = require(dbConfigPath);
+  } catch (error) {
+    // Fallback to env-based configuration
+    require('dotenv').config();
+    const env = process.env || {};
+    dbConfig = {
+      driver: env.DB_DRIVER || env.DATABASE_DRIVER,
+      host: env.DB_HOST,
+      port: env.DB_PORT ? Number(env.DB_PORT) : undefined,
+      user: env.DB_USER || env.DB_USERNAME,
+      password: env.DB_PASSWORD,
+      database: env.DB_DATABASE || env.DB_NAME || env.DB_FILE || env.SQLITE_DB || env.SQLITE_FILENAME
+    };
+    if (!dbConfig.driver) {
+      console.error('\n✗ Error: Could not load database configuration');
+      console.error(`  Make sure ${dbConfigPath} exists OR provide .env variables like DB_DRIVER, DB_HOST, DB_DATABASE`);
+      console.error('  Run "outlet-init" to create the configuration');
+      console.error(`  Details: ${error.message}`);
+      return;
+    }
+  }
+
+  const { DatabaseConnection } = require('../lib/Database/DatabaseConnection');
+  const MigrationManager = require('../lib/Migrations/MigrationManager');
+
+  const connection = new DatabaseConnection(dbConfig);
+  await connection.connect();
+
+  const manager = new MigrationManager(connection);
+
+  try {
+    switch (cmd) {
+    case 'migrate':
+    case 'up':
+      await manager.run();
+      break;
+
+    case 'rollback': {
+      const steps = Number(flags.steps) || 1;
+      await manager.rollback(steps);
+      break;
+    }
+
+    case 'reset': {
+      if (flags.yes || flags.force) {
+        await manager.reset();
+      } else {
+        console.error('✗ Refused to reset without --yes');
+      }
+      break;
+    }
+
+    case 'refresh': {
+      if (flags.yes || flags.force) {
+        await manager.refresh();
+      } else {
+        console.error('✗ Refused to refresh without --yes');
+      }
+      break;
+    }
+
+    case 'fresh': {
+      if (flags.yes || flags.force) {
+        await manager.fresh();
+      } else {
+        console.error('✗ Refused to fresh without --yes');
+      }
+      break;
+    }
+
+    case 'status':
+      await manager.status();
+      break;
+
+    default:
+      console.error(`✗ Unknown command: ${cmd}`);
+    }
+  } catch (error) {
+    console.error('\n✗ Migration error:', error.message);
+    console.error(error.stack);
+  }
+
+  await connection.disconnect();
+}
+
+/**
+ * Run migration commands (migrate, rollback, etc.)
+ */
+async function runMigrationCommands() {
+  console.log('Select a migration command:\n');
+  console.log('1. migrate         - Run all pending migrations');
+  console.log('2. rollback        - Rollback the last batch of migrations');
+  console.log('3. reset           - Rollback all migrations');
+  console.log('4. refresh         - Reset and re-run all migrations');
+  console.log('5. fresh           - Drop all tables and re-run migrations');
+  console.log('6. status          - Show migration status');
+  console.log('0. Exit\n');
+
+  const choice = await question('Enter your choice: ');
+
+  if (choice === '0') {
+    console.log('Goodbye!');
+    return;
+  }
+
+  // Load database configuration
+  const dbConfigPath = path.join(process.cwd(), 'database', 'config.js');
+
+  let dbConfig;
+  try {
+    dbConfig = require(dbConfigPath);
+  } catch (error) {
+    require('dotenv').config();
+    const env = process.env || {};
+    dbConfig = {
+      driver: env.DB_DRIVER || env.DATABASE_DRIVER,
+      host: env.DB_HOST,
+      port: env.DB_PORT ? Number(env.DB_PORT) : undefined,
+      user: env.DB_USER || env.DB_USERNAME,
+      password: env.DB_PASSWORD,
+      database: env.DB_DATABASE || env.DB_NAME || env.DB_FILE || env.SQLITE_DB || env.SQLITE_FILENAME
+    };
+    if (!dbConfig.driver) {
+      console.error('\n✗ Error: Could not load database configuration');
+      console.error(`  Make sure ${dbConfigPath} exists OR provide .env variables like DB_DRIVER, DB_HOST, DB_DATABASE`);
+      console.error('  Run "outlet-init" to create the configuration');
+      console.error(`  Details: ${error.message}`);
+      return;
+    }
+  }
+
+  const { DatabaseConnection } = require('../lib/Database/DatabaseConnection');
+  const MigrationManager = require('../lib/Migrations/MigrationManager');
+
+  const connection = new DatabaseConnection(dbConfig);
+  await connection.connect();
+
+  const manager = new MigrationManager(connection);
+
+  try {
+    switch (choice) {
+    case '1':
+      await manager.run();
+      break;
+
+    case '2': {
+      const steps = await question('How many batches to rollback? (default: 1): ');
+      await manager.rollback(parseInt(steps) || 1);
+      break;
+    }
+
+    case '3': {
+      const confirmReset = await question('Are you sure you want to reset all migrations? (yes/no): ');
+      if (confirmReset.toLowerCase() === 'yes') {
+        await manager.reset();
+      } else {
+        console.log('Reset cancelled');
+      }
+      break;
+    }
+
+    case '4': {
+      const confirmRefresh = await question('Are you sure you want to refresh all migrations? (yes/no): ');
+      if (confirmRefresh.toLowerCase() === 'yes') {
+        await manager.refresh();
+      } else {
+        console.log('Refresh cancelled');
+      }
+      break;
+    }
+
+    case '5': {
+      const confirmFresh = await question('⚠️  WARNING: This will DROP ALL TABLES! Continue? (yes/no): ');
+      if (confirmFresh.toLowerCase() === 'yes') {
+        await manager.fresh();
+      } else {
+        console.log('Fresh cancelled');
+      }
+      break;
+    }
+
+    case '6':
+      await manager.status();
+      break;
+
+    default:
+      console.log('Invalid choice');
+    }
+  } catch (error) {
+    console.error('\n✗ Migration error:', error.message);
+    console.error(error.stack);
+  }
+
+  await connection.disconnect();
+}
+
+// Run the CLI
+main().catch(error => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/lib/Database/DatabaseConnection.js

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

package/lib/Migrations/Migration.js

@@ -0,0 +1,48 @@
+/**
+ * Base Migration Class
+ * All migrations should extend this class
+ */
+
+class Migration {
+  constructor(connection) {
+    this.connection = connection;
+  }
+
+  /**
+   * Run the migrations
+   */
+  async up() {
+    throw new Error('Migration up() method must be implemented');
+  }
+
+  /**
+   * Reverse the migrations
+   */
+  async down() {
+    throw new Error('Migration down() method must be implemented');
+  }
+
+  /**
+   * Get the migration name
+   */
+  static getName() {
+    return this.name;
+  }
+
+  /**
+   * Execute raw SQL
+   */
+  async execute(sql) {
+    return await this.connection.execute(sql);
+  }
+
+  /**
+   * Get the Schema builder
+   */
+  getSchema() {
+    const { Schema } = require('../Schema/Schema');
+    return new Schema(this.connection);
+  }
+}
+
+module.exports = Migration;