@superfunctions/http-hono 0.1.0

package/README.md

@@ -0,0 +1,222 @@
+# @superfunctions/http-hono
+
+Hono adapter for [@superfunctions/http](../http) - Use framework-agnostic routers with Hono.
+
+## Installation
+
+```bash
+npm install @superfunctions/http @superfunctions/http-hono hono
+```
+
+## Quick Start
+
+```typescript
+import { Hono } from 'hono';
+import { createRouter } from '@superfunctions/http';
+import { toHonoHandler } from '@superfunctions/http-hono';
+
+// Define your router (framework-agnostic)
+const apiRouter = createRouter({
+  routes: [
+    {
+      method: 'GET',
+      path: '/users/:id',
+      handler: async (req, ctx) => {
+        return Response.json({ id: ctx.params.id });
+      },
+    },
+  ],
+});
+
+// Use with Hono
+const app = new Hono();
+app.route('/api', toHonoHandler(apiRouter));
+
+export default app;
+```
+
+## API
+
+### `toHonoHandler(router)`
+
+Converts a `@superfunctions/http` router to a Hono instance.
+
+**Parameters:**
+- `router`: Router instance from `@superfunctions/http`
+
+**Returns:** `Hono`
+
+**Example:**
+```typescript
+import { toHonoHandler } from '@superfunctions/http-hono';
+
+const honoApp = toHonoHandler(myRouter);
+app.route('/api', honoApp);
+```
+
+
+## Usage Examples
+
+### With Middleware
+
+```typescript
+import { createRouter } from '@superfunctions/http';
+import { toHonoHandler } from '@superfunctions/http-hono';
+
+const router = createRouter({
+  middleware: [
+    async (req, ctx, next) => {
+      // Auth middleware
+      const token = req.headers.get('Authorization');
+      if (!token) {
+        return Response.json({ error: 'Unauthorized' }, { status: 401 });
+      }
+      return next();
+    },
+  ],
+  routes: [
+    {
+      method: 'GET',
+      path: '/protected',
+      handler: async () => Response.json({ data: 'secret' }),
+    },
+  ],
+});
+
+const app = new Hono();
+app.route('/api', toHonoHandler(router));
+```
+
+### With Custom Context
+
+```typescript
+interface AppContext {
+  db: Database;
+}
+
+const router = createRouter<AppContext>({
+  context: { db: myDatabase },
+  routes: [
+    {
+      method: 'GET',
+      path: '/users',
+      handler: async (req, ctx) => {
+        const users = await ctx.db.findMany({ model: 'users' });
+        return Response.json(users);
+      },
+    },
+  ],
+});
+
+const app = new Hono();
+app.route('/api', toHonoHandler(router));
+```
+
+### Multiple Routers
+
+```typescript
+const usersRouter = createRouter({ routes: [/* user routes */] });
+const postsRouter = createRouter({ routes: [/* post routes */] });
+
+const app = new Hono();
+app.route('/api/users', toHonoHandler(usersRouter));
+app.route('/api/posts', toHonoHandler(postsRouter));
+```
+
+### Edge Runtime Example
+
+```typescript
+// Cloudflare Workers
+import { createRouter } from '@superfunctions/http';
+import { toHonoHandler } from '@superfunctions/http-hono';
+
+const router = createRouter({
+  routes: [
+    { method: 'GET', path: '/', handler: async () => Response.json({ ok: true }) }
+  ]
+});
+
+const app = new Hono();
+app.route('/', toHonoHandler(router));
+
+export default app;
+```
+
+## Alternative: Universal Handler
+
+Since Hono uses Web Standards natively, you can also use the router directly without the adapter:
+
+```typescript
+import { Hono } from 'hono';
+import { createRouter } from '@superfunctions/http';
+
+const router = createRouter({
+  routes: [/* routes */]
+});
+
+const app = new Hono();
+app.all('/*', (c) => router.handler(c.req.raw));
+```
+
+**When to use the adapter:**
+- ✅ Full per-route registration
+- ✅ Framework-native patterns
+- ✅ Better integration with Hono middleware
+
+**When to use universal handler:**
+- ✅ Simpler setup
+- ✅ Single catch-all route
+- ✅ Minimal code
+
+## Important Notes
+
+### Web Standards
+
+Hono uses Web Standard `Request` and `Response` natively, making this adapter very lightweight with near-zero overhead.
+
+### Route Paths
+
+Routes are registered relative to the mount point:
+
+```typescript
+const router = createRouter({
+  routes: [
+    { method: 'GET', path: '/hello', handler: () => Response.json({ msg: 'hi' }) }
+  ]
+});
+
+// Route accessible at: /api/hello
+app.route('/api', toHonoHandler(router));
+```
+
+### HEAD Requests
+
+Hono doesn't have a built-in `head` method, so HEAD requests in your router are automatically skipped. Most frameworks handle HEAD automatically from GET routes.
+
+## TypeScript
+
+Full TypeScript support with proper types:
+
+```typescript
+import type { Router } from '@superfunctions/http';
+import type { Hono } from 'hono';
+
+const myRouter: Router = createRouter({ routes: [...] });
+const honoApp: Hono = toHonoHandler(myRouter);
+```
+
+## Edge Runtime Support
+
+Works seamlessly with:
+- ✅ Cloudflare Workers
+- ✅ Deno Deploy
+- ✅ Vercel Edge Functions
+- ✅ Bun
+
+## Compatibility
+
+- Hono 4.x ✅
+
+## License
+
+MIT

