@aklinker1/zeta 2.1.2 → 2.2.0

package/dist/client.d.mts

@@ -0,0 +1,71 @@
+import { t as ErrorResponse } from "./schema-DKqL09oQ.mjs";
+import { T as GetResponseOutput, a as App, c as ApplyAppPrefix, f as BaseRoutes, s as ApplyAppDataPrefix, v as GetAppRoutes, y as GetRequestParamsInput } from "./types-BvjPE9EM.mjs";
+
+//#region src/client.d.ts
+/**
+ * Type-safe client based on routes defined server-side.
+ */
+interface AppClient<TRoutes extends BaseRoutes> {
+  fetch<TMethod extends keyof TRoutes, TRoute extends keyof TRoutes[TMethod]>(method: TMethod, route: TRoute, inputs: GetRequestParamsInput<TRoutes, TMethod, TRoute>): Promise<GetResponseOutput<TRoutes, TMethod, TRoute>>;
+  fetch<TRoute extends keyof TRoutes["ANY"]>(method: string, route: TRoute, inputs: GetRequestParamsInput<TRoutes, "ANY", TRoute>): Promise<GetResponseOutput<TRoutes, "ANY", TRoute>>;
+}
+/**
+ * Creates a type-safe client based on the server-side app. This is only useful
+ * if your frontend is in the same TypeScript project as your backend, and you
+ * can reference it's types in the frontend.
+ *
+ * If that's not the case, generate your client using the OpenAPI docs.
+ *
+ * @example
+ * ```ts
+ * // Server-side:
+ * import { createApp } from "@aklinker1/zeta";
+ *
+ * const app = createApp();
+ * export type App = typeof app;
+ *
+ * // Client-side:
+ * import type { App } from "../server";
+ * //     ^^^^ MAKE SURE TO ONLY IMPORT THE TYPE HERE
+ *
+ * const client = createAppClient<App>();
+ * ```
+ */
+declare function createAppClient<TApp extends App>(options?: CreateAppClientOptions): AppClient<GetClientRoutes<TApp>>;
+/**
+ * Helper for converting an `App` to the routes it exposes.
+ */
+type GetClientRoutes<TApp> = TApp extends App<infer AppData> ? ApplyAppDataPrefix<AppData>["routes"] : never;
+/**
+ * Thrown by the client when the response is not OK. When an `HttpError` is
+ * thrown server-side, this is the error throw client-side.
+ */
+declare class RequestError extends Error {
+  status: number;
+  response: ErrorResponse;
+  constructor(message: string, status: number, response: ErrorResponse, options?: ErrorOptions);
+}
+/**
+ * Helper for converting an `App` type to `AppClient`.
+ */
+type GetAppClient<TApp extends App> = App extends {
+  prefix: string;
+} ? GetAppClient<ApplyAppPrefix<TApp>> : AppClient<GetAppRoutes<TApp> extends BaseRoutes ? GetAppRoutes<TApp> : never>;
+/**
+ * Configure the client's behavior.
+ */
+type CreateAppClientOptions = {
+  fetch?: typeof fetch;
+  /**
+   * Base URL used when making requests.
+   * @default location.origin
+   */
+  baseUrl?: string;
+  /**
+   * List of headers to send on every request.
+   * @default {}
+   */
+  headers?: Record<string, string>;
+};
+//#endregion
+export { AppClient, CreateAppClientOptions, GetAppClient, GetClientRoutes, RequestError, createAppClient };

package/dist/client.mjs

