webspresso 0.0.97 → 0.0.98

package/bin/commands/build.js

@@ -0,0 +1,99 @@
+/**
+ * Build Command
+ * Build production assets (Tailwind CSS and esbuild JS bundle with manifest.json)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { buildBundle } = require('../../src/bundle');
+
+function registerCommand(program) {
+  program
+    .command('build')
+    .alias('build:assets')
+    .description('Build production assets (Tailwind CSS and esbuild JS with manifest.json)')
+    .option('--no-css', 'Skip CSS build')
+    .option('--no-js', 'Skip JS bundle build')
+    .option('--no-hash', 'Disable content hashing in asset filenames')
+    .action(async (options = {}) => {
+      const cwd = process.cwd();
+      const pkgPath = path.join(cwd, 'package.json');
+      if (!fs.existsSync(pkgPath)) {
+        console.error('❌ Not a Webspresso project! Run this command in your project directory.');
+        process.exit(1);
+      }
+
+      let packageJson = {};
+      try {
+        packageJson = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      } catch (_) {}
+
+      console.log('\n📦 Building Webspresso production assets...\n');
+
+      let cssBuilt = false;
+      let jsBuilt = false;
+
+      // 1. Build CSS (Tailwind)
+      if (options.css !== false) {
+        const hasCssScript = Boolean(packageJson.scripts && packageJson.scripts['build:css']);
+        const hasInputCss = fs.existsSync(path.join(cwd, 'src', 'input.css'));
+
+        if (hasCssScript) {
+          try {
+            console.log('🎨 Compiling Tailwind CSS...');
+            execSync('npm run build:css', { stdio: 'inherit', cwd });
+            cssBuilt = true;
+          } catch (err) {
+            console.error('❌ CSS build failed:', err.message);
+          }
+        } else if (hasInputCss) {
+          console.log('ℹ️  src/input.css found but no "build:css" script. Run "npx webspresso add tailwind" to configure.');
+        }
+      }
+
+      // 2. Build JS Bundle with manifest.json (esbuild)
+      if (options.js !== false) {
+        const hasClientEntry = fs.existsSync(path.join(cwd, 'src', 'client', 'main.js')) ||
+          fs.existsSync(path.join(cwd, 'src', 'client', 'main.ts')) ||
+          fs.existsSync(path.join(cwd, 'src', 'client', 'index.js'));
+        const hasEsbuild = Boolean(
+          (packageJson.devDependencies && packageJson.devDependencies.esbuild) ||
+          (packageJson.dependencies && packageJson.dependencies.esbuild)
+        );
+
+        if (hasClientEntry || hasEsbuild) {
+          try {
+            console.log('⚡ Bundling client JavaScript with esbuild...');
+            const result = await buildBundle({
+              cwd,
+              hash: options.hash !== false,
+              minify: true,
+              sourcemap: true,
+              outdir: path.join(cwd, 'public', 'dist'),
+            });
+            jsBuilt = true;
+            console.log(`✅ Client assets bundled and manifest created at: ${path.relative(cwd, result.manifestPath)}`);
+          } catch (err) {
+            // Fallback to npm run build:js if custom script exists
+            if (packageJson.scripts && packageJson.scripts['build:js']) {
+              try {
+                execSync('npm run build:js', { stdio: 'inherit', cwd });
+                jsBuilt = true;
+              } catch (subErr) {
+                console.error('❌ JS build failed:', subErr.message);
+              }
+            } else {
+              console.error('❌ JS bundle build failed:', err.message);
+            }
+          }
+        }
+      }
+
+      console.log('\n✨ Asset build complete!\n');
+      if (cssBuilt) console.log('  ✓ CSS: public/css/style.css');
+      if (jsBuilt) console.log('  ✓ JS: public/dist/ & manifest.json');
+    });
+}
+
+module.exports = { registerCommand };

package/bin/commands/dev.js

@@ -32,6 +32,7 @@ function registerCommand(program) {
     .description('Start development server')
     .option('-p, --port <port>', 'Port number', '3000')
     .option('--no-css', 'Skip CSS watch (if Tailwind is set up)')
+    .option('--no-js', 'Skip client JS watch (if esbuild / watch:js is set up)')
     .action((options) => {
       if (!fs.existsSync('server.js')) {
         console.error('❌ server.js not found! Make sure you are in a Webspresso project.');
@@ -41,56 +42,84 @@ function registerCommand(program) {
       process.env.PORT = options.port;
       process.env.NODE_ENV = 'development';
       
-      const hasTailwind = fs.existsSync('tailwind.config.js') && fs.existsSync('src/input.css');
+      let packageJson = {};
+      if (fs.existsSync('package.json')) {
+        try {
+          packageJson = JSON.parse(fs.readFileSync('package.json', 'utf-8'));
+        } catch (_) {}
+      }
+      const hasTailwindV3 = fs.existsSync('tailwind.config.js') && fs.existsSync('src/input.css');
+      const hasTailwindV4 = fs.existsSync('src/input.css') && Boolean(
+        (packageJson.devDependencies && (packageJson.devDependencies['@tailwindcss/cli'] || packageJson.devDependencies['tailwindcss'])) ||
+        (packageJson.scripts && packageJson.scripts['watch:css'])
+      );
+      const hasTailwind = hasTailwindV3 || hasTailwindV4;
       const shouldWatchCss = hasTailwind && options.css !== false;
+
+      const hasJsWatch = Boolean(
+        (packageJson.scripts && packageJson.scripts['watch:js']) ||
+        fs.existsSync('src/client/main.js') ||
+        fs.existsSync('src/client/main.ts') ||
+        fs.existsSync('esbuild.config.js')
+      );
+      const shouldWatchJs = hasJsWatch && options.js !== false && Boolean(packageJson.scripts && packageJson.scripts['watch:js']);
       
       // Build watch arguments
       const watchArgs = buildWatchArgs();
       const watchDirs = watchArgs.filter(a => a.startsWith('--watch-path')).map(a => a.split('=')[1]);
       
+      const watchingLabels = ['server.js'];
+      if (watchDirs.length) watchingLabels.push(...watchDirs);
+      if (shouldWatchCss) watchingLabels.push('CSS');
+      if (shouldWatchJs) watchingLabels.push('JS (esbuild)');
+
+      console.log(`\n🚀 Starting development server on port ${options.port}...`);
+      console.log(`   Watching: ${watchingLabels.join(', ')}\n`);
+
+      const managedProcesses = [];
+      let isCleaningUp = false;
+
+      const cleanup = (code = 0) => {
+        if (isCleaningUp) return;
+        isCleaningUp = true;
+        for (const p of managedProcesses) {
+          try {
+            if (p && !p.killed) {
+              p.kill('SIGTERM');
+            }
+          } catch (_) {}
+        }
+        process.exit(code);
+      };
+
+      process.once('SIGINT', () => cleanup(0));
+      process.once('SIGTERM', () => cleanup(0));
+
       if (shouldWatchCss) {
-        console.log(`\n🚀 Starting development server on port ${options.port}...`);
-        console.log(`   Watching: server.js${watchDirs.length ? ', ' + watchDirs.join(', ') : ''}, CSS\n`);
-        
-        // Start CSS watch
         const cssWatch = spawn('npm', ['run', 'watch:css'], {
-          stdio: 'inherit',
-          shell: true
-        });
-        
-        // Start server with watch paths
-        const server = spawn('node', watchArgs, {
           stdio: 'inherit',
           shell: true,
-          env: { ...process.env, PORT: options.port, 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 {
-        console.log(`\n🚀 Starting development server on port ${options.port}...`);
-        console.log(`   Watching: server.js${watchDirs.length ? ', ' + watchDirs.join(', ') : ''}\n`);
-        
-        const child = spawn('node', watchArgs, {
+        managedProcesses.push(cssWatch);
+        cssWatch.on('exit', () => cleanup(0));
+      }
+
+      if (shouldWatchJs) {
+        const jsWatch = spawn('npm', ['run', 'watch:js'], {
           stdio: 'inherit',
           shell: true,
-          env: { ...process.env, PORT: options.port, NODE_ENV: 'development' }
-        });
-        
-        child.on('exit', (code) => {
-          process.exit(code || 0);
         });
+        managedProcesses.push(jsWatch);
+        jsWatch.on('exit', () => cleanup(0));
       }
+
+      const server = spawn('node', watchArgs, {
+        stdio: 'inherit',
+        shell: true,
+        env: { ...process.env, PORT: options.port, NODE_ENV: 'development' },
+      });
+      managedProcesses.push(server);
+      server.on('exit', (code) => cleanup(code || 0));
     });
 }
 

package/bin/commands/doctor.js

@@ -215,6 +215,32 @@ function registerCommand(program) {
         warnings += 1;
       }
 
+      console.log('\nTailwind CSS');
+      console.log('------------');
+      const inputCssPath = path.join(cwd, 'src', 'input.css');
+      if (fs.existsSync(inputCssPath)) {
+        let isV4 = false;
+        try {
+          const inputCssContent = fs.readFileSync(inputCssPath, 'utf8');
+          isV4 = inputCssContent.includes('@import "tailwindcss"') || inputCssContent.includes("@import 'tailwindcss'");
+        } catch (_) {}
+
+        if (isV4) {
+          line('✓', 'Tailwind CSS v4 detected (@import "tailwindcss" — Oxide engine, zero-config)');
+        } else {
+          line('✓', 'Tailwind CSS v3 detected (PostCSS / tailwind.config.js)');
+        }
+        const outputCss = path.join(cwd, 'public', 'css', 'style.css');
+        if (fs.existsSync(outputCss)) {
+          line('✓', 'public/css/style.css compiled output present');
+        } else {
+          line('⚠', 'public/css/style.css not found. Run "npm run build:css" to compile stylesheets.');
+          warnings += 1;
+        }
+      } else {
+        line('○', 'No src/input.css found (Tailwind CSS not configured)');
+      }
+
       console.log('\nAI Agent Guidelines');
       console.log('-------------------');
       const agentsMdPath = path.join(cwd, 'AGENTS.md');

package/bin/commands/email-prune.js

@@ -0,0 +1,47 @@
+/**
+ * Prune old email log records (CLI)
+ */
+
+'use strict';
+
+const { loadDbConfig, createDbInstance } = require('../utils/db');
+
+function registerCommand(program) {
+  program
+    .command('email:prune')
+    .description('Delete email log rows older than the given retention window')
+    .option('--days <n>', 'Delete rows older than this many days', '90')
+    .option('--table <name>', 'Table name', 'email_logs')
+    .option('-e, --env <environment>', 'Environment (development, production)', 'development')
+    .option('-c, --config <path>', 'Path to database config file')
+    .action(async (options) => {
+      const days = parseInt(options.days, 10);
+      if (Number.isNaN(days) || days < 1) {
+        console.error('❌ --days must be a positive integer');
+        process.exit(1);
+      }
+
+      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);
+      const olderThan = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+
+      try {
+        const { purgeEmailLogs } = require('../../plugins/email/purge');
+        const deleted = await purgeEmailLogs(knex, {
+          tableName: options.table,
+          olderThan,
+        });
+        console.log(`✅ Deleted ${deleted} email log row(s) with created_at before ${olderThan.toISOString()}.\n`);
+      } catch (err) {
+        console.error('❌ email:prune failed:', err.message);
+        process.exit(1);
+      } finally {
+        await knex.destroy();
+      }
+    });
+}
+
+module.exports = { registerCommand };

