@scriptc/compiler 0.4.0 → 0.4.2

package/shims/undici/core/request.ts

@@ -0,0 +1,313 @@
+// undici's per-dispatch request record (lib/core/request.js): option
+// validation, header processing, and the handler callbacks with their
+// diagnostics_channel publications.
+import { channels } from "./diagnostics.ts";
+import { InvalidArgumentError, NotSupportedError } from "./errors.ts";
+import type { DispatchHandlers, DispatchOptions, Profile } from "./types.ts";
+
+const tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
+const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
+const invalidPathRegex = /[^!-ÿ]/;
+
+export class Request {
+  origin: string;
+  method: string;
+  path: string;
+  body: Buffer | null;
+  /** Header name/value pairs in insertion order (host and content-length
+   * are consumed into their own fields, like undici). */
+  headerPairs: string[];
+  host: string | null;
+  contentLength: number | null;
+  contentType: string | null;
+  completed: boolean;
+  aborted: boolean;
+  idempotent: boolean;
+  blocking: boolean;
+  reset: boolean | null;
+  headersTimeout: number | null;
+  bodyTimeout: number | null;
+  throwOnError: boolean;
+  servername: string | null;
+  error: Error | null;
+  abortFn: ((err?: Error) => void) | null;
+  handler: DispatchHandlers;
+  profile: Profile;
+  /** The request as diagnostics_channel subscribers see it: one untyped
+   * object per request, so its identity is stable across publications.
+   * The request keeps its completed and headers fields current. */
+  diagnostic: unknown;
+
+  constructor(origin: string, opts: DispatchOptions, handler: DispatchHandlers, profile: Profile) {
+    const path = opts.path;
+    const method = opts.method;
+    if (typeof path !== "string") {
+      throw new InvalidArgumentError("path must be a string");
+    } else if (
+      path[0] !== "/" &&
+      !(path.startsWith("http://") || path.startsWith("https://")) &&
+      method !== "CONNECT"
+    ) {
+      throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
+    } else if (invalidPathRegex.test(path)) {
+      throw new InvalidArgumentError("invalid request path");
+    }
+    if (typeof method !== "string") {
+      throw new InvalidArgumentError("method must be a string");
+    } else if (!tokenRegExp.test(method)) {
+      throw new InvalidArgumentError("invalid request method");
+    }
+    if (method === "CONNECT") {
+      throw new NotSupportedError(
+        "scriptc's undici client does not implement CONNECT requests yet",
+      );
+    }
+    const headersTimeout = opts.headersTimeout ?? null;
+    if (headersTimeout !== null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) {
+      throw new InvalidArgumentError("invalid headersTimeout");
+    }
+    const bodyTimeout = opts.bodyTimeout ?? null;
+    if (bodyTimeout !== null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) {
+      throw new InvalidArgumentError("invalid bodyTimeout");
+    }
+
+    this.origin = origin;
+    this.method = method;
+    this.path = path;
+    this.headersTimeout = headersTimeout;
+    this.bodyTimeout = bodyTimeout;
+    // 7.x dropped throwOnError (the responseError interceptor replaced it).
+    if (profile.major >= 7 && opts.throwOnError !== undefined) {
+      throw new InvalidArgumentError("invalid throwOnError");
+    }
+    this.throwOnError = opts.throwOnError === true;
+
+    const body = opts.body ?? null;
+    if (body === null) {
+      this.body = null;
+    } else if (typeof body === "string") {
+      this.body = body.length > 0 ? Buffer.from(body) : null;
+    } else {
+      this.body =
+        body.byteLength > 0 ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null;
+    }
+
+    this.completed = false;
+    this.profile = profile;
+    this.aborted = false;
+    this.idempotent = opts.idempotent ?? (method === "HEAD" || method === "GET");
+    this.blocking = opts.blocking ?? (profile.major >= 7 ? method !== "HEAD" : false);
+    this.reset = opts.reset ?? null;
+    this.host = null;
+    this.contentLength = null;
+    this.contentType = null;
+    this.headerPairs = [];
+    this.error = null;
+    this.abortFn = null;
+
+    const headers = opts.headers ?? null;
+    if (headers !== null) {
+      if (Array.isArray(headers)) {
+        if (headers.length % 2 !== 0) throw new InvalidArgumentError("headers array must be even");
+        for (let i = 0; i < headers.length; i += 2) {
+          processHeader(this, headers[i]!, headers[i + 1]!, profile);
+        }
+      } else {
+        for (const key of Object.keys(headers)) {
+          const value = headers[key];
+          if (value === undefined) continue;
+          if (typeof value === "string") {
+            processHeader(this, key, value, profile);
+          } else if (profile.major >= 7) {
+            for (const item of value) processHeader(this, key, item, profile);
+          } else {
+            throw new InvalidArgumentError(`invalid ${key} header`);
+          }
+        }
+      }
+    }
+
+    this.servername = serverName(this.host);
+    this.handler = handler;
+    this.diagnostic = null;
+    if (channels.create.hasSubscribers) channels.create.publish({ request: this.diagnosticView() });
+  }
+
+  diagnosticView(): unknown {
+    if (this.diagnostic === null) {
+      // addHeader adds a header as undici's Request.addHeader does (the
+      // tracing instrumentations' header injection).
+      const view: any = {
+        origin: this.origin,
+        completed: this.completed,
+        method: this.method,
+        path: this.path,
+        headers: this.diagnosticHeaders(),
+        addHeader: (key: string, value: string): unknown => {
+          this.addHeader(key, value);
+          return view;
+        },
+      };
+      this.diagnostic = view;
+    }
+    return this.diagnostic;
+  }
+
+  /** The diagnostics view's headers: undici 7 publishes its header array,
+   * undici 5 the raw block. */
+  diagnosticHeaders(): string | string[] {
+    return this.profile.major >= 7 ? this.headerPairs.slice() : this.headers;
+  }
+
+  /** The DiagnosticsChannel.Request view's raw header block. */
+  get headers(): string {
+    let out = "";
+    for (let i = 0; i < this.headerPairs.length; i += 2) {
+      out += `${this.headerPairs[i]}: ${this.headerPairs[i + 1]}\r\n`;
+    }
+    return out;
+  }
+
+  addHeader(key: string, value: string): Request {
+    processHeader(this, key, value, this.profile);
+    const view: any = this.diagnostic;
+    if (view !== null) view.headers = this.diagnosticHeaders();
+    return this;
+  }
+
+  onBodySent(chunk: Buffer): void {
+    const cb = this.handler.onBodySent;
+    if (cb !== undefined) {
+      try {
+        this.handler.onBodySent!(chunk.length, chunk.length);
+      } catch (err) {
+        this.onError(err as Error);
+      }
+    }
+  }
+
+  onRequestSent(): void {
+    if (channels.bodySent.hasSubscribers)
+      channels.bodySent.publish({ request: this.diagnosticView() });
+  }
+
+  onConnect(abort: (err?: Error) => void): void {
+    if (this.error !== null) {
+      abort(this.error);
+      return;
+    }
+    this.abortFn = abort;
+    if (this.handler.onConnect !== undefined) this.handler.onConnect!(abort);
+  }
+
+  onHeaders(
+    statusCode: number,
+    headers: Buffer[],
+    resume: () => void,
+    statusText: string,
+  ): boolean {
+    if (channels.headers.hasSubscribers) {
+      channels.headers.publish({
+        request: this.diagnosticView(),
+        response: { statusCode, headers, statusText },
+      });
+    }
+    if (this.handler.onHeaders === undefined) return true;
+    return this.handler.onHeaders!(statusCode, headers, resume, statusText);
+  }
+
+  onData(chunk: Buffer): boolean {
+    if (this.handler.onData === undefined) return true;
+    return this.handler.onData!(chunk);
+  }
+
+  onComplete(trailers: Buffer[]): void {
+    this.completed = true;
+    const view: any = this.diagnostic;
+    if (view !== null) view.completed = true;
+    if (channels.trailers.hasSubscribers)
+      channels.trailers.publish({ request: this.diagnosticView(), trailers });
+    if (this.handler.onComplete !== undefined) {
+      const raw: string[] = [];
+      for (const t of trailers) raw.push(t.toString("latin1"));
+      this.handler.onComplete!(raw);
+    }
+  }
+
+  onError(error: Error): void {
+    if (channels.error.hasSubscribers)
+      channels.error.publish({ request: this.diagnosticView(), error });
+    if (this.aborted) return;
+    this.aborted = true;
+    if (this.handler.onError !== undefined) this.handler.onError!(error);
+  }
+}
+
+function processHeader(request: Request, key: string, val: string, profile: Profile): void {
+  const lower = key.toLowerCase();
+  // undici 7 checks the name and every value before the special cases;
+  // undici 5 checks the first Host value before storing it. Either way a
+  // CR or LF in a value never reaches the request head.
+  if (profile.major >= 7) {
+    if (!tokenRegExp.test(lower)) throw new InvalidArgumentError("invalid header key");
+    if (headerCharRegex.test(val)) throw new InvalidArgumentError(`invalid ${key} header`);
+  }
+  if (lower === "host") {
+    // The client writes the Host value into the request head as given.
+    if (headerCharRegex.test(val)) throw new InvalidArgumentError(`invalid ${key} header`);
+    if (request.host === null) {
+      if (headerCharRegex.test(val)) throw new InvalidArgumentError(`invalid ${key} header`);
+      request.host = val;
+      return;
+    }
+    if (profile.major >= 7) throw new InvalidArgumentError("duplicate host header");
+  } else if (lower === "content-length") {
+    if (request.contentLength === null) {
+      const n = parseInt(val, 10);
+      if (!Number.isFinite(n) || (profile.major >= 7 && !/^\d+$/.test(val))) {
+        throw new InvalidArgumentError("invalid content-length header");
+      }
+      request.contentLength = n;
+      return;
+    }
+    // The client writes the one Content-Length it validated or computed
+    // from the body; a second field would frame the request twice. Both
+    // profiles reject it with undici 7's error (5.x sends it as given).
+    throw new InvalidArgumentError("duplicate content-length header");
+  }
+  if (lower === "content-type" && request.contentType === null && !headerCharRegex.test(val)) {
+    request.contentType = val;
+    request.headerPairs.push(key, val);
+    return;
+  }
+  if (lower === "transfer-encoding" || lower === "keep-alive" || lower === "upgrade") {
+    throw new InvalidArgumentError(`invalid ${lower} header`);
+  }
+  if (lower === "connection") {
+    if (profile.major < 7) throw new InvalidArgumentError("invalid connection header");
+    for (const token of val.toLowerCase().split(",")) {
+      const trimmed = token.trim();
+      if (!tokenRegExp.test(trimmed)) throw new InvalidArgumentError("invalid connection header");
+      if (trimmed === "close") request.reset = true;
+    }
+    return;
+  }
+  if (lower === "expect") throw new NotSupportedError("expect header not supported");
+  if (!tokenRegExp.test(key)) throw new InvalidArgumentError("invalid header key");
+  if (headerCharRegex.test(val)) throw new InvalidArgumentError(`invalid ${key} header`);
+  request.headerPairs.push(key, val);
+}
+
+/** util.getServerName: the Host header without its port; null for IPs. */
+function serverName(host: string | null): string | null {
+  if (host === null || host === "") return null;
+  let name = host;
+  if (name.startsWith("[")) {
+    const idx = name.indexOf("]");
+    if (idx !== -1) name = name.slice(1, idx);
+    return null;
+  }
+  const idx = name.indexOf(":");
+  if (idx !== -1) name = name.slice(0, idx);
+  return /^\d+\.\d+\.\d+\.\d+$/.test(name) ? null : name;
+}

