express-file-cluster 0.1.4 → 0.1.5

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "express-file-cluster",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Enterprise-grade, zero-boilerplate backend framework with file-based routing and multi-core clustering",
   "license": "MIT",
   "type": "module",
+  "files": [
+    "dist"
+  ],
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/auth/index.ts

@@ -1,71 +0,0 @@
-import type { RequestHandler, Response } from 'express';
-import jwt from 'jsonwebtoken';
-import type { AuthStrategy } from '../types.js';
-
-interface AuthConfig {
-  secret: string;
-  strategy: AuthStrategy;
-  expiresIn: string;
-  cookieDomain?: string | undefined;
-}
-
-let _config: AuthConfig | null = null;
-
-export function configureAuth(config: AuthConfig): void {
-  _config = config;
-}
-
-function getConfig(): AuthConfig {
-  if (!_config) throw new Error('[EFC] Auth not configured — pass jwtSecret to ignite()');
-  return _config;
-}
-
-export function issueToken(res: Response, payload: Record<string, unknown>): void {
-  const { secret, expiresIn, cookieDomain } = getConfig();
-  // expiresIn is a plain string (e.g. '7d'); cast satisfies jwt's branded StringValue
-  const token = jwt.sign(payload, secret, { expiresIn: expiresIn as jwt.SignOptions['expiresIn'] & string });
-  res.cookie('efc_token', token, {
-    httpOnly: true,
-    secure: process.env['NODE_ENV'] === 'production',
-    sameSite: 'strict',
-    ...(cookieDomain !== undefined && { domain: cookieDomain }),
-  });
-}
-
-export function revokeToken(res: Response): void {
-  res.clearCookie('efc_token');
-}
-
-export function signToken(payload: Record<string, unknown>): string {
-  const { secret, expiresIn } = getConfig();
-  return jwt.sign(payload, secret, { expiresIn: expiresIn as jwt.SignOptions['expiresIn'] & string });
-}
-
-export const requireAuth: RequestHandler = (req, res, next) => {
-  const { secret, strategy } = getConfig();
-
-  try {
-    let token: string | undefined;
-
-    if (strategy === 'http-only') {
-      const cookies = (req as typeof req & { cookies: Record<string, string> }).cookies;
-      token = cookies['efc_token'];
-    } else {
-      const auth = req.headers['authorization'];
-      if (typeof auth === 'string' && auth.startsWith('Bearer ')) {
-        token = auth.slice(7);
-      }
-    }
-
-    if (!token) {
-      res.status(401).json({ error: 'Unauthorized' });
-      return;
-    }
-
-    const decoded = jwt.verify(token, secret);
-    (req as typeof req & { user: unknown }).user = decoded;
-    next();
-  } catch {
-    res.status(401).json({ error: 'Unauthorized' });
-  }
-};

package/src/cli/commands/build.ts

@@ -1,43 +0,0 @@
-import { Command } from 'commander';
-import { spawn } from 'node:child_process';
-import chalk from 'chalk';
-
-export function buildCommand(): Command {
-  const cmd = new Command('build');
-
-  cmd
-    .argument('<mode>', 'prod')
-    .description('Build the application for production')
-    .action((mode: string) => {
-      if (mode !== 'prod') {
-        console.error(chalk.red(`Unknown build mode: ${mode}. Use 'prod'.`));
-        process.exit(1);
-      }
-      buildProd();
-    });
-
-  return cmd;
-}
-
-function buildProd(): void {
-  console.log(chalk.cyan('[EFC] Building for production…'));
-
-  // Type-check first
-  const tsc = spawn('npx', ['tsc', '--noEmit'], { stdio: 'inherit' });
-
-  tsc.on('exit', (code) => {
-    if (code !== 0) {
-      console.error(chalk.red('[EFC] TypeScript errors found. Fix them before building.'));
-      process.exit(1);
-    }
-
-    const tsup = spawn('npx', ['tsup'], { stdio: 'inherit' });
-    tsup.on('exit', (tsupCode) => {
-      if (tsupCode === 0) {
-        console.log(chalk.green('[EFC] Build complete → dist/'));
-      } else {
-        process.exit(tsupCode ?? 1);
-      }
-    });
-  });
-}

