webspresso 0.0.13 → 0.0.14

package/bin/commands/page.js

@@ -0,0 +1,134 @@
+/**
+ * Page Command
+ * Add a new page to the current project
+ */
+
+const inquirer = require('inquirer');
+const fs = require('fs');
+const path = require('path');
+
+function registerCommand(program) {
+  program
+    .command('page')
+    .description('Add a new page to the current project')
+    .action(async () => {
+      if (!fs.existsSync('pages')) {
+        console.error('❌ Not a Webspresso project! Run this command in your project directory.');
+        process.exit(1);
+      }
+      
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'route',
+          message: 'Route path (e.g., /about or /blog/post):',
+          validate: (input) => {
+            if (!input.startsWith('/')) {
+              return 'Route must start with /';
+            }
+            return true;
+          }
+        },
+        {
+          type: 'confirm',
+          name: 'hasConfig',
+          message: 'Add route config file (.js)?',
+          default: false
+        },
+        {
+          type: 'confirm',
+          name: 'hasLocales',
+          message: 'Add locale files?',
+          default: false
+        }
+      ]);
+      
+      const route = answers.route.replace(/^\//, '');
+      const routePath = path.join('pages', route);
+      const dirPath = path.dirname(routePath);
+      const fileName = path.basename(routePath);
+      
+      // Create directory
+      fs.mkdirSync(dirPath, { recursive: true });
+      
+      // Create .njk file
+      const templateName = fileName === 'index' ? 'index' : fileName;
+      const njkFile = path.join(dirPath, `${templateName}.njk`);
+      
+      const njkContent = `{% extends "layout.njk" %}
+
+{% block content %}
+<div>
+  <h1>{{ t('title') or '${route}' }}</h1>
+  <p>{{ t('description') or 'Page content' }}</p>
+</div>
+{% endblock %}
+`;
+      
+      fs.writeFileSync(njkFile, njkContent);
+      console.log(`✅ Created ${njkFile}`);
+      
+      // Create config file if requested
+      if (answers.hasConfig) {
+        const jsFile = path.join(dirPath, `${templateName}.js`);
+        const jsContent = `module.exports = {
+  async load(req, ctx) {
+    return {
+      // Add your data here
+    };
+  },
+  
+  meta(req, ctx) {
+    return {
+      title: ctx.t('meta.title') || '${route}',
+      description: ctx.t('meta.description') || ''
+    };
+  }
+};
+`;
+        
+        fs.writeFileSync(jsFile, jsContent);
+        console.log(`✅ Created ${jsFile}`);
+      }
+      
+      // Create locales if requested
+      if (answers.hasLocales) {
+        const localesDir = path.join(dirPath, 'locales');
+        fs.mkdirSync(localesDir, { recursive: true });
+        
+        const enContent = {
+          title: route,
+          description: 'Page description',
+          meta: {
+            title: `${route} - Webspresso`,
+            description: 'Page description'
+          }
+        };
+        
+        fs.writeFileSync(
+          path.join(localesDir, 'en.json'),
+          JSON.stringify(enContent, null, 2) + '\n'
+        );
+        
+        const trContent = {
+          title: route,
+          description: 'Sayfa açıklaması',
+          meta: {
+            title: `${route} - Webspresso`,
+            description: 'Sayfa açıklaması'
+          }
+        };
+        
+        fs.writeFileSync(
+          path.join(localesDir, 'tr.json'),
+          JSON.stringify(trContent, null, 2) + '\n'
+        );
+        
+        console.log(`✅ Created locale files in ${localesDir}`);
+      }
+      
+      console.log(`\n✅ Page created at ${route}\n`);
+    });
+}
+
+module.exports = { registerCommand };

package/bin/commands/seed.js

