@fluojs/platform-nodejs 1.0.6 → 2.0.0

package/dist/node/internal-node-early-hints.js

@@ -0,0 +1,99 @@
+import { validateHeaderName, validateHeaderValue } from 'node:http';
+import { EarlyHintsWriteError, RequestAbortedError } from '@fluojs/http';
+
+/**
+ * Create the request-scoped Early Hints writer shared by Node-backed adapters.
+ *
+ * @param response Native Node response that emits HTTP 103 informational responses.
+ * @param isCommitted Probe for facade-level final response ownership.
+ * @returns An Early Hints capability that settles on native write, error, or disconnect.
+ */
+export function createNodeEarlyHintsCapability(response, isCommitted) {
+  return {
+    write(headers) {
+      if (isCommitted() || response.headersSent || response.writableEnded) {
+        return Promise.reject(new EarlyHintsWriteError('Cannot write HTTP 103 Early Hints after the final response is committed.'));
+      }
+      if (response.destroyed || response.socket?.destroyed) {
+        return Promise.reject(new RequestAbortedError('Request aborted before HTTP 103 Early Hints could be written.'));
+      }
+      let nativeHeaders;
+      try {
+        nativeHeaders = cloneEarlyHintsHeaders(headers);
+      } catch (cause) {
+        return Promise.reject(new EarlyHintsWriteError('HTTP 103 Early Hints contains an invalid header name or value.', {
+          cause
+        }));
+      }
+      if (!hasNonEmptyLink(nativeHeaders.link)) {
+        return Promise.reject(new EarlyHintsWriteError('HTTP 103 Early Hints requires at least one non-empty link value.'));
+      }
+      return new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => {
+          response.removeListener('close', onClose);
+          response.removeListener('error', onError);
+        };
+        const settle = action => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          cleanup();
+          action();
+        };
+        const onClose = () => {
+          settle(() => reject(new RequestAbortedError('Request aborted while HTTP 103 Early Hints were being written.')));
+        };
+        const onError = cause => {
+          settle(() => reject(new EarlyHintsWriteError('Native HTTP transport failed to write HTTP 103 Early Hints.', {
+            cause
+          })));
+        };
+        const onWritten = () => {
+          settle(resolve);
+        };
+        response.once('close', onClose);
+        response.once('error', onError);
+        try {
+          response.writeEarlyHints(nativeHeaders, onWritten);
+        } catch (cause) {
+          settle(() => reject(new EarlyHintsWriteError('Native HTTP transport rejected HTTP 103 Early Hints.', {
+            cause
+          })));
+        }
+      });
+    }
+  };
+}
+function hasNonEmptyLink(link) {
+  return typeof link === 'string' ? link.length > 0 : Array.isArray(link) && link.length > 0 && link.every(value => typeof value === 'string' && value.length > 0);
+}
+function cloneEarlyHintsHeaders(headers) {
+  const cloned = Object.create(null);
+  const names = new Set();
+  for (const [name, value] of Object.entries(headers)) {
+    validateHeaderName(name);
+    const normalizedName = name.toLowerCase();
+    if (normalizedName === 'content-length' || normalizedName === 'transfer-encoding') {
+      throw new TypeError(`Header is not permitted in HTTP 103 Early Hints: ${name}`);
+    }
+    if (names.has(normalizedName)) {
+      throw new TypeError(`Duplicate Early Hints header name: ${name}`);
+    }
+    names.add(normalizedName);
+    if (typeof value === 'string') {
+      validateHeaderValue(name, value);
+      cloned[normalizedName] = value;
+      continue;
+    }
+    if (!Array.isArray(value) || !value.every(entry => typeof entry === 'string')) {
+      throw new TypeError(`Invalid Early Hints header value: ${name}`);
+    }
+    for (const entry of value) {
+      validateHeaderValue(name, entry);
+    }
+    cloned[normalizedName] = [...value];
+  }
+  return cloned;
+}

package/dist/node/internal-node-listen.d.ts

