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

package/dist/index.cjs

@@ -128,19 +128,6 @@ var KaitoResponse = class {
   }
 };
 
-// src/util.ts
-function createUtilities(getContext) {
-  return {
-    getContext,
-    router: () => Router.create()
-  };
-}
-function parsable(parse) {
-  return {
-    parse
-  };
-}
-
 // src/router/router.ts
 var Router = class _Router {
   state;
@@ -153,9 +140,10 @@ var Router = class _Router {
       return {};
     }
     const result = {};
-    for (const [key, parsable2] of Object.entries(schema)) {
+    for (const key in schema) {
+      if (!schema.hasOwnProperty(key)) continue;
       const value = url.searchParams.get(key);
-      result[key] = parsable2.parse(value);
+      result[key] = schema[key].parse(value);
     }
     return result;
   }
@@ -246,9 +234,6 @@ var Router = class _Router {
           params
         });
         if (result instanceof Response) {
-          if (server.enableClientResponseHints) {
-            result.headers.set("x-kaito-is-response", "1");
-          }
           return result;
         }
         return response.toResponse({
@@ -294,11 +279,7 @@ var Router = class _Router {
 };
 
 // src/server.ts
-function createKaitoHandler(userConfig) {
-  const config = {
-    enableClientResponseHints: true,
-    ...userConfig
-  };
+function createKaitoHandler(config) {
   const handle = config.router.freeze(config);
   return async (request) => {
     if (config.before) {
@@ -313,6 +294,19 @@ function createKaitoHandler(userConfig) {
     return response;
   };
 }
+
+// src/util.ts
+function createUtilities(getContext) {
+  return {
+    getContext,
+    router: () => Router.create()
+  };
+}
+function parsable(parse) {
+  return {
+    parse
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   KaitoError,

package/dist/index.d.cts

@@ -126,25 +126,8 @@ type ServerConfig<ContextFrom> = {
      * ```
      */
     transform?: (req: Request, res: Response) => Promise<Response | void | undefined>;
-    /**
-     * Controls whether the server includes a header to indicate non-JSON responses.
-     *
-     * When a route handler returns a `Response` object, this setting determines if
-     * the server adds a header indicating the response should not be parsed as JSON.
-     *
-     * The `@kaito-http/client` package checks for this header's presence:
-     * - If present: Returns the raw Response object
-     * - If absent: Attempts to parse the response as JSON
-     *
-     * You might want to disable this feature when:
-     * 1. Using a custom client that doesn't recognize this header
-     * 2. Security requirements prevent exposing framework details in headers
-     *
-     * @default true
-     */
-    enableClientResponseHints: boolean;
 };
-declare function createKaitoHandler<Context>(userConfig: MakeOptional<ServerConfig<Context>, 'enableClientResponseHints'>): (request: Request) => Promise<Response>;
+declare function createKaitoHandler<Context>(config: ServerConfig<Context>): (request: Request) => Promise<Response>;
 
 type PrefixRoutesPathInner<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer ContextFrom, infer ContextTo, infer Result, infer Path, infer Method, infer Query, infer BodyOutput> ? Route<ContextFrom, ContextTo, Result, `${Prefix}${Path}`, Method, Query, BodyOutput> : never;
 type PrefixRoutesPath<Prefix extends `/${string}`, R extends AnyRoute> = R extends R ? PrefixRoutesPathInner<R, Prefix> : never;

package/dist/index.d.ts

@@ -126,25 +126,8 @@ type ServerConfig<ContextFrom> = {
      * ```
      */
     transform?: (req: Request, res: Response) => Promise<Response | void | undefined>;
-    /**
-     * Controls whether the server includes a header to indicate non-JSON responses.
-     *
-     * When a route handler returns a `Response` object, this setting determines if
-     * the server adds a header indicating the response should not be parsed as JSON.
-     *
-     * The `@kaito-http/client` package checks for this header's presence:
-     * - If present: Returns the raw Response object
-     * - If absent: Attempts to parse the response as JSON
-     *
-     * You might want to disable this feature when:
-     * 1. Using a custom client that doesn't recognize this header
-     * 2. Security requirements prevent exposing framework details in headers
-     *
-     * @default true
-     */
-    enableClientResponseHints: boolean;
 };
-declare function createKaitoHandler<Context>(userConfig: MakeOptional<ServerConfig<Context>, 'enableClientResponseHints'>): (request: Request) => Promise<Response>;
+declare function createKaitoHandler<Context>(config: ServerConfig<Context>): (request: Request) => Promise<Response>;
 
 type PrefixRoutesPathInner<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer ContextFrom, infer ContextTo, infer Result, infer Path, infer Method, infer Query, infer BodyOutput> ? Route<ContextFrom, ContextTo, Result, `${Prefix}${Path}`, Method, Query, BodyOutput> : never;
 type PrefixRoutesPath<Prefix extends `/${string}`, R extends AnyRoute> = R extends R ? PrefixRoutesPathInner<R, Prefix> : never;

package/dist/index.js

@@ -96,19 +96,6 @@ var KaitoResponse = class {
   }
 };
 
-// src/util.ts
-function createUtilities(getContext) {
-  return {
-    getContext,
-    router: () => Router.create()
-  };
-}
-function parsable(parse) {
-  return {
-    parse
-  };
-}
-
 // src/router/router.ts
 var Router = class _Router {
   state;
@@ -121,9 +108,10 @@ var Router = class _Router {
       return {};
     }
     const result = {};
-    for (const [key, parsable2] of Object.entries(schema)) {
+    for (const key in schema) {
+      if (!schema.hasOwnProperty(key)) continue;
       const value = url.searchParams.get(key);
-      result[key] = parsable2.parse(value);
+      result[key] = schema[key].parse(value);
     }
     return result;
   }
@@ -214,9 +202,6 @@ var Router = class _Router {
           params
         });
         if (result instanceof Response) {
-          if (server.enableClientResponseHints) {
-            result.headers.set("x-kaito-is-response", "1");
-          }
           return result;
         }
         return response.toResponse({
@@ -262,11 +247,7 @@ var Router = class _Router {
 };
 
 // src/server.ts
-function createKaitoHandler(userConfig) {
-  const config = {
-    enableClientResponseHints: true,
-    ...userConfig
-  };
+function createKaitoHandler(config) {
   const handle = config.router.freeze(config);
   return async (request) => {
     if (config.before) {
@@ -281,6 +262,19 @@ function createKaitoHandler(userConfig) {
     return response;
   };
 }
+
+// src/util.ts
+function createUtilities(getContext) {
+  return {
+    getContext,
+    router: () => Router.create()
+  };
+}
+function parsable(parse) {
+  return {
+    parse
+  };
+}
 export {
   KaitoError,
   KaitoRequest,

package/dist/stream/stream.cjs

@@ -25,6 +25,7 @@ __export(stream_exports, {
   SSEController: () => SSEController,
   sse: () => sse,
   sseEventToString: () => sseEventToString,
+  sseFromAnyReadable: () => sseFromAnyReadable,
   stream: () => stream
 });
 module.exports = __toCommonJS(stream_exports);
@@ -63,8 +64,8 @@ function sseEventToString(event) {
     result += `retry:${event.retry}
 `;
   }
-  if (event.data) {
-    result += `data:${event.data}`;
+  if (event.data !== void 0) {
+    result += `data:${JSON.stringify(event.data)}`;
   }
   return result;
 }
@@ -79,8 +80,11 @@ var SSEController = class {
   close() {
     this.controller.close();
   }
+  [Symbol.dispose]() {
+    this.close();
+  }
 };
-function sse(source) {
+function sseFromSource(source) {
   const start = source.start;
   const pull = source.pull;
   const cancel = source.cancel;
@@ -99,6 +103,33 @@ function sse(source) {
   });
   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,
@@ -106,5 +137,6 @@ function sse(source) {
   SSEController,
   sse,
   sseEventToString,
+  sseFromAnyReadable,
   stream
 });

package/dist/stream/stream.d.cts

@@ -1,35 +1,39 @@
-declare class KaitoStreamResponse<T> extends Response {
-    constructor(body: ReadableStream<T>);
+declare class KaitoStreamResponse<R> extends Response {
+    constructor(body: ReadableStream<R>);
     [Symbol.asyncIterator](): AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>;
 }
-declare class KaitoSSEResponse extends KaitoStreamResponse<string> {
+declare class KaitoSSEResponse<_ClientType> extends KaitoStreamResponse<string> {
 }
-declare function stream<T = string>(body: UnderlyingDefaultSource<T>): KaitoStreamResponse<T>;
-type SSEEvent = ({
-    data: string;
-    event: string;
+declare function stream<R>(body: UnderlyingDefaultSource<R>): KaitoStreamResponse<R>;
+type SSEEvent<T, E extends string> = ({
+    data: T;
+    event?: E | undefined;
 } | {
-    data: string;
-    event?: string | undefined;
-} | {
-    data?: string | undefined;
-    event: string;
+    data?: T | undefined;
+    event: E;
 }) & {
     retry?: number;
     id?: string;
 };
-declare function sseEventToString(event: SSEEvent): string;
-declare class SSEController {
+/**
+ * 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): void;
+    enqueue(event: SSEEvent<U, E>): void;
     close(): void;
+    [Symbol.dispose](): void;
 }
-interface SSESource {
+interface SSESource<U, E extends string> {
     cancel?: UnderlyingSourceCancelCallback;
-    start?(controller: SSEController): Promise<void>;
-    pull?(controller: SSEController): Promise<void>;
+    start?(controller: SSEController<U, E>): Promise<void>;
+    pull?(controller: SSEController<U, E>): Promise<void>;
 }
-declare function sse(source: SSESource): KaitoSSEResponse;
+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, stream };
+export { KaitoSSEResponse, KaitoStreamResponse, SSEController, type SSEEvent, type SSESource, sse, sseEventToString, sseFromAnyReadable, stream };

package/dist/stream/stream.d.ts

@@ -1,35 +1,39 @@
-declare class KaitoStreamResponse<T> extends Response {
-    constructor(body: ReadableStream<T>);
+declare class KaitoStreamResponse<R> extends Response {
+    constructor(body: ReadableStream<R>);
     [Symbol.asyncIterator](): AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>;
 }
-declare class KaitoSSEResponse extends KaitoStreamResponse<string> {
+declare class KaitoSSEResponse<_ClientType> extends KaitoStreamResponse<string> {
 }
-declare function stream<T = string>(body: UnderlyingDefaultSource<T>): KaitoStreamResponse<T>;
-type SSEEvent = ({
-    data: string;
-    event: string;
+declare function stream<R>(body: UnderlyingDefaultSource<R>): KaitoStreamResponse<R>;
+type SSEEvent<T, E extends string> = ({
+    data: T;
+    event?: E | undefined;
 } | {
-    data: string;
-    event?: string | undefined;
-} | {
-    data?: string | undefined;
-    event: string;
+    data?: T | undefined;
+    event: E;
 }) & {
     retry?: number;
     id?: string;
 };
-declare function sseEventToString(event: SSEEvent): string;
-declare class SSEController {
+/**
+ * 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): void;
+    enqueue(event: SSEEvent<U, E>): void;
     close(): void;
+    [Symbol.dispose](): void;
 }
-interface SSESource {
+interface SSESource<U, E extends string> {
     cancel?: UnderlyingSourceCancelCallback;
-    start?(controller: SSEController): Promise<void>;
-    pull?(controller: SSEController): Promise<void>;
+    start?(controller: SSEController<U, E>): Promise<void>;
+    pull?(controller: SSEController<U, E>): Promise<void>;
 }
-declare function sse(source: SSESource): KaitoSSEResponse;
+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, stream };
+export { KaitoSSEResponse, KaitoStreamResponse, SSEController, type SSEEvent, type SSESource, sse, sseEventToString, sseFromAnyReadable, stream };

package/dist/stream/stream.js

@@ -34,8 +34,8 @@ function sseEventToString(event) {
     result += `retry:${event.retry}
 `;
   }
-  if (event.data) {
-    result += `data:${event.data}`;
+  if (event.data !== void 0) {
+    result += `data:${JSON.stringify(event.data)}`;
   }
   return result;
 }
@@ -50,8 +50,11 @@ var SSEController = class {
   close() {
     this.controller.close();
   }
+  [Symbol.dispose]() {
+    this.close();
+  }
 };
-function sse(source) {
+function sseFromSource(source) {
   const start = source.start;
   const pull = source.pull;
   const cancel = source.cancel;
@@ -70,11 +73,39 @@ function sse(source) {
   });
   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,13 +1,13 @@
 {
   "name": "@kaito-http/core",
-  "version": "3.0.0-beta.20",
+  "version": "3.0.0-beta.21",
   "type": "module",
   "author": "Alistair Smith <hi@alistair.sh>",
   "description": "Functional HTTP Framework for TypeScript",
   "scripts": {
     "build": "tsup",
-    "test": "node --test --import=tsx ./src/**/*.test.ts",
-    "attw": "attw --profile node16 --pack ."
+    "attw": "attw --profile node16 --pack .",
+    "test": "node --test --import=tsx ./src/**/*.test.ts"
   },
   "exports": {
     "./package.json": "./package.json",

package/src/router/router.ts

@@ -4,7 +4,7 @@ import {KaitoRequest} from '../request.ts';
 import {KaitoResponse} from '../response.ts';
 import type {AnyQueryDefinition, AnyRoute, Route} from '../route.ts';
 import type {ServerConfig} from '../server.ts';
-import type {ErroredAPIResponse, MakeOptional, Parsable} from '../util.ts';
+import type {ErroredAPIResponse, Parsable} from '../util.ts';
 import type {KaitoMethod} from './types.ts';
 
 type PrefixRoutesPathInner<R extends AnyRoute, Prefix extends `/${string}`> =
@@ -46,9 +46,10 @@ export class Router<ContextFrom, ContextTo, R extends AnyRoute> {
 		}
 
 		const result: Record<PropertyKey, unknown> = {};
-		for (const [key, parsable] of Object.entries(schema)) {
+		for (const key in schema) {
+			if (!schema.hasOwnProperty(key)) continue;
 			const value = url.searchParams.get(key);
-			result[key] = parsable.parse(value);
+			result[key] = (schema[key] as Parsable).parse(value);
 		}
 
 		return result as {
@@ -111,7 +112,7 @@ export class Router<ContextFrom, ContextTo, R extends AnyRoute> {
 		});
 	};
 
-	public freeze = (server: Omit<MakeOptional<ServerConfig<ContextFrom>, 'enableClientResponseHints'>, 'router'>) => {
+	public freeze = (server: Omit<ServerConfig<ContextFrom>, 'router'>) => {
 		const routes = new Map<string, Map<KaitoMethod, AnyRoute>>();
 
 		for (const route of this.state.routes) {
@@ -187,10 +188,6 @@ export class Router<ContextFrom, ContextTo, R extends AnyRoute> {
 				});
 
 				if (result instanceof Response) {
-					if (server.enableClientResponseHints) {
-						result.headers.set('x-kaito-is-response', '1');
-					}
-
 					return result;
 				}
 

package/src/server.ts

@@ -1,7 +1,7 @@
 import type {KaitoError} from './error.ts';
 import type {KaitoRequest} from './request.ts';
 import type {Router} from './router/router.ts';
-import type {GetContext, MakeOptional} from './util.ts';
+import type {GetContext} from './util.ts';
 
 export type Before = (req: Request) => Promise<Response | void | undefined>;
 
@@ -64,34 +64,9 @@ export type ServerConfig<ContextFrom> = {
 	 * ```
 	 */
 	transform?: (req: Request, res: Response) => Promise<Response | void | undefined>;
-
-	/**
-	 * Controls whether the server includes a header to indicate non-JSON responses.
-	 *
-	 * When a route handler returns a `Response` object, this setting determines if
-	 * the server adds a header indicating the response should not be parsed as JSON.
-	 *
-	 * The `@kaito-http/client` package checks for this header's presence:
-	 * - If present: Returns the raw Response object
-	 * - If absent: Attempts to parse the response as JSON
-	 *
-	 * You might want to disable this feature when:
-	 * 1. Using a custom client that doesn't recognize this header
-	 * 2. Security requirements prevent exposing framework details in headers
-	 *
-	 * @default true
-	 */
-	enableClientResponseHints: boolean;
 };
 
-export function createKaitoHandler<Context>(
-	userConfig: MakeOptional<ServerConfig<Context>, 'enableClientResponseHints'>,
-) {
-	const config: ServerConfig<Context> = {
-		enableClientResponseHints: true,
-		...userConfig,
-	};
-
+export function createKaitoHandler<Context>(config: ServerConfig<Context>) {
 	const handle = config.router.freeze(config);
 
 	return async (request: Request): Promise<Response> => {

package/src/stream/stream.ts

@@ -129,12 +129,13 @@ export function sse<U, E extends string, T extends SSEEvent<U, E>>(
 				// TODO: use `using` once Node.js supports it
 				// // ensures close is called on controller when we're done
 				// using c = controller;
-
-				for await (const event of generator) {
-					controller.enqueue(event);
+				try {
+					for await (const event of generator) {
+						controller.enqueue(event);
+					}
+				} finally {
+					controller.close();
 				}
-
-				controller.close();
 			},
 		});
 	} else {