webspresso 0.0.13 → 0.0.15

package/README.md

@@ -782,14 +782,10 @@ Webspresso includes a minimal, Eloquent-inspired ORM built on Knex with Zod sche
 ### Quick Start
 
 ```javascript
-const { z } = require('zod');
-const { createSchemaHelpers, defineModel, createDatabase } = require('webspresso');
+const { zdb, defineModel, createDatabase } = require('webspresso');
 
-// 1. Create schema helpers
-const zdb = createSchemaHelpers(z);
-
-// 2. Define your schema with database metadata
-const UserSchema = z.object({
+// 1. Define your schema with database metadata
+const UserSchema = zdb.schema({
   id: zdb.id(),
   email: zdb.string({ unique: true, index: true }),
   name: zdb.string({ maxLength: 100 }),
@@ -841,6 +837,7 @@ The `zdb` helpers wrap Zod schemas with database column metadata:
 | `zdb.datetime(opts)` | DATETIME column | `nullable` |
 | `zdb.timestamp(opts)` | TIMESTAMP column | `auto: 'create'\|'update'`, `nullable` |
 | `zdb.json(opts)` | JSON column | `nullable` |
+| `zdb.array(itemSchema, opts)` | ARRAY column (stored as JSON) | `nullable` |
 | `zdb.enum(values, opts)` | ENUM column | `default`, `nullable` |
 | `zdb.foreignKey(table, opts)` | Foreign key (bigint) | `referenceColumn`, `nullable` |
 | `zdb.foreignUuid(table, opts)` | Foreign key (uuid) | `referenceColumn`, `nullable` |

package/bin/commands/add-tailwind.js

@@ -0,0 +1,151 @@
+/**
+ * Add Tailwind Command
+ * Add Tailwind CSS to the project with build process
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function registerCommand(program) {
+  program
+    .command('add tailwind')
+    .description('Add Tailwind CSS to the project with build process')
+    .action(async () => {
+      if (!fs.existsSync('package.json')) {
+        console.error('❌ Not a Webspresso project! Run this command in your project directory.');
+        process.exit(1);
+      }
+      
+      console.log('\n🎨 Adding Tailwind CSS to your project...\n');
+      
+      // Read package.json
+      const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf-8'));
+      
+      // Add dev dependencies
+      if (!packageJson.devDependencies) {
+        packageJson.devDependencies = {};
+      }
+      
+      packageJson.devDependencies['tailwindcss'] = '^3.4.1';
+      packageJson.devDependencies['postcss'] = '^8.4.35';
+      packageJson.devDependencies['autoprefixer'] = '^10.4.17';
+      
+      // Add build scripts
+      if (!packageJson.scripts) {
+        packageJson.scripts = {};
+      }
+      
+      packageJson.scripts['build:css'] = 'tailwindcss -i ./src/input.css -o ./public/css/style.css --minify';
+      packageJson.scripts['watch:css'] = 'tailwindcss -i ./src/input.css -o ./public/css/style.css --watch';
+      
+      // Update dev script to include CSS watch
+      if (packageJson.scripts.dev) {
+        packageJson.scripts.dev = 'npm run watch:css & node --watch server.js';
+      }
+      
+      // Update start script to build CSS
+      if (packageJson.scripts.start) {
+        packageJson.scripts.start = 'npm run build:css && NODE_ENV=production node server.js';
+      }
+      
+      fs.writeFileSync('package.json', JSON.stringify(packageJson, null, 2) + '\n');
+      console.log('✅ Updated package.json');
+      
+      // Create src directory if it doesn't exist
+      if (!fs.existsSync('src')) {
+        fs.mkdirSync('src', { recursive: true });
+      }
+      
+      // Create input.css
+      const inputCss = `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+`;
+      
+      fs.writeFileSync('src/input.css', inputCss);
+      console.log('✅ Created src/input.css');
+      
+      // Create tailwind.config.js
+      const tailwindConfig = `/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: [
+    './pages/**/*.{njk,js}',
+    './views/**/*.njk',
+    './src/**/*.js'
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}
+`;
+      
+      fs.writeFileSync('tailwind.config.js', tailwindConfig);
+      console.log('✅ Created tailwind.config.js');
+      
+      // Create postcss.config.js
+      const postcssConfig = `module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}
+`;
+      
+      fs.writeFileSync('postcss.config.js', postcssConfig);
+      console.log('✅ Created postcss.config.js');
+      
+      // Check if layout.njk exists and update it (before creating CSS)
+      const layoutPath = 'views/layout.njk';
+      if (fs.existsSync(layoutPath)) {
+        let layoutContent = fs.readFileSync(layoutPath, 'utf-8');
+        
+        // Remove CDN script if exists
+        layoutContent = layoutContent.replace(
+          /<script src="https:\/\/cdn\.tailwindcss\.com"><\/script>/g,
+          ''
+        );
+        
+        // Add local CSS link if not exists
+        if (!layoutContent.includes('/css/style.css')) {
+          layoutContent = layoutContent.replace(
+            /(<\/head>)/,
+            '  <link rel="stylesheet" href="/css/style.css">\n$1'
+          );
+        }
+        
+        fs.writeFileSync(layoutPath, layoutContent);
+        console.log('✅ Updated views/layout.njk');
+      }
+      
+      // Create public/css directory
+      if (!fs.existsSync('public/css')) {
+        fs.mkdirSync('public/css', { recursive: true });
+      }
+      
+      // Create placeholder CSS
+      fs.writeFileSync('public/css/style.css', '/* Run npm run build:css */\n');
+      console.log('✅ Created public/css/style.css');
+      
+      // Try to build CSS if tailwindcss is already installed
+      const tailwindBin = path.join(process.cwd(), 'node_modules', '.bin', 'tailwindcss');
+      if (fs.existsSync(tailwindBin)) {
+        try {
+          console.log('\n🎨 Building Tailwind CSS from your templates...');
+          execSync('npm run build:css', { stdio: 'inherit', cwd: process.cwd() });
+          console.log('✅ Tailwind CSS built successfully!\n');
+        } catch (err) {
+          console.log('\n⚠️  CSS build failed. Run "npm run build:css" manually.\n');
+        }
+      } else {
+        console.log('\n✅ Tailwind CSS added successfully!\n');
+        console.log('Next steps:');
+        console.log('  npm install');
+        console.log('  npm run build:css');
+        console.log('  npm run dev\n');
+      }
+    });
+}
+
+module.exports = { registerCommand };

package/bin/commands/api.js

@@ -0,0 +1,70 @@
+/**
+ * API Command
+ * Add a new API endpoint to the current project
+ */
+
+const inquirer = require('inquirer');
+const fs = require('fs');
+const path = require('path');
+
+function registerCommand(program) {
+  program
+    .command('api')
+    .description('Add a new API endpoint 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: 'API route path (e.g., /api/users or /api/users/[id]):',
+          validate: (input) => {
+            if (!input.startsWith('/api/')) {
+              return 'API route must start with /api/';
+            }
+            return true;
+          }
+        },
+        {
+          type: 'list',
+          name: 'method',
+          message: 'HTTP method:',
+          choices: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
+          default: 'GET'
+        }
+      ]);
+      
+      const route = answers.route.replace(/^\/api\//, '');
+      const routePath = path.join('pages', 'api', route);
+      const dirPath = path.dirname(routePath);
+      const fileName = path.basename(routePath);
+      
+      // Create directory
+      fs.mkdirSync(dirPath, { recursive: true });
+      
+      // Create API file
+      const apiFile = path.join(dirPath, `${fileName}.${answers.method.toLowerCase()}.js`);
+      
+      const apiContent = `/**
+ * ${answers.method} ${answers.route}
+ */
+
+module.exports = async function handler(req, res) {
+  res.json({
+    message: 'Hello from ${answers.route}',
+    method: '${answers.method}',
+    timestamp: new Date().toISOString()
+  });
+};
+`;
+      
+      fs.writeFileSync(apiFile, apiContent);
+      console.log(`\n✅ Created ${apiFile}\n`);
+    });
+}
+
+module.exports = { registerCommand };

package/bin/commands/db-make.js

@@ -0,0 +1,76 @@
+/**
+ * DB Make Command
+ * Create a new migration file
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { loadDbConfig } = require('../utils/db');
+const { getDefaultMigrationContent } = require('../utils/migration');
+
+function registerCommand(program) {
+  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`);
+    });
+}
+
+module.exports = { registerCommand };

