@routar/core 1.5.0 → 1.7.0

package/dist/index.cjs

@@ -8,6 +8,96 @@ function defineRouter(prefix, endpoints) {
   return { prefix, endpoints };
 }
 
+// src/middleware.ts
+var TimeoutError = class extends Error {
+  constructor(ms) {
+    super(`Request timed out after ${ms}ms`);
+    this.ms = ms;
+    this.name = "TimeoutError";
+  }
+};
+function definePlugin(plugin) {
+  return plugin;
+}
+function logger(options) {
+  const log = options?.log ?? ((msg, data) => console.log(msg, data));
+  const timings = /* @__PURE__ */ new WeakMap();
+  return definePlugin({
+    name: "logger",
+    onRequest: (opts) => {
+      timings.set(opts, Date.now());
+      log(`[routar] ${opts.method} ${opts.url}`, {
+        params: opts.params,
+        body: opts.body
+      });
+      return opts;
+    },
+    onResponse: (res, opts) => {
+      log(
+        `[routar] ${opts.method} ${opts.url} \u2014 ${Date.now() - (timings.get(opts) ?? Date.now())}ms`
+      );
+      timings.delete(opts);
+      return res;
+    },
+    onError: (err, opts) => {
+      log(
+        `[routar] ${opts.method} ${opts.url} \u2014 error after ${Date.now() - (timings.get(opts) ?? Date.now())}ms`,
+        err
+      );
+      timings.delete(opts);
+      throw err;
+    }
+  });
+}
+function withRetry(count, options) {
+  return async (opts, next) => {
+    let lastError;
+    for (let attempt = 0; attempt <= count; attempt++) {
+      try {
+        return await next(opts);
+      } catch (err) {
+        lastError = err;
+        if (attempt === count) break;
+        if (options?.shouldRetry && !options.shouldRetry(err, attempt)) break;
+      }
+    }
+    throw lastError;
+  };
+}
+function withTimeout(ms) {
+  return async (opts, next) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new TimeoutError(ms)), ms);
+    const { signal, cleanup } = opts.signal ? anySignal([opts.signal, controller.signal]) : { signal: controller.signal, cleanup: () => {
+    } };
+    try {
+      return await next({ ...opts, signal });
+    } finally {
+      clearTimeout(timer);
+      cleanup();
+    }
+  };
+}
+function anySignal(signals) {
+  const controller = new AbortController();
+  const onAbort = () => controller.abort();
+  const attached = [];
+  for (const s of signals) {
+    if (s.aborted) {
+      controller.abort();
+      break;
+    }
+    s.addEventListener("abort", onAbort, { once: true });
+    attached.push(s);
+  }
+  return {
+    signal: controller.signal,
+    cleanup: () => attached.forEach((s) => {
+      s.removeEventListener("abort", onAbort);
+    })
+  };
+}
+
 // src/utils/path.ts
 function joinPaths(...segments) {
   const joined = segments.filter((s) => s !== "").join("/").replace(/\/+/g, "/");
@@ -37,6 +127,26 @@ var ValidationError = class extends Error {
     }
   }
 };
+var StandardSchemaError = class extends Error {
+  constructor(issues) {
+    super(
+      issues.map((issue) => issue.message).join("; ") || "Standard Schema validation failed"
+    );
+    this.name = "StandardSchemaError";
+    this.issues = issues;
+  }
+};
+
+// src/utils/run-validator.ts
+async function runValidator(validator, data) {
+  if (typeof validator.parse === "function") {
+    return validator.parse(data);
+  }
+  const standard = validator["~standard"];
+  const result = await standard.validate(data);
+  if (result.issues) throw new StandardSchemaError(result.issues);
+  return result.value;
+}
 
 // src/create-api.ts
 function createApi(executor, routerOrPrefixOrEndpoints, endpointsArgOrOptions, optionsArg) {
@@ -75,11 +185,10 @@ function resolveArgs(second, third, fourth) {
     options: third
   };
 }
