express-file-cluster 0.1.2 → 0.1.4

package/src/cli/commands/start.ts

@@ -24,14 +24,20 @@ export function startCommand(): Command {
   return cmd;
 }
 
-function buildDevEnv(cwd: string): NodeJS.ProcessEnv {
-  const env: NodeJS.ProcessEnv = { ...process.env, NODE_ENV: 'development' };
+function parseDotenv(cwd: string): Record<string, string> {
   const envFile = path.join(cwd, '.env');
-  if (fs.existsSync(envFile)) {
-    const existing = (process.env['NODE_OPTIONS'] ?? '').trim();
-    env['NODE_OPTIONS'] = `${existing} --env-file ${envFile}`.trim();
+  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 env;
+  return vars;
 }
 
 function startDev(): void {
@@ -48,11 +54,10 @@ function startDev(): void {
   const localTsx = path.join(cwd, 'node_modules', '.bin', 'tsx');
   const tsx = fs.existsSync(localTsx) ? localTsx : 'tsx';
 
-  const child = spawn(tsx, ['watch', entry], {
-    stdio: 'inherit',
-    env: buildDevEnv(cwd),
-  });
+  // .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));
 }
 
@@ -67,14 +72,12 @@ function startProd(): void {
 
   console.log(chalk.cyan('[EFC] Starting production server…'));
 
-  const envFile = path.join(cwd, '.env');
-  const nodeArgs = fs.existsSync(envFile) ? ['--env-file', envFile, distEntry] : [distEntry];
-
-  const child = spawn('node', nodeArgs, {
+  // 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));
 }
 

package/src/ignite.test.ts

@@ -0,0 +1,196 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import request from 'supertest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import type { Server } from 'node:http';
+import { ignite } from './index.js';
+
+// helpers ----------------------------------------------------------------
+
+function tmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'efc-ignite-'));
+}
+
+function writeRoute(dir: string, name: string, code: string) {
+  const file = path.join(dir, name);
+  fs.writeFileSync(file, code);
+  return file;
+}
+
+function closeServer(server: Server): Promise<void> {
+  return new Promise((resolve, reject) => {
+    server.closeAllConnections(); // release keep-alive connections so close() fires promptly
+    server.close((e) => (e ? reject(e) : resolve()));
+  });
+}
+
+// -----------------------------------------------------------------------
+
+describe('ignite() — server integration', () => {
+  let apiDir: string;
+  let server: Server | undefined;
+
+  beforeEach(() => {
+    apiDir = tmpDir();
+    // ensure no DATABASE_URL so connectMongo is never called
+    delete process.env['DATABASE_URL'];
+    delete process.env['CORS_ORIGINS'];
+  });
+
+  afterEach(async () => {
+    if (server) { await closeServer(server); server = undefined; }
+    fs.rmSync(apiDir, { recursive: true, force: true });
+  });
+
+  // --- route serving ----------------------------------------------------
+
+  it('serves a GET route', async () => {
+    writeRoute(apiDir, 'health.js', `export const GET = async (_req, res) => res.json({ ok: true });`);
+    server = await ignite({ apiDir, cluster: false, port: 0 });
+    const res = await request(server).get('/health');
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual({ ok: true });
+  });
+
+  it('serves a POST route', async () => {
+    writeRoute(apiDir, 'echo.js', `export const POST = async (req, res) => res.status(201).json(req.body);`);
+    server = await ignite({ apiDir, cluster: false, port: 0 });
+    const res = await request(server).post('/echo').send({ msg: 'hello' });
+    expect(res.status).toBe(201);
+    expect(res.body).toEqual({ msg: 'hello' });
+  });
+
+  it('resolves dynamic route params', async () => {
+    fs.mkdirSync(path.join(apiDir, 'users'));
+    writeRoute(
+      path.join(apiDir, 'users'), '[id].js',
+      `export const GET = async (req, res) => res.json({ id: req.params.id });`,
+    );
+    server = await ignite({ apiDir, cluster: false, port: 0 });
+    const res = await request(server).get('/users/42');
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual({ id: '42' });
+  });
+
+  it('returns 405 for an unregistered method', async () => {
+    writeRoute(apiDir, 'items.js', `export const GET = async (_req, res) => res.json([]);`);
+    server = await ignite({ apiDir, cluster: false, port: 0 });
+    const res = await request(server).post('/items');
+    expect(res.status).toBe(405);
+  });
+
+  // --- body parsing -----------------------------------------------------
+
+  it('parses JSON bodies automatically', async () => {
+    writeRoute(apiDir, 'body.js', `export const POST = async (req, res) => res.json(req.body);`);
+    server = await ignite({ apiDir, cluster: false, port: 0 });
+    const res = await request(server)
+      .post('/body')
+      .set('Content-Type', 'application/json')
+      .send(JSON.stringify({ x: 1 }));
+    expect(res.body).toEqual({ x: 1 });
+  });
+
+  it('parses URL-encoded bodies automatically', async () => {
+    writeRoute(apiDir, 'form.js', `export const POST = async (req, res) => res.json(req.body);`);
+    server = await ignite({ apiDir, cluster: false, port: 0 });
+    const res = await request(server)
+      .post('/form')
+      .set('Content-Type', 'application/x-www-form-urlencoded')
+      .send('name=efc&version=1');
+    expect(res.body).toEqual({ name: 'efc', version: '1' });
+  });
+
+  // --- CORS -------------------------------------------------------------
+
+  it('allows all origins by default', async () => {
+    writeRoute(apiDir, 'ping.js', `export const GET = async (_req, res) => res.json({});`);
+    server = await ignite({ apiDir, cluster: false, port: 0 });
+    const res = await request(server).get('/ping').set('Origin', 'http://unknown.example');
+    expect(res.headers['access-control-allow-origin']).toBe('http://unknown.example');
+  });
+
+  it('restricts origins when CORS_ORIGINS is set', async () => {
+    process.env['CORS_ORIGINS'] = 'http://allowed.example';
+    writeRoute(apiDir, 'ping.js', `export const GET = async (_req, res) => res.json({});`);
+    server = await ignite({ apiDir, cluster: false, port: 0 });
+
+    const allowed = await request(server).get('/ping').set('Origin', 'http://allowed.example');
+    expect(allowed.headers['access-control-allow-origin']).toBe('http://allowed.example');
+
+    const blocked = await request(server).get('/ping').set('Origin', 'http://evil.example');
+    expect(blocked.headers['access-control-allow-origin']).toBeUndefined();
+  });
+
+  it('supports multiple origins in CORS_ORIGINS', async () => {
+    process.env['CORS_ORIGINS'] = 'http://a.example, http://b.example';
+    writeRoute(apiDir, 'ping.js', `export const GET = async (_req, res) => res.json({});`);
+    server = await ignite({ apiDir, cluster: false, port: 0 });
+
+    const a = await request(server).get('/ping').set('Origin', 'http://a.example');
+    expect(a.headers['access-control-allow-origin']).toBe('http://a.example');
+
+    const b = await request(server).get('/ping').set('Origin', 'http://b.example');
+    expect(b.headers['access-control-allow-origin']).toBe('http://b.example');
+  });
+
+  it('disables CORS when cors: false', async () => {
+    writeRoute(apiDir, 'ping.js', `export const GET = async (_req, res) => res.json({});`);
+    server = await ignite({ apiDir, cluster: false, cors: false, port: 0 });
+    const res = await request(server).get('/ping').set('Origin', 'http://anywhere.example');
+    expect(res.headers['access-control-allow-origin']).toBeUndefined();
+  });
+
+  // --- port & env auto-reading ------------------------------------------
+
+  it('reads PORT from env when port is not passed', async () => {
+    process.env['PORT'] = '0'; // 0 = OS assigns a free port
+    writeRoute(apiDir, 'hi.js', `export const GET = async (_req, res) => res.json({ hi: true });`);
+    server = await ignite({ apiDir, cluster: false, port: 0 });
+    const addr = server.address() as { port: number };
+    expect(addr.port).toBeGreaterThan(0);
+    delete process.env['PORT'];
+  });
+
+  it('falls back to port 3000 when PORT env is absent', async () => {
+    delete process.env['PORT'];
+    writeRoute(apiDir, 'hi.js', `export const GET = async (_req, res) => res.json({});`);
+    server = await ignite({ apiDir, cluster: false, port: 0 }); // 0 avoids binding 3000 in tests
+    const addr = server.address() as { port: number };
+    expect(addr.port).toBeGreaterThan(0);
+  });
+
+  it('ignores NaN port and falls back to env PORT', async () => {
+    process.env['PORT'] = '0';
+    writeRoute(apiDir, 'hi.js', `export const GET = async (_req, res) => res.json({});`);
+    server = await ignite({ apiDir, cluster: false, port: Number(undefined) }); // NaN
+    const addr = server.address() as { port: number };
+    expect(addr.port).toBeGreaterThan(0);
+    delete process.env['PORT'];
+  });
+
+  // --- error handling ---------------------------------------------------
+
+  it('returns 404 for unknown routes', async () => {
+    writeRoute(apiDir, 'exists.js', `export const GET = async (_req, res) => res.json({});`);
+    server = await ignite({ apiDir, cluster: false, port: 0 });
+    const res = await request(server).get('/does-not-exist');
+    expect(res.status).toBe(404);
+  });
+
+  it('returns structured JSON for HttpError', async () => {
+    // Attach statusCode directly to avoid cross-module instanceof issues in tests
+    writeRoute(
+      apiDir, 'fail.js',
+      `export const GET = async (_req, _res, next) => {
+         const err = Object.assign(new Error('Invalid input'), { statusCode: 422 });
+         next(err);
+       };`,
+    );
+    server = await ignite({ apiDir, cluster: false, port: 0 });
+    const res = await request(server).get('/fail');
+    expect(res.status).toBe(422);
+    expect(res.body).toMatchObject({ error: 'Invalid input', statusCode: 422 });
+  });
+});

package/src/index.ts

@@ -1,9 +1,10 @@
-import 'dotenv/config';
+import http from 'node:http';
 import express from 'express';
 import cors from 'cors';
 import cookieParser from 'cookie-parser';
 import cluster from 'node:cluster';
 import os from 'node:os';
+import dotenv from 'dotenv';
 import type { EFCConfig } from './types.js';
 import { scanDir } from './router/scan.js';
 import { mountRoutes } from './router/mount.js';
@@ -15,24 +16,39 @@ import { setDbClient } from './db/index.js';
 import { scanTasks } from './tasks/scanner.js';
 import { initBullMQ } from './tasks/bullmq-backend.js';
 
-export async function ignite(config: EFCConfig): Promise<void> {
+// Load .env only outside production — production envs are injected by the platform
+if (process.env['NODE_ENV'] !== 'production') {
+  dotenv.config();
+}
+
+function detectDatabase(url?: string): 'mongodb' | 'postgresql' | undefined {
+  if (!url) return undefined;
+  if (url.startsWith('mongodb')) return 'mongodb';
+  if (url.startsWith('postgres')) return 'postgresql';
+  return undefined;
+}
+
+export async function ignite(config: EFCConfig): Promise<http.Server | undefined> {
   const {
     port: _port,
-    cluster: clusterEnabled = true,
     workers,
     apiDir,
-    jwtSecret,
-    authStrategy = 'http-only',
     globalMiddlewares = [],
     onWorkerReady,
     onWorkerCrash,
     onError,
   } = config;
 
-  const port =
-    _port != null && !Number.isNaN(_port)
-      ? _port
-      : Number(process.env['PORT']) || 3000;
+  // All runtime values fall back to environment variables
+  const envPort = process.env['PORT'] != null ? Number(process.env['PORT']) : NaN;
+  const port = (_port != null && !Number.isNaN(_port)) ? _port
+    : !Number.isNaN(envPort) ? envPort
+    : 3000;
+  const databaseUrl = config.databaseUrl ?? process.env['DATABASE_URL'];
+  const database = config.database ?? detectDatabase(databaseUrl);
+  const jwtSecret = config.jwtSecret ?? process.env['JWT_SECRET'];
+  const authStrategy = config.authStrategy ?? 'http-only';
+  const clusterEnabled = config.cluster ?? process.env['NODE_ENV'] === 'production';
 
   if (clusterEnabled && cluster.isPrimary) {
     runMaster({
@@ -51,7 +67,7 @@ export async function ignite(config: EFCConfig): Promise<void> {
     let origin: string | string[] | boolean;
     if (envOrigins) {
       const list = envOrigins.split(',').map((o) => o.trim()).filter(Boolean);
-      origin = list.length === 1 ? list[0]! : list;
+      origin = list; // always array so cors validates against the request Origin
     } else if (typeof corsOption === 'object' && corsOption.origin !== undefined) {
       origin = corsOption.origin;
     } else {
@@ -70,8 +86,8 @@ export async function ignite(config: EFCConfig): Promise<void> {
   }
 
   // Pre-Flight step 1: Connect database
-  if (config.database === 'mongodb' && config.databaseUrl) {
-    const conn = await connectMongo(config.databaseUrl);
+  if (database === 'mongodb' && databaseUrl) {
+    const conn = await connectMongo(databaseUrl);
     setDbClient(conn as unknown as Record<string, unknown>);
   }
 
@@ -115,8 +131,10 @@ export async function ignite(config: EFCConfig): Promise<void> {
         res: express.Response,
         _next: express.NextFunction,
       ) => {
-        if (err instanceof HttpError) {
-          res.status(err.statusCode).json({ error: err.message, statusCode: err.statusCode });
+        const asHttp = err instanceof Error && 'statusCode' in err
+          ? (err as HttpError) : null;
+        if (asHttp) {
+          res.status(asHttp.statusCode).json({ error: asHttp.message, statusCode: asHttp.statusCode });
         } else {
           console.error('[EFC] Unhandled error:', err);
           res.status(500).json({ error: 'Internal Server Error', statusCode: 500 });
@@ -125,15 +143,37 @@ export async function ignite(config: EFCConfig): Promise<void> {
     );
   }
 
-  await new Promise<void>((resolve) => {
-    app.listen(port, () => {
+  return new Promise<http.Server>((resolve, reject) => {
+    const server = app.listen(port);
+
+    server.once('listening', () => {
       const wid = (cluster.worker as { id: number } | undefined)?.id ?? 'primary';
-      console.log(`[EFC] Worker ${wid} listening on :${port}`);
-      resolve();
+      const addr = server.address() as { port: number } | null;
+      console.log(`[EFC] Worker ${wid} listening on :${addr?.port ?? port}`);
+      resolve(server);
     });
+
+    server.once('error', reject);
   });
 }
 
+export function gracefulShutdown(server: http.Server, timeoutMs = 10_000): void {
+  const shutdown = (signal: string) => {
+    console.log(`[EFC] ${signal} received — closing server gracefully…`);
+    server.closeIdleConnections();
+    server.close(() => {
+      console.log('[EFC] Server closed');
+      process.exit(0);
+    });
+    setTimeout(() => {
+      console.error('[EFC] Forced exit after timeout');
+      process.exit(1);
+    }, timeoutMs).unref();
+  };
+  process.once('SIGTERM', () => shutdown('SIGTERM'));
+  process.once('SIGINT', () => shutdown('SIGINT'));
+}
+
 export { HttpError } from './errors.js';
 export { compose } from './compose.js';
 export { db, setDbClient, getDbClient, defineModel } from './db/index.js';