@aklinker1/zeta 2.1.2 → 2.2.0

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-0dai2wUm.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 { a as App } from "./types-BvjPE9EM.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,47 @@
+import { Z as RequestContext, a as App, st as Transport } from "../types-BvjPE9EM.mjs";
+
+//#region src/transports/bun-transport.d.ts
+type BunTransport = Transport<[request: Request, server: Bun.Server]>;
+declare function createBunTransport(options?: Omit<Bun.ServeFunctionOptions<any, any>, "fetch" | "port">): BunTransport;
+/**
+ * Given the request context, return Bun's `server` object. Throws an error if the bun transport is not provided on the top-level app.
+ *
+ * @example
+ * ```ts
+ * const app = createApp({
+ *   transport: createBunTransport(),
+ * }).get("/", (ctx) => {
+ *   const server = getBunServer(ctx);
+ * })
+ * ```
+ *
+ * @see `bunServerPlugin` to add the `server` object to request context directly.
+ */
+declare function getBunServer(ctx: RequestContext): Bun.Server;
+/**
+ * Plugin that decorates Bun's `server` object in the request context.
+ *
+ * @example
+ * ```ts
+ * const app = createApp({
+ *   transport: createBunTransport(),
+ * })
+ *   .use(bunServerPlugin)
+ *   .get("/", ({ server }) => {
+ *     // ...
+ *   })
+ * ```
+ *
+ * @see `getBunServer` for a simple function to return the server
+ */
+declare const bunServerPlugin: App<{
+  prefix: "";
+  ctx: {
+    server: Bun.Server;
+  };
+  exported: true;
+  routes: {};
+  transport: BunTransport;
+}>;
+//#endregion
+export { BunTransport, bunServerPlugin, createBunTransport, getBunServer };

package/dist/transports/bun-transport.mjs

@@ -0,0 +1,58 @@
+import { t as createApp } from "../app-Bc9Kn3KA.mjs";
+//#region src/transports/bun-transport.ts
+const SERVER_KEY = Symbol("bun-transport.server");
+function createBunTransport(options) {
+	const listen = (port, fetch, cb) => {
+		Bun.serve({
+			...options,
+			port,
+			fetch
+		});
+		if (cb) setTimeout(cb, 0);
+	};
+	const decorate = (ctx, _request, server) => {
+		ctx[SERVER_KEY] = server;
+	};
+	return {
+		listen,
+		decorate
+	};
+}
+/**
+* Given the request context, return Bun's `server` object. Throws an error if the bun transport is not provided on the top-level app.
+*
+* @example
+* ```ts
+* const app = createApp({
+*   transport: createBunTransport(),
+* }).get("/", (ctx) => {
+*   const server = getBunServer(ctx);
+* })
+* ```
+*
+* @see `bunServerPlugin` to add the `server` object to request context directly.
+*/
+function getBunServer(ctx) {
+	const server = ctx[SERVER_KEY];
+	if (!server) throw Error("Bun server not found. Did you forget to provide the bun transport?");
+	return server;
+}
+/**
+* Plugin that decorates Bun's `server` object in the request context.
+*
+* @example
+* ```ts
+* const app = createApp({
+*   transport: createBunTransport(),
+* })
+*   .use(bunServerPlugin)
+*   .get("/", ({ server }) => {
+*     // ...
+*   })
+* ```
+*
+* @see `getBunServer` for a simple function to return the server
+*/
+const bunServerPlugin = createApp().onTransform((ctx) => ({ server: getBunServer(ctx) })).export();
+//#endregion
+export { bunServerPlugin, createBunTransport, getBunServer };

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