package/dist/adapter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Hono adapter for @superfunctions/http
+ */
+import type { Router } from '@superfunctions/http';
+import { Hono } from 'hono';
+/**
+ * Convert a @superfunctions/http Router to a Hono instance
+ *
+ * This registers all routes from the router with their respective HTTP methods.
+ * Hono uses Web Standards natively, so translation is minimal.
+ */
+export declare function toHonoHandler(router: Router): Hono;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE5B;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CA6BlD"}

package/dist/adapter.js

@@ -0,0 +1,34 @@
+/**
+ * Hono adapter for @superfunctions/http
+ */
+import { Hono } from 'hono';
+/**
+ * Convert a @superfunctions/http Router to a Hono instance
+ *
+ * This registers all routes from the router with their respective HTTP methods.
+ * Hono uses Web Standards natively, so translation is minimal.
+ */
+export function toHonoHandler(router) {
+    const app = new Hono();
+    // Get all routes from the router
+    const routes = router.getRoutes();
+    // Register each route with Hono
+    for (const route of routes) {
+        const method = route.method.toLowerCase();
+        // Hono doesn't have a 'head' method, so we'll skip HEAD requests
+        // or treat them as GET (HEAD is rare and usually handled automatically)
+        if (method === 'head') {
+            continue;
+        }
+        app[method](route.path, async (c) => {
+            // Hono's c.req.raw is already a Web Standard Request
+            const webRequest = c.req.raw;
+            // Handle with router
+            const webResponse = await router.handle(webRequest);
+            // Return Web Standard Response (Hono handles this natively)
+            return webResponse;
+        });
+    }
+    return app;
+}
+//# sourceMappingURL=adapter.js.map

package/dist/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE5B;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,MAAc;IAC1C,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;IAEvB,iCAAiC;IACjC,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC;IAElC,gCAAgC;IAChC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,WAAW,EAAoC,CAAC;QAE5E,iEAAiE;QACjE,wEAAwE;QACxE,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;YACtB,SAAS;QACX,CAAC;QAED,GAAG,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;YAClC,qDAAqD;YACrD,MAAM,UAAU,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;YAE7B,qBAAqB;YACrB,MAAM,WAAW,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;YAEpD,4DAA4D;YAC5D,OAAO,WAAW,CAAC;QACrB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @superfunctions/http-hono - Hono adapter
+ */
+export { toHonoHandler } from './adapter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+/**
+ * @superfunctions/http-hono - Hono adapter
+ */
+export { toHonoHandler } from './adapter.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@superfunctions/http-hono",
+  "version": "0.1.0",
+  "description": "Hono adapter for @superfunctions/http",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "lint": "echo 'lint not configured'",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "peerDependencies": {
+    "@superfunctions/http": "^0.1.0",
+    "hono": "^4.0.0"
+  },
+  "devDependencies": {
+    "@superfunctions/http": "^0.1.0",
+    "@types/node": "^22.0.0",
+    "hono": "^4.6.16",
+    "typescript": "^5.6.0",
+    "vitest": "^3.2.4"
+  },
+  "keywords": [
+    "http",
+    "hono",
+    "adapter",
+    "router",
+    "superfunctions"
+  ],
+  "author": "21n",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/21nCo/super-functions/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/21nCo/super-functions.git",
+    "directory": "packages/http-hono"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}