webspresso 0.0.6 → 0.0.7

package/bin/webspresso.js

@@ -785,6 +785,261 @@ module.exports = {
     }
   });
 
+// ============================================================================
+// Database Commands
+// ============================================================================
+
+/**
+ * Load database configuration
+ * @param {string} [configPath] - Custom config path
+ * @returns {Object} Database config
+ */
+function loadDbConfig(configPath) {
+  const defaultPaths = ['webspresso.db.js', 'knexfile.js'];
+  const paths = configPath ? [configPath, ...defaultPaths] : defaultPaths;
+  
+  for (const p of paths) {
+    const fullPath = path.resolve(process.cwd(), p);
+    if (fs.existsSync(fullPath)) {
+      return { config: require(fullPath), path: fullPath };
+    }
+  }
+  
+  console.error('❌ Database config not found. Create webspresso.db.js or knexfile.js');
+  process.exit(1);
+}
+
+/**
+ * Create database instance from config
+ * @param {Object} config - Database config
+ * @param {string} [env] - Environment name
+ * @returns {Promise<Object>} Database instance
+ */
+async function createDbInstance(config, env) {
+  const environment = env || process.env.NODE_ENV || 'development';
+  const dbConfig = config[environment] || config;
+  
+  // Dynamic import knex
+  let knex;
+  try {
+    knex = require('knex');
+  } catch {
+    console.error('❌ Knex not installed. Run: npm install knex');
+    process.exit(1);
+  }
+  
+  return knex(dbConfig);
+}
+
+// db:migrate command
+program
+  .command('db:migrate')
+  .description('Run pending database migrations')
+  .option('-e, --env <environment>', 'Environment (development, production)', 'development')
+  .option('-c, --config <path>', 'Path to database config file')
+  .action(async (options) => {
+    const { config, path: configPath } = loadDbConfig(options.config);
+    console.log(`\n📦 Using config: ${configPath}`);
+    console.log(`   Environment: ${options.env}\n`);
+    
+    const knex = await createDbInstance(config, options.env);
+    
+    try {
+      const migrationConfig = config.migrations || {};
+      const [batch, migrations] = await knex.migrate.latest(migrationConfig);
+      
+      if (migrations.length === 0) {
+        console.log('✅ Already up to date.\n');
+      } else {
+        console.log(`Running migrations (batch ${batch}):`);
+        for (const m of migrations) {
+          console.log(`  → ${m}`);
+        }
+        console.log(`\n✅ Done. ${migrations.length} migration(s) completed.\n`);
+      }
+    } catch (err) {
+      console.error('❌ Migration failed:', err.message);
+      process.exit(1);
+    } finally {
+      await knex.destroy();
+    }
+  });
+
+// db:rollback command
+program
+  .command('db:rollback')
+  .description('Rollback the last batch of migrations')
+  .option('-e, --env <environment>', 'Environment (development, production)', 'development')
+  .option('-c, --config <path>', 'Path to database config file')
+  .option('-a, --all', 'Rollback all migrations')
+  .action(async (options) => {
+    const { config, path: configPath } = loadDbConfig(options.config);
+    console.log(`\n📦 Using config: ${configPath}`);
+    console.log(`   Environment: ${options.env}\n`);
+    
+    const knex = await createDbInstance(config, options.env);
+    
+    try {
+      const migrationConfig = {
+        ...(config.migrations || {}),
+        ...(options.all ? { all: true } : {}),
+      };
+      
+      const [batch, migrations] = await knex.migrate.rollback(migrationConfig);
+      
+      if (migrations.length === 0) {
+        console.log('✅ Nothing to rollback.\n');
+      } else {
+        console.log(`Rolling back${options.all ? ' all' : ''} migrations:`);
+        for (const m of migrations) {
+          console.log(`  ← ${m}`);
+        }
+        console.log(`\n✅ Done. ${migrations.length} migration(s) rolled back.\n`);
+      }
+    } catch (err) {
+      console.error('❌ Rollback failed:', err.message);
+      process.exit(1);
+    } finally {
+      await knex.destroy();
+    }
+  });
+
+// db:status command
+program
+  .command('db:status')
+  .description('Show migration status')
+  .option('-e, --env <environment>', 'Environment (development, production)', 'development')
+  .option('-c, --config <path>', 'Path to database config file')
+  .action(async (options) => {
+    const { config, path: configPath } = loadDbConfig(options.config);
+    console.log(`\n📦 Using config: ${configPath}`);
+    console.log(`   Environment: ${options.env}\n`);
+    
+    const knex = await createDbInstance(config, options.env);
+    
+    try {
+      const migrationConfig = config.migrations || {};
+      const [completed, pending] = await knex.migrate.list(migrationConfig);
+      
+      console.log('Migration Status');
+      console.log('================\n');
+      
+      // Sort all migrations by name
+      const all = [
+        ...completed.map(m => ({ name: m.name || m, completed: true })),
+        ...pending.map(m => ({ name: m.name || m, completed: false })),
+      ].sort((a, b) => a.name.localeCompare(b.name));
+      
+      if (all.length === 0) {
+        console.log('  No migrations found.\n');
+      } else {
+        for (const m of all) {
+          const status = m.completed ? '✓' : '○';
+          const suffix = m.completed ? '' : ' (pending)';
+          console.log(`  ${status} ${m.name}${suffix}`);
+        }
+        console.log(`\n  Total: ${all.length} (${completed.length} completed, ${pending.length} pending)\n`);
+      }
+    } catch (err) {
+      console.error('❌ Failed to get status:', err.message);
+      process.exit(1);
+    } finally {
+      await knex.destroy();
+    }
+  });
+
+// db:make command
+program
+  .command('db:make <name>')
+  .description('Create a new migration file')
+  .option('-c, --config <path>', 'Path to database config file')
+  .option('-m, --model <model>', 'Generate migration from model (requires models directory)')
+  .action(async (name, options) => {
+    const { config, path: configPath } = loadDbConfig(options.config);
+    console.log(`\n📦 Using config: ${configPath}\n`);
+    
+    const migrationDir = config.migrations?.directory || './migrations';
+    
+    // Ensure migrations directory exists
+    if (!fs.existsSync(migrationDir)) {
+      fs.mkdirSync(migrationDir, { recursive: true });
+      console.log(`Created directory: ${migrationDir}`);
+    }
+    
+    // Generate filename with timestamp
+    const now = new Date();
+    const timestamp = [
+      now.getFullYear(),
+      String(now.getMonth() + 1).padStart(2, '0'),
+      String(now.getDate()).padStart(2, '0'),
+      '_',
+      String(now.getHours()).padStart(2, '0'),
+      String(now.getMinutes()).padStart(2, '0'),
+      String(now.getSeconds()).padStart(2, '0'),
+    ].join('');
+    
+    const filename = `${timestamp}_${name}.js`;
+    const filepath = path.join(migrationDir, filename);
+    
+    let content;
+    
+    if (options.model) {
+      // Try to load model and generate migration from schema
+      const modelsDir = config.models || './models';
+      const modelPath = path.resolve(process.cwd(), modelsDir, `${options.model}.js`);
+      
+      if (fs.existsSync(modelPath)) {
+        try {
+          const model = require(modelPath);
+          const { scaffoldMigration } = require('../core/orm/migrations/scaffold');
+          content = scaffoldMigration(model);
+          console.log(`Generated migration from model: ${options.model}`);
+        } catch (err) {
+          console.warn(`⚠️  Could not generate from model: ${err.message}`);
+          console.log('   Creating empty migration instead.\n');
+          content = getDefaultMigrationContent(name);
+        }
+      } else {
+        console.warn(`⚠️  Model not found: ${modelPath}`);
+        console.log('   Creating empty migration instead.\n');
+        content = getDefaultMigrationContent(name);
+      }
+    } else {
+      content = getDefaultMigrationContent(name);
+    }
+    
+    fs.writeFileSync(filepath, content);
+    console.log(`✅ Created: ${filepath}\n`);
+  });
+
+/**
+ * Get default migration content
+ * @param {string} name - Migration name
+ * @returns {string}
+ */
+function getDefaultMigrationContent(name) {
+  // Parse table name from migration name (e.g., create_users_table -> users)
+  const match = name.match(/^create_(\w+)_table$/);
+  const tableName = match ? match[1] : 'table_name';
+  
+  return `/**
+ * Migration: ${name}
+ */
+
+exports.up = function(knex) {
+  return knex.schema.createTable('${tableName}', (table) => {
+    table.bigIncrements('id').primary();
+    // Add your columns here
+    table.timestamps(true, true);
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('${tableName}');
+};
+`;
+}
+
 // Parse arguments
 program.parse();
 