@@ -0,0 +1,48 @@
+import { Z as RequestContext, a as App, st as Transport } from "../types-BvjPE9EM.mjs";
+
+//#region src/transports/deno-transport.d.ts
+type DenoTransport = Transport<[request: Request, server: Deno.HttpServer]>;
+type ServeOptions = Parameters<typeof Deno.serve>[0];
+declare function createDenoTransport(options?: Omit<ServeOptions, "port">): DenoTransport;
+/**
+ * Given the request context, return Deno's `server` object. Throws an error if the Deno transport is not provided on the top-level app.
+ *
+ * @example
+ * ```ts
+ * const app = createApp({
+ *   transport: createDenoTransport(),
+ * }).get("/", (ctx) => {
+ *   const server = getDenoServer(ctx);
+ * })
+ * ```
+ *
+ * @see `denoServerPlugin` to add the `server` object to request context directly.
+ */
+declare function getDenoServer(ctx: RequestContext): Deno.HttpServer;
+/**
+ * Plugin that decorates Deno's `server` object in the request context.
+ *
+ * @example
+ * ```ts
+ * const app = createApp({
+ *   transport: createDenoTransport(),
+ * })
+ *   .use(denoServerPlugin)
+ *   .get("/", ({ server }) => {
+ *     // ...
+ *   })
+ * ```
+ *
+ * @see `getDenoServer` for a simple function to return the server
+ */
+declare const denoServerPlugin: App<{
+  prefix: "";
+  ctx: {
+    server: Deno.HttpServer;
+  };
+  exported: true;
+  routes: {};
+  transport: DenoTransport;
+}>;
+//#endregion
+export { DenoTransport, createDenoTransport, denoServerPlugin, getDenoServer };

package/dist/transports/deno-transport.mjs

@@ -0,0 +1,57 @@
+import { t as createApp } from "../app-Bc9Kn3KA.mjs";
+//#region src/transports/deno-transport.ts
+const SERVER_KEY = Symbol("deno-transport.server");
+function createDenoTransport(options) {
+	const listen = (port, fetch, cb) => {
+		Deno.serve({
+			...options,
+			port
+		}, fetch);
+		if (cb) setTimeout(cb, 0);
+	};
+	const decorate = (ctx, _request, server) => {
+		ctx[SERVER_KEY] = server;
+	};
+	return {
+		listen,
+		decorate
+	};
+}
+/**
+* Given the request context, return Deno's `server` object. Throws an error if the Deno transport is not provided on the top-level app.
+*
+* @example
+* ```ts
+* const app = createApp({
+*   transport: createDenoTransport(),
+* }).get("/", (ctx) => {
+*   const server = getDenoServer(ctx);
+* })
+* ```
+*
+* @see `denoServerPlugin` to add the `server` object to request context directly.
+*/
+function getDenoServer(ctx) {
+	const server = ctx[SERVER_KEY];
+	if (!server) throw Error("Deno server not found. Did you forget to provide the deno transport?");
+	return server;
+}
+/**
+* Plugin that decorates Deno's `server` object in the request context.
+*
+* @example
+* ```ts
+* const app = createApp({
+*   transport: createDenoTransport(),
+* })
+*   .use(denoServerPlugin)
+*   .get("/", ({ server }) => {
+*     // ...
+*   })
+* ```
+*
+* @see `getDenoServer` for a simple function to return the server
+*/
+const denoServerPlugin = createApp().onTransform((ctx) => ({ server: getDenoServer(ctx) })).export();
+//#endregion
+export { createDenoTransport, denoServerPlugin, getDenoServer };

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

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

package/dist/transports/fetch-transport.mjs

@@ -0,0 +1,25 @@
+//#region src/transports/fetch-transport.ts
+function createFetchTransport() {
+	const listen = (port, fetch, cb) => {
+		if (globalThis.Bun) Bun.serve({
+			port,
+			fetch
+		});
+		else if (globalThis.Deno) Deno.serve({ port }, fetch);
+		else throw Error(`Cannot automatically detect which transport to use. You must specify a transport in your top-level app:
+
+  ---
+  import { createBunTransport } from '@aklinker1/zeta/transports/bun-transport';
+
+  const app = createApp({
+    transport: createBunTransport(),
+  })
+
+  app.listen();
+  ---`);
+		if (cb) setTimeout(cb, 0);
+	};
+	return { listen };
+}
+//#endregion
+export { createFetchTransport };