@@ -0,0 +1,154 @@
+/**
+ * Seed Command
+ * Run database seeders to populate database with fake data
+ */
+
+const inquirer = require('inquirer');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { loadDbConfig } = require('../utils/db');
+const { getSeedFileTemplate } = require('../utils/seed');
+
+function registerCommand(program) {
+  program
+    .command('seed')
+    .description('Run database seeders to populate database with fake data')
+    .option('-c, --config <path>', 'Path to database config file')
+    .option('-e, --env <environment>', 'Environment (development, production)', 'development')
+    .option('--setup', 'Setup seed files if they don\'t exist')
+    .action(async (options) => {
+      // Check if it's a Webspresso project
+      if (!fs.existsSync(path.join(process.cwd(), 'server.js')) && 
+          !fs.existsSync(path.join(process.cwd(), 'pages'))) {
+        console.error('❌ Not a Webspresso project! Run this command in your project directory.');
+        process.exit(1);
+      }
+
+      // Check for faker in the project's node_modules
+      // Use require.resolve with paths to ensure we load from the project directory
+      let faker;
+      try {
+        // Try to resolve from project's node_modules first
+        const resolvedPath = require.resolve('@faker-js/faker', { 
+          paths: [process.cwd(), path.join(process.cwd(), 'node_modules')] 
+        });
+        faker = require(resolvedPath);
+      } catch {
+        console.error('❌ @faker-js/faker not installed.');
+        
+        // Check if it's in package.json
+        const packageJsonPath = path.join(process.cwd(), 'package.json');
+        let shouldInstall = false;
+        
+        if (fs.existsSync(packageJsonPath)) {
+          try {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            const hasFaker = packageJson.dependencies?.['@faker-js/faker'] || 
+                            packageJson.devDependencies?.['@faker-js/faker'];
+            
+            if (hasFaker) {
+              console.log('   @faker-js/faker is in package.json but not installed.');
+              console.log('   Run: npm install');
+              process.exit(1);
+            } else {
+              // Ask if user wants to install it
+              const { install } = await inquirer.prompt([
+                {
+                  type: 'confirm',
+                  name: 'install',
+                  message: 'Install @faker-js/faker now?',
+                  default: true
+                }
+              ]);
+              
+              if (install) {
+                shouldInstall = true;
+              } else {
+                console.log('   Install it manually with: npm install @faker-js/faker');
+                process.exit(1);
+              }
+            }
+          } catch (err) {
+            console.log('   Install it with: npm install @faker-js/faker');
+            process.exit(1);
+          }
+        } else {
+          console.log('   Install it with: npm install @faker-js/faker');
+          process.exit(1);
+        }
+        
+        // Install faker if user confirmed
+        if (shouldInstall) {
+          console.log('\n📦 Installing @faker-js/faker...\n');
+          try {
+            execSync('npm install @faker-js/faker', {
+              stdio: 'inherit',
+              cwd: process.cwd()
+            });
+            console.log('\n✅ @faker-js/faker installed successfully!\n');
+            
+            // Try to require again from project's node_modules
+            const resolvedPath = require.resolve('@faker-js/faker', { 
+              paths: [process.cwd(), path.join(process.cwd(), 'node_modules')] 
+            });
+            // Clear cache to ensure fresh load
+            delete require.cache[resolvedPath];
+            faker = require(resolvedPath);
+          } catch (err) {
+            console.error('\n❌ Failed to install @faker-js/faker:', err.message);
+            console.log('   Install it manually with: npm install @faker-js/faker');
+            process.exit(1);
+          }
+        }
+      }
+
+      // Load database config
+      const { config, path: configPath } = loadDbConfig(options.config);
+      console.log(`\n📦 Using config: ${configPath}`);
+      console.log(`   Environment: ${options.env}\n`);
+
+      // Check if models directory exists
+      const modelsDir = path.join(process.cwd(), 'models');
+      if (!fs.existsSync(modelsDir)) {
+        console.error('❌ models/ directory not found.');
+        console.log('   Create models first, then run: webspresso seed');
+        process.exit(1);
+      }
+
+      // Check if seeds directory exists
+      const seedsDir = path.join(process.cwd(), 'seeds');
+      const seedIndexPath = path.join(seedsDir, 'index.js');
+      
+      if (!fs.existsSync(seedsDir) || !fs.existsSync(seedIndexPath)) {
+        if (options.setup) {
+          console.log('📝 Setting up seed files...\n');
+          
+          // Create seeds directory
+          if (!fs.existsSync(seedsDir)) {
+            fs.mkdirSync(seedsDir, { recursive: true });
+          }
+          
+          // Create seed index file
+          const seedIndex = getSeedFileTemplate();
+          
+          fs.writeFileSync(seedIndexPath, seedIndex);
+          console.log('✅ Seed files created!\n');
+        } else {
+          console.error('❌ seeds/index.js not found.');
+          console.log('   Run with --setup flag to create seed files: webspresso seed --setup');
+          process.exit(1);
+        }
+      }
+
+      // Run the seed script
+      try {
+        require(seedIndexPath);
+      } catch (error) {
+        console.error('❌ Failed to run seed:', error.message);
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = { registerCommand };

package/bin/commands/start.js

@@ -0,0 +1,30 @@
+/**
+ * Start Command
+ * Start production server
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function registerCommand(program) {
+  program
+    .command('start')
+    .description('Start production server')
+    .option('-p, --port <port>', 'Port number', '3000')
+    .action((options) => {
+      if (!fs.existsSync('server.js')) {
+        console.error('❌ server.js not found! Make sure you are in a Webspresso project.');
+        process.exit(1);
+      }
+      
+      process.env.PORT = options.port;
+      process.env.NODE_ENV = 'production';
+      
+      console.log(`\n🚀 Starting production server on port ${options.port}...\n`);
+      
+      const serverPath = path.resolve(process.cwd(), 'server.js');
+      require(serverPath);
+    });
+}
+
+module.exports = { registerCommand };

package/bin/utils/db.js

@@ -0,0 +1,54 @@
+/**
+ * Database Utilities
+ * Functions for loading database configuration and creating instances
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 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);
+}
+
+module.exports = {
+  loadDbConfig,
+  createDbInstance
+};

package/bin/utils/migration.js

@@ -0,0 +1,36 @@
+/**
+ * Migration Utilities
+ * Functions for generating migration file content
+ */
+
+/**
+ * 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}');
+};
+`;
+}
+
+module.exports = {
+  getDefaultMigrationContent
+};

package/bin/utils/project.js

@@ -0,0 +1,97 @@
+/**
+ * Project Setup Utilities
+ * Functions for installing dependencies and starting development server
+ */
+
+const { execSync, spawn } = require('child_process');
+
+/**
+ * Run installation and build process
+ * @param {string} projectPath - Project directory path
+ * @param {boolean} useTailwind - Whether Tailwind CSS is enabled
+ * @returns {Promise<void>}
+ */
+async function runInstallation(projectPath, useTailwind) {
+  console.log('\n📦 Installing dependencies...\n');
+  try {
+    execSync('npm install', { 
+      stdio: 'inherit', 
+      cwd: projectPath 
+    });
+    
+    if (useTailwind) {
+      console.log('\n🎨 Building Tailwind CSS...\n');
+      execSync('npm run build:css', { 
+        stdio: 'inherit', 
+        cwd: projectPath 
+      });
+    }
+    
+    console.log('\n✅ Installation complete!\n');
+  } catch (err) {
+    console.error('❌ Installation failed:', err.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Start development server
+ * @param {string} projectPath - Project directory path
+ * @param {boolean} useTailwind - Whether Tailwind CSS is enabled
+ * @returns {void}
+ */
+function startDevServer(projectPath, useTailwind) {
+  console.log('\n🚀 Starting development server...\n');
+  console.log('Press Ctrl+C to stop\n');
+  
+  if (useTailwind) {
+    // Start CSS watch and server together
+    const cssWatch = spawn('npm', ['run', 'watch:css'], {
+      stdio: 'inherit',
+      shell: true,
+      cwd: projectPath
+    });
+    
+    const server = spawn('node', ['--watch', 'server.js'], {
+      stdio: 'inherit',
+      shell: true,
+      cwd: projectPath,
+      env: { ...process.env, PORT: process.env.PORT || '3000', NODE_ENV: 'development' }
+    });
+    
+    // Handle exit
+    const cleanup = () => {
+      cssWatch.kill();
+      server.kill();
+      process.exit(0);
+    };
+    
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    
+    cssWatch.on('exit', cleanup);
+    server.on('exit', cleanup);
+  } else {
+    // Just start server
+    const server = spawn('node', ['--watch', 'server.js'], {
+      stdio: 'inherit',
+      shell: true,
+      cwd: projectPath,
+      env: { ...process.env, PORT: process.env.PORT || '3000', NODE_ENV: 'development' }
+    });
+    
+    server.on('exit', (code) => {
+      process.exit(code || 0);
+    });
+    
+    process.on('SIGINT', () => {
+      server.kill();
+      process.exit(0);
+    });
+  }
+}
+
+module.exports = {
+  runInstallation,
+  startDevServer
+};

package/bin/utils/seed.js

@@ -0,0 +1,112 @@
+/**
+ * Seed Utilities
+ * Functions for generating seed file templates
+ */
+
+/**
+ * Get seed file template content
+ * @returns {string} Seed file template
+ */
+function getSeedFileTemplate() {
+  return `require('dotenv').config();
+const { faker } = require('@faker-js/faker');
+const path = require('path');
+const fs = require('fs');
+const { createDatabase, getAllModels } = require('webspresso/orm');
+const dbConfig = require('../webspresso.db.js');
+
+const db = createDatabase(dbConfig);
+const seeder = db.seeder(faker);
+
+/**
+ * Load all models from models/ directory
+ */
+function loadModels() {
+  const modelsDir = path.join(__dirname, '..', 'models');
+  
+  if (!fs.existsSync(modelsDir)) {
+    return [];
+  }
+  
+  const modelFiles = fs.readdirSync(modelsDir)
+    .filter(file => file.endsWith('.js') && !file.startsWith('_'));
+  
+  const loadedModels = [];
+  for (const file of modelFiles) {
+    try {
+      require(path.join(modelsDir, file));
+      loadedModels.push(file);
+    } catch (error) {
+      console.warn(\`⚠️  Failed to load model from \${file}:\`, error.message);
+    }
+  }
+  
+  return loadedModels;
+}
+
+/**
+ * Seed database with fake data
+ * This script automatically detects models in the models/ directory
+ * and generates seed data based on their schemas.
+ */
+async function runSeeds() {
+  try {
+    console.log('🌱 Starting seed process...');
+    
+    // Load all models
+    const loadedFiles = loadModels();
+    
+    if (loadedFiles.length === 0) {
+      console.log('⚠️  No model files found in models/ directory.');
+      console.log('   Create models first, then run: webspresso seed');
+      await db.knex.destroy();
+      return;
+    }
+    
+    // Get all registered models
+    const models = getAllModels();
+    
+    if (models.size === 0) {
+      console.log('⚠️  No models registered. Make sure your model files export models using defineModel().');
+      await db.knex.destroy();
+      return;
+    }
+    
+    console.log(\`📦 Found \${models.size} model(s):\`);
+    for (const [name] of models) {
+      console.log(\`   - \${name}\`);
+    }
+    
+    // Seed each model
+    const results = {};
+    for (const [modelName, model] of models) {
+      console.log(\`\\n🌱 Seeding \${modelName}...\`);
+      
+      // Default count: 10 records per model
+      const count = 10;
+      const records = await seeder.seed(modelName, count);
+      results[modelName] = records.length;
+      
+      console.log(\`✅ Created \${records.length} \${modelName} record(s)\`);
+    }
+    
+    console.log(\`\\n✨ Seed completed! Created:\`);
+    for (const [modelName, count] of Object.entries(results)) {
+      console.log(\`   - \${count} \${modelName} record(s)\`);
+    }
+    
+    await db.knex.destroy();
+  } catch (error) {
+    console.error('❌ Seed failed:', error);
+    await db.knex.destroy().catch(() => {});
+    process.exit(1);
+  }
+}
+
+runSeeds();
+`;
+}
+
+module.exports = {
+  getSeedFileTemplate
+};