@kaito-http/core 3.0.0-beta.16 → 3.0.0-beta.21

package/dist/stream/stream.cjs

@@ -0,0 +1,142 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/stream/stream.ts
+var stream_exports = {};
+__export(stream_exports, {
+  KaitoSSEResponse: () => KaitoSSEResponse,
+  KaitoStreamResponse: () => KaitoStreamResponse,
+  SSEController: () => SSEController,
+  sse: () => sse,
+  sseEventToString: () => sseEventToString,
+  sseFromAnyReadable: () => sseFromAnyReadable,
+  stream: () => stream
+});
+module.exports = __toCommonJS(stream_exports);
+var KaitoStreamResponse = class extends Response {
+  constructor(body) {
+    super(body, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const chunk of this.body) {
+      yield chunk;
+    }
+  }
+};
+var KaitoSSEResponse = class extends KaitoStreamResponse {
+};
+function stream(body) {
+  return new KaitoStreamResponse(new ReadableStream(body));
+}
+function sseEventToString(event) {
+  let result = "";
+  if (event.event) {
+    result += `event:${event.event}
+`;
+  }
+  if (event.id) {
+    result += `id:${event.id}
+`;
+  }
+  if (event.retry) {
+    result += `retry:${event.retry}
+`;
+  }
+  if (event.data !== void 0) {
+    result += `data:${JSON.stringify(event.data)}`;
+  }
+  return result;
+}
+var SSEController = class {
+  controller;
+  constructor(controller) {
+    this.controller = controller;
+  }
+  enqueue(event) {
+    this.controller.enqueue(sseEventToString(event) + "\n\n");
+  }
+  close() {
+    this.controller.close();
+  }
+  [Symbol.dispose]() {
+    this.close();
+  }
+};
+function sseFromSource(source) {
+  const start = source.start;
+  const pull = source.pull;
+  const cancel = source.cancel;
+  const readable = new ReadableStream({
+    ...cancel ? { cancel } : {},
+    ...start ? {
+      start: async (controller) => {
+        await start(new SSEController(controller));
+      }
+    } : {},
+    ...pull ? {
+      pull: async (controller) => {
+        await pull(new SSEController(controller));
+      }
+    } : {}
+  });
+  return new KaitoSSEResponse(readable);
+}
+function sse(source) {
+  const evaluated = typeof source === "function" ? source() : source;
+  if ("next" in evaluated) {
+    const generator = evaluated;
+    return sseFromSource({
+      async start(controller) {
+        try {
+          for await (const event of generator) {
+            controller.enqueue(event);
+          }
+        } finally {
+          controller.close();
+        }
+      }
+    });
+  } else {
+    return sseFromSource(evaluated);
+  }
+}
+function sseFromAnyReadable(stream2, transform) {
+  const transformer = new TransformStream({
+    transform: (chunk, controller) => {
+      controller.enqueue(transform(chunk));
+    }
+  });
+  return sse(stream2.pipeThrough(transformer));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KaitoSSEResponse,
+  KaitoStreamResponse,
+  SSEController,
+  sse,
+  sseEventToString,
+  sseFromAnyReadable,
+  stream
+});

package/dist/stream/stream.d.cts

