@tuyau/core 1.0.0 → 1.2.0

package/build/client/index.js

@@ -13,11 +13,18 @@ function buildSearchParams(query) {
       const encodedKey = encodeURIComponent(key);
       const fullKey = prefix ? `${prefix}[${encodedKey}]` : encodedKey;
       if (Array.isArray(value)) {
-        for (const item of value) {
-          if (item !== void 0 && item !== null) {
+        value.forEach((item, index) => {
+          if (item === void 0 || item === null) return;
+          if (item instanceof Date) {
+            parts.push(`${fullKey}[]=${encodeURIComponent(item.toISOString())}`);
+          } else if (typeof item === "object") {
+            serialize2(item, `${fullKey}[${index}]`);
+          } else {
             parts.push(`${fullKey}[]=${encodeURIComponent(item)}`);
           }
-        }
+        });
+      } else if (value instanceof Date) {
+        parts.push(`${fullKey}=${encodeURIComponent(value.toISOString())}`);
       } else if (typeof value === "object") {
         serialize2(value, fullKey);
       } else {
@@ -29,28 +36,234 @@ function buildSearchParams(query) {
   return parts.length ? parts.join("&") : "";
 }
 
-// src/client/errors.ts
-async function parseResponse(response) {
-  if (!response) return;
-  const responseType = response.headers.get("Content-Type")?.split(";")[0];
-  if (responseType === "application/json") {
-    return await response.json();
-  } else if (responseType === "application/octet-stream") {
-    return await response.arrayBuffer();
+// src/client/router.ts
+var TuyauRouter = class _TuyauRouter {
+  #entries;
+  #baseUrl;
+  constructor(entries, baseUrl) {
+    this.#entries = entries;
+    this.#baseUrl = baseUrl;
   }
-  return await response.text();
-}
-var TuyauHTTPError = class extends Error {
+  /**
+   * Matches a route name against a pattern that may contain `*` wildcards.
+   * `*` matches one or more dot-separated segments via recursive backtracking.
+   */
+  static matchesRouteNamePattern(routeName, pattern) {
+    if (pattern === routeName) return true;
+    if (!pattern.includes("*")) return false;
+    const patternParts = pattern.split(".");
+    const routeParts = routeName.split(".");
+    function match(pIdx, rIdx) {
+      if (pIdx === patternParts.length) return rIdx === routeParts.length;
+      if (patternParts[pIdx] === "*") {
+        const remainingPattern = patternParts.length - pIdx - 1;
+        for (let i = rIdx + 1; i <= routeParts.length - remainingPattern; i++) {
+          if (match(pIdx + 1, i)) return true;
+        }
+        return false;
+      }
+      if (rIdx >= routeParts.length) return false;
+      if (patternParts[pIdx] !== routeParts[rIdx]) return false;
+      return match(pIdx + 1, rIdx + 1);
+    }
+    return match(0, 0);
+  }
+  /**
+   * Matches a URL pathname against an AdonisJS route pattern and extracts
+   * dynamic parameters. Supports `:param`, `:param?` (optional), and `*` (wildcard).
+   *
+   * Returns a record of extracted params on match, or `null` on mismatch.
+   */
+  static matchPathAgainstPattern(pathname, pattern) {
+    const urlSegments = pathname.split("/").filter(Boolean);
+    const patternSegments = pattern.split("/").filter(Boolean);
+    const params = {};
+    let ui = 0;
+    for (const seg of patternSegments) {
+      if (seg === "*") {
+        if (ui >= urlSegments.length) return null;
+        params["*"] = urlSegments.slice(ui).join("/");
+        return params;
+      }
+      if (seg.startsWith(":")) {
+        const optional = seg.endsWith("?");
+        const name = seg.slice(1, optional ? -1 : void 0);
+        if (ui < urlSegments.length) {
+          params[name] = urlSegments[ui++];
+        } else if (!optional) {
+          return null;
+        }
+        continue;
+      }
+      if (ui >= urlSegments.length || urlSegments[ui] !== seg) return null;
+      ui++;
+    }
+    return ui === urlSegments.length ? params : null;
+  }
+  #getCurrentPathname() {
+    if (typeof globalThis.window === "undefined") return void 0;
+    const pathname = globalThis.window.location.pathname;
+    const basePathname = new URL(this.#baseUrl).pathname;
+    if (basePathname !== "/" && pathname.startsWith(basePathname)) {
+      return pathname.slice(basePathname.length) || "/";
+    }
+    return pathname;
+  }
+  #isNavigableRoute(endpoint) {
+    return endpoint.methods.includes("GET") || endpoint.methods.includes("HEAD");
+  }
+  #findCurrentRouteName(pathname) {
+    for (const [name, endpoint] of this.#entries) {
+      if (!this.#isNavigableRoute(endpoint)) continue;
+      if (_TuyauRouter.matchPathAgainstPattern(pathname, endpoint.pattern)) return name;
+    }
+    return void 0;
+  }
+  #matchesCurrentRoute(pathname, routeName, options) {
+    for (const [name, endpoint] of this.#entries) {
+      if (!this.#isNavigableRoute(endpoint)) continue;
+      if (!_TuyauRouter.matchesRouteNamePattern(name, routeName)) continue;
+      const params = _TuyauRouter.matchPathAgainstPattern(pathname, endpoint.pattern);
+      if (!params) continue;
+      if (options?.params) {
+        const mismatch = Object.entries(options.params).some(
+          ([key, value]) => params[key] !== String(value)
+        );
+        if (mismatch) continue;
+      }
+      if (options?.query) {
+        if (!this.#matchesQueryString(globalThis.window.location.search, options.query)) continue;
+      }
+      return true;
+    }
+    return false;
+  }
+  #parseQueryString(search) {
+    if (!search || search === "?") return {};
+    const result = {};
+    for (const [key, value] of new URLSearchParams(search)) {
+      const current = result[key];
+      if (current === void 0) {
+        result[key] = value;
+        continue;
+      }
+      result[key] = Array.isArray(current) ? [...current, value] : [current, value];
+    }
+    return result;
+  }
+  #matchesQueryString(search, query) {
+    const currentQuery = this.#parseQueryString(search);
+    const expectedQuery = this.#parseQueryString(buildSearchParams(query));
+    return Object.entries(expectedQuery).every(([key, value]) => {
+      const currentValue = currentQuery[key];
+      if (currentValue === void 0) return false;
+      if (Array.isArray(value)) {
+        return Array.isArray(currentValue) ? value.length === currentValue.length && value.every((entry, index) => currentValue[index] === entry) : value.length === 1 && currentValue === value[0];
+      }
+      return Array.isArray(currentValue) ? currentValue.length === 1 && currentValue[0] === value : currentValue === value;
+    });
+  }
+  /**
+   * Checks if a route name exists in the registry.
+   */
+  has(routeName) {
+    return this.#entries.some(([name]) => _TuyauRouter.matchesRouteNamePattern(name, routeName));
+  }
+  current(routeName, options) {
+    const pathname = this.#getCurrentPathname();
+    if (!pathname) return routeName ? false : void 0;
+    if (!routeName) return this.#findCurrentRouteName(pathname);
+    return this.#matchesCurrentRoute(pathname, routeName, options);
+  }
+};
+
+// src/client/promise.ts
+var TuyauPromise = class {
+  #promise;
+  constructor(promise) {
+    this.#promise = promise;
+  }
+  then(onfulfilled, onrejected) {
+    return this.#promise.then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.#promise.catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.#promise.finally(onfinally);
+  }
+  /**
+   * Returns a tuple instead of throwing on error.
+   * - On success: `[data, null]`
+   * - On error: `[null, TuyauError]`
+   */
+  safe() {
+    return this.#promise.then(
+      (data) => [data, null],
+      (error) => [null, error]
+    );
+  }
+};
+
+// src/client/errors.ts
+var TuyauError = class extends Error {
+  /**
+   * Error kind exposed by Tuyau.
+   * - `'http'`: the server responded with a non-2xx status code.
+   * - `'network'`: the request failed before receiving a response.
+   */
+  kind;
+  /**
+   * HTTP status code returned by the server.
+   * `undefined` when the request failed before a response was received.
+   */
   status;
+  /**
+   * Original Ky response object for HTTP errors.
+   * `undefined` for network errors.
+   */
   rawResponse;
+  /**
+   * Original Ky request object when available.
+   */
   rawRequest;
+  /**
+   * Parsed error payload returned by the server.
+   * `undefined` for network errors.
+   */
   response;
+  constructor(message, options) {
+    super(message, options);
+    this.status = void 0;
+    this.response = void 0;
+    this.rawResponse = void 0;
+    this.rawRequest = void 0;
+    this.name = "TuyauError";
+  }
+  /**
+   * Type guard that narrows the error to a specific HTTP status code.
+   * After calling `isStatus(422)`, the `response` property is narrowed
+   * to the type associated with that status code.
+   */
+  isStatus(status) {
+    return this.kind === "http" && this.status === status;
+  }
+  /**
+   * Type guard that narrows to a 422 validation error.
+   * Alias for `isStatus(422)`.
+   */
+  isValidationError() {
+    return this.isStatus(422);
+  }
+};
+var TuyauHTTPError = class extends TuyauError {
   constructor(kyError, response) {
     const status = kyError.response?.status;
     const reason = status ? `status code ${status}` : "an unknown error";
     const url = kyError.request?.url.replace(kyError.options.prefixUrl || "", "");
     const message = kyError.response ? `Request failed with ${reason}: ${kyError.request?.method.toUpperCase()} /${url}` : `Request failed with ${reason}`;
     super(message, { cause: kyError });
+    this.kind = "http";
     this.rawResponse = kyError.response;
     this.response = response;
     this.status = kyError.response?.status;
@@ -58,12 +271,11 @@ var TuyauHTTPError = class extends Error {
     this.name = "TuyauHTTPError";
   }
 };
-var TuyauNetworkError = class extends Error {
-  cause;
+var TuyauNetworkError = class extends TuyauError {
   constructor(cause, request) {
     const message = request ? `Network error: ${request.method.toUpperCase()} ${request.url}` : "Network error occurred";
     super(message, { cause });
-    this.cause = cause;
+    this.kind = "network";
     this.name = "TuyauNetworkError";
   }
 };
@@ -83,6 +295,16 @@ function segmentsToRouteName(segments) {
 function segmentsToKebabRouteName(segments) {
   return segments.map((segment) => segment.replace(/[A-Z]/g, (g) => `-${g.toLowerCase()}`)).join(".");
 }
+async function parseResponse(response) {
+  if (!response) return;
+  const responseType = response.headers.get("Content-Type")?.split(";")[0];
+  if (responseType === "application/json") {
+    return await response.json();
+  } else if (responseType === "application/octet-stream") {
+    return await response.arrayBuffer();
+  }
+  return await response.text();
+}
 
 // src/client/tuyau.ts
 var Tuyau = class {
@@ -91,6 +313,7 @@ var Tuyau = class {
   #entries;
   #client;
   #config;
+  #router;
   /**
    * Merges the default Ky configuration with user-provided config
    */
@@ -128,6 +351,7 @@ var Tuyau = class {
     this.api = this.#makeNamed([]);
     this.#entries = Object.entries(this.#config.registry.routes);
     this.urlFor = this.#createUrlBuilder();
+    this.#router = new TuyauRouter(this.#entries, this.#config.baseUrl);
     this.#applyPlugins();
     this.#client = ky.create(this.#mergeKyConfiguration());
   }
@@ -174,45 +398,48 @@ var Tuyau = class {
   /**
    * Performs the actual HTTP request with proper body formatting
    */
-  async #doFetch(name, method, args) {
-    const url = this.#buildUrl(name, method, args);
-    let key = "json";
-    let body = args.body;
-    if (!(body instanceof FormData) && this.#hasFile(body)) {
-      body = serialize(body, { indices: true });
-      key = "body";
-    } else if (body instanceof FormData) {
-      key = "body";
-    }
-    const isGetOrHead = ["GET", "HEAD"].includes(method);
-    const { body: _, ...restArgs } = args;
-    const requestOptions = {
-      searchParams: buildSearchParams(args?.query || {}),
-      [key]: !isGetOrHead ? body : void 0,
-      ...restArgs
-    };
-    try {
-      const res = await this.#client[this.#getLowercaseMethod(method)](
-        removeSlash(url),
-        requestOptions
-      );
-      let data;
-      const responseType = res.headers.get("Content-Type")?.split(";")[0]?.trim();
-      if (responseType === "application/json") {
-        data = await res.json();
-      } else if (responseType === "application/octet-stream") {
-        data = await res.arrayBuffer();
-      } else {
-        data = await res.text();
+  #doFetch(name, method, args) {
+    const promise = (async () => {
+      const url = this.#buildUrl(name, method, args);
+      let key = "json";
+      let body = args.body;
+      if (!(body instanceof FormData) && this.#hasFile(body)) {
+        body = serialize(body, { indices: true });
+        key = "body";
+      } else if (body instanceof FormData) {
+        key = "body";
       }
-      return data;
-    } catch (originalError) {
-      if (originalError instanceof HTTPError) {
-        const parsedResponse = await parseResponse(originalError.response);
-        throw new TuyauHTTPError(originalError, parsedResponse);
+      const isGetOrHead = ["GET", "HEAD"].includes(method);
+      const { body: _, responseType: requestedResponseType, ...restArgs } = args;
+      const requestOptions = {
+        searchParams: buildSearchParams(args?.query || {}),
+        [key]: !isGetOrHead ? body : void 0,
+        ...restArgs
+      };
+      try {
+        const res = await this.#client[this.#getLowercaseMethod(method)](
+          removeSlash(url),
+          requestOptions
+        );
+        let data;
+        if (requestedResponseType) {
+          data = await res[requestedResponseType]();
+        } else {
+          const contentType = res.headers.get("Content-Type")?.split(";")[0]?.trim();
+          if (contentType === "application/json") data = await res.json();
+          else if (contentType === "application/octet-stream") data = await res.arrayBuffer();
+          else data = await res.text();
+        }
+        return data;
+      } catch (originalError) {
+        if (originalError instanceof HTTPError) {
+          const parsedResponse = await parseResponse(originalError.response);
+          throw new TuyauHTTPError(originalError, parsedResponse);
+        }
+        throw new TuyauNetworkError(originalError, { url, method });
       }
-      throw new TuyauNetworkError(originalError, { url, method });
-    }
+    })();
+    return new TuyauPromise(promise);
   }
   /**
    * Finds an endpoint definition by HTTP method and pattern
@@ -302,14 +529,24 @@ var Tuyau = class {
     }
     return new Proxy({}, { get: (_t, prop) => this.#makeNamed([...segments, String(prop)]) });
   }
+  /**
+   * Checks if a route name exists in the registry.
+   */
+  has(routeName) {
+    return this.#router.has(routeName);
+  }
+  current(routeName, options) {
+    return this.#router.current(routeName, options);
+  }
 };
 function createTuyau(config) {
   return new Tuyau(config);
 }
 export {
   Tuyau,
+  TuyauError,
   TuyauHTTPError,
   TuyauNetworkError,
-  createTuyau,
-  parseResponse
+  TuyauPromise,
+  createTuyau
 };