webspresso 0.0.6 → 0.0.8

package/bin/webspresso.js

@@ -18,25 +18,113 @@ program
 
 // New project command
 program
-  .command('new <project-name>')
+  .command('new [project-name]')
   .description('Create a new Webspresso project')
   .option('-t, --template <template>', 'Template to use (minimal, full)', 'minimal')
   .option('--no-tailwind', 'Skip Tailwind CSS setup')
   .option('-i, --install', 'Auto install dependencies and build CSS')
-  .action(async (projectName, options) => {
+  .action(async (projectNameArg, options) => {
     const useTailwind = options.tailwind !== false;
     const autoInstall = options.install === true;
-    const projectPath = path.resolve(projectName);
     
-    if (fs.existsSync(projectPath)) {
-      console.error(`❌ Directory ${projectName} already exists!`);
-      process.exit(1);
+    let projectName;
+    let projectPath;
+    let useCurrentDir = false;
+    
+    if (!projectNameArg) {
+      // No project name provided - ask if they want to use current directory
+      const currentDirName = path.basename(process.cwd());
+      const currentDirFiles = fs.readdirSync(process.cwd());
+      const hasExistingFiles = currentDirFiles.some(f => !f.startsWith('.'));
+      
+      const { useCurrent } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'useCurrent',
+          message: `Install in current directory (${currentDirName})?`,
+          default: true
+        }
+      ]);
+      
+      if (useCurrent) {
+        useCurrentDir = true;
+        projectPath = process.cwd();
+        
+        // Check for existing Webspresso files
+        if (fs.existsSync(path.join(projectPath, 'server.js')) || 
+            fs.existsSync(path.join(projectPath, 'pages'))) {
+          console.error('❌ Current directory already contains a Webspresso project!');
+          process.exit(1);
+        }
+        
+        // Warn if there are existing files
+        if (hasExistingFiles) {
+          const { continueAnyway } = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'continueAnyway',
+              message: '⚠️  Current directory is not empty. Continue anyway?',
+              default: false
+            }
+          ]);
+          
+          if (!continueAnyway) {
+            console.log('Cancelled.');
+            process.exit(0);
+          }
+        }
+        
+        // Ask for project name (for package.json)
+        const { name } = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'name',
+            message: 'Project name:',
+            default: currentDirName,
+            validate: (input) => {
+              if (!input.trim()) return 'Project name is required';
+              if (!/^[a-z0-9-_]+$/i.test(input)) return 'Project name can only contain letters, numbers, hyphens, and underscores';
+              return true;
+            }
+          }
+        ]);
+        
+        projectName = name;
+      } else {
+        // Ask for directory name
+        const { dirName } = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'dirName',
+            message: 'Project directory name:',
+            validate: (input) => {
+              if (!input.trim()) return 'Directory name is required';
+              if (!/^[a-z0-9-_]+$/i.test(input)) return 'Directory name can only contain letters, numbers, hyphens, and underscores';
+              if (fs.existsSync(path.resolve(input))) return `Directory ${input} already exists!`;
+              return true;
+            }
+          }
+        ]);
+        
+        projectName = dirName;
+        projectPath = path.resolve(dirName);
+      }
+    } else {
+      projectName = projectNameArg;
+      projectPath = path.resolve(projectNameArg);
+      
+      if (fs.existsSync(projectPath)) {
+        console.error(`❌ Directory ${projectName} already exists!`);
+        process.exit(1);
+      }
     }
     
     console.log(`\n🚀 Creating new Webspresso project: ${projectName}\n`);
     
-    // Create directory structure
-    fs.mkdirSync(projectPath, { recursive: true });
+    // Create directory structure (skip root if using current dir)
+    if (!useCurrentDir) {
+      fs.mkdirSync(projectPath, { recursive: true });
+    }
     fs.mkdirSync(path.join(projectPath, 'pages'), { recursive: true });
     fs.mkdirSync(path.join(projectPath, 'pages', 'locales'), { recursive: true });
     fs.mkdirSync(path.join(projectPath, 'views'), { recursive: true });
@@ -361,7 +449,9 @@ module.exports = {
         
         console.log('\n✅ Project ready!\n');
         console.log('Start developing:');
-        console.log(`  cd ${projectName}`);
+        if (!useCurrentDir) {
+          console.log(`  cd ${projectName}`);
+        }
         console.log('  npm run dev\n');
       } catch (err) {
         console.error('❌ Installation failed:', err.message);
@@ -370,7 +460,9 @@ module.exports = {
     } else {
       console.log('\n✅ Project created successfully!\n');
       console.log('Next steps:');
-      console.log(`  cd ${projectName}`);
+      if (!useCurrentDir) {
+        console.log(`  cd ${projectName}`);
+      }
       console.log('  npm install');
       if (useTailwind) {
         console.log('  npm run build:css');
@@ -785,6 +877,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,
+};
+