express-file-cluster 0.1.4 → 0.1.6

package/src/ignite.test.ts

@@ -1,196 +0,0 @@
-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,191 +0,0 @@
-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';
-import { runMaster } from './cluster/index.js';
-import { configureAuth } from './auth/index.js';
-import { HttpError } from './errors.js';
-import { connectMongo } from './db/mongo.js';
-import { setDbClient } from './db/index.js';
-import { scanTasks } from './tasks/scanner.js';
-import { initBullMQ } from './tasks/bullmq-backend.js';
-
-// 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,
-    workers,
-    apiDir,
-    globalMiddlewares = [],
-    onWorkerReady,
-    onWorkerCrash,
-    onError,
-  } = config;
-
-  // 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({
-      workers: workers ?? os.cpus().length,
-      ...(onWorkerReady !== undefined && { onWorkerReady }),
-      ...(onWorkerCrash !== undefined && { onWorkerCrash }),
-    });
-    return;
-  }
-
-  const app = express();
-
-  const corsOption = config.cors ?? true;
-  if (corsOption !== false) {
-    const envOrigins = process.env['CORS_ORIGINS'];
-    let origin: string | string[] | boolean;
-    if (envOrigins) {
-      const list = envOrigins.split(',').map((o) => o.trim()).filter(Boolean);
-      origin = list; // always array so cors validates against the request Origin
-    } else if (typeof corsOption === 'object' && corsOption.origin !== undefined) {
-      origin = corsOption.origin;
-    } else {
-      origin = true;
-    }
-    const corsOpts = typeof corsOption === 'object' ? { ...corsOption, origin } : { origin };
-    app.use(cors(corsOpts));
-  }
-
-  app.use(express.json());
-  app.use(express.urlencoded({ extended: true }));
-  app.use(cookieParser());
-
-  for (const mw of globalMiddlewares) {
-    app.use(mw);
-  }
-
-  // Pre-Flight step 1: Connect database
-  if (database === 'mongodb' && databaseUrl) {
-    const conn = await connectMongo(databaseUrl);
-    setDbClient(conn as unknown as Record<string, unknown>);
-  }
-
-  // Pre-Flight step 2: Configure auth
-  if (jwtSecret) {
-    const cookieDomain = process.env['COOKIE_DOMAIN'];
-    configureAuth({
-      secret: jwtSecret,
-      strategy: authStrategy,
-      expiresIn: process.env['JWT_EXPIRES_IN'] ?? '7d',
-      ...(cookieDomain !== undefined && { cookieDomain }),
-    });
-  }
-
-  // Pre-Flight step 3: Scan and register tasks
-  if (config.tasksDir) {
-    await scanTasks(config.tasksDir);
-  }
-
-  // Pre-Flight step 4: Start task queue backend
-  if (config.tasks) {
-    if (config.tasks.backend === 'bullmq') {
-      await initBullMQ({
-        redisUrl: config.tasks.redisUrl ?? 'redis://localhost:6379',
-        concurrency: config.tasks.concurrency ?? 5,
-      });
-    }
-  }
-
-  // Pre-Flight step 5: Scan routes and mount
-  const routes = scanDir(apiDir);
-  await mountRoutes(app, routes);
-
-  if (onError) {
-    app.use(onError);
-  } else {
-    app.use(
-      (
-        err: unknown,
-        _req: express.Request,
-        res: express.Response,
-        _next: express.NextFunction,
-      ) => {
-        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 });
-        }
-      },
-    );
-  }
-
-  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';
-      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';
-export { scanDir } from './router/scan.js';
-export type {
-  EFCConfig,
-  CorsConfig,
-  RouteEntry,
-  TaskOptions,
-  TaskDefinition,
-  DatabaseEngine,
-  AuthStrategy,
-  ModelSchema,
-  ModelCRUD,
-} from './types.js';

package/src/router/mount.test.ts

