lifecycleion 0.0.19 → 0.0.21

package/dist/lib/http-client-mock/index.d.ts

@@ -1,4 +1,5 @@
-import { H as HTTPAdapter, Q as QueryObject, C as ContentType, A as AdapterType, a as AdapterRequest, b as AdapterResponse } from '../../types-Mso0dYOS.js';
+import { H as HTTPAdapter, Q as QueryObject, C as ContentType, A as AdapterType, a as AdapterRequest, b as AdapterResponse } from '../../types-BONtIhQ5.js';
+export { c as AdapterProgressEvent, d as HTTPMethod } from '../../types-BONtIhQ5.js';
 import '../../types-BW0vnSzd.js';
 
 interface MockFormData {
@@ -73,6 +74,53 @@ interface MockResponse {
      *   the same identity (name + path + domain) and typically `maxAge: 0`
      */
     cookies?: Record<string, string | MockCookieOptions | null>;
+    /**
+     * Simulate a response-body failure that happens **after** headers arrive, so
+     * consumers can test the `isStreamError` branch without a real socket.
+     *
+     * `status`, `headers` and cookies are reported as given, but `body` resolves as
+     * `null` whatever the handler set and the response carries
+     * `isStreamError: true`, which `HTTPClient` treats as terminal.
+     *
+     * Pass `true` for the default `'stream_response_error'`, or name the code.
+     */
+    streamError?: boolean | 'stream_write_error' | 'stream_response_error';
+    /**
+     * Simulate a failure that produced **no response at all** — a refused
+     * connection, a name that did not resolve, a socket dropped before headers.
+     *
+     * Nothing from the handler's response is delivered: no body, headers, cookies,
+     * or terminal progress. The response carries `isTransportError: true`.
+     *
+     * Pass `true` for a plain `status: 0` failure, or an object to exercise the
+     * replay signals a real adapter would attach:
+     *
+     * ```ts
+     * // Proven undelivered — a POST may be replayed
+     * { status: 200, transportError: { wasDefinitelyNotSent: true } }
+     *
+     * // Delivery unknown — a POST is not replayed
+     * { status: 200, transportError: true }
+     *
+     * // Nothing should retry this, whatever the method (a TLS failure)
+     * { status: 200, transportError: { status: 495, isRetryable: false } }
+     * ```
+     */
+    transportError?: boolean | MockTransportErrorOptions;
+}
+/** Shape of a simulated transport failure. See {@link MockResponse.transportError}. */
+interface MockTransportErrorOptions {
+    /**
+     * Diagnostic status to preserve, as adapters do for TLS failures (`495`).
+     * Defaults to `0`, the ordinary "no response" status.
+     */
+    status?: number;
+    /** Proof no request bytes reached the server. Authorizes replaying a write. */
+    wasDefinitelyNotSent?: boolean;
+    /** Set `false` for a failure no method should retry. */
+    isRetryable?: boolean;
+    /** Message for the generated `errorCause`. */
+    message?: string;
 }
 type MockRouteHandler = (request: MockRequest) => MockResponse | Promise<MockResponse>;
 interface MockAdapterConfig {
@@ -126,4 +174,4 @@ declare class MockAdapter implements HTTPAdapter {
     send(request: AdapterRequest): Promise<AdapterResponse>;
 }
 
-export { MockAdapter, type MockAdapterConfig, type MockAdapterRoutes, type MockCookieOptions, type MockFormData, type MockRequest, type MockResponse, type MockRouteHandler };
+export { AdapterRequest, AdapterResponse, AdapterType, HTTPAdapter, MockAdapter, type MockAdapterConfig, type MockAdapterRoutes, type MockCookieOptions, type MockFormData, type MockRequest, type MockResponse, type MockRouteHandler, type MockTransportErrorOptions };

package/dist/lib/http-client-mock/index.js

@@ -27,20 +27,6 @@ var REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([
 
 // src/lib/http-client/utils.ts
 import qs from "qs";
-
-// src/lib/domain-utils/domain-utils.ts
-import { getDomain, getSubdomain, getPublicSuffix } from "tldts";
-
-// src/lib/domain-utils/helpers.ts
-import { toASCII } from "tr46";
-var INTERNAL_PSEUDO_TLDS = Object.freeze(
-  /* @__PURE__ */ new Set(["localhost", "local", "test", "internal"])
-);
-
-// src/lib/domain-utils/domain-utils.ts
-import { getDomain as getDomain2, getSubdomain as getSubdomain2 } from "tldts";
-
-// src/lib/http-client/utils.ts
 function resolveAbsoluteURL(url, baseURL) {
   if (!url) {
     return url;
@@ -226,13 +212,33 @@ var MockAdapter = class {
     if (request.signal?.aborted) {
       throwAbortError();
     }
-    const responseBody = shouldOmitResponseBody(method, mockResponse.status) ? null : serializeResponseBody(mockResponse);
+    if (mockResponse.transportError) {
+      const options = mockResponse.transportError === true ? {} : mockResponse.transportError;
+      return {
+        status: options.status ?? 0,
+        isTransportError: true,
+        ...options.isRetryable !== void 0 ? { isRetryable: options.isRetryable } : {},
+        ...options.wasDefinitelyNotSent !== void 0 ? { wasDefinitelyNotSent: options.wasDefinitelyNotSent } : {},
+        headers: {},
+        body: null,
+        errorCause: new Error(
+          options.message ?? "Mock transport error (MockResponse.transportError)"
+        )
+      };
+    }
+    const streamErrorCode = resolveMockStreamErrorCode(
+      mockResponse.streamError
+    );
+    const intendedBody = shouldOmitResponseBody(method, mockResponse.status) ? null : serializeResponseBody(mockResponse);
+    const responseBody = streamErrorCode !== void 0 ? null : intendedBody;
     request.onUploadProgress?.({ loaded: 1, total: 1, progress: 1 });
-    request.onDownloadProgress?.({
-      loaded: responseBody?.length ?? 0,
-      total: responseBody?.length ?? 0,
-      progress: 1
-    });
+    if (streamErrorCode === void 0) {
+      request.onDownloadProgress?.({
+        loaded: responseBody?.length ?? 0,
+        total: responseBody?.length ?? 0,
+        progress: 1
+      });
+    }
     const responseHeaders = {
       ...mockResponse.headers ?? {}
     };
@@ -244,7 +250,7 @@ var MockAdapter = class {
         responseHeaders["set-cookie"] = [...existingArr, ...setCookieEntries];
       }
     }
-    if (!hasHeader(responseHeaders, "content-type") && responseBody !== null) {
+    if (!hasHeader(responseHeaders, "content-type") && intendedBody !== null) {
       const ct = mockResponse.contentType ?? inferContentType(mockResponse.body);
       if (ct === "json") {
         responseHeaders["content-type"] = "application/json";
@@ -263,10 +269,23 @@ var MockAdapter = class {
       wasRedirectDetected: REDIRECT_STATUS_CODES.has(mockResponse.status),
       ...detectedRedirectURL ? { detectedRedirectURL } : {},
       headers: normalizedResponseHeaders,
-      body: responseBody
+      body: responseBody,
+      ...streamErrorCode !== void 0 ? {
+        isStreamError: true,
+        streamErrorCode,
+        errorCause: new Error(
+          "Mock response stream error (MockResponse.streamError)"
+        )
+      } : {}
     };
   }
 };
+function resolveMockStreamErrorCode(streamError) {
+  if (streamError === void 0 || streamError === false) {
+    return void 0;
+  }
+  return streamError === true ? "stream_response_error" : streamError;
+}
 function buildRoutes(router) {
   function on(method, path, handler) {
     try {
@@ -289,7 +308,8 @@ function buildRoutes(router) {
   };
 }
 function isDuplicateRouteRegistrationError(error) {
-  return error instanceof Error && error.message.includes("already declared for route");
+  const message = readObjectMember(error, "message");
+  return isErrorValue(error) && typeof message === "string" && message.includes("already declared for route");
 }
 function duplicateRouteRegistrationError(method, path, cause) {
   return new Error(
@@ -461,11 +481,38 @@ function awaitAbortable(value, signal) {
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
-        reject(error instanceof Error ? error : new Error(String(error)));
+        reject(normalizeError(error));
       }
     );
   });
 }
+function readObjectMember(source, key) {
+  if (source === null || typeof source !== "object" && typeof source !== "function") {
+    return void 0;
+  }
+  try {
+    return source[key];
+  } catch {
+    return void 0;
+  }
+}
+function isErrorValue(value) {
+  try {
+    return value instanceof Error;
+  } catch {
+    return false;
+  }
+}
+function normalizeError(value) {
+  if (isErrorValue(value)) {
+    return value;
+  }
+  try {
+    return new Error(String(value));
+  } catch {
+    return new Error("Unknown error");
+  }
+}
 function sleepAbortable(ms, signal) {
   if (signal.aborted) {
     throw new InternalMockAbortError();