fluxion-ts 0.1.5 → 0.2.1

package/README.md

@@ -288,6 +288,11 @@ interface FluxionOptions {
   logger?: 'one-line' | 'json-line' | InjectionConfig;
   apiExts?: string[];
   routerExclude?: string[];
+  https?: {
+    key: string | Buffer;
+    cert: string | Buffer;
+    ca?: string | Buffer | Array<string | Buffer>;
+  };
 }
 ```
 
@@ -382,6 +387,116 @@ interface WorkerOptions {
 
 Current implementation uses `maxWorkerCount` for process count and reports CPU/memory telemetry from workers.
 
+### `https`
+
+HTTPS server configuration. When provided, Fluxion creates an HTTPS server instead of HTTP.
+
+```ts
+fluxion({
+  dir: './dynamicDirectory',
+  host: '127.0.0.1',
+  port: 9443,
+  https: {
+    key: './certs/private-key.pem',  // 私钥文件路径或内容
+    cert: './certs/certificate.pem', // 证书文件路径或内容
+    ca: './certs/ca-bundle.crt',    // 可选：CA 证书链
+  },
+});
+```
+
+Relative paths are resolved relative to `moduleDir`. PEM content can be passed directly as strings.
+
+### `dir`
+
+Dynamic directory root. Created automatically if missing.
+
+### `host`
+
+Host passed to `server.listen`.
+
+### `port`
+
+Business server port.
+
+### `metaPort`
+
+Primary meta API port. Defaults to `port + 1` and must be different from `port`.
+
+### `reloadDelay`
+
+Debounce delay for file re-registration. Defaults to `300` and must be at least `50`.
+
+### `apiExts`
+
+Extensions registered as API handlers. Defaults to:
+
+```ts
+['.ts']
+```
+
+Example:
+
+```ts
+fluxion({
+  dir: './dynamicDirectory',
+  host: '127.0.0.1',
+  port: 3000,
+  apiExts: ['.ts', '.mjs'],
+});
+```
+
+### `routerExclude`
+
+Extensions excluded from both API and static registration.
+
+Example:
+
+```ts
+routerExclude: ['.map']
+```
+
+### `maxRequestBytes`
+
+Maximum accepted request body size. Defaults to `8_000_000`.
+
+### `logger`
+
+Built-in modes:
+
+- `one-line`
+- `json-line`
+
+A custom logger can be loaded through an injection config object whose module exports a function.
+
+### `injections`
+
+Worker startup injections. Each item is loaded with `require(modulePath)` and called as a factory. The resulting instances are stored on:
+
+```ts
+globalThis[Symbol.for('fluxion.injection')]
+```
+
+### `workerOptions`
+
+Runtime tuning options:
+
+```ts
+interface WorkerOptions {
+  maxWorkerCount: number;
+  requestTimeoutMs: number;
+  maxInflight: number;
+  memorySoftLimitMb: number;
+  memoryHardLimitMb: number;
+  memorySampleIntervalMs: number;
+  maxOldGenerationSizeMb: number;
+  maxYoungGenerationSizeMb: number;
+  stackSizeMb: number;
+  maxResponseBytes: number;
+}
+```
+
+Current implementation uses `maxWorkerCount` for process count and reports CPU/memory telemetry from workers.
+
 ## Build and Test
 
 ```bash

package/dist/index.cjs

@@ -1,10 +1,11 @@
 'use strict';
 
 var fs = require('node:fs');
+var path = require('node:path');
 var cluster = require('node:cluster');
 var os = require('node:os');
 var http = require('node:http');
-var path = require('node:path');
+var https = require('node:https');
 
 const ANSI_BACKGROUND_OFFSET = 10;
 
@@ -660,12 +661,56 @@ function expectLoggerOption(o) {
     }
     throw new Error(`[FluxionTs error] Invalid logger option, must be 'one-line', 'json-line' or { modulePath: string; name: string; }`);
 }
