@aklinker1/zeta 2.1.1 → 2.1.3

package/dist/schema-IKHh0I39.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-IKHh0I39.mjs";
+export { ErrorResponse, ErrorResponseJsonSchema, FormDataBody, NoResponse, UploadFileBody, UploadFilesBody, ZetaSchema, isZetaSchema };

package/dist/schema.mjs

@@ -0,0 +1,151 @@
+//#region src/schema.ts
+function createZetaSchema(name, validate, toJsonSchema, meta = {}) {
+	const parentMeta = meta;
+	return {
+		"~zeta": {
+			type: name,
+			meta
+		},
+		"~standard": {
+			vendor: "@aklinker/zeta",
+			version: 1,
+			validate
+		},
+		meta(meta) {
+			return createZetaSchema(name, validate, void 0, {
+				...parentMeta,
+				...meta
+			});
+		},
+		toJsonSchema
+	};
+}
+/**
+* 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,
+*     }
+*   },
+*   () => {
+*     // ...
+*   }
+* );
+* ```
+*/
+const ErrorResponse = createZetaSchema("ErrorResponse", (value) => {
+	if (value == null) return { issues: [{ message: `Expected an object, received ${value}` }] };
+	if (typeof value !== "object") return { issues: [{ message: `Expected an object, received ${typeof value}` }] };
+	const issues = [];
+	if (typeof value.name !== "string") issues.push({
+		message: `Expected a string, received ${typeof value.name}`,
+		path: ["name"]
+	});
+	if (typeof value.message !== "string") issues.push({
+		message: `Expected a string, received ${typeof value.message}`,
+		path: ["message"]
+	});
+	if (typeof value.status !== "number") issues.push({
+		message: `Expected a number, received ${typeof value.status}`,
+		path: ["status"]
+	});
+	if (issues.length > 0) return { issues };
+	return { value };
+});
+function isZetaSchema(schema) {
+	return schema?.["~standard"]?.vendor === "@aklinker/zeta";
+}
+const ErrorResponseJsonSchema = {
+	type: "object",
+	properties: {
+		status: {
+			type: "number",
+			description: "HTTP status code",
+			example: 400
+		},
+		name: {
+			type: "string",
+			description: "The error's name",
+			example: "Bad Request"
+		},
+		message: {
+			type: "string",
+			description: "User-facing error message",
+			example: "Property 'name' is required"
+		}
+	},
+	required: [
+		"status",
+		"name",
+		"message"
+	]
+};
+/**
+* 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,
+*     }
+*   },
+*   () => {
+*     // ...
+*   }
+* );
+* ```
+*/
+const NoResponse = createZetaSchema("NoResponse", (value) => {
+	return value != null ? { issues: [{ message: `Expected undefined or null, got ${typeof value}` }] } : { value: void 0 };
+});
+const FormDataBody = createZetaSchema("FormDataBody", (value) => {
+	return value instanceof FormData ? { value } : { issues: [{ message: `Expected FormData, got ${typeof value}` }] };
+}, () => ({
+	type: "object",
+	additionalProperties: true
+}), { contentType: "multipart/form-data" });
+const UploadFileBody = createZetaSchema("UploadFileBody", (value) => {
+	if (!(value instanceof FormData)) return { issues: [{ message: `Expected FormData, got ${typeof value}` }] };
+	const file = value.get("file");
+	if (!(file instanceof File)) return { issues: [{ message: `Expected File, got ${typeof file}` }] };
+	return { value: file };
+}, () => ({
+	type: "object",
+	properties: { file: {
+		type: "string",
+		format: "binary"
+	} }
+}), { contentType: "multipart/form-data" });
+const UploadFilesBody = createZetaSchema("UploadFilesBody", (value) => {
+	if (!(value instanceof FormData)) return { issues: [{ message: `Expected FormData, got ${typeof value}` }] };
+	const files = value.getAll("files");
+	if (!Array.isArray(files)) return { issues: [{ message: `Expected array of Files, got ${typeof files}` }] };
+	const issues = [];
+	for (const file of files) if (!(file instanceof File)) issues.push(`Expected File, got ${typeof file}`);
+	if (issues.length > 0) return { issues: issues.map((message) => ({ message })) };
+	return { value: files };
+}, () => ({
+	type: "object",
+	properties: { files: {
+		type: "array",
+		items: {
+			type: "string",
+			format: "binary"
+		}
+	} }
+}), { contentType: "multipart/form-data" });
+//#endregion
+export { ErrorResponse, ErrorResponseJsonSchema, FormDataBody, NoResponse, UploadFileBody, UploadFilesBody, isZetaSchema };

package/dist/serialization-C8e7ECQ2.mjs