package/src/cli/commands/diagnostics.ts

@@ -1,124 +0,0 @@
-import { Command } from 'commander';
-import { scanDir } from '../../router/scan.js';
-import path from 'node:path';
-import fs from 'node:fs';
-import chalk from 'chalk';
-
-export function diagnosticsCommands(): Command[] {
-  return [routesCommand(), tasksCommand(), doctorCommand()];
-}
-
-function routesCommand(): Command {
-  return new Command('routes')
-    .description('Print the resolved route table')
-    .action(() => {
-      const apiDir = resolveApiDir();
-      if (!apiDir) {
-        console.error(chalk.red('[EFC] Could not find apiDir (expected src/api)'));
-        process.exit(1);
-      }
-
-      const routes = scanDir(apiDir);
-      if (routes.length === 0) {
-        console.log(chalk.yellow('No routes found.'));
-        return;
-      }
-
-      console.log(chalk.bold('\n  Route Table\n'));
-      console.log(chalk.dim('  ' + '─'.repeat(60)));
-      for (const route of routes) {
-        const rel = path.relative(process.cwd(), route.filePath);
-        console.log(`  ${chalk.cyan(route.urlPath.padEnd(35))} ${chalk.dim(rel)}`);
-      }
-      console.log(chalk.dim('  ' + '─'.repeat(60)));
-      console.log(chalk.dim(`\n  ${routes.length} route(s) found\n`));
-    });
-}
-
-function tasksCommand(): Command {
-  return new Command('tasks')
-    .description('List registered background tasks')
-    .action(() => {
-      const tasksDir = resolveTasksDir();
-      if (!tasksDir || !fs.existsSync(tasksDir)) {
-        console.log(chalk.yellow('No tasks directory found.'));
-        return;
-      }
-
-      const files = fs.readdirSync(tasksDir).filter((f) => /\.(ts|js)$/.test(f));
-      if (files.length === 0) {
-        console.log(chalk.yellow('No tasks found.'));
-        return;
-      }
-
-      console.log(chalk.bold('\n  Background Tasks\n'));
-      for (const file of files) {
-        console.log(`  ${chalk.cyan(path.basename(file, path.extname(file)))}`);
-      }
-      console.log();
-    });
-}
-
-function doctorCommand(): Command {
-  return new Command('doctor')
-    .description('Validate config, env vars, and project setup')
-    .action(() => {
-      const cwd = process.cwd();
-      const checks: { label: string; ok: boolean; hint?: string }[] = [
-        {
-          label: 'package.json exists',
-          ok: fs.existsSync(path.join(cwd, 'package.json')),
-        },
-        {
-          label: 'tsconfig.json exists',
-          ok: fs.existsSync(path.join(cwd, 'tsconfig.json')),
-          hint: 'Run `tsc --init` to create one',
-        },
-        {
-          label: 'src/api directory exists',
-          ok: fs.existsSync(path.join(cwd, 'src', 'api')),
-          hint: 'Create src/api/ and add route files',
-        },
-        {
-          label: 'DATABASE_URL set',
-          ok: Boolean(process.env['DATABASE_URL']),
-          hint: 'Add DATABASE_URL to .env',
-        },
-        {
-          label: 'JWT_SECRET set',
-          ok: Boolean(process.env['JWT_SECRET']),
-          hint: 'Add JWT_SECRET to .env (generate: openssl rand -hex 64)',
-        },
-      ];
-
-      console.log(chalk.bold('\n  EFC Doctor\n'));
-      let allOk = true;
-      for (const check of checks) {
-        const icon = check.ok ? chalk.green('✓') : chalk.red('✗');
-        console.log(`  ${icon}  ${check.label}`);
-        if (!check.ok) {
-          allOk = false;
-          if (check.hint) console.log(chalk.dim(`       → ${check.hint}`));
-        }
-      }
-      console.log();
-      if (allOk) {
-        console.log(chalk.green('  All checks passed!\n'));
-      } else {
-        console.log(chalk.yellow('  Some checks failed. Fix the issues above.\n'));
-        process.exit(1);
-      }
-    });
-}
-
-function resolveApiDir(): string | null {
-  const cwd = process.cwd();
-  const candidates = [path.join(cwd, 'src', 'api'), path.join(cwd, 'api')];
-  return candidates.find((d) => fs.existsSync(d)) ?? null;
-}
-
-function resolveTasksDir(): string | null {
-  const cwd = process.cwd();
-  const candidates = [path.join(cwd, 'src', 'tasks'), path.join(cwd, 'tasks')];
-  return candidates.find((d) => fs.existsSync(d)) ?? null;
-}