package/shims/undici/core/timers.ts

@@ -0,0 +1,80 @@
+// undici 7.x's fast timers (lib/util/timers.js): one unref'd native timer
+// ticking every 499 ms drives every headers/body timeout, so those fire on
+// the first tick at least `delay` after the timer (re)started.
+const RESOLUTION_MS = 1e3;
+const TICK_MS = (RESOLUTION_MS >> 1) - 1;
+const NOT_IN_LIST = -2;
+const TO_BE_CLEARED = -1;
+const PENDING = 0;
+const ACTIVE = 1;
+
+let fastNow = 0;
+// The ticking native timer, held as its refresh closure.
+let refreshTick: (() => void) | null = null;
+const fastTimers: FastTimer[] = [];
+
+function onTick(): void {
+  fastNow += TICK_MS;
+  let idx = 0;
+  let len = fastTimers.length;
+  while (idx < len) {
+    const timer = fastTimers[idx]!;
+    if (timer.state === PENDING) {
+      timer.idleStart = fastNow - TICK_MS;
+      timer.state = ACTIVE;
+    } else if (timer.state === ACTIVE && fastNow >= timer.idleStart + timer.idleTimeout) {
+      timer.state = TO_BE_CLEARED;
+      timer.idleStart = -1;
+      timer.onTimeout();
+    }
+    if (timer.state === TO_BE_CLEARED) {
+      timer.state = NOT_IN_LIST;
+      if (--len !== 0) fastTimers[idx] = fastTimers[len]!;
+    } else {
+      ++idx;
+    }
+  }
+  fastTimers.length = len;
+  // An idle tick stops; the next timer schedules a new one.
+  if (fastTimers.length !== 0) refreshTimeout();
+  else refreshTick = null;
+}
+
+function refreshTimeout(): void {
+  const refresh = refreshTick;
+  if (refresh !== null) {
+    refresh();
+  } else {
+    const timeout = setTimeout(onTick, TICK_MS);
+    timeout.unref();
+    refreshTick = () => {
+      timeout.refresh();
+    };
+  }
+}
+
+export class FastTimer {
+  state: number;
+  idleTimeout: number;
+  idleStart: number;
+  onTimeout: () => void;
+
+  constructor(callback: () => void, delay: number) {
+    this.state = NOT_IN_LIST;
+    this.idleTimeout = delay;
+    this.idleStart = -1;
+    this.onTimeout = callback;
+    this.refresh();
+  }
+
+  refresh(): void {
+    if (this.state === NOT_IN_LIST) fastTimers.push(this);
+    if (refreshTick === null || fastTimers.length === 1) refreshTimeout();
+    this.state = PENDING;
+  }
+
+  clear(): void {
+    this.state = TO_BE_CLEARED;
+    this.idleStart = -1;
+  }
+}

