millas 0.1.0

package/src/cache/drivers/FileDriver.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const fs   = require('fs-extra');
+const path = require('path');
+
+/**
+ * FileDriver
+ *
+ * Filesystem-backed cache. Persists across restarts.
+ * Stores each key as a JSON file inside the cache directory.
+ *
+ * CACHE_DRIVER=file
+ */
+class FileDriver {
+  constructor(config = {}) {
+    this._dir = config.path || path.join(process.cwd(), 'storage/cache');
+    fs.ensureDirSync(this._dir);
+  }
+
+  async set(key, value, ttl = 0) {
+    const payload = {
+      value,
+      expiresAt: ttl > 0 ? Date.now() + ttl * 1000 : null,
+      storedAt:  Date.now(),
+    };
+    await fs.writeJson(this._filePath(key), payload);
+    return true;
+  }
+
+  async get(key) {
+    const file = this._filePath(key);
+    if (!(await fs.pathExists(file))) return null;
+
+    try {
+      const payload = await fs.readJson(file);
+      if (payload.expiresAt && Date.now() > payload.expiresAt) {
+        await fs.remove(file);
+        return null;
+      }
+      return payload.value;
+    } catch {
+      return null;
+    }
+  }
+
+  async has(key) {
+    return (await this.get(key)) !== null;
+  }
+
+  async delete(key) {
+    const file = this._filePath(key);
+    if (await fs.pathExists(file)) {
+      await fs.remove(file);
+      return true;
+    }
+    return false;
+  }
+
+  async deletePattern(prefix) {
+    const files = await fs.readdir(this._dir);
+    let count   = 0;
+    for (const file of files) {
+      if (file.startsWith(this._hash(prefix))) {
+        await fs.remove(path.join(this._dir, file));
+        count++;
+      }
+    }
+    return count;
+  }
+
+  async flush() {
+    const files = await fs.readdir(this._dir);
+    for (const file of files) {
+      if (file.endsWith('.json')) await fs.remove(path.join(this._dir, file));
+    }
+    return true;
+  }
+
+  async remember(key, ttl, fn) {
+    const cached = await this.get(key);
+    if (cached !== null) return cached;
+    const value = await fn();
+    await this.set(key, value, ttl);
+    return value;
+  }
+
+  async increment(key, amount = 1) {
+    const current = (await this.get(key)) ?? 0;
+    const next    = Number(current) + amount;
+    await this.set(key, next);
+    return next;
+  }
+
+  async decrement(key, amount = 1) {
+    return this.increment(key, -amount);
+  }
+
+  async add(key, value, ttl = 0) {
+    if (await this.has(key)) return false;
+    await this.set(key, value, ttl);
+    return true;
+  }
+
+  async getMany(keys) {
+    const result = {};
+    for (const key of keys) result[key] = await this.get(key);
+    return result;
+  }
+
+  async setMany(entries, ttl = 0) {
+    for (const [key, value] of Object.entries(entries)) {
+      await this.set(key, value, ttl);
+    }
+    return true;
+  }
+
+  async gc() {
+    const files = await fs.readdir(this._dir);
+    const now   = Date.now();
+    let count   = 0;
+    for (const file of files) {
+      if (!file.endsWith('.json')) continue;
+      try {
+        const p = await fs.readJson(path.join(this._dir, file));
+        if (p.expiresAt && now > p.expiresAt) {
+          await fs.remove(path.join(this._dir, file));
+          count++;
+        }
+      } catch { /* skip */ }
+    }
+    return count;
+  }
+
+  // ─── Internal ─────────────────────────────────────────────────────────────
+
+  _filePath(key) {
+    return path.join(this._dir, `${this._hash(key)}.json`);
+  }
+
+  _hash(key) {
+    // Simple deterministic hash for filenames
+    let h = 5381;
+    for (let i = 0; i < key.length; i++) {
+      h = ((h << 5) + h) ^ key.charCodeAt(i);
+      h = h >>> 0;
+    }
+    return h.toString(16).padStart(8, '0') + '_' +
+      key.replace(/[^a-z0-9_-]/gi, '_').slice(0, 40);
+  }
+}
+
+module.exports = FileDriver;

package/src/cache/drivers/MemoryDriver.js