@@ -1,75 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import express from 'express';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { mountRoutes } from './mount.js';
-import type { RouteEntry } from '../types.js';
-
-function makeApp() {
-  return express();
-}
-
-describe('mountRoutes', () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'efc-mount-test-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('mounts a GET handler from a route module', async () => {
-    const file = path.join(tmpDir, 'health.js');
-    fs.writeFileSync(
-      file,
-      `export const GET = async (req, res) => res.json({ ok: true });`,
-    );
-
-    const app = makeApp();
-    const routes: RouteEntry[] = [{ urlPath: '/health', filePath: file, params: [] }];
-
-    await mountRoutes(app, routes);
-
-    const stack = app._router?.stack ?? [];
-    const hasRoute = stack.some(
-      (layer: { route?: { path: string; methods: Record<string, boolean> } }) =>
-        layer.route?.path === '/health' && layer.route?.methods?.get,
-    );
-    expect(hasRoute).toBe(true);
-  });
-
-  it('mounts multiple methods from a single route file', async () => {
-    const file = path.join(tmpDir, 'users.js');
-    fs.writeFileSync(
-      file,
-      `export const GET = async (req, res) => res.json([]);
-       export const POST = async (req, res) => res.status(201).json({});`,
-    );
-
-    const app = makeApp();
-    const routes: RouteEntry[] = [{ urlPath: '/users', filePath: file, params: [] }];
-
-    await mountRoutes(app, routes);
-
-    // Express registers one layer per method; collect all /users layers
-    type Layer = { route?: { path: string; methods: Record<string, boolean> } };
-    const stack: Layer[] = app._router?.stack ?? [];
-    const layers = stack.filter((l) => l.route?.path === '/users');
-    const methods = layers.flatMap((l) => Object.keys(l.route?.methods ?? {}));
-    expect(methods).toContain('get');
-    expect(methods).toContain('post');
-  });
-
-  it('skips non-function exports silently', async () => {
-    const file = path.join(tmpDir, 'noop.js');
-    fs.writeFileSync(file, `export const middlewares = [];`);
-
-    const app = makeApp();
-    const routes: RouteEntry[] = [{ urlPath: '/noop', filePath: file, params: [] }];
-
-    await expect(mountRoutes(app, routes)).resolves.toBeUndefined();
-  });
-});

package/src/router/mount.ts

@@ -1,49 +0,0 @@
-import type { Application, RequestHandler } from 'express';
-import type { RouteEntry } from '../types.js';
-
-const HTTP_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'] as const;
-type HttpMethod = (typeof HTTP_METHODS)[number];
-
-function asyncWrap(handler: RequestHandler): RequestHandler {
-  return (req, res, next) => {
-    Promise.resolve(handler(req, res, next)).catch(next);
-  };
-}
-
-export async function mountRoutes(app: Application, routes: RouteEntry[]): Promise<void> {
-  for (const route of routes) {
-    const mod = (await import(route.filePath)) as Record<string, unknown>;
-    const routeMiddlewares: RequestHandler[] = Array.isArray(mod['middlewares'])
-      ? (mod['middlewares'] as RequestHandler[])
-      : [];
-
-    const implemented: HttpMethod[] = [];
-    const unimplemented: HttpMethod[] = [];
-
-    for (const method of HTTP_METHODS) {
-      if (typeof mod[method] === 'function') {
-        implemented.push(method);
-        app[method.toLowerCase() as Lowercase<HttpMethod>](
-          route.urlPath,
-          ...routeMiddlewares,
-          asyncWrap(mod[method] as RequestHandler),
-        );
-      } else {
-        unimplemented.push(method);
-      }
-    }
-
-    if (implemented.length > 0 && unimplemented.length > 0) {
-      const allowHeader = implemented.join(', ');
-      app.all(route.urlPath, (req, res, next) => {
-        if ((unimplemented as string[]).includes(req.method)) {
-          res.set('Allow', allowHeader).status(405).json({ error: 'Method Not Allowed' });
-        } else {
-          next();
-        }
-      });
-    }
-  }
-}
-
-export { asyncWrap };

package/src/router/scan.test.ts

@@ -1,23 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { filePathToUrlPath } from './scan.js';
-
-describe('filePathToUrlPath', () => {
-  it('maps static files to their path', () => {
-    expect(filePathToUrlPath('/health.ts')).toBe('/health');
-    expect(filePathToUrlPath('/users/profile.ts')).toBe('/users/profile');
-  });
-
-  it('maps index files to parent path', () => {
-    expect(filePathToUrlPath('/index.ts')).toBe('/');
-    expect(filePathToUrlPath('/users/index.ts')).toBe('/users');
-  });
-
-  it('maps dynamic segments', () => {
-    expect(filePathToUrlPath('/users/[id].ts')).toBe('/users/:id');
-    expect(filePathToUrlPath('/posts/[slug]/comments.ts')).toBe('/posts/:slug/comments');
-  });
-
-  it('handles nested dynamic', () => {
-    expect(filePathToUrlPath('/a/[b]/c/[d].ts')).toBe('/a/:b/c/:d');
-  });
-});

package/src/router/scan.ts