package/shims/undici/core/types.ts

@@ -0,0 +1,167 @@
+// Types shared by the undici entries. They restate the subset of undici's
+// own declarations (types/dispatcher.d.ts, connector.d.ts, ...) that the
+// shim implements; test/package-shims/undici-types.test.ts checks them
+// against the installed 5.x and 7.x declarations.
+import type { Socket } from "node:net";
+import type { Dispatcher } from "./dispatcher.ts";
+
+/** Response and request header records (undici's IncomingHttpHeaders). */
+export type IncomingHttpHeaders = Record<string, string | string[] | undefined>;
+
+/** What a request's `headers` option accepts here: a record or a flat
+ * [name, value, ...] array. */
+export type UndiciHeaders = Record<string, string | string[] | undefined> | string[] | null;
+
+/** The payloads the shim writes. Streams, iterables, Blob and FormData
+ * bodies are outside the implemented subset. */
+export type RequestBody = string | Buffer | Uint8Array | null;
+
+export interface DispatchOptions {
+  origin?: string | URL;
+  path: string;
+  method: string;
+  body?: RequestBody;
+  headers?: UndiciHeaders;
+  idempotent?: boolean;
+  blocking?: boolean;
+  headersTimeout?: number | null;
+  bodyTimeout?: number | null;
+  reset?: boolean;
+  throwOnError?: boolean;
+  // Dispatcher.RequestOptions' members live here too: a record passed to
+  // dispatch() is copied to this shape, and interceptors read them back
+  // through a `params as Dispatcher.RequestOptions` cast, as with undici.
+  opaque?: unknown;
+  signal?: AbortSignal | null;
+  onInfo?: (info: { statusCode: number; headers: IncomingHttpHeaders }) => void;
+  highWaterMark?: number;
+}
+
+/** undici's dispatch-controller (7.x handler API). */
+export interface DispatchController {
+  readonly aborted: boolean;
+  readonly paused: boolean;
+  readonly reason: Error | null;
+  abort(reason: Error): void;
+  pause(): void;
+  resume(): void;
+}
+
+/** Dispatch handlers: the 5.x callbacks, plus 7.x's controller callbacks. */
+export interface DispatchHandlers {
+  onConnect?(abort: (err?: Error) => void): void;
+  onError?(err: Error): void;
+  onHeaders?(
+    statusCode: number,
+    headers: Buffer[],
+    resume: () => void,
+    statusText: string,
+  ): boolean;
+  onData?(chunk: Buffer): boolean;
+  onComplete?(trailers: string[] | null): void;
+  onBodySent?(chunkSize: number, totalBytesSent: number): void;
+  onRequestStart?(controller: DispatchController, context: unknown): void;
+  onResponseStart?(
+    controller: DispatchController,
+    statusCode: number,
+    headers: IncomingHttpHeaders,
+    statusMessage?: string,
+  ): void;
+  onResponseData?(controller: DispatchController, chunk: Buffer): void;
+  onResponseEnd?(controller: DispatchController, trailers: IncomingHttpHeaders): void;
+  onResponseError?(controller: DispatchController, error: Error): void;
+}
+
+export type DispatchFn = (options: DispatchOptions, handler: DispatchHandlers) => boolean;
+
+export type DispatchInterceptor = (dispatch: DispatchFn) => DispatchFn;
+
+/** buildConnector's per-connection parameters. */
+export interface ConnectorOptions {
+  hostname: string;
+  host?: string;
+  protocol: string;
+  port: string;
+  servername?: string;
+  localAddress?: string | null;
+}
+
+export type ConnectorCallback = (err: Error | null, socket: Socket | null) => void;
+
+/** A connector: dials, reports through the callback, and returns the socket
+ * (undici 5 and 7 both return it although their types declare void). */
+export type Connector = (options: ConnectorOptions, callback: ConnectorCallback) => Socket;
+
+/** net/tls connect options a connector forwards (the implemented subset). */
+export interface ConnectorBuildOptions {
+  timeout?: number | null;
+  maxCachedSessions?: number | null;
+  socketPath?: string | null;
+  port?: number;
+  rejectUnauthorized?: boolean;
+  ca?: string | Buffer | (string | Buffer)[];
+  servername?: string;
+  /** net.connect's resolver hook: @types/node's LookupFunction is
+   * assignable (method syntax; the callback takes one address or all). */
+  lookup?(
+    hostname: string,
+    options: unknown,
+    callback: (
+      err: NodeJS.ErrnoException | null,
+      address: string | LookupAddress[],
+      family?: number,
+    ) => void,
+  ): void;
+  keepAlive?: boolean;
+  keepAliveInitialDelay?: number;
+  noDelay?: boolean;
+  autoSelectFamily?: boolean;
+  autoSelectFamilyAttemptTimeout?: number;
+}
+
+export interface LookupAddress {
+  address: string;
+  family: number;
+}
+
+export interface ClientOptions {
+  keepAliveTimeout?: number | null;
+  keepAliveMaxTimeout?: number | null;
+  keepAliveTimeoutThreshold?: number | null;
+  pipelining?: number | null;
+  connect?: ConnectorBuildOptions | Connector | null;
+  maxHeaderSize?: number | null;
+  bodyTimeout?: number | null;
+  headersTimeout?: number | null;
+  strictContentLength?: boolean;
+  maxRequestsPerClient?: number;
+  maxResponseSize?: number | null;
+  connectTimeout?: number | null;
+  localAddress?: string;
+  /** 5.x applies `Client` interceptors; 7.x ignores the option. */
+  interceptors?: { Client?: readonly DispatchInterceptor[] | undefined };
+}
+
+export interface PoolOptions extends ClientOptions {
+  factory?(origin: URL, opts: object): Dispatcher;
+  connections?: number | null;
+  interceptors?: {
+    Pool?: readonly DispatchInterceptor[] | undefined;
+    Client?: readonly DispatchInterceptor[] | undefined;
+  };
+}
+
+export interface AgentOptions extends PoolOptions {
+  factory?(origin: string | URL, opts: object): Dispatcher;
+  interceptors?: {
+    Agent?: readonly DispatchInterceptor[] | undefined;
+    Pool?: readonly DispatchInterceptor[] | undefined;
+    Client?: readonly DispatchInterceptor[] | undefined;
+  };
+}
+
+/** Version-dependent behavior, selected by the importing package's installed
+ * undici (the 5.x or 7.x entry). */
+export interface Profile {
+  major: number;
+}

