@basaltkit/hono 1.1.0 → 1.2.1

package/README.md

@@ -1,3 +1,9 @@
+<p align="center">
+  <a href="https://basaltkit-docs.pages.dev">
+    <img src="https://basaltkit-docs.pages.dev/social-card.png" alt="Basalt" width="440">
+  </a>
+</p>
+
 # @basaltkit/hono
 
 The Basalt adapter for [Hono](https://hono.dev): the same typed routes, enrichers, and guards you'd use with Fastify or Express, running on Hono — on Node.js, Bun, Deno, or *edge* platforms (Cloudflare Workers, Vercel Edge, …). You need this when you want to take your Basalt API outside classic Node, or when you're already using Hono.

package/dist/index.d.ts

@@ -1,15 +1,12 @@
-import * as _basaltkit_core from '@basaltkit/core';
 import { Container } from '@basaltkit/core';
-import * as hono_types from 'hono/types';
-import { BasaltRoute, RequestEnricher, RouteGuard } from '@basaltkit/http';
+import { type BasaltRoute, type RequestEnricher, type RouteGuard } from '@basaltkit/http';
 import { Hono } from 'hono';
-
-declare const HONO: _basaltkit_core.Token<Hono<any, hono_types.BlankSchema, "/">>;
+export declare const HONO: import("@basaltkit/core").Token<Hono<any, import("hono/types").BlankSchema, "/">>;
 /** Default maximum request body size (1 MiB) — override via honoPlugin({ bodyLimit }). */
-declare const DEFAULT_BODY_LIMIT = 1048576;
+export declare const DEFAULT_BODY_LIMIT = 1048576;
 /** Mounts Basalt routes on a Hono app (usable without the plugin). */
-declare function registerRoutes(app: Hono<any>, routes: BasaltRoute[], container?: Container, enrichers?: RequestEnricher[], guards?: RouteGuard[]): void;
-interface HonoPluginOptions {
+export declare function registerRoutes(app: Hono<any>, routes: BasaltRoute[], container?: Container, enrichers?: RequestEnricher[], guards?: RouteGuard[]): void;
+export interface HonoPluginOptions {
     routes?: BasaltRoute[];
     /** Bring your own Hono app; otherwise a fresh one is created. */
     app?: Hono<any>;
@@ -25,6 +22,4 @@ interface HonoPluginOptions {
  * guards you register for Fastify work unchanged — resolve `HONO` for the app
  * to serve (e.g. `@hono/node-server` or an edge runtime's `fetch` export).
  */
-declare function honoPlugin(options?: HonoPluginOptions): _basaltkit_core.BasaltPlugin<unknown>;
-
-export { DEFAULT_BODY_LIMIT, HONO, type HonoPluginOptions, honoPlugin, registerRoutes };
+export declare function honoPlugin(options?: HonoPluginOptions): import("@basaltkit/core").BasaltPlugin<unknown>;

package/dist/index.js

@@ -1,176 +1,206 @@
-// src/index.ts
-import { createToken, definePlugin, ensureMetadata } from "@basaltkit/core";
-import {
-  HttpServerCollector,
-  HTTP_SERVER,
-  runRoute,
-  toErrorResponse
-} from "@basaltkit/http";
-import { Hono } from "hono";
-var HONO = createToken("hono");
-var DEFAULT_BODY_LIMIT = 1048576;
+import { Container, createToken, definePlugin, ensureMetadata } from '@basaltkit/core';
+import { HttpServerCollector, HTTP_SERVER, runRoute, toErrorResponse, isSseResponse, sseProducerOf, driveSse, SSE_HEADERS, } from '@basaltkit/http';
+import { Hono } from 'hono';
+export const HONO = createToken('hono');
+/** Default maximum request body size (1 MiB) — override via honoPlugin({ bodyLimit }). */
+export const DEFAULT_BODY_LIMIT = 1_048_576;
 async function parseBody(context) {
-  const method = context.req.method;
-  if (method === "GET" || method === "HEAD") return void 0;
-  const contentType = context.req.header("content-type") ?? "";
-  try {
-    if (contentType.includes("application/json")) return await context.req.json();
-    if (contentType.includes("form")) return await context.req.parseBody();
-    const text = await context.req.text();
-    return text || void 0;
-  } catch {
-    return void 0;
-  }
+    const method = context.req.method;
+    if (method === 'GET' || method === 'HEAD')
+        return undefined;
+    const contentType = context.req.header('content-type') ?? '';
+    try {
+        if (contentType.includes('application/json'))
+            return await context.req.json();
+        if (contentType.includes('form'))
+            return await context.req.parseBody();
+        const text = await context.req.text();
+        return text || undefined;
+    }
+    catch {
+        return undefined;
+    }
 }
 async function toNeutralRequest(context) {
-  return {
-    method: context.req.method,
-    url: context.req.url,
-    headers: Object.fromEntries(context.req.raw.headers.entries()),
-    params: context.req.param(),
-    query: context.req.query(),
-    body: await parseBody(context),
-    ...context.req.routePath ? { routePattern: context.req.routePath } : {},
-    raw: context
-  };
+    return {
+        method: context.req.method,
+        url: context.req.url,
+        headers: Object.fromEntries(context.req.raw.headers.entries()),
+        params: context.req.param(),
+        query: context.req.query(),
+        body: await parseBody(context),
+        ...(context.req.routePath ? { routePattern: context.req.routePath } : {}),
+        raw: context,
+    };
 }
-var HonoReply = class {
-  constructor(context) {
-    this.context = context;
-  }
-  context;
-  _status = 200;
-  _sent = false;
-  _payload;
-  get sent() {
-    return this._sent;
-  }
-  get statusCode() {
-    return this._status;
-  }
-  get payload() {
-    return this._payload;
-  }
-  get raw() {
-    return this.context;
-  }
-  code(status) {
-    this._status = status;
-    return this;
-  }
-  header(name, value) {
-    this.context.header(name, value);
-    return this;
-  }
-  send(payload) {
-    this._sent = true;
-    this._payload = payload;
-    return this;
-  }
-};
-function toResponse(reply, payload) {
-  const headers = new Headers(reply.context.res?.headers);
-  let body;
-  if (payload === void 0 || payload === null) {
-    body = null;
-  } else if (typeof payload === "string") {
-    body = payload;
-    if (!headers.has("content-type")) headers.set("content-type", "text/plain; charset=utf-8");
-  } else {
-    body = JSON.stringify(payload);
-    headers.set("content-type", "application/json");
-  }
-  return new Response(body, { status: reply.statusCode, headers });
+/** Streams an SSE producer as a Response backed by a ReadableStream (Web streams). */
+function sseResponse(context, producer) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        start(controller) {
+            void driveSse(producer, {
+                write: (frame) => controller.enqueue(encoder.encode(frame)),
+                end: () => {
+                    try {
+                        controller.close();
+                    }
+                    catch {
+                        /* already closed */
+                    }
+                },
+                onClose: (listener) => context.req.raw.signal.addEventListener('abort', listener),
+            });
+        },
+    });
+    const { connection: _connection, ...headers } = SSE_HEADERS;
+    return new Response(stream, { headers });
 }
-function handlerFor(definition, container, enrichers, guards) {
-  return async (context) => {
-    const reply = new HonoReply(context);
-    try {
-      const result = await runRoute(definition, await toNeutralRequest(context), reply, {
-        ...container ? { container } : {},
-        enrichers,
-        guards
-      });
-      return toResponse(reply, reply.sent ? reply.payload : result);
-    } catch (error) {
-      const { status, body } = toErrorResponse(error);
-      return new Response(JSON.stringify(body), {
-        status,
-        headers: { "content-type": "application/json" }
-      });
+/** Neutral reply that buffers the response; the handler emits a native Response. */
+class HonoReply {
+    context;
+    _status = 200;
+    _sent = false;
+    _payload;
+    constructor(context) {
+        this.context = context;
+    }
+    get sent() {
+        return this._sent;
+    }
+    get statusCode() {
+        return this._status;
+    }
+    get payload() {
+        return this._payload;
+    }
+    get raw() {
+        return this.context;
+    }
+    code(status) {
+        this._status = status;
+        return this;
+    }
+    header(name, value) {
+        // Accumulate on the Hono context so headers set in a pre-hook survive to
+        // the final response (a separate reply instance builds it).
+        this.context.header(name, value);
+        return this;
+    }
+    send(payload) {
+        this._sent = true;
+        this._payload = payload;
+        return this;
     }
-  };
 }
-function registerRoutes(app, routes, container, enrichers = [], guards = []) {
-  for (const definition of routes) {
-    app.on(definition.method, definition.url, handlerFor(definition, container, enrichers, guards));
-  }
+function toResponse(reply, payload) {
+    const headers = new Headers(reply.context.res?.headers);
+    let body;
+    if (payload === undefined || payload === null) {
+        body = null;
+    }
+    else if (typeof payload === 'string') {
+        body = payload;
+        if (!headers.has('content-type'))
+            headers.set('content-type', 'text/plain; charset=utf-8');
+    }
+    else {
+        body = JSON.stringify(payload);
+        headers.set('content-type', 'application/json');
+    }
+    return new Response(body, { status: reply.statusCode, headers });
 }
-function honoPlugin(options = {}) {
-  const collector = new HttpServerCollector();
-  return definePlugin({
-    name: "basalt:hono",
-    register({ container }) {
-      container.singleton(HONO, () => options.app ?? new Hono());
-      container.singleton(HTTP_SERVER, () => collector);
-    },
-    boot({ container, hooks }) {
-      const app = container.get(HONO);
-      const routes = options.routes ?? [];
-      const metadata = ensureMetadata(container);
-      const enrichers = metadata.get("http:enrichers");
-      const guards = metadata.get("http:guards");
-      const bodyLimit = options.bodyLimit ?? DEFAULT_BODY_LIMIT;
-      hooks.on("app:booted", () => {
-        app.use(async (context, next) => {
-          const declared = Number(context.req.header("content-length") ?? "");
-          if (Number.isFinite(declared) && declared > bodyLimit) {
-            return context.json(
-              { code: "PAYLOAD_TOO_LARGE", message: `Request body exceeds the ${bodyLimit}-byte limit.` },
-              413
-            );
-          }
-          return next();
-        });
-        if (collector.afterHooks.length) {
-          app.use(async (context, next) => {
-            const start = Date.now();
-            await next();
-            await collector.runAfter(await toNeutralRequest(context), new HonoReply(context), context.res.status, Date.now() - start);
-          });
-        }
-        app.use(async (context, next) => {
-          const reply = new HonoReply(context);
-          if (await collector.runPre(await toNeutralRequest(context), reply)) return toResponse(reply, reply.payload);
-          await next();
-          return void 0;
-        });
-        registerRoutes(app, routes, container, enrichers, guards);
-        for (const { method, url, handler } of collector.extraRoutes) {
-          app.on(method, url, async (context) => {
-            const reply = new HonoReply(context);
-            const result = await handler({ request: await toNeutralRequest(context), reply });
+function handlerFor(definition, container, enrichers, guards) {
+    return async (context) => {
+        const reply = new HonoReply(context);
+        try {
+            const result = await runRoute(definition, await toNeutralRequest(context), reply, {
+                ...(container ? { container } : {}),
+                enrichers,
+                guards,
+            });
+            if (isSseResponse(result))
+                return sseResponse(context, sseProducerOf(result));
             return toResponse(reply, reply.sent ? reply.payload : result);
-          });
         }
-      });
-      for (const definition of routes) {
-        metadata.add("http:routes", {
-          method: definition.method,
-          url: definition.url,
-          meta: definition.meta ?? {},
-          body: definition.body,
-          query: definition.query,
-          params: definition.params,
-          response: definition.response
-        });
-      }
+        catch (error) {
+            const { status, body } = toErrorResponse(error);
+            return new Response(JSON.stringify(body), {
+                status,
+                headers: { 'content-type': 'application/json' },
+            });
+        }
+    };
+}
+/** Mounts Basalt routes on a Hono app (usable without the plugin). */
+export function registerRoutes(app, routes, container, enrichers = [], guards = []) {
+    for (const definition of routes) {
+        app.on(definition.method, definition.url, handlerFor(definition, container, enrichers, guards));
     }
-  });
 }
-export {
-  DEFAULT_BODY_LIMIT,
-  HONO,
-  honoPlugin,
-  registerRoutes
-};
+/**
+ * Runs Basalt on Hono (Node, Bun, Deno, edge). The same routes, enrichers and
+ * guards you register for Fastify work unchanged — resolve `HONO` for the app
+ * to serve (e.g. `@hono/node-server` or an edge runtime's `fetch` export).
+ */
+export function honoPlugin(options = {}) {
+    const collector = new HttpServerCollector();
+    return definePlugin({
+        name: 'basalt:hono',
+        register({ container }) {
+            container.singleton(HONO, () => options.app ?? new Hono());
+            container.singleton(HTTP_SERVER, () => collector);
+        },
+        boot({ container, hooks }) {
+            const app = container.get(HONO);
+            const routes = options.routes ?? [];
+            const metadata = ensureMetadata(container);
+            const enrichers = metadata.get('http:enrichers');
+            const guards = metadata.get('http:guards');
+            // Mount once edge plugins have registered their hooks/routes.
+            const bodyLimit = options.bodyLimit ?? DEFAULT_BODY_LIMIT;
+            hooks.on('app:booted', () => {
+                // Reject oversized bodies up front (Hono/edge has no default cap).
+                app.use(async (context, next) => {
+                    const declared = Number(context.req.header('content-length') ?? '');
+                    if (Number.isFinite(declared) && declared > bodyLimit) {
+                        return context.json({ code: 'PAYLOAD_TOO_LARGE', message: `Request body exceeds the ${bodyLimit}-byte limit.` }, 413);
+                    }
+                    return next();
+                });
+                if (collector.afterHooks.length) {
+                    app.use(async (context, next) => {
+                        const start = Date.now();
+                        await next();
+                        await collector.runAfter(await toNeutralRequest(context), new HonoReply(context), context.res.status, Date.now() - start);
+                    });
+                }
+                app.use(async (context, next) => {
+                    const reply = new HonoReply(context);
+                    if (await collector.runPre(await toNeutralRequest(context), reply))
+                        return toResponse(reply, reply.payload);
+                    await next();
+                    return undefined;
+                });
+                registerRoutes(app, routes, container, enrichers, guards);
+                for (const { method, url, handler } of collector.extraRoutes) {
+                    app.on(method, url, async (context) => {
+                        const reply = new HonoReply(context);
+                        const result = await handler({ request: await toNeutralRequest(context), reply });
+                        return toResponse(reply, reply.sent ? reply.payload : result);
+                    });
+                }
+            });
+            for (const definition of routes) {
+                metadata.add('http:routes', {
+                    method: definition.method,
+                    url: definition.url,
+                    meta: definition.meta ?? {},
+                    body: definition.body,
+                    query: definition.query,
+                    params: definition.params,
+                    response: definition.response,
+                });
+            }
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basaltkit/hono",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Hono adapter for Basalt: run the same typed routes, enrichers and guards on Hono (Node, Bun, Deno, edge) as on Fastify or Express.",
   "license": "MIT",
   "type": "module",
@@ -14,19 +14,18 @@
     "dist"
   ],
   "dependencies": {
-    "@basaltkit/core": "^1.0.0",
-    "@basaltkit/http": "^1.3.0"
+    "@basaltkit/core": "^1.1.2",
+    "@basaltkit/http": "^1.9.1"
   },
   "peerDependencies": {
     "hono": "^4.0.0"
   },
   "devDependencies": {
-    "@types/node": "^22.15.0",
-    "hono": "^4.6.0",
-    "tsup": "^8.4.0",
-    "typescript": "^5.8.0",
-    "vitest": "^3.1.0",
-    "zod": "^3.24.0",
+    "@types/node": "^26.3.0",
+    "hono": "^4.13.4",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.11",
+    "zod": "^3.24.0 || ^4.0.0",
     "@basaltkit/tsconfig": "^0.24.0"
   },
   "publishConfig": {
@@ -34,11 +33,11 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Zebedeu/basalt.git",
+    "url": "git+https://github.com/basaltkit/basalt.git",
     "directory": "packages/hono"
   },
-  "homepage": "https://github.com/Zebedeu/basalt/tree/main/packages/hono#readme",
-  "bugs": "https://github.com/Zebedeu/basalt/issues",
+  "homepage": "https://github.com/basaltkit/basalt/tree/main/packages/hono#readme",
+  "bugs": "https://github.com/basaltkit/basalt/issues",
   "keywords": [
     "basalt",
     "typescript",
@@ -48,7 +47,7 @@
     "edge"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
+    "build": "tsc -p tsconfig.build.json",
     "test": "vitest run",
     "typecheck": "tsc --noEmit"
   }