@naturalcycles/backend-lib 9.77.2 → 9.78.0

package/dist/compressible.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns true if the given Content-Type (parameters, e.g `; charset=utf-8`, are ignored) is compressible.
+ *
+ * Vendored (and modernized) from the `compressible` package.
+ * Instead of loading the whole `mime-db` (~2500 types), it's reduced to the equivalent:
+ * a regex + the list of compressible types that the regex doesn't match (as of mime-db@1.54.0).
+ * No type matched by the regex is marked as non-compressible in mime-db.
+ */
+export declare function compressible(type: string): boolean;

package/dist/compressible.js

@@ -0,0 +1,57 @@
+/**
+ * Returns true if the given Content-Type (parameters, e.g `; charset=utf-8`, are ignored) is compressible.
+ *
+ * Vendored (and modernized) from the `compressible` package.
+ * Instead of loading the whole `mime-db` (~2500 types), it's reduced to the equivalent:
+ * a regex + the list of compressible types that the regex doesn't match (as of mime-db@1.54.0).
+ * No type matched by the regex is marked as non-compressible in mime-db.
+ */
+export function compressible(type) {
+    const mime = EXTRACT_TYPE_REGEX.exec(type)[1].toLowerCase();
+    return COMPRESSIBLE_TYPE_REGEX.test(mime) || COMPRESSIBLE_TYPES.has(mime);
+}
+const EXTRACT_TYPE_REGEX = /^\s*([^;\s]*)/;
+const COMPRESSIBLE_TYPE_REGEX = /^text\/|\+(?:json|text|xml)$/;
+const COMPRESSIBLE_TYPES = new Set([
+    'application/dart',
+    'application/ecmascript',
+    'application/javascript',
+    'application/json',
+    'application/octet-stream',
+    'application/postscript',
+    'application/raml+yaml',
+    'application/rtf',
+    'application/tar',
+    'application/toml',
+    'application/vnd.dart',
+    'application/vnd.ms-fontobject',
+    'application/vnd.ms-opentype',
+    'application/wasm',
+    'application/x-httpd-php',
+    'application/x-javascript',
+    'application/x-ns-proxy-autoconfig',
+    'application/x-sh',
+    'application/x-tar',
+    'application/x-virtualbox-hdd',
+    'application/x-virtualbox-ova',
+    'application/x-virtualbox-ovf',
+    'application/x-virtualbox-vbox',
+    'application/x-virtualbox-vdi',
+    'application/x-virtualbox-vhd',
+    'application/x-virtualbox-vmdk',
+    'application/x-www-form-urlencoded',
+    'application/xml',
+    'application/xml-dtd',
+    'font/otf',
+    'font/ttf',
+    'image/bmp',
+    'image/vnd.adobe.photoshop',
+    'image/vnd.microsoft.icon',
+    'image/vnd.ms-dds',
+    'image/x-icon',
+    'image/x-ms-bmp',
+    'message/rfc822',
+    'model/gltf-binary',
+    'x-shader/x-fragment',
+    'x-shader/x-vertex',
+]);

package/dist/onFinished.d.ts

@@ -1,2 +1,14 @@
-import onFinished from 'on-finished';
-export { onFinished };
+import type { IncomingMessage, ServerResponse } from 'node:http';
+/**
+ * Invokes the listener once the request/response has finished (completed, closed or errored).
+ * If it has already finished - the listener is invoked asynchronously (on the next tick).
+ *
+ * Listener runs in the async context (e.g AsyncLocalStorage) of the onFinished caller.
+ *
+ * Vendored (and modernized) from the `on-finished` package, built on top of `stream.finished`.
+ * Stream listeners are attached once per msg (subsequent calls are queued), as `stream.finished`
+ * is too expensive to call per listener (and would exceed the default MaxListeners).
+ */
+export declare function onFinished<T extends IncomingMessage | ServerResponse>(msg: T, listener: Listener<T>): T;
+type Listener<T> = (err: Error | null, msg: T) => void;
+export {};

package/dist/onFinished.js