@@ -0,0 +1,56 @@
+//#region src/internal/serialization.ts
+function smartSerialize(value) {
+	if (value == null) return void 0;
+	switch (typeof value) {
+		case "string": return {
+			contentType: "text/plain",
+			value
+		};
+		case "number":
+		case "boolean":
+		case "bigint": return {
+			contentType: "text/plain",
+			value: String(value)
+		};
+	}
+	if (value instanceof FormData) return {
+		contentType: void 0,
+		value
+	};
+	if (value instanceof File) {
+		const form = new FormData();
+		form.append("file", value);
+		return {
+			contentType: void 0,
+			value: form
+		};
+	}
+	if (typeof FileList !== "undefined" && value instanceof FileList) {
+		const form = new FormData();
+		for (let i = 0; i < value.length; i++) form.append("files", value.item(i));
+		return {
+			contentType: void 0,
+			value: form
+		};
+	}
+	if (value instanceof Blob) return {
+		contentType: value.type,
+		value
+	};
+	return {
+		contentType: "application/json",
+		value: JSON.stringify(value)
+	};
+}
+function smartDeserialize(arg) {
+	if (arg instanceof Request && arg.method === "GET") return;
+	const contentType = arg.headers.get("content-type");
+	if (contentType == null) return;
+	if (contentType.startsWith("application/json")) return arg.json();
+	if (contentType.startsWith("application/x-www-form-urlencoded") || contentType.startsWith("multipart/form-data")) return arg.formData();
+	if (contentType.startsWith("text/")) return arg.text();
+	if (contentType.startsWith("application/octet-stream")) return arg.arrayBuffer();
+	throw Error(`Unknown content type: "${contentType}"`);
+}
+//#endregion
+export { smartSerialize as n, smartDeserialize as t };

package/dist/testing.d.mts

@@ -0,0 +1,26 @@
+import { i as App } from "./types-D9oRVe1E.mjs";
+import { AppClient, CreateAppClientOptions, GetClientRoutes } from "./client.mjs";
+
+//#region src/testing.d.ts
+/**
+ * Create a client for testing your server-side application. When `fetch` is
+ * called, the app's `fetch` function is called instead of using the global
+ * `fetch`.
+ *
+ * @example
+ * ```ts
+ * const app = createApp()
+ *   .get("/example", () => "Hello, world!")
+ *
+ * const client = createTestAppClient(app);
+ *
+ * expect(await client.get("/example")).toEqual("Hello, world!");
+ * ```
+ *
+ * @param app
+ * @param options
+ * @returns An app client used to test your server-side application.
+ */
+declare function createTestAppClient<TApp extends App>(app: TApp, options?: Omit<CreateAppClientOptions, "fetch">): AppClient<GetClientRoutes<TApp>>;
+//#endregion
+export { createTestAppClient };

package/dist/testing.mjs

@@ -0,0 +1,52 @@
+import { createAppClient } from "./client.mjs";
+//#region src/testing.ts
+/**
+* Utilities for testing your server-side application.
+*
+* You don't need to use these utils, you can call the app's `fetch` function directly.
+*
+* ```ts
+* const app = createApp()
+*   .get("/example", () => "Hello, world!")
+* const fetch = app.build();
+*
+* const res = await fetch("http://test/example");
+* expect(res.status).toEqual(200);
+* expect(await res.text()).toEqual("Hello, world!");
+* ```
+*
+* If you just care about the response body or error thrown, you can use the `createTestAppClient`.
+*
+* @see {@link createTestAppClient}
+* @module
+*/
+/**
+* Create a client for testing your server-side application. When `fetch` is
+* called, the app's `fetch` function is called instead of using the global
+* `fetch`.
+*
+* @example
+* ```ts
+* const app = createApp()
+*   .get("/example", () => "Hello, world!")
+*
+* const client = createTestAppClient(app);
+*
+* expect(await client.get("/example")).toEqual("Hello, world!");
+* ```
+*
+* @param app
+* @param options
+* @returns An app client used to test your server-side application.
+*/
+function createTestAppClient(app, options) {
+	const { baseUrl = "http://localhost" } = options ?? {};
+	const fetch = app.build();
+	return createAppClient({
+		baseUrl,
+		...options,
+		fetch: (...args) => fetch(new Request(...args))
+	});
+}
+//#endregion
+export { createTestAppClient };

package/dist/transports/bun-transport.d.mts

@@ -0,0 +1,7 @@
+import { at as Transport } from "../types-D9oRVe1E.mjs";
+import { ServeFunctionOptions } from "@types/bun";
+
+//#region src/transports/bun-transport.d.ts
+declare function createBunTransport(options: Omit<ServeFunctionOptions<any, any>, "fetch" | "port">): Transport;
+//#endregion
+export { createBunTransport };

package/dist/transports/bun-transport.mjs

@@ -0,0 +1,14 @@
+//#region src/transports/bun-transport.ts
+function createBunTransport(options) {
+	const listen = (port, fetch, cb) => {
+		Bun.serve({
+			...options,
+			port,
+			fetch
+		});
+		if (cb) setTimeout(cb, 0);
+	};
+	return { listen };
+}
+//#endregion
+export { createBunTransport };

package/dist/transports/deno-transport.d.mts

@@ -0,0 +1,6 @@
+import { at as Transport } from "../types-D9oRVe1E.mjs";
+
+//#region src/transports/deno-transport.d.ts
+declare function createDenoTransport(): Transport;
+//#endregion
+export { createDenoTransport };

package/dist/transports/deno-transport.mjs

@@ -0,0 +1,13 @@
+//#region src/transports/deno-transport.ts
+function createDenoTransport() {
+	const listen = (port, fetch, cb) => {
+		Deno.serve({
+			port,
+			fetch
+		});
+		if (cb) setTimeout(cb, 0);
+	};
+	return { listen };
+}
+//#endregion
+export { createDenoTransport };