@pawabase/client 0.0.0-stage → 0.1.0

package/src/errors.ts

@@ -0,0 +1,330 @@
+/**
+ * Every failure the client raises is a {@link PawabaseError}.
+ *
+ * Pawabase answers errors in several shapes: a bare string (most `4xx`), a bare
+ * array of validation issues (`422`), an `{error, message, details}` object
+ * (functions, flows, the gateway) and Akountz's own `{detail}` bodies. The
+ * client normalises all of them into one class hierarchy, so application code
+ * checks `error.status`, `error.code` or `instanceof` and never parses a body.
+ */
+
+/** One field a request body was refused for (`422`). */
+export interface ValidationIssue {
+  /** Path to the field, e.g. `["body", "email"]` or `["query", "per_page"]`. */
+  loc: Array<string | number>;
+  /** The field name without the `body`/`query` prefix, e.g. `email`. */
+  field: string;
+  message: string;
+  type?: string;
+  input?: unknown;
+}
+
+export interface ApiErrorInit {
+  status: number;
+  code: string;
+  message: string;
+  details?: unknown;
+  body?: unknown;
+  requestId?: string | null;
+  method?: string;
+  url?: string;
+  retryAfter?: number | null;
+  policy?: string | null;
+  cause?: unknown;
+}
+
+/** The base class of everything this package throws. */
+export class PawabaseError extends Error {
+  override name = "PawabaseError";
+  constructor(message: string, options?: { cause?: unknown }) {
+    super(message, options as ErrorOptions);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+/** The server answered with an error status. */
+export class ApiError extends PawabaseError {
+  override name = "ApiError";
+  /** HTTP status code. */
+  readonly status: number;
+  /**
+   * A stable machine-readable code: the server's own (`rate_limit_exceeded`,
+   * `invalid_api_key`, a flow's `raised` code…) or one derived from the status
+   * (`unauthenticated`, `forbidden`, `not_found`, `conflict`, `validation_failed`,
+   * `rate_limited`, `server_error`).
+   */
+  readonly code: string;
+  /** Structured extras the server sent (validation issues, flow details). */
+  readonly details: unknown;
+  /** The parsed response body exactly as received. */
+  readonly body: unknown;
+  /** The `x-request-id` to quote to an operator; look it up in Studio → Observability. */
+  readonly requestId: string | null;
+  readonly method: string | undefined;
+  readonly url: string | undefined;
+  /** Seconds the server asked the caller to wait (`429`, `503`). */
+  readonly retryAfter: number | null;
+  /** The name of the policy that refused the request (`policy 'x' refused`), when stated. */
+  readonly policy: string | null;
+
+  constructor(init: ApiErrorInit) {
+    super(init.message, { cause: init.cause });
+    this.status = init.status;
+    this.code = init.code;
+    this.details = init.details;
+    this.body = init.body;
+    this.requestId = init.requestId ?? null;
+    this.method = init.method;
+    this.url = init.url;
+    this.retryAfter = init.retryAfter ?? null;
+    this.policy = init.policy ?? null;
+  }
+
+  /** True when `code` matches. Handy in `catch`: `if (e instanceof ApiError && e.is("not_found"))`. */
+  is(code: string): boolean {
+    return this.code === code;
+  }
+}
+
+/** `401`: no or invalid credentials. The API key is wrong, or the user is not signed in (or the token expired). */
+export class AuthenticationError extends ApiError {
+  override name = "AuthenticationError";
+}
+
+/** `403`: signed in (or keyed) but not allowed. {@link ApiError.policy} names the refusing policy when stated. */
+export class PermissionError extends ApiError {
+  override name = "PermissionError";
+}
+
+/** `404`: no such record, route or file, or a read policy hides it. */
+export class NotFoundError extends ApiError {
+  override name = "NotFoundError";
+}
+
+/** `409`: a unique value is taken, or the request conflicts with current state. */
+export class ConflictError extends ApiError {
+  override name = "ConflictError";
+}
+
+/** `400`/`422`: the request was refused before any policy ran. See {@link issues}. */
+export class ValidationError extends ApiError {
+  override name = "ValidationError";
+  readonly issues: ValidationIssue[];
+  constructor(init: ApiErrorInit & { issues: ValidationIssue[] }) {
+    super(init);
+    this.issues = init.issues;
+  }
+  /** The first message for a field, or `undefined`. Useful for form errors. */
+  fieldError(field: string): string | undefined {
+    return this.issues.find((issue) => issue.field === field)?.message;
+  }
+  /** All issues by field: `{ email: ["must be a valid email"], … }`. */
+  byField(): Record<string, string[]> {
+    const out: Record<string, string[]> = {};
+    for (const issue of this.issues) (out[issue.field] ??= []).push(issue.message);
+    return out;
+  }
+}
+
+/** `413`: the body is larger than the gateway or bucket allows. */
+export class PayloadTooLargeError extends ApiError {
+  override name = "PayloadTooLargeError";
+}
+
+/** `429`: rate limited. {@link ApiError.retryAfter} is the wait in seconds. */
+export class RateLimitError extends ApiError {
+  override name = "RateLimitError";
+}
+
+/** `5xx`: the platform failed. `502`/`503`/`504` are retried automatically for safe requests. */
+export class ServerError extends ApiError {
+  override name = "ServerError";
+}
+
+/** The request never produced a response (offline, DNS, refused, reset). */
+export class NetworkError extends PawabaseError {
+  override name = "NetworkError";
+  readonly method: string | undefined;
+  readonly url: string | undefined;
+  constructor(message: string, options?: { cause?: unknown; method?: string; url?: string }) {
+    super(message, options);
+    this.method = options?.method;
+    this.url = options?.url;
+  }
+}
+
+/** The request exceeded its `timeoutMs`. */
+export class TimeoutError extends PawabaseError {
+  override name = "TimeoutError";
+  readonly timeoutMs: number;
+  constructor(timeoutMs: number, options?: { cause?: unknown }) {
+    super(`The request timed out after ${timeoutMs} ms.`, options);
+    this.timeoutMs = timeoutMs;
+  }
+}
+
+/** The caller's `AbortSignal` fired. */
+export class AbortError extends PawabaseError {
+  override name = "AbortError";
+  constructor(message = "The request was aborted.", options?: { cause?: unknown }) {
+    super(message, options);
+  }
+}
+
+/** The client was configured or used incorrectly (no URL, a secret key in a browser…). */
+export class ConfigError extends PawabaseError {
+  override name = "ConfigError";
+}
+
+/** A realtime operation failed: refused, not connected, or no acknowledgement. */
+export class RealtimeError extends PawabaseError {
+  override name = "RealtimeError";
+  readonly code: string;
+  constructor(code: string, message: string, options?: { cause?: unknown }) {
+    super(message, options);
+    this.code = code;
+  }
+}
+
+export function isPawabaseError(value: unknown): value is PawabaseError {
+  return value instanceof PawabaseError;
+}
+
+/** Narrow to an {@link ApiError} with a given status. */
+export function isApiError(value: unknown, status?: number): value is ApiError {
+  return value instanceof ApiError && (status === undefined || value.status === status);
+}
+
+const STATUS_CODES: Record<number, string> = {
+  400: "bad_request",
+  401: "unauthenticated",
+  403: "forbidden",
+  404: "not_found",
+  405: "method_not_allowed",
+  409: "conflict",
+  413: "payload_too_large",
+  415: "unsupported_media_type",
+  422: "validation_failed",
+  429: "rate_limited",
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function toIssues(items: unknown[]): ValidationIssue[] {
+  return items.map((item) => {
+    if (isRecord(item)) {
+      const loc = Array.isArray(item["loc"]) ? (item["loc"] as Array<string | number>) : [];
+      const field =
+        typeof item["field"] === "string"
+          ? item["field"]
+          : loc.filter((part) => part !== "body" && part !== "query" && part !== "path").join(".");
+      const message = String(item["msg"] ?? item["message"] ?? "is invalid");
+      return {
+        loc,
+        field,
+        message,
+        ...(typeof item["type"] === "string" ? { type: item["type"] } : {}),
+        ...("input" in item ? { input: item["input"] } : {}),
+      };
+    }
+    return { loc: [], field: "", message: String(item) };
+  });
+}
+
+function summarise(issues: ValidationIssue[]): string {
+  if (!issues.length) return "The request was refused.";
+  return issues.map((i) => (i.field ? `${i.field}: ${i.message}` : i.message)).join("; ");
+}
+
+/** Parse `Retry-After`: delta seconds or an HTTP date. Returns seconds, or `null`. */
+export function parseRetryAfter(value: string | null | undefined, now = Date.now()): number | null {
+  if (!value) return null;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds;
+  const date = Date.parse(value);
+  if (Number.isNaN(date)) return null;
+  return Math.max(0, (date - now) / 1000);
+}
+
+/** Turn a failed response into the right error class. */
+export function errorFromResponse(input: {
+  status: number;
+  body: unknown;
+  headers?: Headers | undefined;
+  method?: string | undefined;
+  url?: string | undefined;
+}): ApiError {
+  const { status, body } = input;
+  const requestId = input.headers?.get("x-request-id") ?? null;
+  let retryAfter = parseRetryAfter(input.headers?.get("retry-after"));
+  let message = "";
+  let code = STATUS_CODES[status] ?? (status >= 500 ? "server_error" : "http_error");
+  let details: unknown;
+  let issues: ValidationIssue[] | null = null;
+
+  if (typeof body === "string") {
+    message = body.trim();
+  } else if (Array.isArray(body)) {
+    issues = toIssues(body);
+    message = summarise(issues);
+    details = issues;
+  } else if (isRecord(body)) {
+    const detail = body["detail"];
+    const named = body["error"];
+    if (typeof named === "string") code = named;
+    else if (typeof body["code"] === "string") code = body["code"] as string;
+    if (typeof body["message"] === "string") message = body["message"] as string;
+    else if (typeof detail === "string") message = detail;
+    if (Array.isArray(detail)) {
+      issues = toIssues(detail);
+      message ||= summarise(issues);
+      details = issues;
+    } else if (Array.isArray(body["details"])) {
+      details = body["details"];
+      const asIssues = toIssues(body["details"] as unknown[]);
+      if (asIssues.every((issue) => issue.field)) issues = asIssues;
+      message ||= summarise(asIssues);
+    } else if ("details" in body) {
+      details = body["details"];
+    }
+    if (retryAfter === null && typeof body["retry_after"] === "number") retryAfter = body["retry_after"];
+  }
+  if (!message) message = `Request failed with status ${status}.`;
+
+  const policyMatch = /policy '([^']+)' refused/.exec(message);
+  const init: ApiErrorInit = {
+    status,
+    code,
+    message,
+    details,
+    body,
+    requestId,
+    method: input.method,
+    url: input.url,
+    retryAfter,
+    policy: policyMatch?.[1] ?? null,
+  };
+
+  if (status === 422 || (status === 400 && issues)) {
+    return new ValidationError({ ...init, issues: issues ?? [] });
+  }
+  if (status === 401) return new AuthenticationError(init);
+  if (status === 403) return new PermissionError(init);
+  if (status === 404) return new NotFoundError(init);
+  if (status === 409) return new ConflictError(init);
+  if (status === 413) return new PayloadTooLargeError(init);
+  if (status === 429) return new RateLimitError(init);
+  if (status >= 500) return new ServerError(init);
+  return new ApiError(init);
+}
+
+/**
+ * A query the client refuses to send because the server would answer it wrongly
+ * rather than refuse it: two filters on one field (the server keeps only the last),
+ * or an `in` value that contains a comma (the server splits on commas).
+ */
+export class InvalidQueryError extends PawabaseError {
+  override name = "InvalidQueryError";
+}

package/src/files.ts

@@ -0,0 +1,208 @@
+import { ConfigError } from "./errors.js";
+import type { HttpClient } from "./http.js";
+import type { FileEntry, FileListing, SignedUrl, StorageBucket, StoredObject } from "./types.js";
+import { encodePath, isSecretKey } from "./util.js";
+
+/** Anything an upload accepts. Streams upload without buffering but cannot be retried. */
+export type UploadBody =
+  | Blob
+  | ArrayBuffer
+  | ArrayBufferView
+  | string
+  | ReadableStream<Uint8Array>
+  | URLSearchParams
+  | FormData;
+
+export interface UploadOptions {
+  /** The object's content type. Default: the `Blob`'s own type, else `application/octet-stream`. */
+  contentType?: string;
+  signal?: AbortSignal | null | undefined;
+  timeoutMs?: number;
+}
+
+export interface TransferOptions {
+  signal?: AbortSignal | null | undefined;
+  timeoutMs?: number;
+}
+
+function cleanKey(key: string): string {
+  const cleaned = key.replace(/^\/+/, "");
+  if (!cleaned) throw new ConfigError("A storage key cannot be empty.");
+  return cleaned;
+}
+
+/** Storage buckets declared in the project. */
+export class StorageClient {
+  constructor(private readonly http: HttpClient) {}
+
+  /** The buckets this environment has. */
+  async listBuckets(): Promise<StorageBucket[]> {
+    return (await this.http.request<{ data: StorageBucket[] }>({ path: "/storage/v1/buckets" })).data;
+  }
+
+  /** Work with one bucket. */
+  from(bucket: string): BucketClient {
+    return new BucketClient(this.http, bucket);
+  }
+}
+
+export class BucketClient {
+  constructor(
+    private readonly http: HttpClient,
+    readonly name: string,
+  ) {}
+
+  private object(key: string): string {
+    return `/storage/v1/object/${encodeURIComponent(this.name)}/${encodePath(cleanKey(key))}`;
+  }
+
+  /**
+   * Upload (or overwrite) an object. The bucket's policy decides who may, and its
+   * `accepts` and `max_bytes` limits apply: a refused type or size is an error, not a truncated file.
+   */
+  upload(key: string, body: UploadBody, options: UploadOptions = {}): Promise<StoredObject> {
+    const declared =
+      options.contentType ??
+      (typeof Blob !== "undefined" && body instanceof Blob && body.type ? body.type : undefined) ??
+      (typeof body === "string" ? "text/plain; charset=utf-8" : "application/octet-stream");
+    const multipart = typeof FormData !== "undefined" && body instanceof FormData;
+    return this.http.request<StoredObject>({
+      method: "PUT",
+      path: this.object(key),
+      body,
+      ...(multipart ? {} : { headers: { "content-type": declared } }),
+      signal: options.signal,
+      ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
+      // Replacing an object with itself is safe to repeat.
+      idempotent: true,
+    });
+  }
+
+  /** The object's bytes. */
+  download(key: string, options: TransferOptions = {}): Promise<Blob> {
+    return this.http.request<Blob>({ path: this.object(key), parse: "blob", headers: { accept: "*/*" }, ...this.opts(options) });
+  }
+
+  /** The object as text. */
+  downloadText(key: string, options: TransferOptions = {}): Promise<string> {
+    return this.http.request<string>({ path: this.object(key), parse: "text", headers: { accept: "*/*" }, ...this.opts(options) });
+  }
+
+  /** The object parsed as JSON. */
+  async downloadJson<T = unknown>(key: string, options: TransferOptions = {}): Promise<T> {
+    return JSON.parse(await this.downloadText(key, options)) as T;
+  }
+
+  /** The object as a stream, for large files. */
+  async downloadStream(key: string, options: TransferOptions = {}): Promise<ReadableStream<Uint8Array>> {
+    const stream = await this.http.request<ReadableStream<Uint8Array> | null>({
+      path: this.object(key),
+      parse: "stream",
+      headers: { accept: "*/*" },
+      ...this.opts(options),
+    });
+    if (!stream) throw new ConfigError("The response had no body.");
+    return stream;
+  }
+
+  /** The raw response, for its headers (`etag`, `content-type`, `content-length`). */
+  downloadResponse(key: string, options: TransferOptions = {}): Promise<Response> {
+    return this.http.request<Response>({ path: this.object(key), parse: "response", headers: { accept: "*/*" }, ...this.opts(options) });
+  }
+
+  /** Delete an object. A missing object (or one you may not see) is a `NotFoundError`. */
+  async remove(key: string, options: TransferOptions = {}): Promise<void> {
+    await this.http.request({ method: "DELETE", path: this.object(key), ...this.opts(options) });
+  }
+
+  /** One page of objects below a prefix. Pass the returned `cursor` back to continue. */
+  list(options: { prefix?: string; cursor?: string; limit?: number } & TransferOptions = {}): Promise<FileListing> {
+    return this.http.request<FileListing>({
+      path: `/storage/v1/list/${encodeURIComponent(this.name)}`,
+      query: { prefix: options.prefix, cursor: options.cursor, limit: options.limit },
+      ...this.opts(options),
+    });
+  }
+
+  /** Every object below a prefix, page by page. */
+  async *listAll(options: { prefix?: string; pageSize?: number } & TransferOptions = {}): AsyncGenerator<FileEntry, void, void> {
+    let cursor = "";
+    do {
+      const page = await this.list({
+        ...(options.prefix !== undefined ? { prefix: options.prefix } : {}),
+        ...(cursor ? { cursor } : {}),
+        ...(options.pageSize !== undefined ? { limit: options.pageSize } : {}),
+        signal: options.signal,
+      });
+      yield* page.files;
+      cursor = page.cursor;
+    } while (cursor);
+  }
+
+  /**
+   * A URL for an object in a **public** bucket, usable in `<img src>`. The publishable key
+   * travels in the URL (it is meant to be public); a secret key is refused.
+   */
+  getPublicUrl(key: string): string {
+    const apiKey = this.http.config.apiKey;
+    if (isSecretKey(apiKey)) {
+      throw new ConfigError("Refusing to put a secret key in a URL. Use a publishable key, or createSignedUrl().");
+    }
+    return `${this.http.url(this.object(key))}?apikey=${encodeURIComponent(apiKey)}`;
+  }
+
+  /** A temporary URL that lets anyone with it read the object, with no key. Needs read access yourself. */
+  createSignedUrl(key: string, options: { expiresIn?: number } & TransferOptions = {}): Promise<SignedUrl> {
+    return this.sign(key, { method: "GET", expires_in: options.expiresIn ?? 300 }, options);
+  }
+
+  /**
+   * A temporary URL that lets anyone with it upload one object, pinned to a content type
+   * and size. Hand it to a browser or device; it then calls {@link uploadToSignedUrl}.
+   */
+  createSignedUploadUrl(
+    key: string,
+    options: { expiresIn?: number; contentType?: string; maxBytes?: number } & TransferOptions = {},
+  ): Promise<SignedUrl> {
+    return this.sign(
+      key,
+      {
+        method: "PUT",
+        expires_in: options.expiresIn ?? 300,
+        ...(options.contentType ? { content_type: options.contentType } : {}),
+        ...(options.maxBytes ? { max_bytes: options.maxBytes } : {}),
+      },
+      options,
+    );
+  }
+
+  private sign(key: string, body: Record<string, unknown>, options: TransferOptions): Promise<SignedUrl> {
+    return this.http.request<SignedUrl>({
+      method: "POST",
+      path: `/storage/v1/sign/${encodeURIComponent(this.name)}/${encodePath(cleanKey(key))}`,
+      body,
+      idempotent: true,
+      ...this.opts(options),
+    });
+  }
+
+  /** Upload through a signed upload URL. Sends no API key or token: the URL is the credential. */
+  async uploadToSignedUrl(url: string, body: UploadBody, options: UploadOptions = {}): Promise<StoredObject> {
+    const declared =
+      options.contentType ??
+      (typeof Blob !== "undefined" && body instanceof Blob && body.type ? body.type : "application/octet-stream");
+    return this.http.request<StoredObject>({
+      method: "PUT",
+      path: "",
+      absoluteUrl: url,
+      body,
+      headers: { "content-type": declared },
+      signal: options.signal,
+      ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
+    });
+  }
+
+  private opts(options: TransferOptions): { signal: AbortSignal | null | undefined; timeoutMs?: number } {
+    return { signal: options.signal, ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}) };
+  }
+}