@@ -1,2 +1,35 @@
-import onFinished from 'on-finished';
-export { onFinished };
+import { AsyncResource } from 'node:async_hooks';
+import { finished } from 'node:stream';
+/**
+ * Invokes the listener once the request/response has finished (completed, closed or errored).
+ * If it has already finished - the listener is invoked asynchronously (on the next tick).
+ *
+ * Listener runs in the async context (e.g AsyncLocalStorage) of the onFinished caller.
+ *
+ * Vendored (and modernized) from the `on-finished` package, built on top of `stream.finished`.
+ * Stream listeners are attached once per msg (subsequent calls are queued), as `stream.finished`
+ * is too expensive to call per listener (and would exceed the default MaxListeners).
+ */
+export function onFinished(msg, listener) {
+    const m = msg;
+    const queue = m[kQueue];
+    if (queue) {
+        queue.push(bindAsyncContext(listener));
+        return msg;
+    }
+    const q = (m[kQueue] = [bindAsyncContext(listener)]);
+    finished(msg, err => {
+        m[kQueue] = undefined;
+        for (const fn of q)
+            fn(err ?? null, msg);
+    });
+    return msg;
+}
+const kQueue = Symbol('onFinished');
+/**
+ * Faster alternative to `AsyncResource.bind` (which is ~0.8µs per call).
+ */
+function bindAsyncContext(fn) {
+    const resource = new AsyncResource('onFinished');
+    return (err, msg) => resource.runInAsyncScope(fn, null, err, msg);
+}

package/dist/onHeaders.d.ts

@@ -0,0 +1,11 @@
+import type { ServerResponse } from 'node:http';
+/**
+ * Invokes the listener once, right before the response writes its headers
+ * (via `res.writeHead`, which is also called implicitly by the first `write`/`end`).
+ *
+ * Headers passed to `writeHead` are applied to `res` before the listener runs,
+ * so the listener sees (and can modify) the final headers and statusCode.
+ *
+ * Vendored (and modernized) from the `on-headers` package.
+ */
+export declare function onHeaders(res: ServerResponse, listener: (this: ServerResponse) => void): void;

package/dist/onHeaders.js

@@ -0,0 +1,56 @@
+/**
+ * Invokes the listener once, right before the response writes its headers
+ * (via `res.writeHead`, which is also called implicitly by the first `write`/`end`).
+ *
+ * Headers passed to `writeHead` are applied to `res` before the listener runs,
+ * so the listener sees (and can modify) the final headers and statusCode.
+ *
+ * Vendored (and modernized) from the `on-headers` package.
+ */
+export function onHeaders(res, listener) {
+    // Loosely typed, to call it with the (statusCode, reason?) signature, bypassing overloads
+    const prevWriteHead = res.writeHead;
+    let fired = false;
+    res.writeHead = function writeHead(statusCode, reasonOrHeaders, headers) {
+        if (fired)
+            return prevWriteHead.apply(this, arguments);
+        fired = true;
+        const reason = typeof reasonOrHeaders === 'string' ? reasonOrHeaders : undefined;
+        headers = reason === undefined ? reasonOrHeaders : headers;
+        this.statusCode = statusCode;
+        if (headers)
+            setHeaders(this, headers);
+        listener.call(this);
+        // Reason phrase is dropped if the listener changed the statusCode
+        return reason !== undefined && this.statusCode === statusCode
+            ? prevWriteHead.call(this, statusCode, reason)
+            : prevWriteHead.call(this, this.statusCode);
+    };
+}
+function setHeaders(res, headers) {
+    if (!Array.isArray(headers)) {
+        for (const k of Object.keys(headers)) {
+            if (k)
+                res.setHeader(k, headers[k]);
+        }
+        return;
+    }
+    if (Array.isArray(headers[0])) {
+        // 2D: [[k, v], [k, v]]
+        for (const [k, v] of headers) {
+            if (k)
+                res.setHeader(k, v);
+        }
+        return;
+    }
+    // 1D (raw): [k, v, k, v], keys may repeat
+    if (headers.length % 2)
+        throw new TypeError('headers array is malformed');
+    for (let i = 0; i < headers.length; i += 2) {
+        res.removeHeader(headers[i]);
+    }
+    for (let i = 0; i < headers.length; i += 2) {
+        if (headers[i])
+            res.appendHeader(headers[i], headers[i + 1]);
+    }
+}

