webspresso 0.0.5 → 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

@@ -0,0 +1,49 @@
+/**
+ * Schema Applicator
+ * Parses and validates request input against compiled schemas
+ */
+
+/**
+ * Apply compiled schema to request
+ * Parses body, params, and query against their respective schemas
+ * Stores validated results in req.input
+ * 
+ * @param {Object} req - Express request object
+ * @param {Object|null} compiledSchema - Compiled schema from compileSchema
+ * @returns {void}
+ * @throws {ZodError} If validation fails
+ */
+function applySchema(req, compiledSchema) {
+  // Initialize req.input
+  req.input = {
+    body: undefined,
+    params: undefined,
+    query: undefined
+  };
+
+  // No schema means no validation
+  if (!compiledSchema) {
+    return;
+  }
+
+  // Parse body if schema exists
+  if (compiledSchema.body) {
+    req.input.body = compiledSchema.body.parse(req.body);
+  }
+
+  // Parse params if schema exists
+  if (compiledSchema.params) {
+    req.input.params = compiledSchema.params.parse(req.params);
+  }
+
+  // Parse query if schema exists
+  if (compiledSchema.query) {
+    req.input.query = compiledSchema.query.parse(req.query);
+  }
+}
+
+module.exports = {
+  applySchema
+};
+
+

package/core/compileSchema.js

@@ -0,0 +1,69 @@
+/**
+ * Schema Compiler
+ * Compiles schema definitions from API files
+ */
+
+const z = require('zod');
+const schemaCache = require('../utils/schemaCache');
+
+/**
+ * Compile schema from an API module
+ * @param {string} filePath - Absolute file path to API module
+ * @param {Object} apiModule - The loaded API module
+ * @returns {Object|null} Compiled schema object or null if no schema
+ */
+function compileSchema(filePath, apiModule) {
+  // Return cached schema if exists
+  if (schemaCache.has(filePath)) {
+    return schemaCache.get(filePath);
+  }
+
+  // Check if module exports schema
+  const schemaFn = apiModule.schema;
+  
+  // Schema is optional
+  if (schemaFn === undefined) {
+    schemaCache.set(filePath, null);
+    return null;
+  }
+
+  // Schema must be a function
+  if (typeof schemaFn !== 'function') {
+    throw new Error(`Schema in ${filePath} must be a function`);
+  }
+
+  // Call schema function with { z }
+  const compiled = schemaFn({ z });
+
+  // Validate compiled schema structure
+  if (compiled !== null && typeof compiled !== 'object') {
+    throw new Error(`Schema function in ${filePath} must return an object or null`);
+  }
+
+  // Cache and return
+  schemaCache.set(filePath, compiled);
+  return compiled;
+}
+
+/**
+ * Clear schema cache for a file (for hot-reload)
+ * @param {string} filePath - Absolute file path
+ */
+function invalidateSchema(filePath) {
+  schemaCache.del(filePath);
+}
+
+/**
+ * Clear all cached schemas
+ */
+function clearAllSchemas() {
+  schemaCache.clear();
+}
+
+module.exports = {
+  compileSchema,
+  invalidateSchema,
+  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,
+};
+