lifecycleion 0.0.8 → 0.0.10

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

@@ -0,0 +1,525 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/http-client-mock/index.ts
+var http_client_mock_exports = {};
+__export(http_client_mock_exports, {
+  MockAdapter: () => MockAdapter
+});
+module.exports = __toCommonJS(http_client_mock_exports);
+
+// src/lib/http-client/adapters/mock-adapter.ts
+var import_find_my_way = __toESM(require("find-my-way"), 1);
+var import_qs2 = __toESM(require("qs"), 1);
+
+// src/lib/sleep.ts
+async function sleep(time) {
+  return new Promise(function(resolve) {
+    setTimeout(function() {
+      resolve();
+    }, time);
+  });
+}
+
+// src/lib/http-client/consts.ts
+var REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([
+  // 301 Moved Permanently
+  301,
+  // 302 Found
+  302,
+  // 303 See Other
+  303,
+  // 307 Temporary Redirect
+  307,
+  // 308 Permanent Redirect
+  308
+]);
+
+// src/lib/http-client/utils.ts
+var import_qs = __toESM(require("qs"), 1);
+
+// src/lib/domain-utils/domain-utils.ts
+var import_tldts = require("tldts");
+
+// src/lib/domain-utils/helpers.ts
+var import_tr46 = require("tr46");
+var INTERNAL_PSEUDO_TLDS = Object.freeze(
+  /* @__PURE__ */ new Set(["localhost", "local", "test", "internal"])
+);
+
+// src/lib/domain-utils/domain-utils.ts
+var import_tldts2 = require("tldts");
+
+// src/lib/http-client/utils.ts
+function resolveAbsoluteURL(url, baseURL) {
+  if (!url) {
+    return url;
+  }
+  try {
+    return new URL(url).href;
+  } catch {
+  }
+  if (baseURL) {
+    try {
+      const base = baseURL.endsWith("/") ? baseURL : `${baseURL}/`;
+      return new URL(url, base).href;
+    } catch {
+    }
+  }
+  return url;
+}
+function parseContentType(contentTypeHeader) {
+  if (!contentTypeHeader) {
+    return "binary";
+  } else {
+    const lower = contentTypeHeader.trim().toLowerCase();
+    if (lower.includes("application/json") || lower.includes("+json")) {
+      return "json";
+    } else if (lower.startsWith("text/")) {
+      return "text";
+    } else if (lower.includes("application/x-www-form-urlencoded")) {
+      return "text";
+    } else {
+      return "binary";
+    }
+  }
+}
+function normalizeAdapterResponseHeaders(headers) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers)) {
+    const lower = key.toLowerCase();
+    if (lower === "set-cookie") {
+      const chunk = Array.isArray(value) ? value : [value];
+      const existing = result[lower];
+      if (existing === void 0) {
+        result[lower] = chunk;
+      } else {
+        const existingLines = Array.isArray(existing) ? existing : [existing];
+        result[lower] = [...existingLines, ...chunk];
+      }
+    } else {
+      result[lower] = Array.isArray(value) ? value[0] ?? "" : value;
+    }
+  }
+  return result;
+}
+function scalarHeader(headers, lowercaseName) {
+  const v = headers[lowercaseName];
+  if (v === void 0) {
+    return void 0;
+  }
+  return Array.isArray(v) ? v[0] : v;
+}
+function resolveDetectedRedirectURL(requestURL, status, headers, baseURL) {
+  if (![301, 302, 303, 307, 308].includes(status)) {
+    return void 0;
+  }
+  const location = scalarHeader(headers, "location");
+  if (!location) {
+    return void 0;
+  }
+  try {
+    const absoluteRequestURL = resolveAbsoluteURL(requestURL, baseURL);
+    return new URL(location, absoluteRequestURL).toString();
+  } catch {
+    return location;
+  }
+}
+function isPlainJSONBodyObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Reflect.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+// src/lib/http-client/adapters/mock-adapter.ts
+var noop = () => {
+};
+var MockAdapter = class {
+  routes;
+  router;
+  config;
+  constructor(config) {
+    this.config = config ?? {};
+    this.router = (0, import_find_my_way.default)({
+      ignoreTrailingSlash: true,
+      ignoreDuplicateSlashes: false,
+      maxParamLength: 100
+    });
+    this.routes = buildRoutes(this.router);
+  }
+  getType() {
+    return "mock";
+  }
+  async send(request) {
+    const { requestURL, method, headers, body } = request;
+    const materializedHeaders = materializeMockRequestHeaders(headers);
+    if (request.signal?.aborted) {
+      throwAbortError();
+    }
+    request.onUploadProgress?.({ loaded: 0, total: 0, progress: 0 });
+    let path;
+    let queryString;
+    try {
+      const url = new URL(requestURL);
+      path = url.pathname;
+      queryString = url.search.slice(1);
+    } catch {
+      const qIdx = requestURL.indexOf("?");
+      if (qIdx >= 0) {
+        path = requestURL.slice(0, qIdx);
+        queryString = requestURL.slice(qIdx + 1);
+      } else {
+        path = requestURL;
+        queryString = "";
+      }
+    }
+    const query = import_qs2.default.parse(queryString);
+    const cookies = parseCookieHeader(materializedHeaders["cookie"]);
+    const match = this.router.find(method, path);
+    const params = match?.params ?? {};
+    const mockRequest = {
+      method,
+      path,
+      params,
+      query,
+      headers: materializedHeaders,
+      cookies,
+      body: body instanceof FormData ? extractFormData(body) : parseRequestBody(body, materializedHeaders["content-type"])
+    };
+    let mockResponse;
+    if (match === null) {
+      mockResponse = { status: 404, body: { message: "Not Found" } };
+    } else {
+      const handler = match.store;
+      try {
+        mockResponse = await awaitAbortable(
+          handler(mockRequest),
+          request.signal
+        );
+      } catch (handlerError) {
+        if (isInternalAbortError(handlerError)) {
+          throwAbortError();
+        }
+        if (this.config.onError) {
+          try {
+            mockResponse = await awaitAbortable(
+              this.config.onError(mockRequest, handlerError),
+              request.signal
+            );
+          } catch (error) {
+            if (isInternalAbortError(error)) {
+              throwAbortError();
+            }
+            mockResponse = {
+              status: 500,
+              body: { message: "Internal Server Error" }
+            };
+          }
+        } else {
+          mockResponse = {
+            status: 500,
+            body: { message: "Internal Server Error" }
+          };
+        }
+      }
+    }
+    const delay = mockResponse.delay ?? this.config.defaultDelay ?? 0;
+    if (delay > 0) {
+      if (request.signal) {
+        await sleepAbortable(delay, request.signal);
+      } else {
+        await sleep(delay);
+      }
+    }
+    if (request.signal?.aborted) {
+      throwAbortError();
+    }
+    const responseBody = shouldOmitResponseBody(method, mockResponse.status) ? null : serializeResponseBody(mockResponse);
+    request.onUploadProgress?.({ loaded: 1, total: 1, progress: 1 });
+    request.onDownloadProgress?.({
+      loaded: responseBody?.length ?? 0,
+      total: responseBody?.length ?? 0,
+      progress: 1
+    });
+    const responseHeaders = {
+      ...mockResponse.headers ?? {}
+    };
+    if (mockResponse.cookies) {
+      const setCookieEntries = cookiesToSetCookieHeaders(mockResponse.cookies);
+      if (setCookieEntries.length > 0) {
+        const existing = responseHeaders["set-cookie"];
+        const existingArr = existing === void 0 ? [] : Array.isArray(existing) ? existing : [existing];
+        responseHeaders["set-cookie"] = [...existingArr, ...setCookieEntries];
+      }
+    }
+    if (!hasHeader(responseHeaders, "content-type") && responseBody !== null) {
+      const ct = mockResponse.contentType ?? inferContentType(mockResponse.body);
+      if (ct === "json") {
+        responseHeaders["content-type"] = "application/json";
+      } else if (ct === "text") {
+        responseHeaders["content-type"] = "text/plain";
+      }
+    }
+    const normalizedResponseHeaders = normalizeAdapterResponseHeaders(responseHeaders);
+    const detectedRedirectURL = resolveDetectedRedirectURL(
+      request.requestURL,
+      mockResponse.status,
+      normalizedResponseHeaders
+    );
+    return {
+      status: mockResponse.status,
+      wasRedirectDetected: REDIRECT_STATUS_CODES.has(mockResponse.status),
+      ...detectedRedirectURL ? { detectedRedirectURL } : {},
+      headers: normalizedResponseHeaders,
+      body: responseBody
+    };
+  }
+};
+function buildRoutes(router) {
+  function on(method, path, handler) {
+    try {
+      router.on(method, path, noop, handler);
+    } catch (error) {
+      if (isDuplicateRouteRegistrationError(error)) {
+        throw duplicateRouteRegistrationError(method, path, error);
+      }
+      throw error;
+    }
+  }
+  return {
+    get: (path, handler) => on("GET", path, handler),
+    post: (path, handler) => on("POST", path, handler),
+    put: (path, handler) => on("PUT", path, handler),
+    patch: (path, handler) => on("PATCH", path, handler),
+    delete: (path, handler) => on("DELETE", path, handler),
+    head: (path, handler) => on("HEAD", path, handler),
+    clear: () => router.reset()
+  };
+}
+function isDuplicateRouteRegistrationError(error) {
+  return error instanceof Error && error.message.includes("already declared for route");
+}
+function duplicateRouteRegistrationError(method, path, cause) {
+  return new Error(
+    `[MockAdapter] Duplicate route registration for ${method} ${path}. Routes must be unique per method and normalized path.`,
+    { cause }
+  );
+}
+function parseCookieHeader(cookieHeader) {
+  if (!cookieHeader) {
+    return {};
+  }
+  const cookies = {};
+  for (const part of cookieHeader.split(";")) {
+    const eqIdx = part.indexOf("=");
+    if (eqIdx < 0) {
+      continue;
+    }
+    const name = part.slice(0, eqIdx).trim();
+    const value = part.slice(eqIdx + 1).trim();
+    if (name) {
+      cookies[name] = value;
+    }
+  }
+  return cookies;
+}
+function materializeMockRequestHeaders(headers) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers)) {
+    result[key] = Array.isArray(value) ? key.toLowerCase() === "cookie" ? value.join("; ") : value.join(", ") : value;
+  }
+  return result;
+}
+function cookiesToSetCookieHeaders(cookies) {
+  return Object.entries(cookies).map(([name, value]) => {
+    if (value === null) {
+      return `${name}=; Path=/; Max-Age=0`;
+    }
+    if (typeof value === "string") {
+      return `${name}=${value}; Path=/`;
+    }
+    return serializeMockCookieOptions(name, value);
+  });
+}
+function serializeMockCookieOptions(name, cookie) {
+  const parts = [
+    `${name}=${cookie.value}`,
+    `Path=${cookie.path ?? "/"}`
+  ];
+  appendCookieAttribute(parts, "Max-Age", cookie.maxAge);
+  appendCookieAttribute(parts, "Domain", cookie.domain);
+  if (cookie.httpOnly) {
+    parts.push("HttpOnly");
+  }
+  if (cookie.secure) {
+    parts.push("Secure");
+  }
+  appendCookieAttribute(parts, "SameSite", cookie.sameSite);
+  return parts.join("; ");
+}
+function appendCookieAttribute(parts, name, value) {
+  if (value !== void 0 && value !== "") {
+    parts.push(`${name}=${value}`);
+  }
+}
+function extractFormData(fd) {
+  const fields = {};
+  const files = {};
+  for (const [key, value] of fd.entries()) {
+    if (typeof value === "string") {
+      fields[key] = value;
+    } else {
+      files[key] = value;
+    }
+  }
+  return { fields, files };
+}
+function parseRequestBody(body, contentType) {
+  if (body === null || body === void 0) {
+    return void 0;
+  }
+  const parsedContentType = parseContentType(contentType);
+  if (body instanceof Uint8Array) {
+    if (parsedContentType === "binary") {
+      return body;
+    } else if (parsedContentType === "json") {
+      const text = new TextDecoder().decode(body);
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    } else if (parsedContentType === "text") {
+      return new TextDecoder().decode(body);
+    }
+  } else if (parsedContentType === "json") {
+    try {
+      return JSON.parse(body);
+    } catch {
+      return body;
+    }
+  }
+  return body;
+}
+function serializeResponseBody(response) {
+  const { body } = response;
+  if (body === void 0 || body === null) {
+    return null;
+  } else if (body instanceof Uint8Array) {
+    return body;
+  } else if (body instanceof ArrayBuffer) {
+    return new Uint8Array(body);
+  } else if (typeof body === "string") {
+    return new TextEncoder().encode(body);
+  } else if (Array.isArray(body) || isPlainJSONBodyObject(body)) {
+    return new TextEncoder().encode(JSON.stringify(body));
+  }
+  throw new Error(
+    "Unsupported mock response body type. Supported types: string, Uint8Array, ArrayBuffer, plain object, array, null, and undefined."
+  );
+}
+function inferContentType(body) {
+  if (typeof body === "string") {
+    return "text";
+  } else if (body instanceof Uint8Array || body instanceof ArrayBuffer) {
+    return "binary";
+  } else {
+    return "json";
+  }
+}
+function hasHeader(headers, name) {
+  return Object.keys(headers).some(
+    (k) => k.toLowerCase() === name.toLowerCase()
+  );
+}
+var InternalMockAbortError = class extends Error {
+  constructor() {
+    super("The operation was aborted.");
+    this.name = "AbortError";
+  }
+};
+function isInternalAbortError(error) {
+  return error instanceof InternalMockAbortError;
+}
+function throwAbortError() {
+  const err = new Error("The operation was aborted.");
+  err.name = "AbortError";
+  throw err;
+}
+function shouldOmitResponseBody(method, status) {
+  return method === "HEAD" || status === 204 || status === 304;
+}
+function awaitAbortable(value, signal) {
+  if (!signal) {
+    return Promise.resolve(value);
+  }
+  if (signal.aborted) {
+    throw new InternalMockAbortError();
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      reject(new InternalMockAbortError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    Promise.resolve(value).then(
+      (result) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(result);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    );
+  });
+}
+function sleepAbortable(ms, signal) {
+  if (signal.aborted) {
+    throw new InternalMockAbortError();
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(id);
+      reject(new InternalMockAbortError());
+    };
+    const id = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MockAdapter
+});
+//# sourceMappingURL=index.cjs.map