package/dist/server/compressionMiddleware.js

@@ -10,11 +10,11 @@
  * MIT Licensed
  */
 import zlib from 'node:zlib';
-import compressible from 'compressible';
 // @ts-expect-error no types
 import Negotiator from 'negotiator';
-import onHeaders from 'on-headers';
-import vary from 'vary';
+import { compressible } from '../compressible.js';
+import { onHeaders } from '../onHeaders.js';
+import { vary } from '../vary.js';
 const SUPPORTED_ENCODING = ['zstd', 'br', 'gzip', 'deflate', 'identity'];
 const PREFERRED_ENCODING = ['zstd', 'br', 'gzip'];
 const encodingSupported = new Set(['gzip', 'deflate', 'identity', 'br', 'zstd']);

package/dist/vary.d.ts

@@ -0,0 +1,8 @@
+import type { ServerResponse } from 'node:http';
+/**
+ * Adds the field (header name) to the response's Vary header, unless it's already there
+ * (case-insensitive). Vary: * stays as is, and adding '*' replaces the whole header with '*'.
+ *
+ * Vendored (and modernized) from the `vary` package.
+ */
+export declare function vary(res: ServerResponse, field: string): void;

package/dist/vary.js

@@ -0,0 +1,25 @@
+/**
+ * Adds the field (header name) to the response's Vary header, unless it's already there
+ * (case-insensitive). Vary: * stays as is, and adding '*' replaces the whole header with '*'.
+ *
+ * Vendored (and modernized) from the `vary` package.
+ */
+export function vary(res, field) {
+    const header = res.getHeader('Vary');
+    const value = Array.isArray(header) ? header.join(', ') : String(header ?? '');
+    if (!value) {
+        res.setHeader('Vary', field);
+        return;
+    }
+    const fields = new Set(value
+        .toLowerCase()
+        .split(',')
+        .map(f => f.trim()));
+    if (field === '*' || fields.has('*')) {
+        if (value !== '*')
+            res.setHeader('Vary', '*');
+    }
+    else if (!fields.has(field.toLowerCase())) {
+        res.setHeader('Vary', `${value}, ${field}`);
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/backend-lib",
   "type": "module",
-  "version": "9.77.2",
+  "version": "9.78.0",
   "dependencies": {
     "@naturalcycles/db-lib": "^10",
     "@naturalcycles/js-lib": "^15",
@@ -10,21 +10,13 @@
     "@types/cookie-parser": "^1",
     "@types/cors": "^2",
     "@types/express": "^5",
-    "@types/compressible": "^2",
-    "@types/on-finished": "^2",
-    "@types/on-headers": "^1",
-    "@types/vary": "^1",
     "busboy": "^1",
-    "compressible": "^2",
     "cookie-parser": "^1",
     "cors": "^2",
     "express": "^5",
     "helmet": "^8",
     "negotiator": "^1",
-    "on-headers": "^1",
-    "on-finished": "^2",
-    "tslib": "^2",
-    "vary": "^1"
+    "tslib": "^2"
   },
   "peerDependencies": {
     "@sentry/node-core": "^10",

package/src/compressible.ts

@@ -0,0 +1,59 @@
+/**
+ * Returns true if the given Content-Type (parameters, e.g `; charset=utf-8`, are ignored) is compressible.
+ *
+ * Vendored (and modernized) from the `compressible` package.
+ * Instead of loading the whole `mime-db` (~2500 types), it's reduced to the equivalent:
+ * a regex + the list of compressible types that the regex doesn't match (as of mime-db@1.54.0).
+ * No type matched by the regex is marked as non-compressible in mime-db.
+ */
+export function compressible(type: string): boolean {
+  const mime = EXTRACT_TYPE_REGEX.exec(type)![1]!.toLowerCase()
+  return COMPRESSIBLE_TYPE_REGEX.test(mime) || COMPRESSIBLE_TYPES.has(mime)
+}
+
+const EXTRACT_TYPE_REGEX = /^\s*([^;\s]*)/
+const COMPRESSIBLE_TYPE_REGEX = /^text\/|\+(?:json|text|xml)$/
+
+const COMPRESSIBLE_TYPES = new Set([
+  'application/dart',
+  'application/ecmascript',
+  'application/javascript',
+  'application/json',
+  'application/octet-stream',
+  'application/postscript',
+  'application/raml+yaml',
+  'application/rtf',
+  'application/tar',
+  'application/toml',
+  'application/vnd.dart',
+  'application/vnd.ms-fontobject',
+  'application/vnd.ms-opentype',
+  'application/wasm',
+  'application/x-httpd-php',
+  'application/x-javascript',
+  'application/x-ns-proxy-autoconfig',
+  'application/x-sh',
+  'application/x-tar',
+  'application/x-virtualbox-hdd',
+  'application/x-virtualbox-ova',
+  'application/x-virtualbox-ovf',
+  'application/x-virtualbox-vbox',
+  'application/x-virtualbox-vdi',
+  'application/x-virtualbox-vhd',
+  'application/x-virtualbox-vmdk',
+  'application/x-www-form-urlencoded',
+  'application/xml',
+  'application/xml-dtd',
+  'font/otf',
+  'font/ttf',
+  'image/bmp',
+  'image/vnd.adobe.photoshop',
+  'image/vnd.microsoft.icon',
+  'image/vnd.ms-dds',
+  'image/x-icon',
+  'image/x-ms-bmp',
+  'message/rfc822',
+  'model/gltf-binary',
+  'x-shader/x-fragment',
+  'x-shader/x-vertex',
+])

package/src/onFinished.ts

@@ -1,3 +1,44 @@
-import onFinished from 'on-finished'
+import { AsyncResource } from 'node:async_hooks'
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import { finished } from 'node:stream'
 
-export { onFinished }
+/**
+ * Invokes the listener once the request/response has finished (completed, closed or errored).
+ * If it has already finished - the listener is invoked asynchronously (on the next tick).
+ *
+ * Listener runs in the async context (e.g AsyncLocalStorage) of the onFinished caller.
+ *
+ * Vendored (and modernized) from the `on-finished` package, built on top of `stream.finished`.
+ * Stream listeners are attached once per msg (subsequent calls are queued), as `stream.finished`
+ * is too expensive to call per listener (and would exceed the default MaxListeners).
+ */
+export function onFinished<T extends IncomingMessage | ServerResponse>(
+  msg: T,
+  listener: Listener<T>,
+): T {
+  const m = msg as T & { [kQueue]?: Listener<T>[] }
+  const queue = m[kQueue]
+  if (queue) {
+    queue.push(bindAsyncContext(listener))
+    return msg
+  }
+
+  const q = (m[kQueue] = [bindAsyncContext(listener)])
+  finished(msg, err => {
+    m[kQueue] = undefined
+    for (const fn of q) fn(err ?? null, msg)
+  })
+  return msg
+}
+
+type Listener<T> = (err: Error | null, msg: T) => void
+
+const kQueue = Symbol('onFinished')
+
+/**
+ * Faster alternative to `AsyncResource.bind` (which is ~0.8µs per call).
+ */
+function bindAsyncContext<T>(fn: Listener<T>): Listener<T> {
+  const resource = new AsyncResource('onFinished')
+  return (err, msg) => resource.runInAsyncScope(fn, null, err, msg)
+}

package/src/onHeaders.ts

@@ -0,0 +1,66 @@
+import type { OutgoingHttpHeader, OutgoingHttpHeaders, ServerResponse } from 'node:http'
+
+/**
+ * Invokes the listener once, right before the response writes its headers
+ * (via `res.writeHead`, which is also called implicitly by the first `write`/`end`).
+ *
+ * Headers passed to `writeHead` are applied to `res` before the listener runs,
+ * so the listener sees (and can modify) the final headers and statusCode.
+ *
+ * Vendored (and modernized) from the `on-headers` package.
+ */
+export function onHeaders(res: ServerResponse, listener: (this: ServerResponse) => void): void {
+  // Loosely typed, to call it with the (statusCode, reason?) signature, bypassing overloads
+  const prevWriteHead = res.writeHead as (statusCode: number, reason?: string) => ServerResponse
+  let fired = false
+
+  res.writeHead = function writeHead(
+    this: ServerResponse,
+    statusCode: number,
+    reasonOrHeaders?: string | Headers,
+    headers?: Headers,
+  ) {
+    if (fired) return prevWriteHead.apply(this, arguments as any)
+    fired = true
+
+    const reason = typeof reasonOrHeaders === 'string' ? reasonOrHeaders : undefined
+    headers = reason === undefined ? (reasonOrHeaders as Headers | undefined) : headers
+
+    this.statusCode = statusCode
+    if (headers) setHeaders(this, headers)
+    listener.call(this)
+
+    // Reason phrase is dropped if the listener changed the statusCode
+    return reason !== undefined && this.statusCode === statusCode
+      ? prevWriteHead.call(this, statusCode, reason)
+      : prevWriteHead.call(this, this.statusCode)
+  }
+}
+
+type Headers = OutgoingHttpHeaders | OutgoingHttpHeader[]
+
+function setHeaders(res: ServerResponse, headers: Headers): void {
+  if (!Array.isArray(headers)) {
+    for (const k of Object.keys(headers)) {
+      if (k) res.setHeader(k, headers[k]!)
+    }
+    return
+  }
+
+  if (Array.isArray(headers[0])) {
+    // 2D: [[k, v], [k, v]]
+    for (const [k, v] of headers as unknown as [string, OutgoingHttpHeader][]) {
+      if (k) res.setHeader(k, v)
+    }
+    return
+  }
+
+  // 1D (raw): [k, v, k, v], keys may repeat
+  if (headers.length % 2) throw new TypeError('headers array is malformed')
+  for (let i = 0; i < headers.length; i += 2) {
+    res.removeHeader(headers[i] as string)
+  }
+  for (let i = 0; i < headers.length; i += 2) {
+    if (headers[i]) res.appendHeader(headers[i] as string, headers[i + 1] as string | string[])
+  }
+}

package/src/server/compressionMiddleware.ts

@@ -11,11 +11,11 @@
  */
 
 import zlib from 'node:zlib'
-import compressible from 'compressible'
 // @ts-expect-error no types
 import Negotiator from 'negotiator'
-import onHeaders from 'on-headers'
-import vary from 'vary'
+import { compressible } from '../compressible.js'
+import { onHeaders } from '../onHeaders.js'
+import { vary } from '../vary.js'
 import type { BackendRequest, BackendRequestHandler, BackendResponse } from './server.model.js'
 
 export interface CompressionOptions {

package/src/vary.ts

@@ -0,0 +1,29 @@
+import type { ServerResponse } from 'node:http'
+
+/**
+ * Adds the field (header name) to the response's Vary header, unless it's already there
+ * (case-insensitive). Vary: * stays as is, and adding '*' replaces the whole header with '*'.
+ *
+ * Vendored (and modernized) from the `vary` package.
+ */
+export function vary(res: ServerResponse, field: string): void {
+  const header = res.getHeader('Vary')
+  const value = Array.isArray(header) ? header.join(', ') : String(header ?? '')
+  if (!value) {
+    res.setHeader('Vary', field)
+    return
+  }
+
+  const fields = new Set(
+    value
+      .toLowerCase()
+      .split(',')
+      .map(f => f.trim()),
+  )
+
+  if (field === '*' || fields.has('*')) {
+    if (value !== '*') res.setHeader('Vary', '*')
+  } else if (!fields.has(field.toLowerCase())) {
+    res.setHeader('Vary', `${value}, ${field}`)
+  }
+}