@@ -0,0 +1,158 @@
+'use strict';
+
+/**
+ * MemoryDriver
+ *
+ * In-memory cache with TTL support.
+ * Data does not persist across restarts.
+ * Default driver — zero config required.
+ *
+ * CACHE_DRIVER=memory
+ */
+class MemoryDriver {
+  constructor() {
+    this._store = new Map(); // key → { value, expiresAt }
+  }
+
+  /**
+   * Store a value. ttl = seconds (0 = no expiry).
+   */
+  async set(key, value, ttl = 0) {
+    const expiresAt = ttl > 0 ? Date.now() + ttl * 1000 : null;
+    this._store.set(String(key), {
+      value:     JSON.stringify(value),
+      expiresAt,
+    });
+    return true;
+  }
+
+  /**
+   * Retrieve a value. Returns null if missing or expired.
+   */
+  async get(key) {
+    const entry = this._store.get(String(key));
+    if (!entry) return null;
+
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this._store.delete(String(key));
+      return null;
+    }
+
+    return JSON.parse(entry.value);
+  }
+
+  /**
+   * Check if a key exists and has not expired.
+   */
+  async has(key) {
+    return (await this.get(key)) !== null;
+  }
+
+  /**
+   * Delete a key.
+   */
+  async delete(key) {
+    return this._store.delete(String(key));
+  }
+
+  /**
+   * Delete multiple keys matching a prefix.
+   */
+  async deletePattern(prefix) {
+    let count = 0;
+    for (const key of this._store.keys()) {
+      if (key.startsWith(prefix)) {
+        this._store.delete(key);
+        count++;
+      }
+    }
+    return count;
+  }
+
+  /**
+   * Flush the entire cache.
+   */
+  async flush() {
+    this._store.clear();
+    return true;
+  }
+
+  /**
+   * Get or set — return cached value, or run fn() and cache its result.
+   */
+  async remember(key, ttl, fn) {
+    const cached = await this.get(key);
+    if (cached !== null) return cached;
+    const value = await fn();
+    await this.set(key, value, ttl);
+    return value;
+  }
+
+  /**
+   * Increment a numeric value.
+   */
+  async increment(key, amount = 1) {
+    const current = (await this.get(key)) ?? 0;
+    const next    = Number(current) + amount;
+    await this.set(key, next);
+    return next;
+  }
+
+  /**
+   * Decrement a numeric value.
+   */
+  async decrement(key, amount = 1) {
+    return this.increment(key, -amount);
+  }
+
+  /**
+   * Add only if the key does not exist.
+   */
+  async add(key, value, ttl = 0) {
+    if (await this.has(key)) return false;
+    await this.set(key, value, ttl);
+    return true;
+  }
+
+  /**
+   * Get multiple keys at once.
+   */
+  async getMany(keys) {
+    const result = {};
+    for (const key of keys) {
+      result[key] = await this.get(key);
+    }
+    return result;
+  }
+
+  /**
+   * Set multiple key/value pairs at once.
+   */
+  async setMany(entries, ttl = 0) {
+    for (const [key, value] of Object.entries(entries)) {
+      await this.set(key, value, ttl);
+    }
+    return true;
+  }
+
+  /**
+   * Return the number of entries (including expired).
+   */
+  size() {
+    return this._store.size;
+  }
+
+  /**
+   * Purge all expired entries.
+   */
+  gc() {
+    const now = Date.now();
+    for (const [key, entry] of this._store) {
+      if (entry.expiresAt && now > entry.expiresAt) {
+        this._store.delete(key);
+      }
+    }
+  }
+}
+
+module.exports = MemoryDriver;

package/src/cache/drivers/NullDriver.js

@@ -0,0 +1,27 @@
+'use strict';
+
+/**
+ * NullDriver
+ *
+ * A no-op cache driver — always misses, never stores.
+ * Use in tests to disable caching without code changes.
+ *
+ * CACHE_DRIVER=null
+ */
+class NullDriver {
+  async set()               { return true; }
+  async get()               { return null; }
+  async has()               { return false; }
+  async delete()            { return true; }
+  async deletePattern()     { return 0; }
+  async flush()             { return true; }
+  async remember(k, t, fn)  { return fn(); }
+  async increment(k, n = 1) { return n; }
+  async decrement(k, n = 1) { return -n; }
+  async add()               { return true; }
+  async getMany(keys)       { return Object.fromEntries(keys.map(k => [k, null])); }
+  async setMany()           { return true; }
+  async gc()                { return 0; }
+}
+
+module.exports = NullDriver;

package/src/cache/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const Cache        = require('./Cache');
+const MemoryDriver = require('./drivers/MemoryDriver');
+const FileDriver   = require('./drivers/FileDriver');
+const NullDriver   = require('./drivers/NullDriver');
+
+module.exports = { Cache, MemoryDriver, FileDriver, NullDriver };

package/src/cli.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const program = new Command();
+
+program
+  .name('millas')
+  .description(chalk.cyan('⚡ Millas — A modern batteries-included Node.js framework'))
+  .version('0.1.0');
+
+// Load all command modules
+require('./commands/new')(program);
+require('./commands/serve')(program);
+require('./commands/make')(program);
+require('./commands/migrate')(program);
+require('./commands/route')(program);
+require('./commands/queue')(program);
+
+// Unknown command handler
+program.on('command:*', ([cmd]) => {
+  console.error(chalk.red(`\n  Unknown command: ${chalk.bold(cmd)}\n`));
+  console.log(`  Run ${chalk.cyan('millas --help')} to see available commands.\n`);
+  process.exit(1);
+});
+
+module.exports = { program };

