millas 0.2.27 → 0.2.29

package/src/scaffold/maker.js

@@ -325,74 +325,134 @@ async function makeShape(name) {
   return write(filePath, lines.join('\n'));
 }
 async function makeCommand(name) {
-  // If name contains ':' it's a namespaced signature like 'email:SendDigest'.
-  // Split off the namespace prefix and use only the last segment for the
-  // class name / filename, but keep the full input as the signature.
-  const parts      = name.split(':');
-  const basePart   = parts[parts.length - 1];                        // e.g. 'SendDigest'
-  const cleanBase  = basePart.replace(/Command$/i, '');              // strip trailing Command
-  const className  = pascalCase(cleanBase) + 'Command';              // e.g. 'SendDigestCommand'
-
-  // Build signature from the full name:
-  //   'email:SendDigest' → 'email:digest'
-  //   'SendDigest'       → 'send-digest'
-  //   'send-digest'      → 'send-digest'
-  const signatureParts = name
+  // Convert command signature to class name
+  // Examples:
+  //   'user'                  → UserCommand (subcommand group)
+  //   'send:newsletter'       → SendNewsletterCommand (simple)
+  //   'email'                 → EmailCommand (subcommand group)
+  
+  const isGroup = !name.includes(':');
+  
+  const parts = name
     .replace(/Command$/i, '')
     .split(':')
-    .map((seg, i, arr) => {
-      // Last segment: strip camelCase — 'SendDigest' → 'send-digest'
-      if (i === arr.length - 1) {
-        return seg
-          .replace(/([a-z])([A-Z])/g, '$1-$2')
-          .toLowerCase();
-      }
-      // Namespace segments: lowercase as-is
-      return seg.toLowerCase();
-    });
-  const signature = signatureParts.join(':');
+    .map(part => pascalCase(part));
+  
+  const className = parts.join('') + 'Command';
+  const signature = name.toLowerCase();
 
   const filePath = resolveAppPath('app/commands', `${className}.js`);
 
-  const content = `'use strict';
+  let content;
+  
+  if (isGroup) {
+    // Generate subcommand group template
+    content = `'use strict';
 
-const { Command } = require('millas/console');
+const { BaseCommand } = require('millas/console');
 
 /**
  * ${className}
  *
- * Run with:  millas call ${signature}
+ * Command group - methods become subcommands automatically.
+ * Class name auto-derived: ${className} → ${signature}:*
+ *
+ * Examples:
+ *   millas ${signature}:create --name <value>
+ *   millas ${signature}:update <id> --name <value>
+ *   millas ${signature}:delete <id>
  */
-class ${className} extends Command {
-  static signature   = '${signature}';
-  static description = 'Description of ${signature}';
+class ${className} extends BaseCommand {
+  // Optional: Add descriptions for subcommands
+  // static commands = {
+  //   create: 'Create a new ${signature}',
+  //   update: 'Update a ${signature}',
+  //   delete: 'Delete a ${signature}',
+  // };
+
+  // Private helper (underscore = not a command)
+  // async _get${pascalCase(signature)}(id) {
+  //   return this.container.resolve('Database')
+  //     .table('${signature}s').find(id);
+  // }
+
+  // Subcommand: Only options
+  async create({ name }) {
+    // millas ${signature}:create --name <value>
+    this.info('Creating ${signature}...');
+    this.success('${pascalCase(signature)} created!');
+  }
 
-  // Optional: positional arguments
-  // static args = [
-  //   { name: 'target', description: 'The target to act on', default: 'all' },
-  // ];
+  // Subcommand: Positional + options
+  async update(id, { name }) {
+    // millas ${signature}:update <id> --name <value>
+    this.info(\`Updating ${signature} \${id}...\`);
+    this.success('${pascalCase(signature)} updated!');
+  }
 
-  // Optional: named options / flags
+  // Subcommand: Only positional
+  async delete(id) {
+    // millas ${signature}:delete <id>
+    this.info(\`Deleting ${signature} \${id}...\`);
+    this.success('${pascalCase(signature)} deleted!');
+  }
+}
+
+module.exports = ${className};
+`;
+  } else {
+    // Generate simple command template
+    content = `'use strict';
+
+const { BaseCommand } = require('millas/console');
+
+/**
+ * ${className}
+ *
+ * Simple command - uses handle() method.
+ * Command name auto-derived: ${className} → ${signature}
+ * Run with: millas ${signature}
+ */
+class ${className} extends BaseCommand {
+  static description = 'Description of ${signature}';
+  
+  // Optional: simple options (declarative)
   // static options = [
-  //   { flag: '--dry-run',    description: 'Preview without making changes' },
-  //   { flag: '--limit <n>',  description: 'Max items to process', default: '50' },
+  //   { flags: '--dry-run', description: 'Preview without making changes' },
+  //   { flags: '--limit <n>', description: 'Max items', defaultValue: '50' },
   // ];
 
-  async handle() {
-    // const target = this.argument('target');
-    // const limit  = this.option('limit');
-    // const dry    = this.option('dryRun');
+  // Optional: custom arguments (advanced)
+  // addArguments(parser) {
+  //   parser
+  //     .argument('<file>', 'Input file path')
+  //     .argument('[output]', 'Output file path', 'output.txt')
+  //     .option('--force', 'Force overwrite');
+  // }
+
+  // Optional: validate inputs before execution
+  // async validate(...args) {
+  //   if (!args[0]) {
+  //     throw new Error('Missing required argument');
+  //   }
+  // }
+
+  async handle(options) {
+    // Access options: options.dryRun, options.limit, etc.
+    // Access DI container: this.container.resolve('ServiceName')
+    // Logging helpers: this.info(), this.success(), this.warn(), this.error()
 
     this.info('Running ${signature}...');
 
     // Your command logic here
 
-    this.success('Done.');
+    this.success('Done!');
   }
 }
 
 module.exports = ${className};
 `;
+  }
 
   return write(filePath, content);
 }

package/src/schematics/Collection.js

@@ -0,0 +1,28 @@
+const SchematicEngine = require('./SchematicEngine');
+
+class Collection {
+  constructor(name, templatesDir) {
+    this.name = name;
+    this.engine = new SchematicEngine(templatesDir);
+    this.schematics = new Map();
+  }
+
+  add(name, schematicName) {
+    this.schematics.set(name, schematicName);
+    return this;
+  }
+
+  async generate(name, data, options = {}) {
+    const schematicName = this.schematics.get(name);
+    if (!schematicName) {
+      throw new Error(`Schematic '${name}' not found in collection '${this.name}'`);
+    }
+    return await this.engine.generate(schematicName, data, options);
+  }
+
+  list() {
+    return Array.from(this.schematics.keys());
+  }
+}
+
+module.exports = Collection;

package/src/schematics/SchematicEngine.js

@@ -0,0 +1,122 @@
+const fs = require('fs');
+const path = require('path');
+const Template = require('./Template');
+
+class SchematicEngine {
+  constructor(templatesDir) {
+    this.templatesDir = templatesDir;
+  }
+
+  load(name) {
+    const dir = path.join(this.templatesDir, name);
+    const schemaPath = path.join(dir, 'schema.json');
+    
+    if (!fs.existsSync(schemaPath)) {
+      throw new Error(`Schematic not found: ${name}`);
+    }
+    
+    const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
+    return { schema, dir };
+  }
+
+  async generate(name, data, options = {}) {
+    const { schema, dir } = this.load(name);
+    
+    this.#validate(schema, data, options);
+
+    const results = [];
+    const allData = { ...data, ...options };
+
+    for (const fileConfig of schema.files) {
+      // Skip conditional files if condition not met
+      if (fileConfig.condition && !options[fileConfig.condition]) {
+        continue;
+      }
+      
+      const templateFile = this.#selectTemplate(schema, fileConfig, options);
+      const templatePath = path.join(dir, templateFile);
+      
+      if (!fs.existsSync(templatePath)) {
+        throw new Error(`Template file not found: ${templateFile}`);
+      }
+      
+      const templateContent = require(templatePath);
+      const template = new Template(templateContent, { helpers: schema.helpers || {} });
+      const rendered = template.render(allData);
+
+      const outputPath = this.#resolveOutputPath(fileConfig.output, allData);
+
+      if (fs.existsSync(outputPath) && !options.force) {
+        throw new Error(`File already exists: ${outputPath}. Use --force to overwrite.`);
+      }
+
+      this.#ensureDir(path.dirname(outputPath));
+      fs.writeFileSync(outputPath, rendered);
+
+      results.push({ path: outputPath, content: rendered });
+    }
+
+    return results.length === 1 ? results[0] : results;
+  }
+
+  #validate(schema, data, options) {
+    for (const arg of schema.arguments || []) {
+      const value = data[arg.name];
+      
+      if (arg.required && !value) {
+        throw new Error(`Missing required argument: ${arg.name}`);
+      }
+      
+      if (value && arg.type) {
+        const actualType = typeof value;
+        if (actualType !== arg.type) {
+          throw new Error(`Argument '${arg.name}' must be of type ${arg.type}, got ${actualType}`);
+        }
+      }
+      
+      if (value && arg.enum && !arg.enum.includes(value)) {
+        throw new Error(`Argument '${arg.name}' must be one of: ${arg.enum.join(', ')}`);
+      }
+    }
+    
+    for (const opt of schema.options || []) {
+      const value = options[opt.name];
+      
+      if (value !== undefined && opt.type) {
+        const actualType = typeof value;
+        if (actualType !== opt.type) {
+          throw new Error(`Option '${opt.name}' must be of type ${opt.type}, got ${actualType}`);
+        }
+      }
+      
+      if (value && opt.enum && !opt.enum.includes(value)) {
+        throw new Error(`Option '${opt.name}' must be one of: ${opt.enum.join(', ')}`);
+      }
+    }
+  }
+
+  #selectTemplate(schema, fileConfig, options) {
+    for (const [key, value] of Object.entries(options)) {
+      if (value === true) {
+        const variant = `${key}.template.js`;
+        if (fs.existsSync(path.join(this.templatesDir, schema.name, variant))) {
+          return variant;
+        }
+      }
+    }
+    return fileConfig.template;
+  }
+
+  #resolveOutputPath(pattern, allData) {
+    const template = new Template(pattern);
+    return path.join(process.cwd(), template.render(allData));
+  }
+
+  #ensureDir(dir) {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+
+module.exports = SchematicEngine;

package/src/schematics/Template.js

@@ -0,0 +1,99 @@
+class Template {
+  constructor(content, options = {}) {
+    this.content = content;
+    this.helpers = options.helpers || {};
+  }
+
+  render(data) {
+    let result = this.content;
+    
+    // Handle conditionals: {{#if key}}...{{else}}...{{/if}}
+    result = this.#processConditionals(result, data);
+    
+    // Handle loops: {{#each key}}...{{/each}}
+    result = this.#processLoops(result, data);
+    
+    // Handle variables: {{ name }}, {{ name | filter | filter2 }}
+    result = result.replace(/\{\{\s*([^}#/|]+)(\s*\|\s*([^}]+))?\s*\}\}/g, 
+      (match, key, _, filters) => {
+        let value = data[key.trim()];
+        if (value === undefined || value === null) return '';
+        if (filters) value = this.#applyFilters(value, filters.trim());
+        return value;
+      }
+    );
+    
+    return result;
+  }
+
+  #processConditionals(content, data) {
+    // Handle {{#if !key}} negation
+    content = content.replace(/\{\{#if\s+!(\w+)\}\}([\s\S]*?)(?:\{\{else\}\}([\s\S]*?))?\{\{\/if\}\}/g,
+      (match, key, trueBranch, falseBranch = '') => {
+        return !data[key] ? trueBranch : falseBranch;
+      }
+    );
+    
+    // Handle {{#if key}}
+    content = content.replace(/\{\{#if\s+(\w+)\}\}([\s\S]*?)(?:\{\{else\}\}([\s\S]*?))?\{\{\/if\}\}/g,
+      (match, key, trueBranch, falseBranch = '') => {
+        return data[key] ? trueBranch : falseBranch;
+      }
+    );
+    
+    return content;
+  }
+
+  #processLoops(content, data) {
+    return content.replace(/\{\{#each\s+(\w+)\}\}([\s\S]*?)\{\{\/each\}\}/g,
+      (match, key, template) => {
+        const items = data[key];
+        if (!Array.isArray(items)) return '';
+        return items.map(item => {
+          const itemTemplate = new Template(template);
+          return itemTemplate.render(typeof item === 'object' ? item : { item });
+        }).join('');
+      }
+    );
+  }
+
+  #applyFilters(value, filtersStr) {
+    const filterNames = filtersStr.split('|').map(f => f.trim());
+    return filterNames.reduce((val, filterName) => this.#applyFilter(val, filterName), value);
+  }
+
+  #applyFilter(value, filter) {
+    if (value === undefined || value === null) return value;
+    
+    const filters = {
+      pascalCase: str => String(str).replace(/(?:^|[-_])(\w)/g, (_, c) => c.toUpperCase()).replace(/[-_]/g, ''),
+      camelCase: str => {
+        const pascal = String(str).replace(/(?:^|[-_])(\w)/g, (_, c) => c.toUpperCase()).replace(/[-_]/g, '');
+        return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+      },
+      snakeCase: str => String(str).replace(/[A-Z]/g, (c, i) => (i ? '_' : '') + c.toLowerCase()).replace(/[-\s]/g, '_'),
+      kebabCase: str => String(str).replace(/[A-Z]/g, (c, i) => (i ? '-' : '') + c.toLowerCase()).replace(/[_\s]/g, '-'),
+      plural: str => {
+        const s = String(str);
+        if (s.endsWith('s')) return s;
+        if (s.endsWith('y')) return s.slice(0, -1) + 'ies';
+        return s + 's';
+      },
+      singular: str => {
+        const s = String(str);
+        if (s.endsWith('ies')) return s.slice(0, -3) + 'y';
+        if (s.endsWith('s')) return s.slice(0, -1);
+        return s;
+      },
+      lower: str => String(str).toLowerCase(),
+      upper: str => String(str).toUpperCase(),
+    };
+    
+    const customFilter = this.helpers[filter];
+    if (customFilter) return customFilter(value);
+    
+    return filters[filter]?.(value) ?? value;
+  }
+}
+
+module.exports = Template;

package/src/schematics/index.js

@@ -0,0 +1,7 @@
+const Template = require('./Template');
+const SchematicEngine = require('./SchematicEngine');
+
+module.exports = {
+  Template,
+  SchematicEngine,
+};

package/src/templates/command/default.template.js

@@ -0,0 +1,14 @@
+module.exports = `const { BaseCommand } = require('millas/src/console');
+
+class {{ name | pascalCase }}Command extends BaseCommand {
+  static signature = '{{ name | kebabCase }}';
+  static description = '{{ name | pascalCase }} command description';
+
+  async run(args, opts) {
+    this.info('Running {{ name | pascalCase }}Command');
+    // Command logic here
+  }
+}
+
+module.exports = {{ name | pascalCase }}Command;
+`;

package/src/templates/command/schema.json

@@ -0,0 +1,19 @@
+{
+  "name": "command",
+  "description": "Generate a new CLI command",
+  "arguments": [
+    {
+      "name": "name",
+      "type": "string",
+      "required": true,
+      "description": "Command name"
+    }
+  ],
+  "options": [],
+  "files": [
+    {
+      "template": "default.template.js",
+      "output": "app/commands/{{ name | pascalCase }}Command.js"
+    }
+  ]
+}

package/src/templates/controller/default.template.js

@@ -0,0 +1,10 @@
+module.exports = `const { Controller } = require('millas/src');
+
+class {{ name | pascalCase }}Controller extends Controller {
+  async handle(req, res) {
+    res.json({ message: 'Hello from {{ name | pascalCase }}Controller' });
+  }
+}
+
+module.exports = {{ name | pascalCase }}Controller;
+`;

package/src/templates/controller/resource.template.js

@@ -0,0 +1,59 @@
+module.exports = `const { Controller } = require('millas/src');
+{{#if model}}
+const {{ model | pascalCase }} = require('../models/{{ model | pascalCase }}');
+{{/if}}
+
+class {{ name | pascalCase }}Controller extends Controller {
+  async index(req, res) {
+{{#if model}}
+    const items = await {{ model | pascalCase }}.all();
+    res.json(items);
+{{else}}
+    res.json({ message: 'List all {{ name | plural }}' });
+{{/if}}
+  }
+
+  async show(req, res) {
+{{#if model}}
+    const item = await {{ model | pascalCase }}.find(req.params.id);
+    if (!item) return res.status(404).json({ error: '{{ model | pascalCase }} not found' });
+    res.json(item);
+{{else}}
+    res.json({ message: 'Show {{ name }} with id: ' + req.params.id });
+{{/if}}
+  }
+
+  async store(req, res) {
+{{#if model}}
+    const item = await {{ model | pascalCase }}.create(req.body);
+    res.status(201).json(item);
+{{else}}
+    res.status(201).json({ message: 'Create new {{ name }}', data: req.body });
+{{/if}}
+  }
+
+  async update(req, res) {
+{{#if model}}
+    const item = await {{ model | pascalCase }}.find(req.params.id);
+    if (!item) return res.status(404).json({ error: '{{ model | pascalCase }} not found' });
+    await item.update(req.body);
+    res.json(item);
+{{else}}
+    res.json({ message: 'Update {{ name }} with id: ' + req.params.id, data: req.body });
+{{/if}}
+  }
+
+  async destroy(req, res) {
+{{#if model}}
+    const item = await {{ model | pascalCase }}.find(req.params.id);
+    if (!item) return res.status(404).json({ error: '{{ model | pascalCase }} not found' });
+    await item.delete();
+    res.status(204).send();
+{{else}}
+    res.status(204).send();
+{{/if}}
+  }
+}
+
+module.exports = {{ name | pascalCase }}Controller;
+`;

package/src/templates/controller/schema.json

@@ -0,0 +1,30 @@
+{
+  "name": "controller",
+  "description": "Generate a new controller",
+  "arguments": [
+    {
+      "name": "name",
+      "type": "string",
+      "required": true,
+      "description": "Controller name"
+    }
+  ],
+  "options": [
+    {
+      "name": "resource",
+      "type": "boolean",
+      "description": "Generate resource controller with CRUD methods"
+    },
+    {
+      "name": "model",
+      "type": "string",
+      "description": "Associated model name"
+    }
+  ],
+  "files": [
+    {
+      "template": "default.template.js",
+      "output": "app/controllers/{{ name | pascalCase }}Controller.js"
+    }
+  ]
+}

package/src/templates/job/default.template.js

@@ -0,0 +1,11 @@
+module.exports = `const { Job } = require('millas/src');
+
+class {{ name | pascalCase }}Job extends Job {
+  async handle(data) {
+    // Job logic here
+    this.logger.info('Processing {{ name | pascalCase }}Job', data);
+  }
+}
+
+module.exports = {{ name | pascalCase }}Job;
+`;

package/src/templates/job/schema.json

@@ -0,0 +1,19 @@
+{
+  "name": "job",
+  "description": "Generate a new job",
+  "arguments": [
+    {
+      "name": "name",
+      "type": "string",
+      "required": true,
+      "description": "Job name"
+    }
+  ],
+  "options": [],
+  "files": [
+    {
+      "template": "default.template.js",
+      "output": "app/jobs/{{ name | pascalCase }}Job.js"
+    }
+  ]
+}

package/src/templates/middleware/default.template.js

@@ -0,0 +1,11 @@
+module.exports = `const { Middleware } = require('millas/src');
+
+class {{ name | pascalCase }}Middleware extends Middleware {
+  async handle(req, res, next) {
+    // Add your middleware logic here
+    next();
+  }
+}
+
+module.exports = {{ name | pascalCase }}Middleware;
+`;

package/src/templates/middleware/schema.json

@@ -0,0 +1,19 @@
+{
+  "name": "middleware",
+  "description": "Generate a new middleware",
+  "arguments": [
+    {
+      "name": "name",
+      "type": "string",
+      "required": true,
+      "description": "Middleware name"
+    }
+  ],
+  "options": [],
+  "files": [
+    {
+      "template": "default.template.js",
+      "output": "app/middleware/{{ name | pascalCase }}Middleware.js"
+    }
+  ]
+}

package/src/templates/migration/default.template.js

@@ -0,0 +1,14 @@
+module.exports = `const { Migration } = require('millas/src');
+
+class {{ name | pascalCase }} extends Migration {
+  async up(schema) {
+    // Define schema changes here
+  }
+
+  async down(schema) {
+    // Reverse schema changes here
+  }
+}
+
+module.exports = {{ name | pascalCase }};
+`;

package/src/templates/migration/schema.json

@@ -0,0 +1,19 @@
+{
+  "name": "migration",
+  "description": "Generate a new migration",
+  "arguments": [
+    {
+      "name": "name",
+      "type": "string",
+      "required": true,
+      "description": "Migration name"
+    }
+  ],
+  "options": [],
+  "files": [
+    {
+      "template": "default.template.js",
+      "output": "database/migrations/{{ timestamp }}_{{ name | snakeCase }}.js"
+    }
+  ]
+}