@@ -1,55 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import type { RouteEntry } from '../types.js';
-
-const ROUTE_FILE_RE = /\.(ts|js|mts|mjs|cts|cjs)$/;
-const DYNAMIC_SEGMENT_RE = /\[([^\]]+)\]/g;
-
-function filePathToUrlPath(relativePath: string): string {
-  let p = relativePath.replace(ROUTE_FILE_RE, '');
-  // index files map to parent path
-  p = p.replace(/\/index$/, '');
-  // [param] → :param
-  p = p.replace(DYNAMIC_SEGMENT_RE, ':$1');
-  return p === '' ? '/' : p.startsWith('/') ? p : `/${p}`;
-}
-
-function extractParams(relativePath: string): string[] {
-  const params: string[] = [];
-  let match: RegExpExecArray | null;
-  const re = new RegExp(DYNAMIC_SEGMENT_RE.source, 'g');
-  while ((match = re.exec(relativePath)) !== null) {
-    if (match[1]) params.push(match[1]);
-  }
-  return params;
-}
-
-export function scanDir(dir: string, base: string = dir): RouteEntry[] {
-  if (!fs.existsSync(dir)) return [];
-
-  const entries: RouteEntry[] = [];
-  const items = fs.readdirSync(dir, { withFileTypes: true });
-
-  for (const item of items) {
-    const fullPath = path.join(dir, item.name);
-    if (item.isDirectory()) {
-      entries.push(...scanDir(fullPath, base));
-    } else if (ROUTE_FILE_RE.test(item.name)) {
-      const relative = '/' + path.relative(base, fullPath).replace(/\\/g, '/');
-      entries.push({
-        urlPath: filePathToUrlPath(relative),
-        filePath: fullPath,
-        params: extractParams(relative),
-      });
-    }
-  }
-
-  // Sort: static routes before dynamic ones at each segment level
-  return entries.sort((a, b) => {
-    const aDynamic = a.urlPath.includes(':') ? 1 : 0;
-    const bDynamic = b.urlPath.includes(':') ? 1 : 0;
-    return aDynamic - bDynamic || a.urlPath.localeCompare(b.urlPath);
-  });
-}
-
-export { filePathToUrlPath };

package/src/tasks/bullmq-backend.ts

@@ -1,76 +0,0 @@
-import type { Job } from 'bullmq';
-import { taskRegistry, setEnqueueImpl } from './index.js';
-import { runInThread } from './thread-runner.js';
-
-interface BullMQOpts {
-  redisUrl: string;
-  concurrency: number;
-}
-
-export async function initBullMQ(opts: BullMQOpts): Promise<void> {
-  let bullmq: typeof import('bullmq');
-  try {
-    bullmq = await import('bullmq');
-  } catch {
-    throw new Error('[EFC] bullmq is not installed. Run: npm install bullmq');
-  }
-
-  const connection = parseRedisUrl(opts.redisUrl);
-  const queue = new bullmq.Queue('efc', { connection });
-
-  const worker = new bullmq.Worker(
-    'efc',
-    async (job: Job) => {
-      const def = taskRegistry.get(job.name);
-      if (!def) {
-        throw new Error(`[EFC] No task registered for name: ${job.name}`);
-      }
-
-      if (def.options.thread && def.filePath) {
-        await runInThread(def.filePath, job.data);
-      } else {
-        await def.handler(job.data);
-      }
-    },
-    { connection, concurrency: opts.concurrency },
-  );
-
-  worker.on('failed', (job: Job | undefined, err: Error) => {
-    console.error(`[EFC] Task ${job?.name ?? 'unknown'} failed:`, err.message);
-  });
-
-  worker.on('completed', (job: Job) => {
-    console.log(`[EFC] Task ${job.name} completed (id=${job.id})`);
-  });
-
-  setEnqueueImpl(async (name, payload) => {
-    const def = taskRegistry.get(name);
-    if (!def) {
-      throw new Error(`[EFC] Cannot enqueue unknown task: "${name}". Is the task file in tasksDir?`);
-    }
-
-    await queue.add(name, payload, {
-      attempts: def.options.retries ?? 3,
-      backoff: {
-        type: def.options.backoff ?? 'exponential',
-        delay: 1000,
-      },
-    });
-  });
-
-  console.log('[EFC] BullMQ backend initialised');
-}
-
-function parseRedisUrl(url: string): { host: string; port: number; password?: string } {
-  try {
-    const u = new URL(url);
-    const result: { host: string; port: number; password?: string } = {
-      host: u.hostname || 'localhost',
-      port: parseInt(u.port || '6379', 10),
-    };
-    if (u.password) result.password = u.password;
-    return result;
-  } catch {
-    return { host: 'localhost', port: 6379 };
-  }
-}