package/bin/commands/make-job.js

@@ -0,0 +1,86 @@
+'use strict';
+
+/**
+ * Webspresso CLI - make:job Command
+ * Scaffolds a background queue job worker in jobs/<name>.js
+ * @module bin/commands/make-job
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function generateJobContent(jobName, queueName = 'default', retries = 3) {
+  return `'use strict';
+
+/**
+ * Background Job: ${jobName}
+ * Dispatched via: req.queue.dispatch('${jobName}', payload)
+ */
+module.exports = {
+  name: '${jobName}',
+  queue: '${queueName}',
+  retries: ${retries},
+  backoff: {
+    type: 'exponential',
+    delay: 1000,
+  },
+  handler: async (payload, ctx) => {
+    const { db, logger } = ctx;
+    if (logger) logger.info('[Job:${jobName}] Processing job:', payload);
+
+    // Business logic goes here:
+    // const repo = db ? db.getRepository('...') : null;
+  },
+};
+`;
+}
+
+function registerCommand(program) {
+  program
+    .command('make:job <name>')
+    .alias('job:make')
+    .description('Scaffold a background queue job worker in jobs/<name>.js')
+    .option('-q, --queue <queue>', 'Target queue name', 'default')
+    .option('-r, --retries <number>', 'Number of retries upon failure', '3')
+    .option('--root <dir>', 'Root directory of the project', process.cwd())
+    .action((nameArg, options) => {
+      const rootDir = path.resolve(options.root || process.cwd());
+      const jobsDir = path.join(rootDir, 'jobs');
+
+      if (!fs.existsSync(jobsDir)) {
+        fs.mkdirSync(jobsDir, { recursive: true });
+      }
+
+      const jobName = String(nameArg || '').trim();
+      if (!jobName) {
+        console.error('❌ Job name is required.');
+        process.exitCode = 1;
+        return;
+      }
+
+      // Support nested folders e.g. emails/welcome
+      const targetFilePath = path.join(jobsDir, `${jobName}.js`);
+      const targetDir = path.dirname(targetFilePath);
+
+      if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+      }
+
+      if (fs.existsSync(targetFilePath)) {
+        console.error(`❌ Job file already exists: jobs/${jobName}.js`);
+        process.exitCode = 1;
+        return;
+      }
+
+      const retries = parseInt(options.retries, 10) || 3;
+      const content = generateJobContent(jobName, options.queue || 'default', retries);
+
+      fs.writeFileSync(targetFilePath, content, 'utf-8');
+      console.log(`\n✅ Created background job: jobs/${jobName}.js (queue: "${options.queue || 'default'}", retries: ${retries})\n`);
+    });
+}
+
+module.exports = {
+  registerCommand,
+  generateJobContent,
+};

package/bin/commands/make-model.js

@@ -0,0 +1,250 @@
+'use strict';
+
+/**
+ * Webspresso CLI - make:model Command
+ * Scaffolds an ORM model in models/<Name>.js with zdb schema and optional migration
+ * @module bin/commands/make-model
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function pluralize(word) {
+  if (!word) return '';
+  const lower = word.toLowerCase();
+  if (lower.endsWith('y') && !/[aeiou]y$/.test(lower)) {
+    return lower.slice(0, -1) + 'ies';
+  }
+  if (lower.endsWith('s') || lower.endsWith('sh') || lower.endsWith('ch') || lower.endsWith('x') || lower.endsWith('z')) {
+    return lower + 'es';
+  }
+  return lower + 's';
+}
+
+function parseFields(fieldsArg) {
+  if (!fieldsArg || typeof fieldsArg !== 'string') return [];
+  const parts = fieldsArg.split(',').map((p) => p.trim()).filter(Boolean);
+  const fields = [];
+
+  for (const part of parts) {
+    const [name, type = 'string', modifier = ''] = part.split(':').map((s) => s.trim());
+    if (!name) continue;
+    fields.push({
+      name,
+      type: type.toLowerCase(),
+      isNullable: modifier.toLowerCase() === 'nullable' || modifier.toLowerCase() === 'optional' || name.endsWith('?'),
+    });
+  }
+
+  return fields;
+}
+
+function generateSchemaLines(fields, softDeletes = false) {
+  const lines = ['    id: zdb.id(),'];
+
+  for (const f of fields) {
+    if (f.name === 'id') continue;
+    let expr = 'zdb.string().min(1)';
+
+    switch (f.type) {
+      case 'text':
+        expr = 'zdb.text().optional()';
+        break;
+      case 'integer':
+      case 'int':
+        expr = f.isNullable ? 'zdb.integer().nullable().optional()' : 'zdb.integer().defaultTo(0)';
+        break;
+      case 'number':
+      case 'float':
+      case 'decimal':
+        expr = f.isNullable ? 'zdb.number().nullable().optional()' : 'zdb.number().defaultTo(0)';
+        break;
+      case 'boolean':
+      case 'bool':
+        expr = 'zdb.boolean().defaultTo(false)';
+        break;
+      case 'json':
+        expr = 'zdb.json().optional()';
+        break;
+      case 'date':
+      case 'datetime':
+        expr = 'zdb.date().optional()';
+        break;
+      case 'email':
+        expr = 'zdb.email().optional()';
+        break;
+      case 'file':
+        expr = 'zdb.file().optional()';
+        break;
+      case 'id':
+        expr = 'zdb.id()';
+        break;
+      case 'string':
+      default:
+        expr = f.isNullable ? 'zdb.string().nullable().optional()' : 'zdb.string().min(1)';
+        break;
+    }
+
+    lines.push(`    ${f.name}: ${expr},`);
+  }
+
+  if (softDeletes) {
+    lines.push('    deletedAt: zdb.softDelete().optional(),');
+  }
+
+  lines.push('    createdAt: zdb.timestamps().createdAt,');
+  lines.push('    updatedAt: zdb.timestamps().updatedAt,');
+
+  return lines.join('\n');
+}
+
+function generateModelContent(modelName, tableName, fields, softDeletes = false) {
+  const schemaCode = generateSchemaLines(fields, softDeletes);
+  const softScope = softDeletes ? `,\n  scopes: {\n    default: (q) => q.whereNull('deletedAt'),\n  }` : '';
+
+  return `'use strict';
+
+const { defineModel, zdb } = require('webspresso');
+
+module.exports = defineModel({
+  name: '${modelName}',
+  table: '${tableName}',
+  schema: {
+${schemaCode}
+  }${softScope},
+});
+`;
+}
+
+function generateMigrationContent(tableName, fields, softDeletes = false) {
+  const colLines = ['    table.increments(\'id\').primary();'];
+
+  for (const f of fields) {
+    if (f.name === 'id') continue;
+    switch (f.type) {
+      case 'text':
+        colLines.push(`    table.text('${f.name}')${f.isNullable ? '.nullable()' : ''};`);
+        break;
+      case 'integer':
+      case 'int':
+        colLines.push(`    table.integer('${f.name}')${f.isNullable ? '.nullable()' : '.defaultTo(0)'};`);
+        break;
+      case 'number':
+      case 'float':
+      case 'decimal':
+        colLines.push(`    table.float('${f.name}')${f.isNullable ? '.nullable()' : '.defaultTo(0)'};`);
+        break;
+      case 'boolean':
+      case 'bool':
+        colLines.push(`    table.boolean('${f.name}').defaultTo(false);`);
+        break;
+      case 'json':
+        colLines.push(`    table.json('${f.name}').nullable();`);
+        break;
+      case 'date':
+      case 'datetime':
+        colLines.push(`    table.datetime('${f.name}').nullable();`);
+        break;
+      default:
+        colLines.push(`    table.string('${f.name}')${f.isNullable ? '.nullable()' : '.notNullable()'};`);
+        break;
+    }
+  }
+
+  if (softDeletes) {
+    colLines.push('    table.datetime(\'deletedAt\').nullable();');
+  }
+
+  colLines.push('    table.timestamps(true, true);');
+
+  return `'use strict';
+
+/**
+ * Migration: Create ${tableName} table
+ */
+exports.up = function(knex) {
+  return knex.schema.createTable('${tableName}', (table) => {
+${colLines.join('\n')}
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('${tableName}');
+};
+`;
+}
+
+function registerCommand(program) {
+  program
+    .command('make:model <name>')
+    .alias('model:make')
+    .description('Scaffold an ORM model in models/<Name>.js with zdb schema')
+    .option('-f, --fields <fields>', 'Comma-separated fields (e.g. title:string,content:text,published:boolean)')
+    .option('-t, --table <table>', 'Custom table name (defaults to pluralized lowercase)')
+    .option('-m, --migration', 'Generate corresponding Knex migration file in migrations/')
+    .option('--soft-deletes', 'Include deletedAt column and default scope for soft delete')
+    .option('--root <dir>', 'Root directory of the project', process.cwd())
+    .action((nameArg, options) => {
+      const rootDir = path.resolve(options.root || process.cwd());
+      const modelsDir = path.join(rootDir, 'models');
+      const migrationsDir = path.join(rootDir, 'migrations');
+
+      if (!fs.existsSync(modelsDir)) {
+        fs.mkdirSync(modelsDir, { recursive: true });
+      }
+
+      // Format Model Name (PascalCase, e.g. post -> Post, blog_post -> BlogPost)
+      const cleanName = String(nameArg || '').trim();
+      const modelName = cleanName.charAt(0).toUpperCase() + cleanName.slice(1);
+      const tableName = options.table ? String(options.table).trim() : pluralize(cleanName.toLowerCase());
+
+      const modelFilePath = path.join(modelsDir, `${modelName}.js`);
+      if (fs.existsSync(modelFilePath)) {
+        console.error(`❌ Model file already exists: models/${modelName}.js`);
+        process.exitCode = 1;
+        return;
+      }
+
+      const fields = parseFields(options.fields);
+      const modelContent = generateModelContent(modelName, tableName, fields, Boolean(options.softDeletes));
+
+      fs.writeFileSync(modelFilePath, modelContent, 'utf-8');
+      console.log(`\n✅ Created model: models/${modelName}.js (table: "${tableName}")`);
+
+      // Optional migration generation
+      if (options.migration) {
+        if (!fs.existsSync(migrationsDir)) {
+          fs.mkdirSync(migrationsDir, { recursive: true });
+        }
+
+        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 migrationFileName = `${timestamp}_create_${tableName}_table.js`;
+        const migrationFilePath = path.join(migrationsDir, migrationFileName);
+        const migrationContent = generateMigrationContent(tableName, fields, Boolean(options.softDeletes));
+
+        fs.writeFileSync(migrationFilePath, migrationContent, 'utf-8');
+        console.log(`✅ Created migration: migrations/${migrationFileName}`);
+      }
+
+      console.log('');
+    });
+}
+
+module.exports = {
+  registerCommand,
+  pluralize,
+  parseFields,
+  generateSchemaLines,
+  generateModelContent,
+  generateMigrationContent,
+};