@@ -0,0 +1,24 @@
+import type { Server as HttpServer } from 'node:http';
+import type { Server as HttpsServer } from 'node:https';
+interface NodeListenRetryOptions {
+    readonly host: string | undefined;
+    readonly port: number;
+    readonly retryDelayMs: number;
+    readonly retryLimit: number;
+}
+type NodeServer = HttpServer | HttpsServer;
+/** Owns one Node server's listen, retry cancellation, and close admission state. */
+export declare class NodeListenLifecycle {
+    private readonly server;
+    private readonly options;
+    private closeInFlight?;
+    private closing;
+    private listenAbortController?;
+    private listenInFlight?;
+    constructor(server: NodeServer, options: NodeListenRetryOptions);
+    close(closeServer: () => Promise<void>): Promise<void>;
+    listen(onAdmitted: () => void): Promise<void>;
+    cancel(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=internal-node-listen.d.ts.map

package/dist/node/internal-node-listen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-node-listen.d.ts","sourceRoot":"","sources":["../../src/node/internal-node-listen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,WAAW,CAAC;AACtD,OAAO,KAAK,EAAE,MAAM,IAAI,WAAW,EAAE,MAAM,YAAY,CAAC;AAExD,UAAU,sBAAsB;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,KAAK,UAAU,GAAG,UAAU,GAAG,WAAW,CAAC;AAU3C,oFAAoF;AACpF,qBAAa,mBAAmB;IAO5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B,OAAO,CAAC,aAAa,CAAC,CAAgB;IACtC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,qBAAqB,CAAC,CAAkB;IAChD,OAAO,CAAC,cAAc,CAAC,CAAgB;gBAGpB,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,sBAAsB;IAGlD,KAAK,CAAC,WAAW,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBtD,MAAM,CAAC,UAAU,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IA8BvC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAkB9B"}

package/dist/node/internal-node-listen.js

@@ -0,0 +1,167 @@
+class NodeListenCancelledError extends Error {
+  name = 'NodeListenCancelledError';
+  constructor() {
+    super('Node HTTP adapter startup was cancelled during shutdown.');
+  }
+}
+
+/** Owns one Node server's listen, retry cancellation, and close admission state. */
+export class NodeListenLifecycle {
+  closeInFlight;
+  closing = false;
+  listenAbortController;
+  listenInFlight;
+  constructor(server, options) {
+    this.server = server;
+    this.options = options;
+  }
+  close(closeServer) {
+    if (this.closeInFlight) {
+      return this.closeInFlight;
+    }
+    this.closing = true;
+    const closeInFlight = (async () => {
+      await this.cancel();
+      await closeServer();
+    })().finally(() => {
+      if (this.closeInFlight === closeInFlight) {
+        this.closeInFlight = undefined;
+        this.closing = false;
+      }
+    });
+    this.closeInFlight = closeInFlight;
+    return closeInFlight;
+  }
+  listen(onAdmitted) {
+    if (this.closing) {
+      return Promise.reject(new NodeListenCancelledError());
+    }
+    if (this.listenInFlight) {
+      return this.listenInFlight;
+    }
+    onAdmitted();
+    const abortController = new AbortController();
+    this.listenAbortController = abortController;
+    const listenInFlight = listenNodeServerWithRetry(this.server, this.options, abortController.signal).finally(() => {
+      if (this.listenInFlight === listenInFlight) {
+        this.listenInFlight = undefined;
+      }
+      if (this.listenAbortController === abortController) {
+        this.listenAbortController = undefined;
+      }
+    });
+    this.listenInFlight = listenInFlight;
+    return listenInFlight;
+  }
+  async cancel() {
+    const listenInFlight = this.listenInFlight;
+    if (!listenInFlight) {
+      return;
+    }
+    this.listenAbortController?.abort();
+    try {
+      await listenInFlight;
+    } catch (error) {
+      if (error instanceof NodeListenCancelledError) {
+        return;
+      }
+      throw error;
+    }
+  }
+}
+function listenNodeServerWithRetry(server, options, signal) {
+  return new Promise((resolve, reject) => {
+    let activeErrorListener;
+    let activeListeningListener;
+    let attemptInFlight = false;
+    let retryTimeout;
+    let settled = false;
+    const finish = error => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (retryTimeout) {
+        clearTimeout(retryTimeout);
+      }
+      if (activeErrorListener) {
+        server.off('error', activeErrorListener);
+      }
+      if (activeListeningListener) {
+        server.off('listening', activeListeningListener);
+      }
+      signal.removeEventListener('abort', onAbort);
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    };
+    const cancel = () => {
+      finish(new NodeListenCancelledError());
+    };
+    const onAbort = () => {
+      if (attemptInFlight) {
+        return;
+      }
+      cancel();
+    };
+    const tryListen = attempt => {
+      if (signal.aborted) {
+        cancel();
+        return;
+      }
+      attemptInFlight = true;
+      const onError = error => {
+        attemptInFlight = false;
+        activeErrorListener = undefined;
+        server.off('listening', onListening);
+        activeListeningListener = undefined;
+        if (signal.aborted) {
+          cancel();
+          return;
+        }
+        if (error.code === 'EADDRINUSE' && attempt < options.retryLimit) {
+          server.close(() => {
+            if (settled) {
+              return;
+            }
+            if (signal.aborted) {
+              cancel();
+              return;
+            }
+            retryTimeout = setTimeout(() => {
+              retryTimeout = undefined;
+              tryListen(attempt + 1);
+            }, options.retryDelayMs);
+          });
+          return;
+        }
+        finish(error);
+      };
+      const onListening = () => {
+        attemptInFlight = false;
+        activeListeningListener = undefined;
+        server.off('error', onError);
+        activeErrorListener = undefined;
+        if (signal.aborted) {
+          server.close(cancel);
+          return;
+        }
+        finish();
+      };
+      activeErrorListener = onError;
+      activeListeningListener = onListening;
+      server.once('error', onError);
+      server.once('listening', onListening);
+      server.listen({
+        host: options.host,
+        port: options.port
+      });
+    };
+    signal.addEventListener('abort', onAbort, {
+      once: true
+    });
+    tryListen(0);
+  });
+}

package/dist/node/internal-node-request.d.ts

@@ -0,0 +1,163 @@
+import type { IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'node:http';
+import { type FrameworkRequest, type FrameworkRequestConnection, PayloadTooLargeException } from '@fluojs/http';
+import type { MultipartOptions } from '@fluojs/runtime';
+type MemoizedValue<T> = () => T;
+type QueryRecord = Record<string, string | string[] | undefined>;
+/**
+ * Options for creating a deferred framework request shell from a Node-backed adapter.
+ */
+export interface DeferredFrameworkRequestShellOptions<RawRequest> {
+    cookieHeader?: string | string[] | undefined;
+    connection?: FrameworkRequestConnection;
+    headers?: FrameworkRequest['headers'];
+    headersFactory?: () => FrameworkRequest['headers'];
+    materializeBody?: () => Promise<void>;
+    method?: string;
+    path: string;
+    query?: QueryRecord;
+    queryFactory?: () => QueryRecord;
+    raw: RawRequest;
+    requestId?: string;
+    signal: AbortSignal | (() => AbortSignal);
+    url: string;
+}
+/**
+ * HTTP payload-size error that closes the underlying Node request stream after the response commits.
+ */
+export declare class NodeRequestPayloadTooLargeException extends PayloadTooLargeException {
+    private readonly request;
+    constructor(request: IncomingMessage);
+    prepareResponse(response: ServerResponse): void;
+}
+/**
+ * Creates a framework request from a raw Node incoming message.
+ *
+ * @param request - Raw Node request carrying headers, URL, and body stream.
+ * @param signal - Abort signal tied to the response lifecycle.
+ * @param multipartOptions - Multipart parser options applied to multipart requests.
+ * @param maxBodySize - Maximum allowed non-multipart body size in bytes.
+ * @param preserveRawBody - Whether to retain the raw request body bytes.
+ * @returns The normalized framework request used by the dispatcher.
+ */
+export declare function createFrameworkRequest(request: IncomingMessage, signal: AbortSignal, multipartOptions?: MultipartOptions, maxBodySize?: number, preserveRawBody?: boolean): Promise<FrameworkRequest>;
+/**
+ * Creates the cheap Node framework request shell before consuming the body stream.
+ *
+ * @param request - Raw Node request carrying headers, URL, and body stream.
+ * @param signal - Abort signal tied to the response lifecycle.
+ * @param multipartOptions - Multipart parser options applied when materializing multipart requests.
+ * @param maxBodySize - Maximum allowed non-multipart body size in bytes.
+ * @param preserveRawBody - Whether materialization should retain raw request body bytes.
+ * @returns The framework request shell with metadata snapshotted and body materialization deferred.
+ */
+export declare function createDeferredFrameworkRequest(request: IncomingMessage, signal: AbortSignal, multipartOptions?: MultipartOptions, maxBodySize?: number, preserveRawBody?: boolean): FrameworkRequest;
+/**
+ * Creates a framework request shell from already-snapshotted Node adapter metadata.
+ *
+ * @param options - Raw request, metadata factories, and deferred body materialization hooks.
+ * @returns A framework request with lazy headers, cookies, query values, and optional body materialization.
+ */
+export declare function createDeferredFrameworkRequestShell<RawRequest>({ cookieHeader, connection, headers, headersFactory, materializeBody, method, path, query, queryFactory, raw, requestId, signal, url, }: DeferredFrameworkRequestShellOptions<RawRequest>): FrameworkRequest;
+/**
+ * Materializes a deferred Node framework request body exactly once.
+ *
+ * @param request - Framework request returned by {@link createDeferredFrameworkRequest}.
+ * @returns A promise that settles after body, rawBody, and files fields are populated when applicable.
+ */
+export declare function materializeFrameworkRequestBody(request: FrameworkRequest): Promise<void>;
+/**
+ * Creates a synchronous memoized value resolver.
+ *
+ * @param factory - Function that computes the value on first access.
+ * @returns A stable resolver that returns the cached value after the first call.
+ */
+export declare function createMemoizedValue<T>(factory: () => T): MemoizedValue<T>;
+/**
+ * Creates an async memoized side-effect resolver.
+ *
+ * @param factory - Async function to run at most once.
+ * @returns A resolver that returns the same in-flight or completed promise for every call.
+ */
+export declare function createMemoizedAsyncValue(factory: () => Promise<void>): () => Promise<void>;
+/**
+ * Creates an abort signal that fires when the Node response closes unexpectedly.
+ *
+ * @param response - Raw Node server response associated with the request.
+ * @returns An abort signal for downstream request cancellation handling.
+ */
+export declare function createRequestSignal(response: ServerResponse): AbortSignal;
+/**
+ * Resolves the request identifier from the preferred inbound headers.
+ *
+ * @param headers - Raw Node request headers.
+ * @returns The request identifier when present.
+ */
+export declare function resolveRequestIdFromHeaders(headers: IncomingHttpHeaders): string | undefined;
+/**
+ * Parses a raw URL search string into the framework query shape.
+ *
+ * @param search - Raw search string, with or without a leading question mark.
+ * @returns Query values where repeated keys become string arrays.
+ */
+export declare function parseQueryParamsFromSearch(search: string): Record<string, string | string[]>;
+/**
+ * Snapshots host-parsed query values when they already match framework semantics.
+ *
+ * @param query - Host query object exposed by a Node-backed adapter.
+ * @returns A cloned query record when all values are strings or string arrays; otherwise `undefined` for raw URL fallback.
+ */
+export declare function snapshotSimpleQueryRecord(query: unknown): QueryRecord | undefined;
+/**
+ * Clones Node request headers into the framework header record shape.
+ *
+ * @param headers - Raw Node incoming headers.
+ * @returns A shallow header snapshot with array values cloned.
+ */
+export declare function cloneRequestHeaders(headers: IncomingHttpHeaders): FrameworkRequest['headers'];
+/**
+ * Clones a single Node header value when it is array-backed.
+ *
+ * @param value - Header value to snapshot.
+ * @returns The original scalar value or a cloned array value.
+ */
+export declare function cloneHeaderValue<T extends string | string[] | undefined>(value: T): T;
+/**
+ * Reads the primary value from a Node header value.
+ *
+ * @param headerValue - Header value that may contain multiple entries.
+ * @returns The first header value when present.
+ */
+export declare function readPrimaryHeaderValue(headerValue: string | string[] | undefined): string | undefined;
+/**
+ * Normalizes a Node content-type header to its primary media type.
+ *
+ * @param headerValue - Raw content-type header value.
+ * @returns Lowercase primary media type without parameters, or `undefined` when absent.
+ */
+export declare function normalizePrimaryContentType(headerValue: string | string[] | undefined): string | undefined;
+/**
+ * Parses a Node cookie header into framework cookie values.
+ *
+ * @param cookieHeader - Raw cookie header value or values.
+ * @returns Cookie name/value pairs with percent-decoded values when possible.
+ */
+export declare function parseCookieHeader(cookieHeader: string | string[] | undefined): Record<string, string>;
+/**
+ * Splits a raw Node request URL into path and search components.
+ *
+ * @param rawUrl - Raw request URL, absolute URL, or undefined value from Node.
+ * @returns The pathname and search string used by framework request matching and query parsing.
+ */
+export declare function splitRawRequestUrl(rawUrl: string | undefined): {
+    path: string;
+    search: string;
+};
+/**
+ * Resolves a raw Node request URL into an absolute URL string.
+ *
+ * @param rawUrl - Raw request URL, absolute URL, or undefined value from Node.
+ * @returns An absolute URL suitable for Web-standard parsers.
+ */
+export declare function resolveAbsoluteRequestUrl(rawUrl: string | undefined): string;
+export {};
+//# sourceMappingURL=internal-node-request.d.ts.map

package/dist/node/internal-node-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-node-request.d.ts","sourceRoot":"","sources":["../../src/node/internal-node-request.ts"],"names":[],"mappings":"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"}