package/shims/undici/core/util.ts

@@ -0,0 +1,67 @@
+// Helpers from undici's lib/core/util.js.
+import { InvalidArgumentError } from "./errors.ts";
+import type { IncomingHttpHeaders, Profile } from "./types.ts";
+
+/** util.parseHeaders over raw [name, value, ...] pairs: lower-cased names,
+ * repeated names collected into arrays. 5.x decodes values as UTF-8 and
+ * treats an empty first value as absent; 7.x decodes latin1. */
+export function parseHeaders(raw: readonly string[], profile: Profile): IncomingHttpHeaders {
+  const obj: IncomingHttpHeaders = {};
+  for (let i = 0; i + 1 < raw.length; i += 2) {
+    const key = raw[i]!.toLowerCase();
+    const value = raw[i + 1]!;
+    const existing = obj[key];
+    const absent = profile.major >= 7 ? existing === undefined : !existing;
+    if (absent) {
+      obj[key] = value;
+    } else if (typeof existing === "string") {
+      obj[key] = [existing, value];
+    } else if (existing !== undefined) {
+      existing.push(value);
+    }
+  }
+  return obj;
+}
+
+/** Raw header Buffers as strings (latin1 on 7.x, UTF-8 on 5.x). */
+export function rawHeaderStrings(raw: readonly Buffer[], profile: Profile): string[] {
+  const out: string[] = [];
+  for (let i = 0; i < raw.length; i++) {
+    // Names are ASCII tokens; values follow the version's decoding.
+    out.push(
+      i % 2 === 0 || profile.major >= 7 ? raw[i]!.toString("latin1") : raw[i]!.toString("utf8"),
+    );
+  }
+  return out;
+}
+
+/** util.parseOrigin: an http(s) origin URL. */
+export function parseOrigin(url: string | URL, profile: Profile): URL {
+  const parsed = parseURL(url, profile);
+  if (parsed.pathname !== "/" || parsed.search !== "" || parsed.hash !== "") {
+    throw new InvalidArgumentError("invalid url");
+  }
+  return parsed;
+}
+
+/** util.parseURL for the string/URL forms. */
+export function parseURL(url: string | URL, profile: Profile): URL {
+  const parsed = typeof url === "string" ? new URL(url) : url;
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    // 7.x checks only string inputs; 5.x checks every input.
+    if (profile.major < 7) throw new InvalidArgumentError("invalid protocol");
+    if (typeof url === "string") {
+      throw new InvalidArgumentError(
+        "Invalid URL protocol: the URL must start with `http:` or `https:`.",
+      );
+    }
+  }
+  return parsed;
+}
+
+/** util.parseKeepAliveTimeout: the server's Keep-Alive `timeout=<s>` hint in
+ * milliseconds, or null. */
+export function parseKeepAliveTimeout(value: string): number | null {
+  const m = /timeout=(\d+)/.exec(value);
+  return m !== null ? parseInt(m[1]!, 10) * 1000 : null;
+}