webspresso 0.0.99 → 0.0.101

package/bin/commands/make-mail.js

@@ -0,0 +1,93 @@
+'use strict';
+
+/**
+ * Webspresso CLI - make:mail Command
+ * Scaffolds a declarative Mailable class in emails/<name>.js
+ * @module bin/commands/make-mail
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function generateMailContent(rawName) {
+  const baseName = rawName.replace(/email$/i, '').replace(/mail$/i, '').trim();
+  const cleanBase = baseName.charAt(0).toUpperCase() + baseName.slice(1);
+  const className = `${cleanBase}Email`;
+  const tplName = cleanBase.toLowerCase();
+
+  return `'use strict';
+
+const { Mailable } = require('webspresso');
+
+/**
+ * Mailable: ${className}
+ * Send via: req.mailer.send(new ${className}(user))
+ */
+class ${className} extends Mailable {
+  constructor(recipient, data = {}) {
+    super();
+    this.recipient = recipient;
+    this.data = data;
+  }
+
+  /**
+   * Build email definition
+   */
+  build() {
+    const toAddress = typeof this.recipient === 'string' ? this.recipient : this.recipient?.email;
+    const toName = typeof this.recipient === 'object' ? this.recipient?.name : undefined;
+
+    this.to(toAddress, toName)
+      .subject('Hello from Webspresso')
+      .view('${tplName}', this.data);
+  }
+}
+
+module.exports = {
+  ${className},
+};
+`;
+}
+
+function registerCommand(program) {
+  program
+    .command('make:mail <name>')
+    .alias('mail:make')
+    .alias('make:mailable')
+    .description('Scaffold a declarative Mailable class in emails/<name>.js')
+    .option('--root <dir>', 'Root directory of the project', process.cwd())
+    .action((nameArg, options) => {
+      const rootDir = path.resolve(options.root || process.cwd());
+      const emailsDir = path.join(rootDir, 'emails');
+
+      if (!fs.existsSync(emailsDir)) {
+        fs.mkdirSync(emailsDir, { recursive: true });
+      }
+
+      const rawName = String(nameArg || '').trim();
+      if (!rawName) {
+        console.error('❌ Mailable name is required.');
+        process.exitCode = 1;
+        return;
+      }
+
+      const cleanName = rawName.replace(/\.js$/, '');
+      const fileName = cleanName.endsWith('Email') ? cleanName : `${cleanName}Email`;
+      const targetFilePath = path.join(emailsDir, `${fileName}.js`);
+
+      if (fs.existsSync(targetFilePath)) {
+        console.error(`❌ Mailable file already exists: ${path.relative(rootDir, targetFilePath)}`);
+        process.exitCode = 1;
+        return;
+      }
+
+      const content = generateMailContent(cleanName);
+      fs.writeFileSync(targetFilePath, content, 'utf-8');
+      console.log(`\n✅ Created Mailable class: ${path.relative(rootDir, targetFilePath)}\n`);
+    });
+}
+
+module.exports = {
+  registerCommand,
+  generateMailContent,
+};

package/bin/commands/make-policy.js

@@ -0,0 +1,106 @@
+'use strict';
+
+/**
+ * Webspresso CLI - make:policy Command
+ * Scaffolds an authorization policy in policies/<name>.policy.js
+ * @module bin/commands/make-policy
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function generatePolicyContent(policyName) {
+  const modelName = policyName.replace(/policy$/i, '').trim();
+  const cleanName = modelName.charAt(0).toUpperCase() + modelName.slice(1);
+
+  return `'use strict';
+
+/**
+ * Authorization Policy: ${cleanName}
+ * Invoked via req.bouncer.authorize('${cleanName.toLowerCase()}.update', record)
+ * or {% if fsy.can('${cleanName.toLowerCase()}.update', record) %}
+ */
+module.exports = {
+  name: '${cleanName.toLowerCase()}',
+
+  /**
+   * Determine whether the user can view any records
+   */
+  async viewAny(user) {
+    return true;
+  },
+
+  /**
+   * Determine whether the user can view the specific record
+   */
+  async view(user, record) {
+    return true;
+  },
+
+  /**
+   * Determine whether the user can create records
+   */
+  async create(user) {
+    return Boolean(user);
+  },
+
+  /**
+   * Determine whether the user can update the record
+   */
+  async update(user, record) {
+    if (!user) return false;
+    if (user.isAdmin || user.role === 'admin') return true;
+    return record && (record.userId === user.id || record.user_id === user.id);
+  },
+
+  /**
+   * Determine whether the user can delete the record
+   */
+  async delete(user, record) {
+    if (!user) return false;
+    return Boolean(user.isAdmin || user.role === 'admin');
+  },
+};
+`;
+}
+
+function registerCommand(program) {
+  program
+    .command('make:policy <name>')
+    .alias('policy:make')
+    .description('Scaffold an authorization policy in policies/<name>.policy.js')
+    .option('--root <dir>', 'Root directory of the project', process.cwd())
+    .action((nameArg, options) => {
+      const rootDir = path.resolve(options.root || process.cwd());
+      const policiesDir = path.join(rootDir, 'policies');
+
+      if (!fs.existsSync(policiesDir)) {
+        fs.mkdirSync(policiesDir, { recursive: true });
+      }
+
+      const rawName = String(nameArg || '').trim();
+      if (!rawName) {
+        console.error('❌ Policy name is required.');
+        process.exitCode = 1;
+        return;
+      }
+
+      const policyBase = rawName.replace(/\.policy(\.js)?$/, '').replace(/\.js$/, '');
+      const targetFilePath = path.join(policiesDir, `${policyBase}.policy.js`);
+
+      if (fs.existsSync(targetFilePath)) {
+        console.error(`❌ Policy file already exists: ${path.relative(rootDir, targetFilePath)}`);
+        process.exitCode = 1;
+        return;
+      }
+
+      const content = generatePolicyContent(policyBase);
+      fs.writeFileSync(targetFilePath, content, 'utf-8');
+      console.log(`\n✅ Created authorization policy: ${path.relative(rootDir, targetFilePath)}\n`);
+    });
+}
+
+module.exports = {
+  registerCommand,
+  generatePolicyContent,
+};

package/bin/commands/run.js

@@ -0,0 +1,195 @@
+'use strict';
+
+/**
+ * Webspresso CLI - run Command
+ * Executes custom management commands with injected framework context
+ * @module bin/commands/run
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { createCommandRegistry, executeCommand } = require('../../core/commands');
+const { createEventDispatcher } = require('../../core/events');
+const { createMailer } = require('../../core/mail');
+const { resolveDbConfigIfExists, createDbInstance } = require('../utils/db');
+
+/**
+ * Helper to parse unknown CLI options into a flags object
+ * e.g. ['--dry-run', '--limit', '50', 'arg1'] -> flags: { dryRun: true, limit: 50 }, args: ['arg1']
+ * @param {string[]} rawArgs
+ * @returns {{ flags: Object, args: string[] }}
+ */
+function parseRawArgs(rawArgs = []) {
+  const flags = {};
+  const args = [];
+
+  for (let i = 0; i < rawArgs.length; i++) {
+    const item = rawArgs[i];
+    if (item.startsWith('--')) {
+      const withoutDashes = item.slice(2);
+      if (withoutDashes.includes('=')) {
+        const [k, v] = withoutDashes.split('=');
+        flags[camelCase(k)] = parseVal(v);
+      } else {
+        const next = rawArgs[i + 1];
+        if (next && !next.startsWith('-')) {
+          flags[camelCase(withoutDashes)] = parseVal(next);
+          i++;
+        } else {
+          flags[camelCase(withoutDashes)] = true;
+        }
+      }
+    } else if (item.startsWith('-') && item.length === 2) {
+      const flagChar = item.slice(1);
+      const next = rawArgs[i + 1];
+      if (next && !next.startsWith('-')) {
+        flags[flagChar] = parseVal(next);
+        i++;
+      } else {
+        flags[flagChar] = true;
+      }
+    } else {
+      args.push(item);
+    }
+  }
+
+  return { flags, args };
+}
+
+function camelCase(str) {
+  return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+function parseVal(val) {
+  if (val === 'true') return true;
+  if (val === 'false') return false;
+  if (val === 'null') return null;
+  if (!Number.isNaN(Number(val)) && val.trim() !== '') return Number(val);
+  return val;
+}
+
+function registerCommand(program) {
+  program
+    .command('run [commandName] [args...]')
+    .alias('command:run')
+    .description('Run a custom management command from commands/ with injected framework context')
+    .option('-d, --dir <path>', 'Custom commands directory (default: ./commands)')
+    .option('-c, --config <path>', 'Path to database config file (optional)')
+    .option('-E, --env <environment>', 'Environment name (default: development)')
+    .allowUnknownOption(true)
+    .action(async (commandName, rawArgs = [], options = {}) => {
+      const rootDir = process.cwd();
+      const commandsDir = options.dir
+        ? path.resolve(rootDir, options.dir)
+        : path.resolve(rootDir, 'commands');
+
+      const registry = createCommandRegistry({ commandsDir });
+      const available = registry.list();
+
+      if (!commandName) {
+        if (available.length === 0) {
+          console.log(`\n⚠️  No custom commands found in "${path.relative(rootDir, commandsDir) || 'commands/'}".`);
+          console.log('   Create your first custom command with:');
+          console.log('   npx webspresso make:command <name>\n');
+          return;
+        }
+
+        console.log(`\n⚡ Available Custom Management Commands (${available.length}):\n`);
+        const maxLen = Math.max(...available.map((c) => c.name.length), 10);
+        for (const cmd of available) {
+          console.log(`  webspresso run ${cmd.name.padEnd(maxLen + 2)} ${cmd.description ? `# ${cmd.description}` : ''}`);
+        }
+        console.log('');
+        return;
+      }
+
+      if (!registry.has(commandName)) {
+        console.error(`\n❌ Error: Command "${commandName}" not found in ${path.relative(rootDir, commandsDir) || 'commands/'}.`);
+        if (available.length > 0) {
+          console.log(`   Available commands: ${registry.names().join(', ')}\n`);
+        } else {
+          console.log('   Use `npx webspresso make:command <name>` to create it.\n');
+        }
+        process.exitCode = 1;
+        return;
+      }
+
+      const cmdDef = registry.get(commandName);
+      const { flags, args } = parseRawArgs(rawArgs);
+
+      // Boot Context
+      let knexInstance = null;
+      let db = null;
+      let services = null;
+      const events = createEventDispatcher();
+      const mailer = createMailer({ backend: 'console' });
+
+      // 1. Database
+      try {
+        const dbInfo = resolveDbConfigIfExists(options.config);
+        if (dbInfo) {
+          knexInstance = await createDbInstance(dbInfo.config, options.env);
+          const { createDatabase } = require('../../core/orm');
+          db = createDatabase({ knex: knexInstance });
+        }
+      } catch (err) {
+        console.warn('⚠️  Could not initialize database for command:', err.message);
+      }
+
+      // 2. Services
+      try {
+        const servicesDir = path.resolve(rootDir, 'services');
+        if (fs.existsSync(servicesDir)) {
+          const { createServiceRegistry } = require('../../src/services');
+          services = createServiceRegistry({ servicesDir, isDev: true });
+        }
+      } catch (err) {
+        console.warn('⚠️  Could not initialize service registry for command:', err.message);
+      }
+
+      // 3. Queue
+      let queue = null;
+      try {
+        const { createQueueDispatcher } = require('../../core/queue');
+        queue = createQueueDispatcher({ db: knexInstance });
+      } catch (_) {
+        queue = {
+          dispatch: async () => {},
+        };
+      }
+
+      console.log(`\n🚀 [webspresso run] Executing "${commandName}"...`);
+      const executionResult = await executeCommand(cmdDef, {
+        args,
+        flags,
+        db,
+        queue,
+        services,
+        mailer,
+        events,
+        logger: console,
+      });
+
+      // Cleanup
+      if (knexInstance && typeof knexInstance.destroy === 'function') {
+        try {
+          await knexInstance.destroy();
+        } catch (_) {}
+      }
+
+      if (executionResult.success) {
+        console.log(`\n✨ Command "${commandName}" completed successfully in ${executionResult.durationMs}ms.\n`);
+      } else {
+        console.error(`\n❌ Command "${commandName}" failed after ${executionResult.durationMs}ms:`);
+        if (executionResult.error) {
+          console.error(executionResult.error.stack || executionResult.error.message);
+        }
+        process.exitCode = 1;
+      }
+    });
+}
+
+module.exports = {
+  registerCommand,
+  parseRawArgs,
+};

package/bin/webspresso.js

@@ -26,6 +26,7 @@ const { registerCommand: registerDbRollback } = require('./commands/db-rollback'
 const { registerCommand: registerDbStatus } = require('./commands/db-status');
 const { registerCommand: registerDbMake } = require('./commands/db-make');
 const { registerCommand: registerDbScaffold } = require('./commands/db-scaffold');
+const { registerCommand: registerDbMakeMigrations } = require('./commands/db-makemigrations');
 const { registerCommand: registerSeed } = require('./commands/seed');
 const { registerCommand: registerAdminSetup } = require('./commands/admin-setup');
 const { registerCommand: registerAdminPassword } = require('./commands/admin-password');
@@ -47,6 +48,15 @@ const { registerCommand: registerMakeModel } = require('./commands/make-model');
 const { registerCommand: registerMakeJob } = require('./commands/make-job');
 const { registerCommand: registerOpenapi } = require('./commands/openapi');
 const { registerCommand: registerTypegen } = require('./commands/typegen');
+const { registerCommand: registerAddDocker } = require('./commands/add-docker');
+const { registerCommand: registerDeployCheck } = require('./commands/deploy-check');
+const { registerCommand: registerRun } = require('./commands/run');
+const { registerCommand: registerList } = require('./commands/list');
+const { registerCommand: registerMakeCommand } = require('./commands/make-command');
+const { registerCommand: registerMakePolicy } = require('./commands/make-policy');
+const { registerCommand: registerMakeFactory } = require('./commands/make-factory');
+const { registerCommand: registerMakeEvent } = require('./commands/make-event');
+const { registerCommand: registerMakeMail } = require('./commands/make-mail');
 
 registerNew(program);
 registerPage(program);
@@ -56,11 +66,13 @@ registerStart(program);
 registerBuild(program);
 registerAddTailwind(program);
 registerAddEsbuild(program);
+registerAddDocker(program);
 registerDbMigrate(program);
 registerDbRollback(program);
 registerDbStatus(program);
 registerDbMake(program);
 registerDbScaffold(program);
+registerDbMakeMigrations(program);
 registerSeed(program);
 registerAdminSetup(program);
 registerAdminPassword(program);
@@ -71,6 +83,7 @@ registerEmailPrune(program);
 registerQueuePrune(program);
 registerUploadPrune(program);
 registerDoctor(program);
+registerDeployCheck(program);
 registerUpgrade(program);
 registerOrmMap(program);
 registerService(program);
@@ -80,8 +93,16 @@ registerAgentsInit(program);
 registerRoutes(program);
 registerMakeModel(program);
 registerMakeJob(program);
+registerMakeCommand(program);
+registerMakePolicy(program);
+registerMakeFactory(program);
+registerMakeEvent(program);
+registerMakeMail(program);
+registerRun(program);
+registerList(program);
 registerOpenapi(program);
 registerTypegen(program);
 
 // Parse arguments
 program.parse();
+

package/core/auth/bouncer.js

@@ -0,0 +1,196 @@
+/**
+ * Webspresso Auth - Bouncer & Policy Authorization Engine (AdonisJS Bouncer & Django Permissions-inspired)
+ * Context-aware authorization helper for routes, handlers, and templates
+ * @module core/auth/bouncer
+ */
+
+const { defaultPolicyManager, AuthorizationError } = require('./policy');
+const { ForbiddenError, UnauthorizedError } = require('../errors');
+
+/**
+ * Context-aware Bouncer instance bound to a specific user
+ */
+class Bouncer {
+  /**
+   * @param {Object|null} user - The subject user (or null for guest)
+   * @param {import('./policy').PolicyManager} [policyManager]
+   */
+  constructor(user = null, policyManager = defaultPolicyManager) {
+    this.user = user;
+    this.policyManager = policyManager;
+  }
+
+  /**
+   * Create a new Bouncer instance for another user
+   * @param {Object|null} user
+   * @returns {Bouncer}
+   */
+  forUser(user) {
+    return new Bouncer(user, this.policyManager);
+  }
+
+  /**
+   * Parse policy and action from arguments
+   * Supports:
+   * 1. ('Post.update', post) -> policy='Post', action='update', resource=post
+   * 2. ('Post', 'update', post) -> policy='Post', action='update', resource=post
+   * 3. ('gate-name', resource) -> policy=null, action='gate-name', resource=resource
+   * 4. (functionRule, resource) -> direct function check
+   * @protected
+   */
+  _parseArgs(actionOrPolicy, ...rest) {
+    if (typeof actionOrPolicy === 'function') {
+      return {
+        isFn: true,
+        fn: actionOrPolicy,
+        resource: rest[0],
+      };
+    }
+
+    if (typeof actionOrPolicy === 'string') {
+      // 1. Dot-notation: 'Post.update'
+      if (actionOrPolicy.includes('.')) {
+        const parts = actionOrPolicy.split('.');
+        const policy = parts[0];
+        const action = parts.slice(1).join('.');
+        return { policy, action, resource: rest[0] };
+      }
+
+      // 2. Separate strings: ('Post', 'update', post)
+      if (rest.length > 0 && typeof rest[0] === 'string') {
+        const policy = actionOrPolicy;
+        const action = rest[0];
+        const resource = rest[1];
+        return { policy, action, resource };
+      }
+
+      // 3. Single gate / permission name: ('edit-settings', setting)
+      return { policy: null, action: actionOrPolicy, resource: rest[0] };
+    }
+
+    return { policy: null, action: String(actionOrPolicy), resource: rest[0] };
+  }
+
+  /**
+   * Check if current user is allowed to perform an action
+   * @param {string|Function} actionOrPolicy
+   * @param {...any} rest
+   * @returns {boolean}
+   */
+  allows(actionOrPolicy, ...rest) {
+    const parsed = this._parseArgs(actionOrPolicy, ...rest);
+
+    // Direct function rule
+    if (parsed.isFn) {
+      try {
+        return Boolean(parsed.fn(this.user, parsed.resource));
+      } catch {
+        return false;
+      }
+    }
+
+    const { policy, action, resource } = parsed;
+
+    // 1. Check Policy Manager (Gates & Policies)
+    if (policy) {
+      if (this.policyManager.hasPolicy(policy)) {
+        return this.policyManager.can(this.user, action, policy, resource);
+      }
+    } else {
+      if (this.policyManager.hasGate(action)) {
+        return this.policyManager.can(this.user, action, null, resource);
+      }
+    }
+
+    // 2. Django-style user permissions matrix check
+    // e.g. user.permissions = ['post.create', 'post.update'] or user.hasPerm(...)
+    if (this.user) {
+      const fullPerm = policy ? `${policy.toLowerCase()}.${action.toLowerCase()}` : action.toLowerCase();
+
+      // Check hasPerm / hasPermission method on user object
+      if (typeof this.user.hasPerm === 'function') {
+        if (this.user.hasPerm(fullPerm, resource)) return true;
+      }
+      if (typeof this.user.hasPermission === 'function') {
+        if (this.user.hasPermission(fullPerm, resource)) return true;
+      }
+
+      // Check permissions array or set
+      const perms = this.user.permissions;
+      if (Array.isArray(perms) || perms instanceof Set) {
+        const permSet = perms instanceof Set ? perms : new Set(perms);
+        if (permSet.has('*') || permSet.has(fullPerm)) {
+          return true;
+        }
+        if (policy && permSet.has(`${policy.toLowerCase()}.*`)) {
+          return true;
+        }
+      }
+
+      // If user has superuser / is_admin flag
+      if (this.user.isSuperuser || this.user.is_superuser) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Check if current user is denied from performing an action
+   * @param {string|Function} actionOrPolicy
+   * @param {...any} rest
+   * @returns {boolean}
+   */
+  denies(actionOrPolicy, ...rest) {
+    return !this.allows(actionOrPolicy, ...rest);
+  }
+
+  /**
+   * Authorize an action. Throws ForbiddenError (or UnauthorizedError) if access is denied.
+   * @param {string|Function} actionOrPolicy
+   * @param {...any} rest
+   * @throws {ForbiddenError|UnauthorizedError}
+   */
+  authorize(actionOrPolicy, ...rest) {
+    if (this.denies(actionOrPolicy, ...rest)) {
+      if (!this.user) {
+        throw new UnauthorizedError('Authentication required to perform this action');
+      }
+      const label = typeof actionOrPolicy === 'string' ? actionOrPolicy : 'action';
+      throw new ForbiddenError(`You are not authorized to perform "${label}"`);
+    }
+    return true;
+  }
+}
+
+/**
+ * Create a Bouncer instance for a user
+ * @param {Object|null} user
+ * @param {import('./policy').PolicyManager} [policyManager]
+ * @returns {Bouncer}
+ */
+function createBouncer(user = null, policyManager = defaultPolicyManager) {
+  return new Bouncer(user, policyManager);
+}
+
+/**
+ * Express middleware that attaches `req.bouncer` automatically
+ * @param {Object} [options={}]
+ * @returns {import('express').RequestHandler}
+ */
+function createBouncerMiddleware(options = {}) {
+  const policyManager = options.policyManager || defaultPolicyManager;
+
+  return function bouncerMiddleware(req, res, next) {
+    const user = req.user || req.auth?.user || null;
+    req.bouncer = new Bouncer(user, policyManager);
+    next();
+  };
+}
+
+module.exports = {
+  Bouncer,
+  createBouncer,
+  createBouncerMiddleware,
+};