package/src/functions.ts

@@ -0,0 +1,131 @@
+import type { HttpClient } from "./http.js";
+import type { QueryValue } from "./util.js";
+import { encodePath } from "./util.js";
+
+export interface CallOptions {
+  headers?: Record<string, string>;
+  signal?: AbortSignal | null | undefined;
+  timeoutMs?: number;
+  /** Allow retrying a `POST` after a network failure. Only when running it twice is harmless. */
+  idempotent?: boolean;
+}
+
+function pass(options: CallOptions): {
+  headers?: Record<string, string>;
+  signal?: AbortSignal | null | undefined;
+  timeoutMs?: number;
+  idempotent?: boolean;
+} {
+  return {
+    ...(options.headers ? { headers: options.headers } : {}),
+    signal: options.signal,
+    ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
+    ...(options.idempotent !== undefined ? { idempotent: options.idempotent } : {}),
+  };
+}
+
+export interface FetchOptions extends CallOptions {
+  method?: string;
+  query?: Record<string, QueryValue | QueryValue[]>;
+  /** An object is sent as JSON; strings, `Blob`, `FormData`, buffers and streams as they are. */
+  body?: unknown;
+  /** Run the function deployed on this branch (`x-pawabase-branch`). */
+  branch?: string;
+}
+
+/** Functions you wrote in your project's code, invoked at `/functions/v1/<name>`. */
+export class FunctionsClient {
+  constructor(private readonly http: HttpClient) {}
+
+  /**
+   * Call a function and return what it returned. The API key needs the
+   * `functions:invoke` scope (an unrestricted key has it).
+   */
+  async invoke<T = unknown>(name: string, input?: unknown, options: CallOptions = {}): Promise<T> {
+    const body = await this.http.request<{ data: T } | undefined>({
+      method: "POST",
+      path: `/functions/v1/${encodePath(name)}`,
+      body: input === undefined ? undefined : input,
+      ...pass(options),
+    });
+    return (body as { data: T } | undefined)?.data as T;
+  }
+
+  /**
+   * Call an HTTP function (`functions/<name>/index.ts`) with any method and path, and get its `Response` as it is — status, headers
+   * and a streaming body. An error status is returned, not thrown; the API key and the signed-in user's token are sent as for any call.
+   *
+   * ```ts
+   * const res = await pawabase.functions.fetch("orders", "/42/items", { method: "POST", body: { sku: "A1" } });
+   * if (res.ok) console.log(await res.json());
+   * ```
+   */
+  fetch(name: string, path = "/", options: FetchOptions = {}): Promise<Response> {
+    const rest = path === "/" || path === "" ? "" : path.startsWith("/") ? path : `/${path}`;
+    return this.http.send({
+      method: options.method ?? (options.body === undefined ? "GET" : "POST"),
+      path: `/functions/v1/${encodePath(name)}${rest}`,
+      ...(options.query ? { query: options.query } : {}),
+      ...(options.body !== undefined ? { body: options.body } : {}),
+      ...pass({ ...options, headers: { ...(options.branch ? { "x-pawabase-branch": options.branch } : {}), ...options.headers } }),
+      throwOnError: false,
+    });
+  }
+}
+
+/**
+ * Flows with an HTTP trigger that has no path, invoked at `/flows/v1/<name>`.
+ * (Flows bound to a path are reached as routes, see {@link RoutesClient}.)
+ */
+export class FlowsClient {
+  constructor(private readonly http: HttpClient) {}
+
+  /**
+   * Run a flow and return its response body: whatever its `response.return` block sends,
+   * or `{ data: … }` with the flow's result when it has none.
+   */
+  run<T = unknown>(name: string, input?: unknown, options: CallOptions = {}): Promise<T> {
+    return this.http.request<T>({
+      method: "POST",
+      path: `/flows/v1/${encodePath(name)}`,
+      body: input === undefined ? undefined : input,
+      ...pass(options),
+    });
+  }
+}
+
+export interface RouteOptions extends CallOptions {
+  query?: Record<string, QueryValue | QueryValue[]>;
+  body?: unknown;
+}
+
+/** Custom routes you defined, served under `/rest/v1/<path>`. */
+export class RoutesClient {
+  constructor(private readonly http: HttpClient) {}
+
+  call<T = unknown>(method: string, path: string, options: RouteOptions = {}): Promise<T> {
+    return this.http.request<T>({
+      method,
+      path: `/rest/v1/${encodePath(path.replace(/^\/+/, ""))}`,
+      ...(options.query ? { query: options.query } : {}),
+      ...(options.body !== undefined ? { body: options.body } : {}),
+      ...pass(options),
+    });
+  }
+
+  get<T = unknown>(path: string, options: Omit<RouteOptions, "body"> = {}): Promise<T> {
+    return this.call<T>("GET", path, options);
+  }
+  post<T = unknown>(path: string, body?: unknown, options: Omit<RouteOptions, "body"> = {}): Promise<T> {
+    return this.call<T>("POST", path, { ...options, body });
+  }
+  put<T = unknown>(path: string, body?: unknown, options: Omit<RouteOptions, "body"> = {}): Promise<T> {
+    return this.call<T>("PUT", path, { ...options, body });
+  }
+  patch<T = unknown>(path: string, body?: unknown, options: Omit<RouteOptions, "body"> = {}): Promise<T> {
+    return this.call<T>("PATCH", path, { ...options, body });
+  }
+  delete<T = unknown>(path: string, options: Omit<RouteOptions, "body"> = {}): Promise<T> {
+    return this.call<T>("DELETE", path, options);
+  }
+}