package/src/commands/make.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const chalk = require('chalk');
+const { makeController, makeModel, makeMiddleware, makeService, makeJob, makeMigration } = require('../scaffold/maker');
+
+module.exports = function (program) {
+
+  program
+    .command('make:controller <name>')
+    .description('Generate a new controller')
+    .option('--resource', 'Generate a resource controller with CRUD methods')
+    .action(async (name, options) => {
+      await run('Controller', () => makeController(name, options));
+    });
+
+  program
+    .command('make:model <name>')
+    .description('Generate a new model')
+    .option('-m, --migration', 'Also create a migration file')
+    .action(async (name, options) => {
+      await run('Model', () => makeModel(name, options));
+    });
+
+  program
+    .command('make:middleware <name>')
+    .description('Generate a new middleware')
+    .action(async (name) => {
+      await run('Middleware', () => makeMiddleware(name));
+    });
+
+  program
+    .command('make:service <name>')
+    .description('Generate a new service class')
+    .action(async (name) => {
+      await run('Service', () => makeService(name));
+    });
+
+  program
+    .command('make:job <name>')
+    .description('Generate a new background job')
+    .action(async (name) => {
+      await run('Job', () => makeJob(name));
+    });
+
+  program
+    .command('make:migration <name>')
+    .description('Generate a blank migration file')
+    .action(async (name) => {
+      await run('Migration', () => makeMigration(name));
+    });
+};
+
+async function run(type, fn) {
+  try {
+    const filePath = await fn();
+    console.log(chalk.green(`\n  ✔ ${type} created: `) + chalk.cyan(filePath) + '\n');
+  } catch (err) {
+    console.error(chalk.red(`\n  ✖ Failed to create ${type}: ${err.message}\n`));
+    process.exit(1);
+  }
+}

package/src/commands/migrate.js