+/**
+ * Read certificate content from a file path or return the content directly.
+ */
+function readCertificateContent(content, moduleDir) {
+    if (Buffer.isBuffer(content)) {
+        return content;
+    }
+    if (typeof content === 'string') {
+        // Check if it looks like a file path (not a PEM certificate)
+        // PEM certificates start with "-----BEGIN"
+        if (!content.startsWith('-----BEGIN')) {
+            const filePath = path.isAbsolute(content) ? content : path.join(moduleDir, content);
+            if (fs.existsSync(filePath)) {
+                return fs.readFileSync(filePath);
+            }
+        }
+        return Buffer.from(content);
+    }
+    throw new Error('[FluxionTs error] Certificate content must be a string or Buffer');
+}
+/**
+ * Normalize HTTPS options.
+ */
+function normalizeHttpsOptions(https, moduleDir) {
+    if (!https) {
+        return undefined;
+    }
+    expect.isObject(https, 'FluxionOptions.https must be an object');
+    expect.isString(https.key, 'FluxionOptions.https.key must be a string');
+    expect.isString(https.cert, 'FluxionOptions.https.cert must be a string');
+    const result = {
+        key: readCertificateContent(https.key, moduleDir),
+        cert: readCertificateContent(https.cert, moduleDir),
+    };
+    if (https.ca !== undefined) {
+        if (Array.isArray(https.ca)) {
+            result.ca = https.ca.map((item) => readCertificateContent(item, moduleDir));
+        }
+        else {
+            result.ca = readCertificateContent(https.ca, moduleDir);
+        }
+    }
+    return result;
+}
 /**
  * Normalize options and create necessary resources like the dynamic directory and logger.
  */
 function normalizeOptions(options) {
     expect.isObject(options, 'FluxionOptions must be an object');
-    let { dir, host, port, metaPort, injections = [], moduleDir = process.cwd(), workerOptions = {}, maxRequestBytes = 8000000, reloadDelay = 300, apiExts = ['.ts'], routerExclude = [], } = options;
+    let { dir, host, port, metaPort, injections = [], moduleDir = process.cwd(), workerOptions = {}, maxRequestBytes = 8_000_000, reloadDelay = 300, apiExts = ['.ts'], routerExclude = [], https, } = options;
     const logger = options.logger ?? 'one-line';
     expectLoggerOption(logger);
     expect.isString(dir, 'FluxionOptions.dir must be a string');
@@ -679,7 +724,7 @@ function normalizeOptions(options) {
     if (port > 65535) {
         throw new Error('[FluxionTs error] FluxionOptions.port must be less than or equal to 65535');
     }
-    metaPort ?? (metaPort = port + 1);
+    metaPort ??= port + 1;
     expect.isPositiveInteger(metaPort, 'FluxionOptions.metaPort must be a positive integer');
     if (metaPort > 65535) {
         throw new Error('[FluxionTs error] FluxionOptions.metaPort must be less than or equal to 65535');
@@ -706,6 +751,7 @@ function normalizeOptions(options) {
         logger,
         apiExts,
         routerExclude,
+        https: normalizeHttpsOptions(https, moduleDir),
     };
 }
 
@@ -933,9 +979,13 @@ function PromiseTry(fn, ...args) {
     return new Promise((resolve, reject) => {
         // in case `fn` throws synchronously, we catch it and reject the promise
         try {
-            fn(...args)
-                .then(resolve)
-                .catch(reject);
+            const r = fn(...args);
+            if (r instanceof Promise) {
+                r.then(resolve).catch(reject);
+            }
+            else {
+                resolve(r);
+            }
         }
         catch (error) {
             reject(error);
@@ -1200,7 +1250,7 @@ function parseCookie(cookieHeader) {
 }
 
 function createWorkerServer(cx) {
-    const server = http.createServer(async (req, res) => {
+    const requestHandler = async (req, res) => {
         const method = req.method ?? 'GET';
         const ip = getRealIp(req);
         const url = toURL(req.url);
@@ -1276,7 +1326,14 @@ function createWorkerServer(cx) {
                 safeSendJson(res, { message: 'Internal Server Error' }, 500 /* HttpCode.InternalServerError */);
             }
         }
-    });
+    };
+    const server = cx.options.https
+        ? https.createServer({
+            key: cx.options.https.key,
+            cert: cx.options.https.cert,
+            ca: cx.options.https.ca,
+        }, requestHandler)
+        : http.createServer(requestHandler);
     server.on('close', () => {
         cx.logger.info('ServerClosed', {
             host: cx.options.host,
@@ -1286,6 +1343,7 @@ function createWorkerServer(cx) {
     server.listen(cx.options.port, cx.options.host, () => {
         cx.logger.info('ServerStarted', {
             pid: process.pid,
+            protocol: cx.options.https ? 'https' : 'http',
             host: cx.options.host,
             port: cx.options.port,
         });