package/core/applySchema.js

@@ -46,3 +46,4 @@ module.exports = {
   applySchema
 };
 
+

package/core/compileSchema.js

@@ -66,3 +66,4 @@ module.exports = {
   clearAllSchemas
 };
 
+

package/core/orm/eager-loader.js

@@ -0,0 +1,232 @@
+/**
+ * Webspresso ORM - Eager Loader
+ * Batch loading algorithm for relations
+ * @module core/orm/eager-loader
+ */
+
+const { resolveRelationModel, getRelationKeys } = require('./model');
+const { applyScopes, createScopeContext } = require('./scopes');
+
+/**
+ * Load relations for a set of records using batch queries
+ * @param {Object[]} records - Records to load relations for
+ * @param {string[]} relationNames - Names of relations to load
+ * @param {import('./types').ModelDefinition} model - Model definition
+ * @param {import('knex').Knex|import('knex').Knex.Transaction} knex - Knex instance
+ * @param {import('./types').ScopeContext} [scopeContext] - Scope context
+ * @returns {Promise<Object[]>} Records with relations attached
+ */
+async function loadRelations(records, relationNames, model, knex, scopeContext) {
+  if (!records.length || !relationNames.length) {
+    return records;
+  }
+
+  const context = scopeContext || createScopeContext();
+
+  // Process each relation
+  for (const relationName of relationNames) {
+    const relation = model.relations[relationName];
+    if (!relation) {
+      console.warn(`Relation "${relationName}" not found on model "${model.name}"`);
+      continue;
+    }
+
+    const { localKey, foreignKey, relatedModel } = getRelationKeys(model, relationName);
+
+    switch (relation.type) {
+      case 'belongsTo':
+        await loadBelongsTo(records, relationName, localKey, foreignKey, relatedModel, knex, context);
+        break;
+      case 'hasMany':
+        await loadHasMany(records, relationName, localKey, foreignKey, relatedModel, knex, context);
+        break;
+      case 'hasOne':
+        await loadHasOne(records, relationName, localKey, foreignKey, relatedModel, knex, context);
+        break;
+    }
+  }
+
+  return records;
+}
+
+/**
+ * Load belongsTo relation
+ * Parent record has foreign key pointing to related record's primary key
+ * Example: User belongsTo Company (user.company_id -> company.id)
+ * 
+ * @param {Object[]} records - Parent records
+ * @param {string} relationName - Relation name
+ * @param {string} localKey - Local primary key (typically 'id')
+ * @param {string} foreignKey - Foreign key on parent (e.g., 'company_id')
+ * @param {import('./types').ModelDefinition} relatedModel - Related model
+ * @param {import('knex').Knex} knex - Knex instance
+ * @param {import('./types').ScopeContext} scopeContext - Scope context
+ */
+async function loadBelongsTo(records, relationName, localKey, foreignKey, relatedModel, knex, scopeContext) {
+  // Collect unique foreign key values
+  const foreignKeyValues = [...new Set(
+    records
+      .map(r => r[foreignKey])
+      .filter(v => v !== null && v !== undefined)
+  )];
+
+  if (foreignKeyValues.length === 0) {
+    // No foreign keys, set all relations to null
+    for (const record of records) {
+      record[relationName] = null;
+    }
+    return;
+  }
+
+  // Build query for related records
+  let qb = knex(relatedModel.table).whereIn(relatedModel.primaryKey, foreignKeyValues);
+  
+  // Apply scopes to related model
+  qb = applyScopes(qb, scopeContext, relatedModel);
+
+  const relatedRecords = await qb;
+
+  // Index related records by primary key
+  const relatedMap = new Map();
+  for (const related of relatedRecords) {
+    relatedMap.set(related[relatedModel.primaryKey], related);
+  }
+
+  // Attach related records to parent records
+  for (const record of records) {
+    const fkValue = record[foreignKey];
+    record[relationName] = fkValue !== null && fkValue !== undefined
+      ? relatedMap.get(fkValue) || null
+      : null;
+  }
+}
+
+/**
+ * Load hasMany relation
+ * Related records have foreign key pointing to parent record's primary key
+ * Example: User hasMany Posts (post.user_id -> user.id)
+ * 
+ * @param {Object[]} records - Parent records
+ * @param {string} relationName - Relation name
+ * @param {string} localKey - Local primary key (typically 'id')
+ * @param {string} foreignKey - Foreign key on related records (e.g., 'user_id')
+ * @param {import('./types').ModelDefinition} relatedModel - Related model
+ * @param {import('knex').Knex} knex - Knex instance
+ * @param {import('./types').ScopeContext} scopeContext - Scope context
+ */
+async function loadHasMany(records, relationName, localKey, foreignKey, relatedModel, knex, scopeContext) {
+  // Collect unique primary key values from parent records
+  const primaryKeyValues = [...new Set(
+    records
+      .map(r => r[localKey])
+      .filter(v => v !== null && v !== undefined)
+  )];
+
+  if (primaryKeyValues.length === 0) {
+    // No primary keys, set all relations to empty arrays
+    for (const record of records) {
+      record[relationName] = [];
+    }
+    return;
+  }
+
+  // Build query for related records
+  let qb = knex(relatedModel.table).whereIn(foreignKey, primaryKeyValues);
+  
+  // Apply scopes to related model
+  qb = applyScopes(qb, scopeContext, relatedModel);
+
+  const relatedRecords = await qb;
+
+  // Group related records by foreign key
+  const relatedGroups = new Map();
+  for (const related of relatedRecords) {
+    const fkValue = related[foreignKey];
+    if (!relatedGroups.has(fkValue)) {
+      relatedGroups.set(fkValue, []);
+    }
+    relatedGroups.get(fkValue).push(related);
+  }
+
+  // Attach related records to parent records
+  for (const record of records) {
+    const pkValue = record[localKey];
+    record[relationName] = relatedGroups.get(pkValue) || [];
+  }
+}
+
+/**
+ * Load hasOne relation
+ * Related record has foreign key pointing to parent record's primary key
+ * Returns single related record (or null)
+ * 
+ * @param {Object[]} records - Parent records
+ * @param {string} relationName - Relation name
+ * @param {string} localKey - Local primary key (typically 'id')
+ * @param {string} foreignKey - Foreign key on related record
+ * @param {import('./types').ModelDefinition} relatedModel - Related model
+ * @param {import('knex').Knex} knex - Knex instance
+ * @param {import('./types').ScopeContext} scopeContext - Scope context
+ */
+async function loadHasOne(records, relationName, localKey, foreignKey, relatedModel, knex, scopeContext) {
+  // Collect unique primary key values from parent records
+  const primaryKeyValues = [...new Set(
+    records
+      .map(r => r[localKey])
+      .filter(v => v !== null && v !== undefined)
+  )];
+
+  if (primaryKeyValues.length === 0) {
+    // No primary keys, set all relations to null
+    for (const record of records) {
+      record[relationName] = null;
+    }
+    return;
+  }
+
+  // Build query for related records
+  let qb = knex(relatedModel.table).whereIn(foreignKey, primaryKeyValues);
+  
+  // Apply scopes to related model
+  qb = applyScopes(qb, scopeContext, relatedModel);
+
+  const relatedRecords = await qb;
+
+  // Index related records by foreign key (first occurrence wins for hasOne)
+  const relatedMap = new Map();
+  for (const related of relatedRecords) {
+    const fkValue = related[foreignKey];
+    if (!relatedMap.has(fkValue)) {
+      relatedMap.set(fkValue, related);
+    }
+  }
+
+  // Attach related records to parent records
+  for (const record of records) {
+    const pkValue = record[localKey];
+    record[relationName] = relatedMap.get(pkValue) || null;
+  }
+}
+
+/**
+ * Load a single relation for a single record
+ * @param {Object} record - Record to load relation for
+ * @param {string} relationName - Name of relation to load
+ * @param {import('./types').ModelDefinition} model - Model definition
+ * @param {import('knex').Knex} knex - Knex instance
+ * @param {import('./types').ScopeContext} [scopeContext] - Scope context
+ * @returns {Promise<Object>} Record with relation attached
+ */
+async function loadRelation(record, relationName, model, knex, scopeContext) {
+  const result = await loadRelations([record], [relationName], model, knex, scopeContext);
+  return result[0];
+}
+
+module.exports = {
+  loadRelations,
+  loadRelation,
+  loadBelongsTo,
+  loadHasMany,
+  loadHasOne,
+};
+