@@ -0,0 +1,39 @@
+declare class KaitoStreamResponse<R> extends Response {
+    constructor(body: ReadableStream<R>);
+    [Symbol.asyncIterator](): AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>;
+}
+declare class KaitoSSEResponse<_ClientType> extends KaitoStreamResponse<string> {
+}
+declare function stream<R>(body: UnderlyingDefaultSource<R>): KaitoStreamResponse<R>;
+type SSEEvent<T, E extends string> = ({
+    data: T;
+    event?: E | undefined;
+} | {
+    data?: T | undefined;
+    event: E;
+}) & {
+    retry?: number;
+    id?: string;
+};
+/**
+ * Converts an SSE Event into a string, ready for sending to the client
+ * @param event The SSE Event
+ * @returns A stringified version
+ */
+declare function sseEventToString(event: SSEEvent<unknown, string>): string;
+declare class SSEController<U, E extends string> implements Disposable {
+    private readonly controller;
+    constructor(controller: ReadableStreamDefaultController<string>);
+    enqueue(event: SSEEvent<U, E>): void;
+    close(): void;
+    [Symbol.dispose](): void;
+}
+interface SSESource<U, E extends string> {
+    cancel?: UnderlyingSourceCancelCallback;
+    start?(controller: SSEController<U, E>): Promise<void>;
+    pull?(controller: SSEController<U, E>): Promise<void>;
+}
+declare function sse<U, E extends string, T extends SSEEvent<U, E>>(source: SSESource<U, E> | AsyncGenerator<T, unknown, unknown> | (() => AsyncGenerator<T, unknown, unknown>)): KaitoSSEResponse<T>;
+declare function sseFromAnyReadable<R, U, E extends string>(stream: ReadableStream<R>, transform: (chunk: R) => SSEEvent<U, E>): KaitoSSEResponse<SSEEvent<U, E>>;
+
+export { KaitoSSEResponse, KaitoStreamResponse, SSEController, type SSEEvent, type SSESource, sse, sseEventToString, sseFromAnyReadable, stream };

package/dist/stream/stream.d.ts

@@ -0,0 +1,39 @@
+declare class KaitoStreamResponse<R> extends Response {
+    constructor(body: ReadableStream<R>);
+    [Symbol.asyncIterator](): AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>;
+}
+declare class KaitoSSEResponse<_ClientType> extends KaitoStreamResponse<string> {
+}
+declare function stream<R>(body: UnderlyingDefaultSource<R>): KaitoStreamResponse<R>;
+type SSEEvent<T, E extends string> = ({
+    data: T;
+    event?: E | undefined;
+} | {
+    data?: T | undefined;
+    event: E;
+}) & {
+    retry?: number;
+    id?: string;
+};
+/**
+ * Converts an SSE Event into a string, ready for sending to the client
+ * @param event The SSE Event
+ * @returns A stringified version
+ */
+declare function sseEventToString(event: SSEEvent<unknown, string>): string;
+declare class SSEController<U, E extends string> implements Disposable {
+    private readonly controller;
+    constructor(controller: ReadableStreamDefaultController<string>);
+    enqueue(event: SSEEvent<U, E>): void;
+    close(): void;
+    [Symbol.dispose](): void;
+}
+interface SSESource<U, E extends string> {
+    cancel?: UnderlyingSourceCancelCallback;
+    start?(controller: SSEController<U, E>): Promise<void>;
+    pull?(controller: SSEController<U, E>): Promise<void>;
+}
+declare function sse<U, E extends string, T extends SSEEvent<U, E>>(source: SSESource<U, E> | AsyncGenerator<T, unknown, unknown> | (() => AsyncGenerator<T, unknown, unknown>)): KaitoSSEResponse<T>;
+declare function sseFromAnyReadable<R, U, E extends string>(stream: ReadableStream<R>, transform: (chunk: R) => SSEEvent<U, E>): KaitoSSEResponse<SSEEvent<U, E>>;
+
+export { KaitoSSEResponse, KaitoStreamResponse, SSEController, type SSEEvent, type SSESource, sse, sseEventToString, sseFromAnyReadable, stream };

package/dist/stream/stream.js