package/bin/commands/db-migrate.js

@@ -0,0 +1,43 @@
+/**
+ * DB Migrate Command
+ * Run pending database migrations
+ */
+
+const { loadDbConfig, createDbInstance } = require('../utils/db');
+
+function registerCommand(program) {
+  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();
+      }
+    });
+}
+
+module.exports = { registerCommand };

package/bin/commands/db-rollback.js

@@ -0,0 +1,48 @@
+/**
+ * DB Rollback Command
+ * Rollback the last batch of migrations
+ */
+
+const { loadDbConfig, createDbInstance } = require('../utils/db');
+
+function registerCommand(program) {
+  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();
+      }
+    });
+}
+
+module.exports = { registerCommand };

package/bin/commands/db-status.js

@@ -0,0 +1,53 @@
+/**
+ * DB Status Command
+ * Show migration status
+ */
+
+const { loadDbConfig, createDbInstance } = require('../utils/db');
+
+function registerCommand(program) {
+  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();
+      }
+    });
+}
+
+module.exports = { registerCommand };

package/bin/commands/dev.js

@@ -0,0 +1,73 @@
+/**
+ * Dev Command
+ * Start development server
+ */
+
+const fs = require('fs');
+const { spawn } = require('child_process');
+
+function registerCommand(program) {
+  program
+    .command('dev')
+    .description('Start development server')
+    .option('-p, --port <port>', 'Port number', '3000')
+    .option('--no-css', 'Skip CSS watch (if Tailwind is set up)')
+    .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 = 'development';
+      
+      const hasTailwind = fs.existsSync('tailwind.config.js') && fs.existsSync('src/input.css');
+      const shouldWatchCss = hasTailwind && options.css !== false;
+      
+      if (shouldWatchCss) {
+        console.log(`\n🚀 Starting development server on port ${options.port}...`);
+        console.log('   Watching CSS and server files...\n');
+        
+        // Start CSS watch
+        const cssWatch = spawn('npm', ['run', 'watch:css'], {
+          stdio: 'inherit',
+          shell: true
+        });
+        
+        // Start server
+        const server = spawn('node', ['--watch', 'server.js'], {
+          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}...\n`);
+        
+        const { spawn } = require('child_process');
+        const child = spawn('node', ['--watch', 'server.js'], {
+          stdio: 'inherit',
+          shell: true,
+          env: { ...process.env, PORT: options.port, NODE_ENV: 'development' }
+        });
+        
+        child.on('exit', (code) => {
+          process.exit(code || 0);
+        });
+      }
+    });
+}
+
+module.exports = { registerCommand };