-function shouldValidate(options, kind) {
+function validateMode(options, kind) {
   const v = options?.validate;
-  if (v === void 0 || v === true) return true;
-  if (v === false) return false;
-  return v[kind] ?? true;
+  const mode = v === void 0 ? true : typeof v === "boolean" || v === "warn" ? v : v[kind] ?? true;
+  return mode === "warn" ? "warn" : mode ? "on" : "off";
 }
 function buildClient(executor, prefix, endpoints, options) {
   const client = {};
@@ -99,39 +208,117 @@ function buildClient(executor, prefix, endpoints, options) {
   return client;
 }
 function buildEndpointFn(executor, prefix, spec, options) {
-  return async (params = {}, signal) => {
+  return async (params = {}, signalOrOptions) => {
+    const call = normalizeCallOptions(signalOrOptions);
+    const reqMode = validateMode(options, "request");
     let validatedParams = params;
-    if (spec.request && shouldValidate(options, "request")) {
+    let requestError = null;
+    if (spec.request && reqMode !== "off") {
       try {
-        validatedParams = spec.request.parse(params);
+        validatedParams = await runValidator(
+          spec.request,
+          params
+        );
       } catch (err) {
-        throw new ValidationError("Request validation failed", err);
+        requestError = new ValidationError("Request validation failed", err);
+        if (reqMode !== "warn") throw requestError;
+        validatedParams = params;
       }
     }
     const url = resolvePath(
       joinPaths(prefix, spec.path),
       validatedParams?.path
     );
-    const raw = await executor.execute({
+    if (requestError) {
+      options?.onValidationError?.(requestError, {
+        kind: "request",
+        method: spec.method,
+        url,
+        data: params
+      });
+    }
+    const raw = await executeWithTimeout(executor, call.timeout, {
       method: spec.method,
       url,
       params: validatedParams?.query,
       body: validatedParams?.body,
-      signal
+      headers: call.headers,
+      signal: call.signal
     });
+    const resMode = validateMode(options, "response");
     let result;
-    if (shouldValidate(options, "response")) {
+    if (resMode === "off") {
+      result = raw;
+    } else {
       try {
-        result = spec.response.parse(raw);
+        result = await runValidator(
+          spec.response,
+          raw
+        );
       } catch (err) {
-        throw new ValidationError("Response validation failed", err);
+        const responseError = new ValidationError(
+          "Response validation failed",
+          err
+        );
+        if (resMode !== "warn") throw responseError;
+        options?.onValidationError?.(responseError, {
+          kind: "response",
+          method: spec.method,
+          url,
+          data: raw
+        });
+        result = raw;
       }
-    } else {
-      result = raw;
     }
     return spec.adapter ? spec.adapter(result) : result;
   };
 }
+function normalizeCallOptions(arg) {
+  if (arg == null) return {};
+  if (isAbortSignal(arg)) return { signal: arg };
+  return arg;
+}
+function isAbortSignal(value) {
+  if (typeof AbortSignal !== "undefined" && value instanceof AbortSignal) {
+    return true;
+  }
+  return typeof value === "object" && value !== null && typeof value.aborted === "boolean" && typeof value.addEventListener === "function";
+}
+function executeWithTimeout(executor, timeout, opts) {
+  if (timeout == null) return executor.execute(opts);
+  const controller = new AbortController();
+  const timer = setTimeout(
+    () => controller.abort(new TimeoutError(timeout)),
+    timeout
+  );
+  const { signal, cleanup } = combineSignals(opts.signal, controller.signal);
+  return (async () => {
+    try {
+      return await executor.execute({ ...opts, signal });
+    } finally {
+      clearTimeout(timer);
+      cleanup();
+    }
+  })();
+}
+function combineSignals(caller, timeoutSignal) {
+  if (!caller) return { signal: timeoutSignal, cleanup: () => {
+  } };
+  if (caller.aborted) return { signal: caller, cleanup: () => {
+  } };
+  const controller = new AbortController();
+  const onCallerAbort = () => controller.abort(caller.reason);
+  const onTimeoutAbort = () => controller.abort(timeoutSignal.reason);
+  caller.addEventListener("abort", onCallerAbort, { once: true });
+  timeoutSignal.addEventListener("abort", onTimeoutAbort, { once: true });
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      caller.removeEventListener("abort", onCallerAbort);
+      timeoutSignal.removeEventListener("abort", onTimeoutAbort);
+    }
+  };
+}
 
 // src/create-executor.ts
 function pluginToMiddleware(plugin) {
@@ -156,7 +343,12 @@ function buildChain(execute, middlewares) {
   );
 }
 function createExecutor(execute, options = {}) {
-  const middlewares = (options.plugins ?? []).map(pluginToMiddleware);
+  const plugins = [...options.plugins ?? []];
+  if (options.unwrap) {
+    const unwrapFn = options.unwrap;
+    plugins.push({ onResponse: (raw) => unwrapFn(raw) });
+  }
+  const middlewares = plugins.map(pluginToMiddleware);
   return { execute: buildChain(execute, middlewares) };
 }
 function dispatchExecutor(resolver) {
@@ -165,96 +357,6 @@ function dispatchExecutor(resolver) {
   };
 }
 
-// src/middleware.ts
-var TimeoutError = class extends Error {
-  constructor(ms) {
-    super(`Request timed out after ${ms}ms`);
-    this.ms = ms;
-    this.name = "TimeoutError";
-  }
-};
-function definePlugin(plugin) {
-  return plugin;
-}
-function logger(options) {
-  const log = options?.log ?? ((msg, data) => console.log(msg, data));
-  const timings = /* @__PURE__ */ new WeakMap();
-  return definePlugin({
-    name: "logger",
-    onRequest: (opts) => {
-      timings.set(opts, Date.now());
-      log(`[routar] ${opts.method} ${opts.url}`, {
-        params: opts.params,
-        body: opts.body
-      });
-      return opts;
-    },
-    onResponse: (res, opts) => {
-      log(
-        `[routar] ${opts.method} ${opts.url} \u2014 ${Date.now() - (timings.get(opts) ?? Date.now())}ms`
-      );
-      timings.delete(opts);
-      return res;
-    },
-    onError: (err, opts) => {
-      log(
-        `[routar] ${opts.method} ${opts.url} \u2014 error after ${Date.now() - (timings.get(opts) ?? Date.now())}ms`,
-        err
-      );
-      timings.delete(opts);
-      throw err;
-    }
-  });
-}
-function withRetry(count, options) {
-  return async (opts, next) => {
-    let lastError;
-    for (let attempt = 0; attempt <= count; attempt++) {
-      try {
-        return await next(opts);
-      } catch (err) {
-        lastError = err;
-        if (attempt === count) break;
-        if (options?.shouldRetry && !options.shouldRetry(err, attempt)) break;
-      }
-    }
-    throw lastError;
-  };
-}
-function withTimeout(ms) {
-  return async (opts, next) => {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(new TimeoutError(ms)), ms);
-    const { signal, cleanup } = opts.signal ? anySignal([opts.signal, controller.signal]) : { signal: controller.signal, cleanup: () => {
-    } };
-    try {
-      return await next({ ...opts, signal });
-    } finally {
-      clearTimeout(timer);
-      cleanup();
-    }
-  };
-}
-function anySignal(signals) {
-  const controller = new AbortController();
-  const onAbort = () => controller.abort();
-  const attached = [];
-  for (const s of signals) {
-    if (s.aborted) {
-      controller.abort();
-      break;
-    }
-    s.addEventListener("abort", onAbort, { once: true });
-    attached.push(s);
-  }
-  return {
-    signal: controller.signal,
-    cleanup: () => attached.forEach((s) => {
-      s.removeEventListener("abort", onAbort);
-    })
-  };
-}
-
 // src/utils/params.ts
 function serializeParams(params) {
   const result = new URLSearchParams();
@@ -295,7 +397,8 @@ function createFetchExecutor(baseURL, options) {
     headers,
     signal
   }) => {
-    const fullURL = new URL(baseURL.replace(/\/$/, "") + url);
+    const resolvedBase = typeof baseURL === "function" ? await baseURL() : baseURL;
+    const fullURL = new URL(resolvedBase.replace(/\/$/, "") + url);
     if (params) {
       serializeParams(params).forEach((v, k) => {
         fullURL.searchParams.set(k, v);
@@ -314,7 +417,7 @@ function createFetchExecutor(baseURL, options) {
     });
     if (!res.ok) {
       const errorBody = await res.json().catch(() => null);
-      throw new HttpError(res.status, res.statusText, errorBody);
+      throw new HttpError(res.status, res.statusText, errorBody, { url: fullURL.toString(), method });
     }
     if (res.status === 204 || res.status === 205 || res.status === 304) {
       return null;
@@ -322,25 +425,97 @@ function createFetchExecutor(baseURL, options) {
     const text = await res.text();
     return text === "" ? null : JSON.parse(text);
   };
-  const executor = createExecutor(transport, { plugins: options?.plugins });
+  const executor = createExecutor(transport, { plugins: options?.plugins, unwrap: options?.unwrap });
   return { execute: buildFetchChain(executor.execute, options?.retry, options?.timeout) };
 }
 var HttpError = class extends Error {
-  constructor(status, statusText, body = null) {
-    super(`HTTP ${status}: ${statusText}`);
+  constructor(status, statusText, body = null, options) {
+    super(`HTTP ${status}: ${statusText}`, { cause: options?.cause });
     this.status = status;
     this.statusText = statusText;
     this.body = body;
     this.name = "HttpError";
+    this.url = options?.url;
+    this.method = options?.method;
   }
 };
 
+// src/utils/compose-request.ts
+var BUCKET_KEYS = ["path", "query", "body"];
+function hasParse(v) {
+  return typeof v.parse === "function";
+}
+async function validateBucket(validator, value) {
+  if (hasParse(validator)) {
+    try {
+      return { value: validator.parse(value) };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { issues: [{ message }] };
+    }
+  }
+  return validator["~standard"].validate(value);
+}
+function composeRequest(buckets) {
+  const entries = BUCKET_KEYS.filter(
+    (k) => buckets[k] !== void 0
+  ).map((k) => [k, buckets[k]]);
+  const shape = {};
+  for (const [k, v] of entries) shape[k] = v;
+  const standard = {
+    "~standard": {
+      version: 1,
+      vendor: "routar",
+      validate: async (data) => {
+        const input = data ?? {};
+        const out = {};
+        const issues = [];
+        for (const [k, v] of entries) {
+          const result = await validateBucket(v, input[k]);
+          if (result.issues) {
+            for (const issue of result.issues) {
+              issues.push({ message: issue.message, path: [k, ...issue.path ?? []] });
+            }
+          } else {
+            out[k] = result.value;
+          }
+        }
+        return issues.length > 0 ? { issues } : { value: out };
+      }
+    }
+  };
+  if (entries.every(([, v]) => hasParse(v))) {
+    const parse = (data) => {
+      const input = data ?? {};
+      const out = {};
+      for (const [k, v] of entries) {
+        out[k] = v.parse(input[k]);
+      }
+      return out;
+    };
+    return Object.assign(standard, { parse, shape });
+  }
+  return Object.assign(standard, { shape });
+}
+
 // src/define-endpoint.ts
 function endpoint(spec) {
+  if (spec.request === void 0 && (spec.pathParams !== void 0 || spec.query !== void 0 || spec.body !== void 0)) {
+    const { pathParams, query, body, ...rest } = spec;
+    return {
+      ...rest,
+      request: composeRequest({
+        path: pathParams,
+        query,
+        body
+      })
+    };
+  }
   return spec;
 }
 
 exports.HttpError = HttpError;
+exports.StandardSchemaError = StandardSchemaError;
 exports.TimeoutError = TimeoutError;
 exports.ValidationError = ValidationError;
 exports.createApi = createApi;
@@ -354,6 +529,7 @@ exports.isRouterDef = isRouterDef;
 exports.joinPaths = joinPaths;
 exports.logger = logger;
 exports.resolvePath = resolvePath;
+exports.runValidator = runValidator;
 exports.serializeParams = serializeParams;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map