@@ -0,0 +1,111 @@
+// src/stream/stream.ts
+var KaitoStreamResponse = class extends Response {
+  constructor(body) {
+    super(body, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const chunk of this.body) {
+      yield chunk;
+    }
+  }
+};
+var KaitoSSEResponse = class extends KaitoStreamResponse {
+};
+function stream(body) {
+  return new KaitoStreamResponse(new ReadableStream(body));
+}
+function sseEventToString(event) {
+  let result = "";
+  if (event.event) {
+    result += `event:${event.event}
+`;
+  }
+  if (event.id) {
+    result += `id:${event.id}
+`;
+  }
+  if (event.retry) {
+    result += `retry:${event.retry}
+`;
+  }
+  if (event.data !== void 0) {
+    result += `data:${JSON.stringify(event.data)}`;
+  }
+  return result;
+}
+var SSEController = class {
+  controller;
+  constructor(controller) {
+    this.controller = controller;
+  }
+  enqueue(event) {
+    this.controller.enqueue(sseEventToString(event) + "\n\n");
+  }
+  close() {
+    this.controller.close();
+  }
+  [Symbol.dispose]() {
+    this.close();
+  }
+};
+function sseFromSource(source) {
+  const start = source.start;
+  const pull = source.pull;
+  const cancel = source.cancel;
+  const readable = new ReadableStream({
+    ...cancel ? { cancel } : {},
+    ...start ? {
+      start: async (controller) => {
+        await start(new SSEController(controller));
+      }
+    } : {},
+    ...pull ? {
+      pull: async (controller) => {
+        await pull(new SSEController(controller));
+      }
+    } : {}
+  });
+  return new KaitoSSEResponse(readable);
+}
+function sse(source) {
+  const evaluated = typeof source === "function" ? source() : source;
+  if ("next" in evaluated) {
+    const generator = evaluated;
+    return sseFromSource({
+      async start(controller) {
+        try {
+          for await (const event of generator) {
+            controller.enqueue(event);
+          }
+        } finally {
+          controller.close();
+        }
+      }
+    });
+  } else {
+    return sseFromSource(evaluated);
+  }
+}
+function sseFromAnyReadable(stream2, transform) {
+  const transformer = new TransformStream({
+    transform: (chunk, controller) => {
+      controller.enqueue(transform(chunk));
+    }
+  });
+  return sse(stream2.pipeThrough(transformer));
+}
+export {
+  KaitoSSEResponse,
+  KaitoStreamResponse,
+  SSEController,
+  sse,
+  sseEventToString,
+  sseFromAnyReadable,
+  stream
+};

package/package.json

@@ -1,17 +1,29 @@
 {
   "name": "@kaito-http/core",
-  "version": "3.0.0-beta.16",
+  "version": "3.0.0-beta.21",
   "type": "module",
   "author": "Alistair Smith <hi@alistair.sh>",
   "description": "Functional HTTP Framework for TypeScript",
   "scripts": {
-    "build": "tsup"
+    "build": "tsup",
+    "attw": "attw --profile node16 --pack .",
+    "test": "node --test --import=tsx ./src/**/*.test.ts"
   },
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "import": "./dist/index.js",
+      "import": {
+        "types": "./src/index.ts",
+        "default": "./dist/index.js"
+      },
       "require": "./dist/index.cjs"
+    },
+    "./stream": {
+      "import": {
+        "types": "./src/stream/stream.ts",
+        "default": "./dist/stream/stream.js"
+      },
+      "require": "./dist/stream/stream.cjs"
     }
   },
   "homepage": "https://github.com/kaito-http/kaito",