package/core/orm/index.js

@@ -0,0 +1,148 @@
+/**
+ * Webspresso ORM
+ * Minimal, Eloquent-inspired ORM with Knex and Zod
+ * @module core/orm
+ */
+
+const { createSchemaHelpers, extractColumnsFromSchema, getColumnMeta } = require('./schema-helpers');
+const { defineModel, getModel, getAllModels, hasModel, clearRegistry } = require('./model');
+const { createRepository } = require('./repository');
+const { createQueryBuilder, QueryBuilder } = require('./query-builder');
+const { runTransaction, createTransactionContext } = require('./transaction');
+const { createMigrationManager } = require('./migrations');
+const { scaffoldMigration, scaffoldAlterMigration, scaffoldDropMigration } = require('./migrations/scaffold');
+const { createScopeContext } = require('./scopes');
+const { createSeeder } = require('./seeder');
+
+/**
+ * Create a database instance
+ * @param {import('./types').DatabaseConfig} config - Database configuration
+ * @returns {import('./types').DatabaseInstance}
+ */
+function createDatabase(config) {
+  // Lazy load knex to avoid requiring it if ORM is not used
+  let knex;
+  try {
+    knex = require('knex');
+  } catch {
+    throw new Error('Knex is required for ORM. Install it with: npm install knex');
+  }
+
+  // Create Knex instance
+  const knexInstance = knex(config);
+
+  // Create migration manager
+  const migrationConfig = config.migrations || {};
+  const migrate = createMigrationManager(knexInstance, migrationConfig);
+
+  // Default scope context
+  let globalScopeContext = createScopeContext();
+
+  /**
+   * Set global tenant ID
+   * @param {*} tenantId - Tenant ID
+   * @returns {DatabaseInstance}
+   */
+  function forTenant(tenantId) {
+    globalScopeContext.tenantId = tenantId;
+    return db;
+  }
+
+  /**
+   * Create a repository for a model
+   * @param {import('./types').ModelDefinition} model - Model definition
+   * @returns {import('./types').Repository}
+   */
+  function createRepo(model) {
+    return createRepository(model, knexInstance, { ...globalScopeContext });
+  }
+
+  /**
+   * Run a callback within a transaction
+   * @param {function(import('./types').TransactionContext): Promise<*>} callback
+   * @returns {Promise<*>}
+   */
+  function transaction(callback) {
+    return runTransaction(knexInstance, callback, { ...globalScopeContext });
+  }
+
+  /**
+   * Get raw Knex instance for advanced queries
+   * @returns {import('knex').Knex}
+   */
+  function raw() {
+    return knexInstance;
+  }
+
+  /**
+   * Close all database connections
+   * @returns {Promise<void>}
+   */
+  async function destroy() {
+    await knexInstance.destroy();
+  }
+
+  /**
+   * Create a seeder instance
+   * @param {Object} faker - Faker instance (@faker-js/faker)
+   * @returns {Object} Seeder API
+   */
+  function seeder(faker) {
+    return createSeeder(faker, knexInstance);
+  }
+
+  const db = {
+    knex: knexInstance,
+    createRepository: createRepo,
+    transaction,
+    migrate,
+    seeder,
+    forTenant,
+    raw,
+    destroy,
+  };
+
+  return db;
+}
+
+// Export everything
+module.exports = {
+  // Main factory
+  createDatabase,
+
+  // Schema helpers
+  createSchemaHelpers,
+  extractColumnsFromSchema,
+  getColumnMeta,
+
+  // Model
+  defineModel,
+  getModel,
+  getAllModels,
+  hasModel,
+  clearRegistry,
+
+  // Repository (for direct use if needed)
+  createRepository,
+
+  // Query builder
+  createQueryBuilder,
+  QueryBuilder,
+
+  // Transaction
+  runTransaction,
+  createTransactionContext,
+
+  // Migrations
+  createMigrationManager,
+  scaffoldMigration,
+  scaffoldAlterMigration,
+  scaffoldDropMigration,
+
+  // Scopes
+  createScopeContext,
+
+  // Seeder
+  createSeeder,
+};
+