express-file-cluster 0.1.2 → 0.1.3

package/src/ignite.test.ts

@@ -0,0 +1,193 @@
+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.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 });
+    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 });
+    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 });
+    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 });
+    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 });
+    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 });
+    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 });
+    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 });
+
+    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 });
+
+    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 });
+    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 });
+    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 });
+    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 });
+    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,4 +1,5 @@
 import 'dotenv/config';
+import http from 'node:http';
 import express from 'express';
 import cors from 'cors';
 import cookieParser from 'cookie-parser';
@@ -15,24 +16,32 @@ 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> {
+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;
 
+  // All runtime values fall back to environment variables
   const port =
-    _port != null && !Number.isNaN(_port)
-      ? _port
-      : Number(process.env['PORT']) || 3000;
+    _port != null && !Number.isNaN(_port) ? _port : Number(process.env['PORT']) || 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 +60,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 +79,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 +124,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,11 +136,11 @@ export async function ignite(config: EFCConfig): Promise<void> {
     );
   }
 
-  await new Promise<void>((resolve) => {
-    app.listen(port, () => {
+  return new Promise<http.Server>((resolve) => {
+    const server = app.listen(port, () => {
       const wid = (cluster.worker as { id: number } | undefined)?.id ?? 'primary';
       console.log(`[EFC] Worker ${wid} listening on :${port}`);
-      resolve();
+      resolve(server);
     });
   });
 }