better-call 0.2.13-beta.2 → 0.2.13-beta.4

package/README.md

@@ -1,3 +1,9 @@
 # Better Call
 
-A tiny TypeScript web framework that lets you create endpoints that can be called like regular functions, while also serving as REST API endpoints. It comes with a very fast router based on radix tree (rou3)[] compatible with different web servers (Node, Bun, NextJs, SvelteKit...), and an RPC client that ensures type-safe endpoint invocations.
+A tiny TypeScript web framework that lets you create endpoints that can be called like regular functions, while also serving as REST API endpoints. It comes with a very fast router [rou3](https://github.com/unjs/rou3), and an RPC client powered by [better-fetch](https://better-fetch.vercel.app) and open API generator (experimental).
+
+## Install
+
+```bash
+pnpm i better-call
+```

package/dist/adapter/node.cjs

@@ -0,0 +1,210 @@
+'use strict';
+
+function splitCookiesString(cookiesString) {
+  if (Array.isArray(cookiesString)) {
+    return cookiesString;
+  }
+  if (typeof cookiesString !== "string") {
+    return [];
+  }
+  const cookiesStrings = [];
+  let pos = 0;
+  let start;
+  let ch;
+  let lastComma;
+  let nextStart;
+  let cookiesSeparatorFound;
+  function skipWhitespace() {
+    if (Array.isArray(cookiesString)) {
+      return pos < cookiesString.length;
+    }
+    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+      pos += 1;
+    }
+    return pos < cookiesString.length;
+  }
+  function notSpecialChar() {
+    if (Array.isArray(cookiesString)) {
+      return pos < cookiesString.length;
+    }
+    ch = cookiesString.charAt(pos);
+    return ch !== "=" && ch !== ";" && ch !== ",";
+  }
+  while (pos < cookiesString.length) {
+    start = pos;
+    cookiesSeparatorFound = false;
+    while (skipWhitespace()) {
+      ch = cookiesString.charAt(pos);
+      if (ch === ",") {
+        lastComma = pos;
+        pos += 1;
+        skipWhitespace();
+        nextStart = pos;
+        while (pos < cookiesString.length && notSpecialChar()) {
+          pos += 1;
+        }
+        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+          cookiesSeparatorFound = true;
+          pos = nextStart;
+          cookiesStrings.push(cookiesString.substring(start, lastComma));
+          start = pos;
+        } else {
+          pos = lastComma + 1;
+        }
+      } else {
+        pos += 1;
+      }
+    }
+    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+      cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+    }
+  }
+  return cookiesStrings;
+}
+
+function get_raw_body(req, body_size_limit) {
+  const h = req.headers;
+  if (!h["content-type"])
+    return null;
+  const content_length = Number(h["content-length"]);
+  if (req.httpVersionMajor === 1 && isNaN(content_length) && h["transfer-encoding"] == null || content_length === 0) {
+    return null;
+  }
+  let length = content_length;
+  if (body_size_limit) {
+    if (!length) {
+      length = body_size_limit;
+    } else if (length > body_size_limit) {
+      throw Error(
+        `Received content-length of ${length}, but only accept up to ${body_size_limit} bytes.`
+      );
+    }
+  }
+  if (req.destroyed) {
+    const readable = new ReadableStream();
+    readable.cancel();
+    return readable;
+  }
+  let size = 0;
+  let cancelled = false;
+  return new ReadableStream({
+    start(controller) {
+      req.on("error", (error) => {
+        cancelled = true;
+        controller.error(error);
+      });
+      req.on("end", () => {
+        if (cancelled)
+          return;
+        controller.close();
+      });
+      req.on("data", (chunk) => {
+        if (cancelled)
+          return;
+        size += chunk.length;
+        if (size > length) {
+          cancelled = true;
+          controller.error(
+            new Error(
+              `request body size exceeded ${content_length ? "'content-length'" : "BODY_SIZE_LIMIT"} of ${length}`
+            )
+          );
+          return;
+        }
+        controller.enqueue(chunk);
+        if (controller.desiredSize === null || controller.desiredSize <= 0) {
+          req.pause();
+        }
+      });
+    },
+    pull() {
+      req.resume();
+    },
+    cancel(reason) {
+      cancelled = true;
+      req.destroy(reason);
+    }
+  });
+}
+function getRequest({
+  request,
+  base,
+  bodySizeLimit
+}) {
+  return new Request(base + request.url, {
+    duplex: "half",
+    method: request.method,
+    body: get_raw_body(request, bodySizeLimit),
+    headers: request.headers
+  });
+}
+async function setResponse(res, response) {
+  for (const [key, value] of response.headers) {
+    try {
+      res.setHeader(
+        key,
+        key === "set-cookie" ? splitCookiesString(response.headers.get(key)) : value
+      );
+    } catch (error) {
+      res.getHeaderNames().forEach((name) => res.removeHeader(name));
+      res.writeHead(500).end(String(error));
+      return;
+    }
+  }
+  res.writeHead(response.status);
+  if (!response.body) {
+    res.end();
+    return;
+  }
+  if (response.body.locked) {
+    res.end(
+      "Fatal error: Response body is locked. This can happen when the response was already read (for example through 'response.json()' or 'response.text()')."
+    );
+    return;
+  }
+  const reader = response.body.getReader();
+  if (res.destroyed) {
+    reader.cancel();
+    return;
+  }
+  const cancel = (error) => {
+    res.off("close", cancel);
+    res.off("error", cancel);
+    reader.cancel(error).catch(() => {
+    });
+    if (error)
+      res.destroy(error);
+  };
+  res.on("close", cancel);
+  res.on("error", cancel);
+  next();
+  async function next() {
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        if (!res.write(value)) {
+          res.once("drain", next);
+          return;
+        }
+      }
+      res.end();
+    } catch (error) {
+      cancel(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+}
+
+function toNodeHandler(handler) {
+  return async (req, res) => {
+    const protocol = req.connection?.encrypted ? "https" : "http";
+    const base = `${protocol}://${req.headers[":authority"] || req.headers.host}`;
+    const response = await handler(getRequest({ base, request: req }));
+    setResponse(res, response);
+  };
+}
+
+exports.getRequest = getRequest;
+exports.setResponse = setResponse;
+exports.toNodeHandler = toNodeHandler;

package/dist/adapter/node.d.cts

@@ -0,0 +1,19 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import * as undici_types from 'undici-types';
+import { R as Router } from '../shared/better-call.7c5f7404.cjs';
+import 'zod';
+import '@asteasolutions/zod-to-openapi/dist/zod-extensions';
+import '@asteasolutions/zod-to-openapi';
+import '@asteasolutions/zod-to-openapi/dist/openapi-registry';
+import 'stream/web';
+
+declare function getRequest({ request, base, bodySizeLimit, }: {
+    base: string;
+    bodySizeLimit?: number;
+    request: IncomingMessage;
+}): undici_types.Request;
+declare function setResponse(res: ServerResponse, response: Response): Promise<void>;
+
+declare function toNodeHandler(handler: Router["handler"]): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+
+export { getRequest, setResponse, toNodeHandler };

package/dist/adapter/node.d.mts

@@ -0,0 +1,19 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import * as undici_types from 'undici-types';
+import { R as Router } from '../shared/better-call.7c5f7404.mjs';
+import 'zod';
+import '@asteasolutions/zod-to-openapi/dist/zod-extensions';
+import '@asteasolutions/zod-to-openapi';
+import '@asteasolutions/zod-to-openapi/dist/openapi-registry';
+import 'stream/web';
+
+declare function getRequest({ request, base, bodySizeLimit, }: {
+    base: string;
+    bodySizeLimit?: number;
+    request: IncomingMessage;
+}): undici_types.Request;
+declare function setResponse(res: ServerResponse, response: Response): Promise<void>;
+
+declare function toNodeHandler(handler: Router["handler"]): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+
+export { getRequest, setResponse, toNodeHandler };

package/dist/adapter/node.d.ts

@@ -0,0 +1,19 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import * as undici_types from 'undici-types';
+import { R as Router } from '../shared/better-call.7c5f7404.js';
+import 'zod';
+import '@asteasolutions/zod-to-openapi/dist/zod-extensions';
+import '@asteasolutions/zod-to-openapi';
+import '@asteasolutions/zod-to-openapi/dist/openapi-registry';
+import 'stream/web';
+
+declare function getRequest({ request, base, bodySizeLimit, }: {
+    base: string;
+    bodySizeLimit?: number;
+    request: IncomingMessage;
+}): undici_types.Request;
+declare function setResponse(res: ServerResponse, response: Response): Promise<void>;
+
+declare function toNodeHandler(handler: Router["handler"]): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+
+export { getRequest, setResponse, toNodeHandler };

package/dist/adapter/node.mjs

@@ -0,0 +1,206 @@
+function splitCookiesString(cookiesString) {
+  if (Array.isArray(cookiesString)) {
+    return cookiesString;
+  }
+  if (typeof cookiesString !== "string") {
+    return [];
+  }
+  const cookiesStrings = [];
+  let pos = 0;
+  let start;
+  let ch;
+  let lastComma;
+  let nextStart;
+  let cookiesSeparatorFound;
+  function skipWhitespace() {
+    if (Array.isArray(cookiesString)) {
+      return pos < cookiesString.length;
+    }
+    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+      pos += 1;
+    }
+    return pos < cookiesString.length;
+  }
+  function notSpecialChar() {
+    if (Array.isArray(cookiesString)) {
+      return pos < cookiesString.length;
+    }
+    ch = cookiesString.charAt(pos);
+    return ch !== "=" && ch !== ";" && ch !== ",";
+  }
+  while (pos < cookiesString.length) {
+    start = pos;
+    cookiesSeparatorFound = false;
+    while (skipWhitespace()) {
+      ch = cookiesString.charAt(pos);
+      if (ch === ",") {
+        lastComma = pos;
+        pos += 1;
+        skipWhitespace();
+        nextStart = pos;
+        while (pos < cookiesString.length && notSpecialChar()) {
+          pos += 1;
+        }
+        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+          cookiesSeparatorFound = true;
+          pos = nextStart;
+          cookiesStrings.push(cookiesString.substring(start, lastComma));
+          start = pos;
+        } else {
+          pos = lastComma + 1;
+        }
+      } else {
+        pos += 1;
+      }
+    }
+    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+      cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+    }
+  }
+  return cookiesStrings;
+}
+
+function get_raw_body(req, body_size_limit) {
+  const h = req.headers;
+  if (!h["content-type"])
+    return null;
+  const content_length = Number(h["content-length"]);
+  if (req.httpVersionMajor === 1 && isNaN(content_length) && h["transfer-encoding"] == null || content_length === 0) {
+    return null;
+  }
+  let length = content_length;
+  if (body_size_limit) {
+    if (!length) {
+      length = body_size_limit;
+    } else if (length > body_size_limit) {
+      throw Error(
+        `Received content-length of ${length}, but only accept up to ${body_size_limit} bytes.`
+      );
+    }
+  }
+  if (req.destroyed) {
+    const readable = new ReadableStream();
+    readable.cancel();
+    return readable;
+  }
+  let size = 0;
+  let cancelled = false;
+  return new ReadableStream({
+    start(controller) {
+      req.on("error", (error) => {
+        cancelled = true;
+        controller.error(error);
+      });
+      req.on("end", () => {
+        if (cancelled)
+          return;
+        controller.close();
+      });
+      req.on("data", (chunk) => {
+        if (cancelled)
+          return;
+        size += chunk.length;
+        if (size > length) {
+          cancelled = true;
+          controller.error(
+            new Error(
+              `request body size exceeded ${content_length ? "'content-length'" : "BODY_SIZE_LIMIT"} of ${length}`
+            )
+          );
+          return;
+        }
+        controller.enqueue(chunk);
+        if (controller.desiredSize === null || controller.desiredSize <= 0) {
+          req.pause();
+        }
+      });
+    },
+    pull() {
+      req.resume();
+    },
+    cancel(reason) {
+      cancelled = true;
+      req.destroy(reason);
+    }
+  });
+}
+function getRequest({
+  request,
+  base,
+  bodySizeLimit
+}) {
+  return new Request(base + request.url, {
+    duplex: "half",
+    method: request.method,
+    body: get_raw_body(request, bodySizeLimit),
+    headers: request.headers
+  });
+}
+async function setResponse(res, response) {
+  for (const [key, value] of response.headers) {
+    try {
+      res.setHeader(
+        key,
+        key === "set-cookie" ? splitCookiesString(response.headers.get(key)) : value
+      );
+    } catch (error) {
+      res.getHeaderNames().forEach((name) => res.removeHeader(name));
+      res.writeHead(500).end(String(error));
+      return;
+    }
+  }
+  res.writeHead(response.status);
+  if (!response.body) {
+    res.end();
+    return;
+  }
+  if (response.body.locked) {
+    res.end(
+      "Fatal error: Response body is locked. This can happen when the response was already read (for example through 'response.json()' or 'response.text()')."
+    );
+    return;
+  }
+  const reader = response.body.getReader();
+  if (res.destroyed) {
+    reader.cancel();
+    return;
+  }
+  const cancel = (error) => {
+    res.off("close", cancel);
+    res.off("error", cancel);
+    reader.cancel(error).catch(() => {
+    });
+    if (error)
+      res.destroy(error);
+  };
+  res.on("close", cancel);
+  res.on("error", cancel);
+  next();
+  async function next() {
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        if (!res.write(value)) {
+          res.once("drain", next);
+          return;
+        }
+      }
+      res.end();
+    } catch (error) {
+      cancel(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+}
+
+function toNodeHandler(handler) {
+  return async (req, res) => {
+    const protocol = req.connection?.encrypted ? "https" : "http";
+    const base = `${protocol}://${req.headers[":authority"] || req.headers.host}`;
+    const response = await handler(getRequest({ base, request: req }));
+    setResponse(res, response);
+  };
+}
+
+export { getRequest, setResponse, toNodeHandler };

package/dist/client.d.cts

@@ -1,7 +1,9 @@
-import * as undici_types from 'undici-types';
 import { BetterFetchOption, BetterFetchResponse } from '@better-fetch/fetch';
-import { R as Router, U as UnionToIntersection, b as Endpoint, H as HasRequiredKeys } from './shared/better-call.342be6c5.cjs';
+import { R as Router, U as UnionToIntersection, b as Endpoint, H as HasRequiredKeys } from './shared/better-call.7c5f7404.cjs';
 import 'zod';
+import '@asteasolutions/zod-to-openapi/dist/zod-extensions';
+import '@asteasolutions/zod-to-openapi';
+import '@asteasolutions/zod-to-openapi/dist/openapi-registry';
 import 'stream/web';
 
 type HasRequired<T extends {
@@ -28,12 +30,10 @@ type RequiredOptionKeys<C extends {
     params: true;
 });
 declare const createClient: <R extends Router | Router["endpoints"]>(options: ClientOptions) => <OPT extends UnionToIntersection<(R extends {
-    handler: (request: Request) => Promise<undici_types.Response>;
     endpoints: Record<string, Endpoint>;
 } ? R["endpoints"] : R) extends {
     [key: string]: infer T_1;
 } ? T_1 extends Endpoint ? { [key in T_1["options"]["method"] extends "GET" ? T_1["path"] : `@${T_1["options"]["method"] extends string ? Lowercase<T_1["options"]["method"]> : never}${T_1["path"]}`]: T_1; } : {} : {}> extends infer T ? { [K_1 in keyof T]: UnionToIntersection<(R extends {
-    handler: (request: Request) => Promise<undici_types.Response>;
     endpoints: Record<string, Endpoint>;
 } ? R["endpoints"] : R) extends {
     [key: string]: infer T_1;

package/dist/client.d.mts

@@ -1,7 +1,9 @@
-import * as undici_types from 'undici-types';
 import { BetterFetchOption, BetterFetchResponse } from '@better-fetch/fetch';
-import { R as Router, U as UnionToIntersection, b as Endpoint, H as HasRequiredKeys } from './shared/better-call.342be6c5.mjs';
+import { R as Router, U as UnionToIntersection, b as Endpoint, H as HasRequiredKeys } from './shared/better-call.7c5f7404.mjs';
 import 'zod';
+import '@asteasolutions/zod-to-openapi/dist/zod-extensions';
+import '@asteasolutions/zod-to-openapi';
+import '@asteasolutions/zod-to-openapi/dist/openapi-registry';
 import 'stream/web';
 
 type HasRequired<T extends {
@@ -28,12 +30,10 @@ type RequiredOptionKeys<C extends {
     params: true;
 });
 declare const createClient: <R extends Router | Router["endpoints"]>(options: ClientOptions) => <OPT extends UnionToIntersection<(R extends {
-    handler: (request: Request) => Promise<undici_types.Response>;
     endpoints: Record<string, Endpoint>;
 } ? R["endpoints"] : R) extends {
     [key: string]: infer T_1;
 } ? T_1 extends Endpoint ? { [key in T_1["options"]["method"] extends "GET" ? T_1["path"] : `@${T_1["options"]["method"] extends string ? Lowercase<T_1["options"]["method"]> : never}${T_1["path"]}`]: T_1; } : {} : {}> extends infer T ? { [K_1 in keyof T]: UnionToIntersection<(R extends {
-    handler: (request: Request) => Promise<undici_types.Response>;
     endpoints: Record<string, Endpoint>;
 } ? R["endpoints"] : R) extends {
     [key: string]: infer T_1;

package/dist/client.d.ts

@@ -1,7 +1,9 @@
-import * as undici_types from 'undici-types';
 import { BetterFetchOption, BetterFetchResponse } from '@better-fetch/fetch';
-import { R as Router, U as UnionToIntersection, b as Endpoint, H as HasRequiredKeys } from './shared/better-call.342be6c5.js';
+import { R as Router, U as UnionToIntersection, b as Endpoint, H as HasRequiredKeys } from './shared/better-call.7c5f7404.js';
 import 'zod';
+import '@asteasolutions/zod-to-openapi/dist/zod-extensions';
+import '@asteasolutions/zod-to-openapi';
+import '@asteasolutions/zod-to-openapi/dist/openapi-registry';
 import 'stream/web';
 
 type HasRequired<T extends {
@@ -28,12 +30,10 @@ type RequiredOptionKeys<C extends {
     params: true;
 });
 declare const createClient: <R extends Router | Router["endpoints"]>(options: ClientOptions) => <OPT extends UnionToIntersection<(R extends {
-    handler: (request: Request) => Promise<undici_types.Response>;
     endpoints: Record<string, Endpoint>;
 } ? R["endpoints"] : R) extends {
     [key: string]: infer T_1;
 } ? T_1 extends Endpoint ? { [key in T_1["options"]["method"] extends "GET" ? T_1["path"] : `@${T_1["options"]["method"] extends string ? Lowercase<T_1["options"]["method"]> : never}${T_1["path"]}`]: T_1; } : {} : {}> extends infer T ? { [K_1 in keyof T]: UnionToIntersection<(R extends {
-    handler: (request: Request) => Promise<undici_types.Response>;
     endpoints: Record<string, Endpoint>;
 } ? R["endpoints"] : R) extends {
     [key: string]: infer T_1;