@@ -23,6 +35,7 @@
   ],
   "license": "MIT",
   "devDependencies": {
+    "@arethetypeswrong/cli": "^0.17.2",
     "@types/node": "^22.10.2",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2"
@@ -30,7 +43,8 @@
   "files": [
     "package.json",
     "README.md",
-    "dist"
+    "dist",
+    "src"
   ],
   "bugs": {
     "url": "https://github.com/kaito-http/kaito/issues"

package/src/error.ts

@@ -0,0 +1,26 @@
+export class WrappedError<T> extends Error {
+	public static maybe<T>(maybeError: T) {
+		if (maybeError instanceof Error) {
+			return maybeError;
+		}
+
+		return WrappedError.from(maybeError);
+	}
+
+	public static from<T>(data: T) {
+		return new WrappedError(data);
+	}
+
+	private constructor(public readonly data: T) {
+		super('Something was thrown, but it was not an instance of Error, so a WrappedError was created.');
+	}
+}
+
+export class KaitoError extends Error {
+	constructor(
+		public readonly status: number,
+		message: string,
+	) {
+		super(message);
+	}
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './error.ts';
+export * from './request.ts';
+export * from './route.ts';
+export * from './router/router.ts';
+export type {KaitoMethod} from './router/types.ts';
+export * from './server.ts';
+export * from './util.ts';

package/src/request.ts

@@ -0,0 +1,47 @@
+export class KaitoRequest {
+	public readonly url: URL;
+
+	private readonly _request: Request;
+
+	public constructor(url: URL, request: Request) {
+		this._request = request;
+		this.url = url;
+	}
+
+	public get headers() {
+		return this._request.headers;
+	}
+
+	public get method() {
+		return this._request.method;
+	}
+
+	public async arrayBuffer(): Promise<ArrayBuffer> {
+		return this._request.arrayBuffer();
+	}
+
+	public async blob(): Promise<Blob> {
+		return this._request.blob();
+	}
+
+	public async formData(): Promise<FormData> {
+		return this._request.formData();
+	}
+
+	public async bytes(): Promise<Uint8Array> {
+		const buffer = await this.arrayBuffer();
+		return new Uint8Array(buffer);
+	}
+
+	public async json(): Promise<unknown> {
+		return this._request.json();
+	}
+
+	public async text(): Promise<string> {
+		return this._request.text();
+	}
+
+	public get request() {
+		return this._request;
+	}
+}

package/src/response.ts

@@ -0,0 +1,72 @@
+import type {APIResponse} from './util.ts';
+
+/**
+ * This class is similar to a `Response` object from the Web Fetch API, but
+ * this with no body stream, and is only used for setting status codes/headers.
+ *
+ * @example
+ * ```ts
+ * const response = new KaitoResponse();
+ *
+ * response.status(200);
+ * response.headers.set('Content-Type', 'application/json');
+ *
+ * console.log(response.headers); // Headers {'content-type': 'application/json'}
+ * ```
+ */
+export class KaitoResponse {
+	private _headers: Headers | null;
+	private _status: number;
+
+	public constructor() {
+		this._headers = null;
+		this._status = 200;
+	}
+
+	public get headers() {
+		if (this._headers === null) {
+			this._headers = new Headers();
+		}
+
+		return this._headers;
+	}
+
+	/**
+	 * Gets the status code of this KaitoResponse instance
+	 * @returns The status code
+	 */
+	public status(): number;
+
+	/**
+	 * Sets the status code of this KaitoResponse instance
+	 * @param status The status code to set
+	 * @returns This KaitoResponse instance
+	 */
+	public status(status: number): this;
+
+	public status(status?: number) {
+		if (status === undefined) {
+			return this._status;
+		}
+
+		this._status = status;
+		return this;
+	}
+
+	/**
+	 * Turn this KaitoResponse instance into a Response instance
+	 * @param body The Kaito JSON format to be sent as the response body
+	 * @returns A Response instance, ready to be sent
+	 */
+	public toResponse<T>(body: APIResponse<T>): Response {
+		const init: ResponseInit = {
+			status: this._status,
+		};
+
+		if (this._headers) {
+			init.headers = this._headers;
+		}
+
+		return Response.json(body, init);
+	}
+}

package/src/route.ts

@@ -0,0 +1,53 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type {KaitoMethod} from './router/types.ts';
+import type {ExtractRouteParams, InferParsable, Parsable} from './util.ts';
+
+export type RouteArgument<Path extends string, Context, QueryOutput, BodyOutput> = {
+	ctx: Context;
+	body: BodyOutput;
+	query: QueryOutput;
+	params: ExtractRouteParams<Path>;
+};
+
+export type AnyQueryDefinition = Record<string, Parsable<any, string | undefined>>;
+
+export type Through<From, To> = (context: From) => Promise<To>;
+
+export type Route<
+	// Router context
+	ContextFrom,
+	ContextTo,
+	// Route information
+	Result,
+	Path extends string,
+	Method extends KaitoMethod,
+	// Schemas
+	Query extends AnyQueryDefinition,
+	Body extends Parsable,
+> = {
+	through: Through<ContextFrom, ContextTo>;
+	body?: Body;
+	query?: Query;
+	path: Path;
+	method: Method;
+	run(
+		arg: RouteArgument<
+			Path,
+			ContextTo,
+			{
+				[Key in keyof Query]: InferParsable<Query[Key]>['output'];
+			},
+			InferParsable<Body>['output']
+		>,
+	): Promise<Result>;
+};
+
+export type AnyRoute<ContextFrom = any, ContextTo = any> = Route<
+	ContextFrom,
+	ContextTo,
+	any,
+	any,
+	any,
+	AnyQueryDefinition,
+	any
+>;