millas 0.2.28 → 0.2.30

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"
+    }
+  ]
+}

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

@@ -0,0 +1,14 @@
+module.exports = `const { Model, fields } = require('millas/src');
+
+class {{ name | pascalCase }} extends Model {
+  static table = '{{ name | snakeCase | plural }}';
+  
+  static fields = {
+    id: fields.id(),
+    created_at: fields.timestamp(),
+    updated_at: fields.timestamp(),
+  };
+}
+
+module.exports = {{ name | pascalCase }};
+`;

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

@@ -0,0 +1,17 @@
+module.exports = `const { Migration } = require('millas/src');
+
+class Create{{ name | pascalCase | plural }}Table extends Migration {
+  async up(schema) {
+    await schema.createTable('{{ name | snakeCase | plural }}', (table) => {
+      table.id();
+      table.timestamps();
+    });
+  }
+
+  async down(schema) {
+    await schema.dropTable('{{ name | snakeCase | plural }}');
+  }
+}
+
+module.exports = Create{{ name | pascalCase | plural }}Table;
+`;

package/src/templates/model/schema.json

@@ -0,0 +1,30 @@
+{
+  "name": "model",
+  "description": "Generate a new model",
+  "arguments": [
+    {
+      "name": "name",
+      "type": "string",
+      "required": true,
+      "description": "Model name"
+    }
+  ],
+  "options": [
+    {
+      "name": "migration",
+      "type": "boolean",
+      "description": "Generate migration file"
+    }
+  ],
+  "files": [
+    {
+      "template": "default.template.js",
+      "output": "app/models/{{ name | pascalCase }}.js"
+    },
+    {
+      "template": "migration.template.js",
+      "output": "database/migrations/{{ timestamp }}_create_{{ name | snakeCase | plural }}_table.js",
+      "condition": "migration"
+    }
+  ]
+}

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

@@ -0,0 +1,12 @@
+module.exports = `class {{ name | pascalCase }}Service {
+  constructor() {
+    // Initialize service
+  }
+
+  async execute() {
+    // Service logic here
+  }
+}
+
+module.exports = {{ name | pascalCase }}Service;
+`;

package/src/templates/service/schema.json

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

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

@@ -0,0 +1,11 @@
+module.exports = `const { Shape } = require('millas/src');
+
+class {{ name | pascalCase }}Shape extends Shape {
+  static rules = {
+    // Define validation rules here
+    // Example: name: v => v.string().required(),
+  };
+}
+
+module.exports = {{ name | pascalCase }}Shape;
+`;

package/src/templates/shape/schema.json

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

package/src/validation/BaseValidator.js

@@ -14,6 +14,7 @@ class BaseValidator {
    * @param {string} [typeError] — message shown when the value fails the base type check
    */
   constructor(typeError) {
+    this._type       = undefined;
     this._typeError    = typeError || null;
     this._required     = false;
     this._requiredMsg  = null;
@@ -162,6 +163,8 @@ class BaseValidator {
    */
   async run(value, key, allData = {}) {
     const label = this._fieldLabel(key);
+    if (this._type === undefined || this._type === null)
+      throw new Error(`[Millas] Validator for "${key}" has no known type.`);
 
     // ── Apply default ───────────────────────────────────────────────────────
     if (this._isEmpty(value) && this._defaultValue !== undefined) {

package/src/validation/types.js

@@ -39,8 +39,8 @@ const { BaseValidator, _titleCase } = require('./BaseValidator');
 // ── StringValidator ────────────────────────────────────────────────────────────
 
 class StringValidator extends BaseValidator {
-  constructor() {
-    super('Must be a string');
+  constructor(message) {
+    super(message || 'Must be a string');
     this._type       = 'string';
     this._minLen     = null;
     this._maxLen     = null;
@@ -479,7 +479,7 @@ function _parseSize(str) {
 
 // ── Factory functions ─────────────────────────────────────────────────────────
 
-const string  = () => new StringValidator();
+const string  = (message) => new StringValidator(message);
 const email   = () => new EmailValidator();
 const number  = () => new NumberValidator();
 const boolean = () => new BooleanValidator();