@@ -0,0 +1,174 @@
+'use strict';
+
+const chalk = require('chalk');
+const path  = require('path');
+const fs    = require('fs-extra');
+
+module.exports = function (program) {
+
+  program
+    .command('makemigrations')
+    .description('Detect model changes and generate migration files')
+    .action(async () => {
+      const ctx = getProjectContext();
+      const { ModelInspector } = require('../orm/migration/ModelInspector');
+      const inspector = new ModelInspector(
+        ctx.modelsPath,
+        ctx.migrationsPath,
+        ctx.snapshotPath
+      );
+      const result = await inspector.makeMigrations();
+      if (result.files.length === 0) {
+        console.log(chalk.yellow(`\n  ${result.message}\n`));
+      } else {
+        console.log(chalk.green(`\n  ✔  ${result.message}`));
+        result.files.forEach(f => console.log(chalk.cyan(`     + ${f}`)));
+        console.log();
+      }
+    });
+
+  program
+    .command('migrate')
+    .description('Run all pending migrations')
+    .action(async () => {
+      const runner = await getRunner();
+      const result = await runner.migrate();
+      printMigrationResult(result, 'Ran');
+    });
+
+  program
+    .command('migrate:fresh')
+    .description('Drop all tables and re-run all migrations')
+    .action(async () => {
+      console.log(chalk.yellow('\n  ⚠  Dropping all tables...\n'));
+      const runner = await getRunner();
+      const result = await runner.fresh();
+      printMigrationResult(result, 'Ran');
+    });
+
+  program
+    .command('migrate:rollback')
+    .description('Rollback the last batch of migrations')
+    .option('--steps <n>', 'Number of batches to rollback', '1')
+    .action(async (options) => {
+      const runner = await getRunner();
+      const result = await runner.rollback(Number(options.steps));
+      printMigrationResult(result, 'Rolled back');
+    });
+
+  program
+    .command('migrate:reset')
+    .description('Rollback all migrations')
+    .action(async () => {
+      const runner = await getRunner();
+      const result = await runner.reset();
+      printMigrationResult(result, 'Rolled back');
+    });
+
+  program
+    .command('migrate:refresh')
+    .description('Rollback all and re-run all migrations')
+    .action(async () => {
+      const runner = await getRunner();
+      const result = await runner.refresh();
+      printMigrationResult(result, 'Ran');
+    });
+
+  program
+    .command('migrate:status')
+    .description('Show the status of all migrations')
+    .action(async () => {
+      const runner = await getRunner();
+      const rows   = await runner.status();
+
+      if (rows.length === 0) {
+        console.log(chalk.yellow('\n  No migration files found.\n'));
+        return;
+      }
+
+      const colW = Math.max(...rows.map(r => r.name.length)) + 2;
+      console.log(`\n  ${'Migration'.padEnd(colW)}  ${'Status'.padEnd(10)}  Batch`);
+      console.log(chalk.gray('  ' + '─'.repeat(colW + 20)));
+
+      for (const row of rows) {
+        const status = row.status === 'Ran'
+          ? chalk.green(row.status.padEnd(10))
+          : chalk.yellow(row.status.padEnd(10));
+        const batch = row.batch ? chalk.gray(String(row.batch)) : chalk.gray('—');
+        console.log(`  ${chalk.cyan(row.name.padEnd(colW))}  ${status}  ${batch}`);
+      }
+      console.log();
+    });
+
+  program
+    .command('db:seed')
+    .description('Run all database seeders')
+    .action(async () => {
+      const ctx = getProjectContext();
+      const seedersDir = ctx.seedersPath;
+
+      if (!fs.existsSync(seedersDir)) {
+        console.log(chalk.yellow('\n  No seeders directory found.\n'));
+        return;
+      }
+
+      const files = fs.readdirSync(seedersDir)
+        .filter(f => f.endsWith('.js') && !f.startsWith('.'))
+        .sort();
+
+      if (files.length === 0) {
+        console.log(chalk.yellow('\n  No seeder files found.\n'));
+        return;
+      }
+
+      console.log();
+      for (const file of files) {
+        const seeder = require(path.join(seedersDir, file));
+        const db = await getDbConnection();
+        await seeder.run(db);
+        console.log(chalk.green(`  ✔  Seeded: ${file}`));
+      }
+      console.log();
+    });
+};
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function getProjectContext() {
+  const cwd = process.cwd();
+  return {
+    migrationsPath: path.join(cwd, 'database/migrations'),
+    seedersPath:    path.join(cwd, 'database/seeders'),
+    modelsPath:     path.join(cwd, 'app/models'),
+    snapshotPath:   path.join(cwd, '.millas/schema.json'),
+  };
+}
+
+async function getDbConnection() {
+  const configPath = path.join(process.cwd(), 'config/database');
+  if (!fs.existsSync(configPath + '.js')) {
+    throw new Error('config/database.js not found. Are you inside a Millas project?');
+  }
+  const config = require(configPath);
+  const DatabaseManager = require('../orm/drivers/DatabaseManager');
+  DatabaseManager.configure(config);
+  return DatabaseManager.connection();
+}
+
+async function getRunner() {
+  const { MigrationRunner } = require('../orm/migration/MigrationRunner');
+  const ctx = getProjectContext();
+  const db  = await getDbConnection();
+  return new MigrationRunner(db, ctx.migrationsPath);
+}
+
+function printMigrationResult(result, verb) {
+  const list = result.ran || result.rolledBack || [];
+  if (list.length === 0) {
+    console.log(chalk.yellow(`\n  ${result.message}\n`));
+    return;
+  }
+  console.log(chalk.green(`\n  ✔  ${result.message}`));
+  list.forEach(f => console.log(chalk.cyan(`     ${verb === 'Ran' ? '+' : '-'} ${f}`)));
+  console.log();
+}

package/src/commands/new.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const ora = require('ora');
+const { generateProject } = require('../scaffold/generator');
+
+module.exports = function (program) {
+  program
+    .command('new <project-name>')
+    .description('Create a new Millas project')
+    .option('--no-install', 'Skip npm install')
+    .action(async (projectName, options) => {
+      console.log();
+      console.log(chalk.cyan('  ⚡ Millas Framework'));
+      console.log(chalk.gray('  Creating a new project...\n'));
+
+      const targetDir = path.resolve(process.cwd(), projectName);
+
+      if (fs.existsSync(targetDir)) {
+        console.error(chalk.red(`  ✖ Directory "${projectName}" already exists.\n`));
+        process.exit(1);
+      }
+
+      const spinner = ora(`  Scaffolding project ${chalk.bold(projectName)}`).start();
+
+      try {
+        await generateProject(projectName, targetDir);
+        spinner.succeed(chalk.green(`  Project "${projectName}" created successfully!`));
+
+        if (options.install !== false) {
+          const installSpinner = ora('  Installing dependencies...').start();
+          const { execSync } = require('child_process');
+          execSync('npm install', { cwd: targetDir, stdio: 'ignore' });
+          installSpinner.succeed(chalk.green('  Dependencies installed!'));
+        }
+
+        console.log();
+        console.log(chalk.bold('  Next steps:'));
+        console.log(chalk.cyan(`    cd ${projectName}`));
+        console.log(chalk.cyan('    millas serve'));
+        console.log();
+      } catch (err) {
+        spinner.fail(chalk.red('  Failed to create project.'));
+        console.error(chalk.red(`\n  Error: ${err.message}\n`));
+        process.exit(1);
+      }
+    });
+};