barehttp 2.1.0 → 2.3.0

package/README.md

@@ -16,7 +16,7 @@ Full-featured slim webserver for microservices with extremely low overhead and r
 ## Requirements
 
 ```bash
-Node.js >= 14.8
+Node.js >= 22
 ```
 
 ## Quick start
@@ -147,6 +147,23 @@ Default `false`
 
 Enable request/response logging, format varies from `production` or `development` environments, though to change use e.g. `NODE_ENV=production`
 
+#### `logger?` (Object)
+
+Configure log outputs for app logs and http request logs.
+
+```typescript
+const app = new BareHttp({
+  logging: true,
+  logger: {
+    app: { file: './logs/app.log' },
+    http: { file: './logs/http.log' },
+    level: 'debug',
+  },
+});
+```
+
+`app.file` and `http.file` accept a path string or `{ path, sync }`, and `http.file` is used only when `logging: true`. `console` (default `true`) keeps stdout logging, and `pretty` (default `true` outside production) controls colored console output. `level` sets the base level and can be overridden per target with `app.level` or `http.level`. Use `sourceMaps: true` to map log locations back to `.ts` files (requires source maps in your build).
+
 #### `ws?` (Boolean)
 
 Default `false`

package/lib/index.d.ts

@@ -2,4 +2,5 @@ export { BareHttp } from './server.js';
 export type { BareHttpType } from './server.js';
 export type { BareRequest } from './request.js';
 export { context } from './context/index.js';
-export { logMe } from './logger/index.js';
+export { configureLogger, logMe } from './logger/index.js';
+export type { LoggerConfig } from './logger/index.js';

package/lib/index.js

@@ -1,3 +1,3 @@
 export { BareHttp } from './server.js';
 export { context } from './context/index.js';
-export { logMe } from './logger/index.js';
+export { configureLogger, logMe } from './logger/index.js';

package/lib/logger/index.d.ts

@@ -1,4 +1,22 @@
+import { type LevelWithSilent } from 'pino';
 import { serializeHttp } from './serializers.js';
