stitchkit 0.77.0 → 0.79.0

package/dist/{index-58jzmnn4.js → index-7ag81v2f.js}

@@ -3,17 +3,29 @@ import {
   inputIsQuery,
   parseSSE,
   readBoundedUtf8Lines
-} from "./index-1rxswfbv.js";
+} from "./index-hb5pf3s4.js";
+import {
+  createTraceContext,
+  formatTraceparent
+} from "./index-fxz0v7vg.js";
 import {
   ContractStreamFrameSchema,
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
   parseTrailingWildcard
-} from "./index-vj3vvpaa.js";
+} from "./index-y01f4223.js";
 import {
   isRecord,
   mapObject,
+  transportResult,
   typedEntries
-} from "./index-qyrqwr4c.js";
+} from "./index-77fekveh.js";
+
+// src/browser/http.ts
+import ky, {
+  isHTTPError,
+  isNetworkError,
+  isTimeoutError
+} from "ky";
 
 // src/browser/cancellation.ts
 class RequestCancellationError extends Error {
@@ -72,13 +84,6 @@ function cancellationError(cause) {
   return new RequestCancellationError(cause);
 }
 
-// src/browser/http.ts
-import ky, {
-  isHTTPError,
-  isNetworkError,
-  isTimeoutError
-} from "ky";
-
 // src/browser/request-id.ts
 var REQUEST_ID_HEADER = "x-request-id";
 function responseTraceId(response) {
@@ -114,6 +119,15 @@ class ApiError extends Error {
 function refuseLocally(path, message) {
   return new ApiError("VALIDATION_ERROR", 0, { issues: [{ path, code: "invalid_type", message }] }, message);
 }
+function shouldRetryBunNetworkError(error) {
+  if (ApiError.is(error) || isHTTPError(error) || isNetworkError(error) || isTimeoutError(error) || error instanceof RequestCancellationError || error instanceof DOMException && (error.name === "AbortError" || error.name === "TimeoutError")) {
+    return;
+  }
+  if (!(error instanceof Error))
+    return;
+  const code = Object.getOwnPropertyDescriptor(error, "code");
+  return code && "value" in code && code.value === "ConnectionRefused" ? true : undefined;
+}
 function parseApiErrorBody(body) {
   if (!isRecord(body) || !isRecord(body.error))
     return null;
@@ -127,6 +141,221 @@ function parseApiErrorBody(body) {
     hint: typeof error.hint === "string" ? error.hint : undefined
   };
 }
+function createRetryAwareFetch(transportFetch, unix) {
+  const runtimeFetch = transportFetch;
+  let attempt = 0;
+  return (input, init) => {
+    attempt += 1;
+    if (unix === undefined && attempt === 1) {
+      return runtimeFetch(input, init);
+    }
+    if (!(input instanceof Request)) {
+      if (unix === undefined)
+        return runtimeFetch(input, init);
+      const unixInit = { ...init, unix };
+      return runtimeFetch(input, unixInit);
+    }
+    const streamedBody = input.body ? { body: input.body, duplex: "half" } : {};
+    const materialized = {
+      ...init,
+      ...unix !== undefined && { unix },
+      method: input.method,
+      headers: input.headers,
+      ...streamedBody,
+      cache: input.cache,
+      credentials: input.credentials,
+      integrity: input.integrity,
+      keepalive: input.keepalive,
+      mode: input.mode,
+      redirect: input.redirect,
+      referrer: input.referrer,
+      referrerPolicy: input.referrerPolicy,
+      signal: input.signal
+    };
+    return runtimeFetch(input.url, materialized);
+  };
+}
+function createHttpClient(config) {
+  if (config.fetch && config.unix) {
+    throw new TypeError("HttpClientConfig.fetch and unix are mutually exclusive");
+  }
+  if (config.unix !== undefined) {
+    if (!config.unix.startsWith("/") || config.unix.includes("\x00")) {
+      throw new TypeError("HttpClientConfig.unix must be an absolute Unix socket path");
+    }
+    if (typeof Reflect.get(globalThis, "Bun") !== "object") {
+      throw new TypeError("HttpClientConfig.unix requires Bun; on Bun or Node use createUnixClientTransport().fetch for an explicit portable transport");
+    }
+  }
+  let ssrCookies = null;
+  let isLoggedOut = false;
+  const listeners = new Set;
+  const suppressUnauthorizedFor = config.suppressUnauthorizedFor ?? [];
+  const parseError = config.parseError ?? parseApiErrorBody;
+  function emit(event) {
+    for (const fn of listeners) {
+      try {
+        fn(event);
+      } catch {}
+    }
+  }
+  const client = ky.create({
+    prefix: config.baseUrl,
+    credentials: config.credentials ?? "include",
+    timeout: false,
+    retry: {
+      limit: config.retry?.limit ?? 2,
+      methods: config.retry?.methods ?? ["get"],
+      statusCodes: config.retry?.statusCodes ?? [],
+      shouldRetry: ({ error }) => shouldRetryBunNetworkError(error)
+    },
+    hooks: {
+      beforeRequest: [
+        ({ request: request2 }) => {
+          if (ssrCookies) {
+            request2.headers.set("Cookie", ssrCookies);
+          }
+          const extra = typeof config.headers === "function" ? config.headers() : config.headers;
+          if (extra) {
+            for (const [key, value] of Object.entries(extra)) {
+              request2.headers.set(key, value);
+            }
+          }
+          if (config.trace && !request2.headers.has("traceparent")) {
+            request2.headers.set("traceparent", formatTraceparent(createTraceContext()));
+          }
+        }
+      ],
+      afterResponse: [
+        async ({ request: request2, response }) => {
+          if (response.status === 401) {
+            const url = new URL(request2.url).pathname;
+            if (!isLoggedOut && !suppressUnauthorizedFor.some((matches) => matches(url))) {
+              isLoggedOut = true;
+              emit({ type: "unauthorized" });
+            }
+          }
+          if (!response.ok) {
+            const body = await response.clone().json().catch(() => null);
+            if (body) {
+              const parsed = parseError(body);
+              if (parsed) {
+                throw new ApiError(parsed.code, response.status, parsed.details, parsed.message, parsed.hint, responseTraceId(response));
+              }
+            }
+          }
+        }
+      ]
+    }
+  });
+  async function request(method, url, data, options = {}) {
+    const cancellation = createRequestCancellation(options.signal, options.timeout ?? config.timeout ?? 30000);
+    const kyOptions = {
+      fetch: createRetryAwareFetch(config.fetch ?? globalThis.fetch.bind(globalThis), config.unix),
+      timeout: false,
+      signal: cancellation.signal
+    };
+    if (options.params) {
+      const searchParams = new URLSearchParams;
+      for (const [key, value] of Object.entries(options.params)) {
+        if (value === undefined)
+          continue;
+        if (Array.isArray(value)) {
+          for (const item of value)
+            searchParams.append(key, String(item));
+        } else {
+          searchParams.set(key, String(value));
+        }
+      }
+      if (searchParams.size > 0) {
+        kyOptions.searchParams = searchParams;
+      }
+    }
+    if (data instanceof FormData) {
+      kyOptions.body = data;
+    } else if (data !== undefined) {
+      kyOptions.json = data;
+    }
+    try {
+      return await cancellation.run(async () => {
+        if (options.responseType === "blob") {
+          return transportResult(await client[method](url, kyOptions).blob());
+        }
+        if (options.responseType === "response") {
+          return transportResult(await client[method](url, kyOptions));
+        }
+        const response = await client[method](url, kyOptions);
+        if (options.responseType === "void") {
+          const text = await response.text();
+          if (text.length > 0) {
+            throw new Error("Server returned data for an endpoint with no output contract");
+          }
+        }
+        if (options.responseType === "void" || response.status === 204 || response.headers.get("content-length") === "0") {
+          return transportResult(undefined);
+        }
+        return await response.json();
+      });
+    } catch (error) {
+      if (error instanceof RequestCancellationError) {
+        throw new ApiError(error.cause === "caller" ? "REQUEST_ABORTED" : "REQUEST_TIMEOUT", 0, undefined, error.message);
+      }
+      if (ApiError.is(error))
+        throw error;
+      emit({ type: "network_error" });
+      const response = isHTTPError(error) ? error.response : undefined;
+      const status = response?.status ?? 0;
+      const msg = error instanceof Error ? error.message : undefined;
+      throw new ApiError("UNKNOWN_ERROR", status, msg ? { message: msg } : undefined, msg, undefined, responseTraceId(response), { cause: error });
+    }
+  }
+  return {
+    baseUrl: config.baseUrl,
+    get: (url, options) => request("get", url, undefined, options),
+    head: (url, options) => request("head", url, undefined, options),
+    post: (url, data, options) => request("post", url, data, options),
+    put: (url, data, options) => request("put", url, data, options),
+    patch: (url, data, options) => request("patch", url, data, options),
+    delete: (url, options) => request("delete", url, undefined, options),
+    setServerContext(cookies) {
+      ssrCookies = cookies;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    logout() {
+      isLoggedOut = true;
+      emit({ type: "logout" });
+    },
+    resetLogoutState() {
+      isLoggedOut = false;
+    }
+  };
+}
+// src/browser/stream.ts
+function parseFailure(raw, error, onParseError) {
+  const failure = error instanceof Error ? error : new Error(String(error));
+  if (!onParseError)
+    throw failure;
+  onParseError(raw, failure);
+}
+async function* parseNDJSON(response, options) {
+  try {
+    for await (const rawLine of readBoundedUtf8Lines(response, options?.maxLineBytes ?? DEFAULT_STREAM_LINE_BYTES, options?.finalLine === "require-newline")) {
+      const line = (rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine).trim();
+      if (line === "")
+        continue;
+      try {
+        yield JSON.parse(line);
+      } catch (error) {
+        parseFailure(line, error, options?.onParseError);
+      }
+    }
+  } catch (error) {
+    parseFailure("", error, options?.onParseError);
+  }
+}
 
 // src/browser/client-multipart.ts
 function isFileDescriptor(value) {
@@ -217,6 +446,52 @@ function resolvePathPrefix(config, args) {
   }
   return config.pathPrefix(args);
 }
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function decodePathSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function createClientRouteMatcher(endpoint, contractPrefix, config) {
+  if (typeof config?.pathPrefix === "function" && (!config.stripPrefixKeys || config.stripPrefixKeys.length === 0)) {
+    throw new Error("Dynamic pathPrefix matchers require stripPrefixKeys");
+  }
+  const markerByKey = {};
+  for (const [index, key] of (config?.stripPrefixKeys ?? []).entries()) {
+    markerByKey[key] = `__stitch_scope_${index}__`;
+  }
+  const pathPrefix = resolvePathPrefix(config, markerByKey);
+  const route = [pathPrefix, contractPrefix, endpoint.path === "/" ? "" : endpoint.path].filter(Boolean).join("/");
+  const patternSegments = route.split("/").filter(Boolean);
+  const wildcard = patternSegments.at(-1)?.startsWith("*") === true;
+  const fixedCount = wildcard ? patternSegments.length - 1 : patternSegments.length;
+  const markers = Object.values(markerByKey);
+  return (pathname) => {
+    const actualSegments = pathname.split("/").filter(Boolean).map(decodePathSegment);
+    if (wildcard ? actualSegments.length < fixedCount : actualSegments.length !== fixedCount) {
+      return false;
+    }
+    for (let index = 0;index < fixedCount; index += 1) {
+      const pattern = patternSegments[index];
+      const actual = actualSegments[index];
+      if (!pattern || actual === undefined)
+        return false;
+      if (pattern.startsWith(":"))
+        continue;
+      let source = escapeRegex(pattern);
+      for (const marker of markers) {
+        source = source.replaceAll(escapeRegex(marker), "[^/]+");
+      }
+      if (!new RegExp(`^${source}$`).test(actual))
+        return false;
+    }
+    return true;
+  };
+}
 function extractParamNames(path) {
   const matches = path.match(/:(\w+)/g);
   const names = matches ? matches.map((match) => match.slice(1)) : [];
@@ -290,29 +565,6 @@ function joinClientBaseUrl(baseUrl, relativeUrl) {
   const path = relativeUrl.startsWith("/") ? relativeUrl : `/${relativeUrl}`;
   return `${base}${path}`;
 }
-// src/browser/stream.ts
-function parseFailure(raw, error, onParseError) {
-  const failure = error instanceof Error ? error : new Error(String(error));
-  if (!onParseError)
-    throw failure;
-  onParseError(raw, failure);
-}
-async function* parseNDJSON(response, options) {
-  try {
-    for await (const rawLine of readBoundedUtf8Lines(response, options?.maxLineBytes ?? DEFAULT_STREAM_LINE_BYTES, options?.finalLine === "require-newline")) {
-      const line = (rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine).trim();
-      if (line === "")
-        continue;
-      try {
-        yield JSON.parse(line);
-      } catch (error) {
-        parseFailure(line, error, options?.onParseError);
-      }
-    }
-  } catch (error) {
-    parseFailure("", error, options?.onParseError);
-  }
-}
 
 // src/browser/contract-stream.ts
 function sourceFor(response, descriptor) {
@@ -448,6 +700,25 @@ function withOutput(endpoint, result, abortStream) {
     return schema.parse(value);
   });
 }
+function contractEndpointMatchers(contract, endpointNames, contractConfig) {
+  const selected = endpointNames ? new Set(endpointNames) : null;
+  const matchers = [];
+  for (const [key, endpoint] of typedEntries(contract.endpoints)) {
+    if (selected && !selected.has(key))
+      continue;
+    if (endpoint.expose && !endpoint.expose.includes("HTTP")) {
+      if (selected) {
+        throw new Error(`Cannot create an HTTP route matcher for non-HTTP endpoint: ${String(key)}`);
+      }
+      continue;
+    }
+    matchers.push(createClientRouteMatcher(endpoint, contract.meta.prefix, contractConfig));
+  }
+  if (selected && matchers.length !== selected.size) {
+    throw new Error("Cannot create an HTTP route matcher for an unknown endpoint");
+  }
+  return matchers;
+}
 function createClient(contract, configOrClient, contractConfig) {
   const client = {};
   const makeExecutor = isHttpAdapter(configOrClient) ? (endpoint) => createHttpExecutor(endpoint, contract.meta.prefix, configOrClient, contractConfig) : (endpoint) => createFetchExecutor(endpoint, contract.meta.prefix, configOrClient, contractConfig);
@@ -461,6 +732,34 @@ function createClient(contract, configOrClient, contractConfig) {
 function createClients(contracts, configOrClient, contractConfig) {
   return mapObject(contracts, (_key, contract) => createClient(contract, configOrClient, contractConfig));
 }
+function buildScopedRegistry(contracts, scopeConfigs, surfaceName, build) {
+  const registry = {};
+  for (const [namespace, value] of Object.entries(contracts)) {
+    const list = Array.isArray(value) ? value : [value];
+    const surface = {};
+    for (const contract of list) {
+      const scope = contract.meta.scope;
+      if (!scope) {
+        throw new Error(`Contract in ${surfaceName} namespace "${namespace}" has no scope`);
+      }
+      const scopeConfig = scopeConfigs[scope];
+      if (!scopeConfig) {
+        throw new Error(`Missing ${surfaceName} config for scope: ${scope}`);
+      }
+      for (const [methodName, method] of Object.entries(build(contract, scopeConfig))) {
+        if (Object.hasOwn(surface, methodName)) {
+          throw new Error(`${surfaceName[0]?.toUpperCase()}${surfaceName.slice(1)} namespace "${namespace}" has duplicate method: ${methodName}`);
+        }
+        surface[methodName] = method;
+      }
+    }
+    registry[namespace] = surface;
+  }
+  return registry;
+}
+function createScopedClients(contracts, configOrClient, scopeConfigs) {
+  return buildScopedRegistry(contracts, scopeConfigs, "client", (contract, config) => createClient(contract, configOrClient, config));
+}
 function isHttpAdapter(value) {
   return typeof value === "object" && "get" in value && typeof value.get === "function";
 }
@@ -633,5 +932,27 @@ async function throwForErrorResponse(res, config, fallbackBody) {
   }
   throw new ApiError("HTTP_ERROR", res.status, { body }, undefined, undefined, responseTraceId(res));
 }
+function createUrlBuilder(contract, source, contractConfig) {
+  const builder = {};
+  for (const [key, endpoint] of typedEntries(contract.endpoints)) {
+    if (endpoint.expose && !endpoint.expose.includes("HTTP"))
+      continue;
+    setClientMethod(builder, key, (args) => {
+      const plan = planClientRequest(endpoint, contract.meta.prefix, args ?? {}, contractConfig);
+      if (endpoint.method !== "GET" && endpoint.method !== "DELETE" && Object.keys(plan.remainingArgs).length > 0) {
+        const fields = Object.keys(plan.remainingArgs).join(", ");
+        throw new Error(`URL builder for ${endpoint.method} ${endpoint.path} received non-URL fields: ${fields}`);
+      }
+      return joinClientBaseUrl(source.baseUrl, plan.relativeUrl);
+    });
+  }
+  return builder;
+}
+function createUrlBuilders(contracts, source, contractConfig) {
+  return mapObject(contracts, (_key, contract) => createUrlBuilder(contract, source, contractConfig));
+}
+function createScopedUrlBuilders(contracts, source, scopeConfigs) {
+  return buildScopedRegistry(contracts, scopeConfigs, "URL builder", (contract, config) => createUrlBuilder(contract, source, config));
+}
 
-export { ApiError, createClient, createClients };
+export { ApiError, createHttpClient, parseNDJSON, contractEndpointMatchers, createClient, createClients, createScopedClients, createUrlBuilder, createUrlBuilders, createScopedUrlBuilders };