package/src/cli/commands/generate.ts

@@ -1,91 +0,0 @@
-import { Command } from 'commander';
-import fs from 'node:fs';
-import path from 'node:path';
-import chalk from 'chalk';
-
-export function generateCommand(): Command {
-  const cmd = new Command('generate').alias('g').description('Scaffold EFC modules');
-
-  cmd
-    .command('route <routePath>')
-    .description('Scaffold a route module, e.g. users/[id]')
-    .action((routePath: string) => generateRoute(routePath));
-
-  cmd
-    .command('task <name>')
-    .description('Scaffold a background task module')
-    .action((name: string) => generateTask(name));
-
-  cmd
-    .command('middleware <name>')
-    .description('Scaffold a middleware module')
-    .action((name: string) => generateMiddleware(name));
-
-  return cmd;
-}
-
-function writeFile(filePath: string, content: string): void {
-  const dir = path.dirname(filePath);
-  fs.mkdirSync(dir, { recursive: true });
-  if (fs.existsSync(filePath)) {
-    console.error(chalk.red(`File already exists: ${filePath}`));
-    process.exit(1);
-  }
-  fs.writeFileSync(filePath, content, 'utf8');
-  console.log(chalk.green(`  created  ${path.relative(process.cwd(), filePath)}`));
-}
-
-function generateRoute(routePath: string): void {
-  const cwd = process.cwd();
-  const filePath = path.join(cwd, 'src', 'api', `${routePath}.ts`);
-
-  const content = `import type { Request, Response } from 'express';
-
-export const GET = async (req: Request, res: Response) => {
-  res.json({ message: 'OK' });
-};
-
-export const POST = async (req: Request, res: Response) => {
-  res.status(201).json({ message: 'Created' });
-};
-`;
-
-  writeFile(filePath, content);
-  console.log(chalk.cyan(`[EFC] Route scaffolded`));
-}
-
-function generateTask(name: string): void {
-  const cwd = process.cwd();
-  const filePath = path.join(cwd, 'src', 'tasks', `${name}.ts`);
-
-  const content = `import { defineTask } from 'express-file-cluster/tasks';
-
-interface ${name}Payload {
-  // TODO: define payload fields
-}
-
-export default defineTask<${name}Payload>(async (payload) => {
-  // TODO: implement task logic
-  console.log('[Task:${name}]', payload);
-});
-`;
-
-  writeFile(filePath, content);
-  console.log(chalk.cyan(`[EFC] Task scaffolded`));
-}
-
-function generateMiddleware(name: string): void {
-  const cwd = process.cwd();
-  const filePath = path.join(cwd, 'src', 'middlewares', `${name}.ts`);
-
-  const content = `import type { Request, Response, NextFunction } from 'express';
-
-export function ${name}(req: Request, res: Response, next: NextFunction): void {
-  // TODO: implement middleware logic
-  next();
-}
-`;
-
-  writeFile(filePath, content);
-  console.log(chalk.cyan(`[EFC] Middleware scaffolded`));
-}