+type LoggerFileConfig = {
+    path: string;
+    sync?: boolean;
+};
+type LoggerTargetConfig = {
+    file?: string | LoggerFileConfig;
+    level?: LevelWithSilent;
+};
+export type LoggerConfig = {
+    console?: boolean;
+    pretty?: boolean;
+    level?: LevelWithSilent;
+    app?: LoggerTargetConfig;
+    http?: LoggerTargetConfig;
+    sourceMaps?: boolean;
+};
+export declare const configureLogger: (config?: LoggerConfig) => void;
 interface LogMeFn {
     (obj: unknown, ...args: []): void;
     (msg: string, ...args: any[]): void;

package/lib/logger/index.js

@@ -1,26 +1,149 @@
-import pino, { destination } from 'pino';
+import pino, { destination, } from 'pino';
+import { mkdirSync } from 'fs';
+import { dirname } from 'path';
 import { serializeLog, serializeHttp } from './serializers.js';
 import { envs } from '../env.js';
-const asyncDest = envs.isProd ? [destination({ sync: false })] : [];
+const defaultPretty = !envs.isProd;
+const defaultFileSync = envs.isProd ? false : true;
 const pinoCommonOptions = {
     timestamp: () => `,"time":"${new Date()[envs.isProd ? 'toISOString' : 'toLocaleTimeString']()}"`,
     formatters: {
         level: (label) => ({ level: label }),
     },
     messageKey: 'message',
-    transport: envs.isProd ? undefined : { target: 'pino-pretty', options: { colorize: true } },
 };
-const logger = pino(pinoCommonOptions, asyncDest[0]);
+const noop = () => { };
+const noopLogger = {
+    trace: noop,
+    debug: noop,
+    info: noop,
+    warn: noop,
+    error: noop,
+    fatal: noop,
+    silent: noop,
+};
+let sourceMapsRegistered = false;
+const enableSourceMaps = (enabled) => {
+    if (!enabled || sourceMapsRegistered)
+        return;
+    sourceMapsRegistered = true;
+    void import('source-map-support/register').catch(() => {
+        sourceMapsRegistered = false;
+    });
+};
+const normalizeFileConfig = (file) => {
+    if (!file)
+        return undefined;
+    if (typeof file === 'string')
+        return { path: file, sync: defaultFileSync };
+    return { path: file.path, sync: file.sync ?? defaultFileSync };
+};
+const ensureLogDir = (filePath) => {
+    const dir = dirname(filePath);
+    if (dir && dir !== '.') {
+        mkdirSync(dir, { recursive: true });
+    }
+};
+const toLoggerLike = (logger) => {
+    const call = (method) => (...args) => logger[method](...args);
+    return {
+        trace: call('trace'),
+        debug: call('debug'),
+        info: call('info'),
+        warn: call('warn'),
+        error: call('error'),
+        fatal: call('fatal'),
+        silent: noop,
+    };
+};
+const buildConsoleLogger = (options, prettyEnabled) => {
+    if (prettyEnabled) {
+        try {
+            const transport = pino.transport({
+                targets: [{ target: 'pino-pretty', options: { colorize: true } }],
+            });
+            return toLoggerLike(pino(options, transport));
+        }
+        catch {
+            return toLoggerLike(pino(options, destination({ dest: 1, sync: false })));
+        }
+    }
+    return toLoggerLike(pino(options, destination({ dest: 1, sync: false })));
+};
+const buildFileLogger = (options, fileConfig) => {
+    ensureLogDir(fileConfig.path);
+    return toLoggerLike(pino(options, destination({ dest: fileConfig.path, sync: fileConfig.sync ?? defaultFileSync })));
+};
+const combineLoggers = (primary, secondary) => {
+    if (!primary && !secondary)
+        return noopLogger;
+    const first = primary ?? noopLogger;
+    const second = secondary ?? noopLogger;
+    return {
+        trace: (...args) => {
+            first.trace(...args);
+            second.trace(...args);
+        },
+        debug: (...args) => {
+            first.debug(...args);
+            second.debug(...args);
+        },
+        info: (...args) => {
+            first.info(...args);
+            second.info(...args);
+        },
+        warn: (...args) => {
+            first.warn(...args);
+            second.warn(...args);
+        },
+        error: (...args) => {
+            first.error(...args);
+            second.error(...args);
+        },
+        fatal: (...args) => {
+            first.fatal(...args);
+            second.fatal(...args);
+        },
+        silent: noop,
+    };
+};
+const buildLogger = (config, target) => {
+    const consoleEnabled = config.console ?? true;
+    const prettyEnabled = config.pretty ?? defaultPretty;
+    const fileConfig = normalizeFileConfig(target?.file);
+    const level = target?.level ?? config.level;
+    const options = { ...pinoCommonOptions };
+    if (level)
+        options.level = level;
+    const consoleLogger = consoleEnabled ? buildConsoleLogger(options, prettyEnabled) : undefined;
+    const fileLogger = fileConfig ? buildFileLogger(options, fileConfig) : undefined;
+    return combineLoggers(consoleLogger, fileLogger);
+};
+let appLogger;
+let httpLogger;
+export const configureLogger = (config = {}) => {
+    enableSourceMaps(config.sourceMaps);
+    if (config.app || config.http) {
+        appLogger = buildLogger(config, config.app);
+        httpLogger = buildLogger(config, config.http);
+    }
+    else {
+        const shared = buildLogger(config);
+        appLogger = shared;
+        httpLogger = shared;
+    }
+};
+configureLogger();
 export const logHttp = (...params) => {
     const { level, logObject } = serializeHttp(...params);
-    logger[level](logObject);
+    httpLogger[level](logObject);
 };
 // TODO: remove the test condition
 export const logMe = {
-    debug: (...args) => !envs.isTest && logger.debug(serializeLog(...args)),
-    info: (...args) => !envs.isTest && logger.info(serializeLog(...args)),
-    warn: (...args) => !envs.isTest && logger.warn(serializeLog(...args)),
-    error: (...args) => !envs.isTest && logger.error(serializeLog(...args)),
-    fatal: (...args) => !envs.isTest && logger.fatal(serializeLog(...args)),
-    trace: (...args) => !envs.isTest && logger.trace(serializeLog(...args)),
+    debug: (...args) => !envs.isTest && appLogger.debug(serializeLog(...args)),
+    info: (...args) => !envs.isTest && appLogger.info(serializeLog(...args)),
+    warn: (...args) => !envs.isTest && appLogger.warn(serializeLog(...args)),
+    error: (...args) => !envs.isTest && appLogger.error(serializeLog(...args)),
+    fatal: (...args) => !envs.isTest && appLogger.fatal(serializeLog(...args)),
+    trace: (...args) => !envs.isTest && appLogger.trace(serializeLog(...args)),
 };

package/lib/server.d.ts

@@ -1,11 +1,13 @@
 import { ServerOptions } from 'ws';
 import { Ajv } from 'ajv';
 import { BareRequest, CacheOpts } from './request.js';
+import type { LoggerConfig } from './logger/index.js';
 import { CookiesManagerOptions } from './middlewares/cookies/cookie-manager.js';
 import { HttpMethodsUnion, StatusCodesUnion } from './utils/index.js';
 import { CorsOptions } from './middlewares/cors/cors.js';
 import { WebSocketServer } from './websocket.js';
 import { Server } from 'http';
+import { ServerOptions as ServerHTTPSOptions } from 'https';
 type Middleware = (flow: BareRequest) => Promise<void> | void;
 type Handler<H extends {
     [key: string]: string | undefined;
@@ -62,6 +64,10 @@ type BareOptions<A extends IP> = {
      * Default `false`
      */
     logging?: boolean;
+    /**
+     * Logger configuration. Controls outputs for app and http logs.
+     */
+    logger?: LoggerConfig;
     errorHandlerMiddleware?: ErrorHandler;
     /**
      * Request time format in `seconds` or `milliseconds`
@@ -89,6 +95,10 @@ type BareOptions<A extends IP> = {
      * Enable Cors
      */
     cors?: boolean | CorsOptions;
+    /**
+     * Custom HTTPS options for the server
+     */
+    httpsOptions?: ServerHTTPSOptions;
 };
 type ExtractRouteParams<T extends string> = T extends `${string}:${infer Param}/${infer Rest}` ? {
     [K in Param | keyof ExtractRouteParams<Rest>]: string;

package/lib/server.js

@@ -1,7 +1,7 @@
 import Router from 'find-my-way';
 import { Ajv } from 'ajv';
 import { BareRequest } from './request.js';
-import { logMe } from './logger/index.js';
+import { configureLogger, logMe } from './logger/index.js';
 import { context, enableContext, newContext } from './context/index.js';
 import { HttpMethods, } from './utils/index.js';
 import { Cors } from './middlewares/cors/cors.js';
@@ -9,6 +9,7 @@ import { WebSocketServer } from './websocket.js';
 import { generateRouteSchema } from './schemas/generator.js';
 import dns from 'dns';
 import { createServer } from 'http';
+import { createServer as createServerHTTPS } from 'https';
 export class BareServer {
     bareOptions;
     server;
@@ -29,7 +30,12 @@ export class BareServer {
     constructor(bareOptions = {}) {
         this.bareOptions = bareOptions;
         // init
-        this.server = createServer(this.#listener.bind(this));
+        if (bareOptions.httpsOptions) {
+            this.server = createServerHTTPS(bareOptions.httpsOptions, this.#onRequest);
+        }
+        else {
+            this.server = createServer(this.#onRequest);
+        }
         this.attachGracefulHandlers();
         this.attachRoutesDeclarator();
         this.applyLaunchOptions();
@@ -55,6 +61,7 @@ export class BareServer {
             this.#router.lookup(flow._originalRequest, flow._originalResponse);
         });
     };
+    #onRequest = this.#listener.bind(this);
     /**
      * This function generates previously defined middlewares for the sequential execution
      */
@@ -75,6 +82,8 @@ export class BareServer {
     };
     applyLaunchOptions = () => {
         const { bareOptions: bo } = this;
+        if (bo.logger)
+            configureLogger(bo.logger);
         if (bo.setRandomPort) {
             this.#port = undefined;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "barehttp",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Lightweight and fast Node.js web server",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -53,6 +53,7 @@
     "lodash": "^4.17.21",
     "pino": "^10.1.0",
     "pino-pretty": "^13.1.3",
+    "source-map-support": "^0.5.21",
     "ts-morph": "^27.0.2",
     "ws": "^8.18.3"
   },