@@ -0,0 +1,73 @@
+import { n as smartSerialize, t as smartDeserialize } from "./serialization-0dai2wUm.mjs";
+//#region src/client.ts
+/**
+* Creates a type-safe client based on the server-side app. This is only useful
+* if your frontend is in the same TypeScript project as your backend, and you
+* can reference it's types in the frontend.
+*
+* If that's not the case, generate your client using the OpenAPI docs.
+*
+* @example
+* ```ts
+* // Server-side:
+* import { createApp } from "@aklinker1/zeta";
+*
+* const app = createApp();
+* export type App = typeof app;
+*
+* // Client-side:
+* import type { App } from "../server";
+* //     ^^^^ MAKE SURE TO ONLY IMPORT THE TYPE HERE
+*
+* const client = createAppClient<App>();
+* ```
+*/
+function createAppClient(options) {
+	const { baseUrl = location.origin, fetch = globalThis.fetch, headers = {} } = options ?? {};
+	const buildSearchParams = (query) => {
+		return new URLSearchParams(Object.entries(query).filter(([, value]) => value != null).map(([key, value]) => [key, String(value)])).toString();
+	};
+	const buildPath = (route, params) => {
+		return Object.entries(params).reduce((path, [key, value]) => path.replace(key === "**" ? key : new RegExp(`\\*{2}:${key}|:${key}`), encodeURIComponent(String(value))), route);
+	};
+	return { async fetch(method, route, inputs) {
+		const searchParams = inputs.query == null ? "" : `?${buildSearchParams(inputs.query).toString()}`;
+		const url = `${join(baseUrl, inputs.params == null ? route : buildPath(route, inputs.params))}${searchParams}`;
+		const init = {
+			body: void 0,
+			method: method.toUpperCase(),
+			headers: { ...headers }
+		};
+		const serializedBody = inputs.body == null ? void 0 : smartSerialize(inputs.body);
+		if (serializedBody) {
+			init.body = serializedBody.value;
+			if (serializedBody.contentType) init.headers["Content-Type"] = serializedBody.contentType;
+		}
+		try {
+			const res = await fetch(url, init);
+			const response = await smartDeserialize(res);
+			if (!res.ok) throw new RequestError(response?.message ?? "Unknown error", res.status, response);
+			return response;
+		} catch (err) {
+			throw Error("Fetch failed", { cause: err });
+		}
+	} };
+}
+/**
+* Thrown by the client when the response is not OK. When an `HttpError` is
+* thrown server-side, this is the error throw client-side.
+*/
+var RequestError = class extends Error {
+	constructor(message, status, response, options) {
+		super(message, options);
+		this.status = status;
+		this.response = response;
+		this.name = "RequestError";
+	}
+};
+/** Join string together using `/` without double slashes. */
+function join(...paths) {
+	return paths.map((path) => path.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
+}
+//#endregion
+export { RequestError, createAppClient };

package/dist/index.d.mts

@@ -0,0 +1,317 @@
+import { i as NoResponse, l as HttpStatus, s as ZetaSchema, t as ErrorResponse, u as getHttpStatusName } from "./schema-DKqL09oQ.mjs";
+import { a as App, d as BasePrefix, i as AnyTransport, st as Transport, tt as SchemaAdapter, u as BasePath } from "./types-BvjPE9EM.mjs";
+import { OpenAPI, OpenAPIV3_1 } from "openapi-types";
+
+//#region src/app.d.ts
+/**
+ * Create a server-side, Zeta application.
+ *
+ * Zeta provides simple support for serving applications using `Bun.serve` and
+ * `Deno.serve` by calling `app.listen(3000)`.
+ *
+ * If you need more customization, you can use the `build` method to create a
+ * `fetch` function and serve it however you like.
+ *
+ * @example
+ * ```ts
+ * import { createApp } from "@aklinker1/zeta";
+ *
+ * const app = createApp({ prefix: "/api" })
+ *   .get("/health", () => "OK")
+ *   .get("/users", () => ["user1", "user2"]);
+ *
+ * app.listen(3000);
+ *
+ * // Or serve the app yourself
+ * const fetch = app.build();
+ * Bun.serve({ fetch, ... });
+ * Deno.serve({ ... }, fetch);
+ * ```
+ *
+ * @param options Configure application behavior.
+ */
+declare function createApp<TPrefix extends BasePrefix = "", TTransport extends AnyTransport = Transport>(options?: CreateAppOptions<TPrefix, TTransport>): App<{
+  ctx: {};
+  exported: false;
+  prefix: TPrefix;
+  routes: {};
+  transport: TTransport;
+}>;
+/**
+ * Configure how the app is created.
+ */
+type CreateAppOptions<TPrefix extends BasePrefix = "", TTransport extends AnyTransport = Transport> = {
+  /**
+   * The origin to use when constructing URLs.
+   * @default "http://localhost"
+   */
+  origin?: string;
+  /**
+   * Add a prefix to the beginning of all routes in the app.
+   */
+  prefix?: TPrefix;
+  /**
+   * Tell Zeta which library you're using for validation. OpenAPI docs cannot
+   * be served without a schema adapter.
+   *
+   * @example
+   * ```ts
+   * import { zodSchemaAdapter } from "@aklinker1/zeta/adapters/zod-schema-adapter"
+   *
+   * const app = createApp({
+   *   openApi: {
+   *     schemaAdapter: zodSchemaAdapter,
+   *   },
+   * });
+   * ```
+   */
+  schemaAdapter?: SchemaAdapter;
+  /**
+   * Tell Zeta how to serve your app over a port. By default, Zeta will detect
+   * if you're runtime is Bun or Deno, and use the appropriate transport.
+   *
+   * If you need to customize the transport, like adding an `idleTimeout` to
+   * bun, you can do so by passing options into the transport's factory function.
+   *
+   * @example
+   * ```ts
+   * import { createBunTransport } from "@aklinker1/zeta/transports/bun-transport"
+   *
+   * const app = createApp({
+   *   transport: createBunTransport(),
+   * });
+   * ```
+   */
+  transport?: TTransport;
+  /**
+   * Where the OpenAPI JSON docs is hosted.
+   * @default "/openapi.json"
+   */
+  openApiRoute?: BasePath;
+  /**
+   * Where the Scalar UI is hosted.
+   * @default "/scalar"
+   */
+  scalarRoute?: BasePath; /** Configure how your application's OpenAPI docs are generated. */
+  openApi?: Partial<OpenAPIV3_1.Document> & {};
+  /**
+   * OpenAPI tags to apply to all routes in this app. Route-level tags will
+   * override these app-level tags.
+   *
+   * @example
+   * ```ts
+   * const usersApp = createApp({
+   *   prefix: "/users",
+   *   tags: ["Users"],
+   * })
+   *   .get("/", {}, () => [...])  // Will have ["Users"] tag
+   *   .get("/:id", { tags: ["Admin"] }, () => {...})  // Will have ["Admin"] tag (overrides app-level)
+   * ```
+   */
+  tags?: string[];
+  /**
+   * OpenAPI security requirements to apply to all routes in this app.
+   * Route-level security will override these app-level security requirements.
+   *
+   * @example
+   * ```ts
+   * const authApp = createApp({
+   *   prefix: "/auth",
+   *   security: [{ bearerAuth: [] }],
+   * })
+   *   .get("/profile", {}, () => {...})  // Will require bearerAuth
+   *   .get("/admin", { security: [{ adminKey: [] }] }, () => {...})  // Will require adminKey (overrides app-level)
+   * ```
+   */
+  security?: OpenAPI.Document["security"];
+  /**
+   * Configure [Scalar](https://scalar.com/) UI docs.
+   * @see https://github.com/scalar/scalar/blob/main/documentation/configuration.md#list-of-all-attributes
+   */
+  scalar?: any;
+};
+//#endregion
+//#region src/errors.d.ts
+/**
+ * Base class of all HTTP errors. You can throw this error or throw any of the
+ * subclasses. Zeta will automatically detect and handle these errors, setting
+ * the appropriate status code and message.
+ *
+ * Error responses will include the stacktrace during development. To hide the
+ * stacktrace in production, set the `NODE_ENV` environment variable to
+ * `production`.
+ *
+ * @example
+ * ```ts
+ * throw new HttpError(HttpStatus.BadRequest, "Bad request")
+ * // OR
+ * throw new BadRequestError()
+ * ```
+ */
+declare class HttpError extends Error {
+  readonly status: HttpStatus;
+  readonly additionalInfo?: Record<string, any> | undefined;
+  constructor(status: HttpStatus, message: string, additionalInfo?: Record<string, any> | undefined, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.BadRequest, "Bad Request", ...)` */
+declare class BadRequestHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.Unauthorized, "Unauthorized", ...)` */
+declare class UnauthorizedHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.PaymentRequired, "Payment Required", ...)` */
+declare class PaymentRequiredHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.Forbidden, "Forbidden", ...)` */
+declare class ForbiddenHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.NotFound, "Not Found", ...)` */
+declare class NotFoundHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.MethodNotAllowed, "Method Not Allowed", ...)` */
+declare class MethodNotAllowedHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.NotAcceptable, "Not Acceptable", ...)` */
+declare class NotAcceptableHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.ProxyAuthenticationRequired, "Proxy Authentication Required", ...)` */
+declare class ProxyAuthenticationRequiredHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.RequestTimeout, "Request Timeout", ...)` */
+declare class RequestTimeoutHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.Conflict, "Conflict", ...)` */
+declare class ConflictHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.Gone, "Gone", ...)` */
+declare class GoneHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.LengthRequired, "Length Required", ...)` */
+declare class LengthRequiredHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.PreconditionFailed, "Precondition Failed", ...)` */
+declare class PreconditionFailedHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.ContentTooLarge, "Content Too Large", ...)` */
+declare class ContentTooLargeHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.UriTooLong, "URI Too Long", ...)` */
+declare class UriTooLongHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.UnsupportedMediaType, "Unsupported Media Type", ...)` */
+declare class UnsupportedMediaTypeHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.RangeNotSatisfiable, "Range Not Satisfiable", ...)` */
+declare class RangeNotSatisfiableHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.ExpectationFailed, "Expectation Failed", ...)` */
+declare class ExpectationFailedHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.ImATeapot, "I'm a Teapot", ...)` */
+declare class ImATeapotHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.MisdirectedRequest, "Misdirected Request", ...)` */
+declare class MisdirectedRequestHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.UnprocessableEntity, "Unprocessable Entity", ...)` */
+declare class UnprocessableEntityHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.Locked, "Locked", ...)` */
+declare class LockedHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.FailedDependency, "Failed Dependency", ...)` */
+declare class FailedDependencyHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.TooEarly, "Too Early", ...)` */
+declare class TooEarlyHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.UpgradeRequired, "Upgrade Required", ...)` */
+declare class UpgradeRequiredHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.PreconditionRequired, "Precondition Required", ...)` */
+declare class PreconditionRequiredHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.TooManyRequests, "Too Many Requests", ...)` */
+declare class TooManyRequestsHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.RequestHeaderFieldsTooLarge, "Request Header Fields Too Large", ...)` */
+declare class RequestHeaderFieldsTooLargeHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.UnavailableForLegalReasons, "Unavailable For Legal Reasons", ...)` */
+declare class UnavailableForLegalReasonsHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.InternalServerError, "Internal Server Error", ...)` */
+declare class InternalServerErrorHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.NotImplemented, "Not Implemented", ...)` */
+declare class NotImplementedHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.BadGateway, "Bad Gateway", ...)` */
+declare class BadGatewayHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.ServiceUnavailable, "Service Unavailable", ...)` */
+declare class ServiceUnavailableHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.GatewayTimeout, "Gateway Timeout", ...)` */
+declare class GatewayTimeoutHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.HttpVersionNotSupported, "HTTP Version Not Supported", ...)` */
+declare class HttpVersionNotSupportedHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.VariantAlsoNegotiates, "Variant Also Negotiates", ...)` */
+declare class VariantAlsoNegotiatesHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.InsufficientStorage, "Insufficient Storage", ...)` */
+declare class InsufficientStorageHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.LoopDetected, "Loop Detected", ...)` */
+declare class LoopDetectedHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.NotExtended, "Not Extended", ...)` */
+declare class NotExtendedHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+/** Shorthand for `new HttpError(HttpStatus.NetworkAuthenticationRequired, "Network Authentication Required", ...)` */
+declare class NetworkAuthenticationRequiredHttpError extends HttpError {
+  constructor(message?: string, additionalInfo?: Record<string, any>, options?: ErrorOptions);
+}
+//#endregion
+export { type App, BadGatewayHttpError, BadRequestHttpError, ConflictHttpError, ContentTooLargeHttpError, CreateAppOptions, ErrorResponse, ExpectationFailedHttpError, FailedDependencyHttpError, ForbiddenHttpError, GatewayTimeoutHttpError, GoneHttpError, HttpError, HttpStatus, HttpVersionNotSupportedHttpError, ImATeapotHttpError, InsufficientStorageHttpError, InternalServerErrorHttpError, LengthRequiredHttpError, LockedHttpError, LoopDetectedHttpError, MethodNotAllowedHttpError, MisdirectedRequestHttpError, NetworkAuthenticationRequiredHttpError, NoResponse, NotAcceptableHttpError, NotExtendedHttpError, NotFoundHttpError, NotImplementedHttpError, PaymentRequiredHttpError, PreconditionFailedHttpError, PreconditionRequiredHttpError, ProxyAuthenticationRequiredHttpError, RangeNotSatisfiableHttpError, RequestHeaderFieldsTooLargeHttpError, RequestTimeoutHttpError, ServiceUnavailableHttpError, TooEarlyHttpError, TooManyRequestsHttpError, UnauthorizedHttpError, UnavailableForLegalReasonsHttpError, UnprocessableEntityHttpError, UnsupportedMediaTypeHttpError, UpgradeRequiredHttpError, UriTooLongHttpError, VariantAlsoNegotiatesHttpError, type ZetaSchema, createApp, getHttpStatusName };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { A as RangeNotSatisfiableHttpError, B as UpgradeRequiredHttpError, C as NotExtendedHttpError, D as PreconditionFailedHttpError, E as PaymentRequiredHttpError, F as TooManyRequestsHttpError, H as VariantAlsoNegotiatesHttpError, I as UnauthorizedHttpError, L as UnavailableForLegalReasonsHttpError, M as RequestTimeoutHttpError, N as ServiceUnavailableHttpError, O as PreconditionRequiredHttpError, P as TooEarlyHttpError, R as UnprocessableEntityHttpError, S as NotAcceptableHttpError, T as NotImplementedHttpError, U as HttpStatus, V as UriTooLongHttpError, W as getHttpStatusName, _ as LockedHttpError, a as ContentTooLargeHttpError, b as MisdirectedRequestHttpError, c as ForbiddenHttpError, d as HttpError, f as HttpVersionNotSupportedHttpError, g as LengthRequiredHttpError, h as InternalServerErrorHttpError, i as ConflictHttpError, j as RequestHeaderFieldsTooLargeHttpError, k as ProxyAuthenticationRequiredHttpError, l as GatewayTimeoutHttpError, m as InsufficientStorageHttpError, n as BadGatewayHttpError, o as ExpectationFailedHttpError, p as ImATeapotHttpError, r as BadRequestHttpError, s as FailedDependencyHttpError, t as createApp, u as GoneHttpError, v as LoopDetectedHttpError, w as NotFoundHttpError, x as NetworkAuthenticationRequiredHttpError, y as MethodNotAllowedHttpError, z as UnsupportedMediaTypeHttpError } from "./app-Bc9Kn3KA.mjs";
+import { ErrorResponse, NoResponse } from "./schema.mjs";
+export { BadGatewayHttpError, BadRequestHttpError, ConflictHttpError, ContentTooLargeHttpError, ErrorResponse, ExpectationFailedHttpError, FailedDependencyHttpError, ForbiddenHttpError, GatewayTimeoutHttpError, GoneHttpError, HttpError, HttpStatus, HttpVersionNotSupportedHttpError, ImATeapotHttpError, InsufficientStorageHttpError, InternalServerErrorHttpError, LengthRequiredHttpError, LockedHttpError, LoopDetectedHttpError, MethodNotAllowedHttpError, MisdirectedRequestHttpError, NetworkAuthenticationRequiredHttpError, NoResponse, NotAcceptableHttpError, NotExtendedHttpError, NotFoundHttpError, NotImplementedHttpError, PaymentRequiredHttpError, PreconditionFailedHttpError, PreconditionRequiredHttpError, ProxyAuthenticationRequiredHttpError, RangeNotSatisfiableHttpError, RequestHeaderFieldsTooLargeHttpError, RequestTimeoutHttpError, ServiceUnavailableHttpError, TooEarlyHttpError, TooManyRequestsHttpError, UnauthorizedHttpError, UnavailableForLegalReasonsHttpError, UnprocessableEntityHttpError, UnsupportedMediaTypeHttpError, UpgradeRequiredHttpError, UriTooLongHttpError, VariantAlsoNegotiatesHttpError, createApp, getHttpStatusName };

package/dist/schema-DKqL09oQ.d.mts

@@ -0,0 +1,168 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/status.d.ts
+/**
+ * Enum containing all HTTP status codes.
+ */
+declare enum HttpStatus {
+  Continue = 100,
+  SwitchingProtocols = 101,
+  ProcessingDeprecated = 102,
+  EarlyHints = 103,
+  Ok = 200,
+  Created = 201,
+  Accepted = 202,
+  NonAuthoritativeInformation = 203,
+  NoContent = 204,
+  ResetContent = 205,
+  PartialContent = 206,
+  MultiStatus = 207,
+  AlreadyReported = 208,
+  ImUsed = 226,
+  MultipleChoices = 300,
+  MovedPermanently = 301,
+  Found = 302,
+  SeeOther = 303,
+  NotModified = 304,
+  UseProxyDeprecated = 305,
+  Unused = 306,
+  TemporaryRedirect = 307,
+  PermanentRedirect = 308,
+  BadRequest = 400,
+  Unauthorized = 401,
+  PaymentRequired = 402,
+  Forbidden = 403,
+  NotFound = 404,
+  MethodNotAllowed = 405,
+  NotAcceptable = 406,
+  ProxyAuthenticationRequired = 407,
+  RequestTimeout = 408,
+  Conflict = 409,
+  Gone = 410,
+  LengthRequired = 411,
+  PreconditionFailed = 412,
+  ContentTooLarge = 413,
+  UriTooLong = 414,
+  UnsupportedMediaType = 415,
+  RangeNotSatisfiable = 416,
+  ExpectationFailed = 417,
+  ImATeapot = 418,
+  MisdirectedRequest = 421,
+  UnprocessableEntity = 422,
+  Locked = 423,
+  FailedDependency = 424,
+  TooEarly = 425,
+  UpgradeRequired = 426,
+  PreconditionRequired = 428,
+  TooManyRequests = 429,
+  RequestHeaderFieldsTooLarge = 431,
+  UnavailableForLegalReasons = 451,
+  InternalServerError = 500,
+  NotImplemented = 501,
+  BadGateway = 502,
+  ServiceUnavailable = 503,
+  GatewayTimeout = 504,
+  HttpVersionNotSupported = 505,
+  VariantAlsoNegotiates = 506,
+  InsufficientStorage = 507,
+  LoopDetected = 508,
+  NotExtended = 510,
+  NetworkAuthenticationRequired = 511
+}
+/**
+ * Returns the name of the HTTP status code (200 -> "OK").
+ * @param status The HTTP status code.
+ * @returns The name of the HTTP status code or `undefined` if the status code is not recognized.
+ */
+declare function getHttpStatusName(status: number): string | undefined;
+//#endregion
+//#region src/schema.d.ts
+type ZetaSchema<Input = unknown, Output = Input> = StandardSchemaV1<Input, Output> & {
+  "~zeta": {
+    type: string;
+    meta: Record<string, any>;
+  };
+  toJsonSchema?(): any;
+  meta(meta?: Record<string, any>): ZetaSchema<Input, Output>;
+};
+/**
+ * A schema for an error response. Use when defining additional status codes
+ * that an operation might return with:
+ *
+ * ```ts
+ * import { ErrorResponse } from '@aklinker/zeta';
+ *
+ * app.get(
+ *   "/api/item/:itemId",
+ *   {
+ *     responses: {
+ *       200: Item.optional(),
+ *       404: ErrorResponse,
+ *     }
+ *   },
+ *   () => {
+ *     // ...
+ *   }
+ * );
+ * ```
+ */
+declare const ErrorResponse: ZetaSchema<unknown, ErrorResponse>;
+declare function isZetaSchema(schema: any): schema is ZetaSchema;
+/**
+ * The actual type an error response conforms to.
+ */
+type ErrorResponse = {
+  [additionalInfo: string]: any;
+  name: string;
+  message: string;
+  status: HttpStatus;
+  stack?: string[];
+  cause?: ErrorResponse;
+};
+declare const ErrorResponseJsonSchema: {
+  type: "object";
+  properties: {
+    status: {
+      type: "number";
+      description: string;
+      example: number;
+    };
+    name: {
+      type: "string";
+      description: string;
+      example: string;
+    };
+    message: {
+      type: "string";
+      description: string;
+      example: string;
+    };
+  };
+  required: string[];
+};
+/**
+ * A schema for when you want to not return a response. Use when defining
+ * additional status codes that an operation might return with:
+ *
+ * ```ts
+ * import { NoResponse } from '@aklinker/zeta';
+ *
+ * app.get(
+ *   "/api/item/:itemId",
+ *   {
+ *     responses: {
+ *       [HttpStatus.Accepted]: NoResponse,
+ *     }
+ *   },
+ *   () => {
+ *     // ...
+ *   }
+ * );
+ * ```
+ */
+declare const NoResponse: ZetaSchema<undefined | null | void, void>;
+declare const FormDataBody: ZetaSchema<FormData>;
+declare const UploadFileBody: ZetaSchema<File>;
+declare const UploadFilesBody: ZetaSchema<FileList, File[]>;
+//#endregion
+export { UploadFileBody as a, isZetaSchema as c, NoResponse as i, HttpStatus as l, ErrorResponseJsonSchema as n, UploadFilesBody as o, FormDataBody as r, ZetaSchema as s, ErrorResponse as t, getHttpStatusName as u };

package/dist/schema.d.mts

@@ -0,0 +1,2 @@
+import { a as UploadFileBody, c as isZetaSchema, i as NoResponse, n as ErrorResponseJsonSchema, o as UploadFilesBody, r as FormDataBody, s as ZetaSchema, t as ErrorResponse } from "./schema-DKqL09oQ.mjs";
+export { ErrorResponse, ErrorResponseJsonSchema, FormDataBody, NoResponse, UploadFileBody, UploadFilesBody, ZetaSchema, isZetaSchema };