package/src/cli/commands/run.ts

@@ -1,28 +0,0 @@
-import { Command } from 'commander';
-import { spawn } from 'node:child_process';
-import chalk from 'chalk';
-
-export function runCommand(): Command {
-  const cmd = new Command('run');
-
-  cmd
-    .argument('<runner>', 'tests')
-    .description('Run EFC sub-commands (tests)')
-    .allowUnknownOption()
-    .action((runner: string) => {
-      if (runner === 'tests') {
-        runTests(cmd.args.slice(1));
-      } else {
-        console.error(chalk.red(`Unknown runner: ${runner}. Use 'tests'.`));
-        process.exit(1);
-      }
-    });
-
-  return cmd;
-}
-
-function runTests(extraArgs: string[]): void {
-  console.log(chalk.cyan('[EFC] Running tests via Vitest…'));
-  const child = spawn('npx', ['vitest', 'run', ...extraArgs], { stdio: 'inherit' });
-  child.on('exit', (code) => process.exit(code ?? 0));
-}

package/src/cli/commands/start.ts

@@ -1,93 +0,0 @@
-import { Command } from 'commander';
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import fs from 'node:fs';
-import chalk from 'chalk';
-
-export function startCommand(): Command {
-  const cmd = new Command('start');
-
-  cmd
-    .argument('<mode>', 'dev | prod')
-    .description('Start the EFC server')
-    .action((mode: string) => {
-      if (mode === 'dev') {
-        startDev();
-      } else if (mode === 'prod') {
-        startProd();
-      } else {
-        console.error(chalk.red(`Unknown mode: ${mode}. Use 'dev' or 'prod'.`));
-        process.exit(1);
-      }
-    });
-
-  return cmd;
-}
-
-function parseDotenv(cwd: string): Record<string, string> {
-  const envFile = path.join(cwd, '.env');
-  if (!fs.existsSync(envFile)) return {};
-  const vars: Record<string, string> = {};
-  for (const line of fs.readFileSync(envFile, 'utf8').split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-    const eq = trimmed.indexOf('=');
-    if (eq === -1) continue;
-    const key = trimmed.slice(0, eq).trim();
-    const raw = trimmed.slice(eq + 1).trim();
-    vars[key] = raw.replace(/^(['"])(.*)\1$/, '$2');
-  }
-  return vars;
-}
-
-function startDev(): void {
-  const entry = resolveEntry();
-  if (!entry) {
-    console.error(chalk.red('[EFC] Could not find entry point. Expected src/index.ts or index.ts'));
-    process.exit(1);
-  }
-
-  console.log(chalk.cyan('[EFC] Starting development server…'));
-  console.log(chalk.dim(`  Entry: ${entry}`));
-
-  const cwd = process.cwd();
-  const localTsx = path.join(cwd, 'node_modules', '.bin', 'tsx');
-  const tsx = fs.existsSync(localTsx) ? localTsx : 'tsx';
-
-  // .env values are base; existing process.env takes precedence (same as dotenv default)
-  const env: NodeJS.ProcessEnv = { ...parseDotenv(cwd), ...process.env, NODE_ENV: 'development' };
-
-  const child = spawn(tsx, ['watch', entry], { stdio: 'inherit', env });
-  child.on('exit', (code) => process.exit(code ?? 0));
-}
-
-function startProd(): void {
-  const cwd = process.cwd();
-  const distEntry = path.join(cwd, 'dist', 'index.js');
-
-  if (!fs.existsSync(distEntry)) {
-    console.error(chalk.red('[EFC] dist/index.js not found. Run `efc build prod` first.'));
-    process.exit(1);
-  }
-
-  console.log(chalk.cyan('[EFC] Starting production server…'));
-
-  // Production env comes exclusively from process.env — no .env file loading.
-  // Platforms (Docker, Kubernetes, Railway, Heroku, etc.) inject vars directly.
-  const child = spawn('node', [distEntry], {
-    stdio: 'inherit',
-    env: { ...process.env, NODE_ENV: 'production' },
-  });
-  child.on('exit', (code) => process.exit(code ?? 0));
-}
-
-function resolveEntry(): string | null {
-  const cwd = process.cwd();
-  const candidates = [
-    path.join(cwd, 'src', 'index.ts'),
-    path.join(cwd, 'index.ts'),
-    path.join(cwd, 'src', 'index.js'),
-    path.join(cwd, 'index.js'),
-  ];
-  return candidates.find((f) => fs.existsSync(f)) ?? null;
-}

package/src/cli/index.ts

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-import { Command } from 'commander';
-import { startCommand } from './commands/start.js';
-import { buildCommand } from './commands/build.js';
-import { runCommand } from './commands/run.js';
-import { generateCommand } from './commands/generate.js';
-import { diagnosticsCommands } from './commands/diagnostics.js';
-
-const program = new Command('efc')
-  .description('Express File Cluster CLI')
-  .version('0.1.0');
-
-program.addCommand(startCommand());
-program.addCommand(buildCommand());
-program.addCommand(runCommand());
-program.addCommand(generateCommand());
-
-for (const cmd of diagnosticsCommands()) {
-  program.addCommand(cmd);
-}
-
-program.parse(process.argv);

package/src/cluster/index.ts

@@ -1,31 +0,0 @@
-import cluster from 'node:cluster';
-import os from 'node:os';
-
-interface ClusterOptions {
-  workers?: number;
-  onWorkerReady?: ((id: number) => void) | undefined;
-  onWorkerCrash?: ((id: number, code: number) => void) | undefined;
-}
-
-export function runMaster(options: ClusterOptions = {}): void {
-  const count = options.workers ?? os.cpus().length;
-
-  console.log(`[EFC] Primary ${process.pid} starting ${count} workers`);
-
-  for (let i = 0; i < count; i++) {
-    cluster.fork();
-  }
-
-  cluster.on('online', (worker) => {
-    options.onWorkerReady?.(worker.id);
-  });
-
-  cluster.on('exit', (worker, code, signal) => {
-    const exitCode = code ?? (signal ? -1 : 0);
-    console.warn(`[EFC] Worker ${worker.id} exited (code=${exitCode}), respawning…`);
-    options.onWorkerCrash?.(worker.id, exitCode);
-    cluster.fork();
-  });
-}
-
-export { cluster };

package/src/compose.ts

@@ -1,26 +0,0 @@
-import type { RequestHandler } from 'express';
-
-export function compose(...handlers: RequestHandler[]): RequestHandler {
-  return (req, res, next) => {
-    let index = 0;
-
-    function dispatch(i: number): void {
-      if (i >= handlers.length) {
-        next();
-        return;
-      }
-      const handler = handlers[i];
-      if (!handler) {
-        next();
-        return;
-      }
-      try {
-        Promise.resolve(handler(req, res, () => dispatch(i + 1))).catch(next);
-      } catch (err) {
-        next(err);
-      }
-    }
-
-    dispatch(index);
-  };
-}

package/src/db/index.ts

@@ -1,31 +0,0 @@
-// Thread-local DB client populated during Pre-Flight.
-// The Proxy ensures callers import `db` once and never null-check it —
-// it throws with a helpful message if accessed before Pre-Flight completes.
-
-type AnyClient = Record<string, unknown>;
-
-let _client: AnyClient | null = null;
-
-export function setDbClient(client: AnyClient): void {
-  _client = client;
-}
-
-export function getDbClient(): AnyClient {
-  if (!_client) {
-    throw new Error('[EFC] db not ready — accessed before Pre-Flight completed');
-  }
-  return _client;
-}
-
-export const db: AnyClient = new Proxy({} as AnyClient, {
-  get(_target, prop: string) {
-    return getDbClient()[prop];
-  },
-  set(_target, prop: string, value: unknown) {
-    getDbClient()[prop] = value;
-    return true;
-  },
-});
-
-export { connectMongo } from './mongo.js';
-export { defineModel } from './model.js';

package/src/db/model.ts

@@ -1,95 +0,0 @@
-import type { ModelSchema, ModelCRUD } from '../types.js';
-
-type AnyRecord = Record<string, unknown> & { id: string };
-
-function normalise(doc: Record<string, unknown>): AnyRecord {
-  const id = doc['_id'] ? String(doc['_id']) : '';
-  return { ...doc, id } as AnyRecord;
-}
-
-async function getModel(name: string, schemaObj: Record<string, unknown>): Promise<import('mongoose').Model<Record<string, unknown>>> {
-  let mg: typeof import('mongoose');
-  try {
-    mg = await import('mongoose');
-  } catch {
-    throw new Error('[EFC] mongoose is not installed. Run: npm install mongoose');
-  }
-
-  if (mg.models[name]) return mg.models[name] as import('mongoose').Model<Record<string, unknown>>;
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const schema = new mg.Schema(schemaObj as any, { timestamps: true });
-  return mg.model<Record<string, unknown>>(name, schema);
-}
-
-function buildMongooseSchema(schema: ModelSchema): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
-  for (const [key, def] of Object.entries(schema)) {
-    const entry: Record<string, unknown> = {};
-    switch (def.type) {
-      case 'string':   entry['type'] = String; break;
-      case 'number':   entry['type'] = Number; break;
-      case 'boolean':  entry['type'] = Boolean; break;
-      case 'date':     entry['type'] = Date; break;
-      case 'object':   entry['type'] = Object; break;
-      case 'array':    entry['type'] = Array; break;
-    }
-    if (def.required !== undefined) entry['required'] = def.required;
-    if (def.unique !== undefined)   entry['unique'] = def.unique;
-    if (def.default !== undefined)  entry['default'] = def.default;
-    out[key] = entry;
-  }
-  return out;
-}
-
-export function defineModel<T extends Record<string, unknown>>(
-  name: string,
-  schema: ModelSchema,
-): ModelCRUD<T> {
-  const mongooseSchema = buildMongooseSchema(schema);
-
-  return {
-    async find(filter = {}) {
-      const M = await getModel(name, mongooseSchema);
-      const docs = await M.find(filter as Record<string, unknown>).lean();
-      return (docs as Record<string, unknown>[]).map(normalise) as (T & { id: string })[];
-    },
-
-    async findById(id) {
-      const M = await getModel(name, mongooseSchema);
-      const doc = await M.findById(id).lean();
-      if (!doc) return null;
-      return normalise(doc as Record<string, unknown>) as T & { id: string };
-    },
-
-    async findOne(filter) {
-      const M = await getModel(name, mongooseSchema);
-      const doc = await M.findOne(filter as Record<string, unknown>).lean();
-      if (!doc) return null;
-      return normalise(doc as Record<string, unknown>) as T & { id: string };
-    },
-
-    async create(data) {
-      const M = await getModel(name, mongooseSchema);
-      const doc = await M.create(data);
-      return normalise(doc.toObject() as Record<string, unknown>) as T & { id: string };
-    },
-
-    async update(id, data) {
-      const M = await getModel(name, mongooseSchema);
-      const doc = await M.findByIdAndUpdate(id, data, { new: true }).lean();
-      if (!doc) return null;
-      return normalise(doc as Record<string, unknown>) as T & { id: string };
-    },
-
-    async delete(id) {
-      const M = await getModel(name, mongooseSchema);
-      await M.findByIdAndDelete(id);
-    },
-
-    async count(filter = {}) {
-      const M = await getModel(name, mongooseSchema);
-      return M.countDocuments(filter as Record<string, unknown>);
-    },
-  };
-}