@kubun/plugin-http 0.10.0 → 0.12.0

package/lib/index.d.ts

@@ -7,10 +7,12 @@ import { Hono } from 'hono';
 export type HTTPPluginOptions = {
     /** Port to listen on. Default: 4321 (falls back to a random available port). */
     port?: number;
-    /** Allowed CORS origin(s). Default: ['*']. Comma-separated strings are split. */
+    /** Allowed CORS origin(s). Default: deny cross-origin. Comma-separated strings are split. */
     allowedOrigin?: string | Array<string>;
     /** Namespace prefix for all plugin-managed routes (health, info, protocols). Default: '/'. */
     prefix?: string;
+    /** Maximum request body size in bytes, enforced by the transport. Default: 1 MiB. */
+    bodyLimit?: number;
 };
 /**
  * API provided by the HTTP infrastructure plugin.
@@ -30,8 +32,10 @@ export type HTTPPluginAPI = {
 export type GraphAppOptions = {
     /** The RPC plugin API (already resolved). */
     rpc: RPCPluginAPI;
-    /** Allowed CORS origin(s). Default: ['*']. */
+    /** Allowed CORS origin(s). Default: deny cross-origin. */
     allowedOrigin?: string | Array<string>;
+    /** Maximum request body size in bytes, enforced by the transport. Default: 1 MiB. */
+    bodyLimit?: number;
 };
 /**
  * A mountable Hono sub-app with graph protocol routes.

package/lib/index.js

@@ -1 +1,154 @@
-import{defer as t}from"@enkaku/async";import{ServerTransport as e}from"@enkaku/http-server-transport";import{serve as r}from"@hono/node-server";import o from"get-port";import{Hono as n}from"hono";function i(t){return null==t?["*"]:"string"==typeof t?t.split(",").map(t=>t.trim()):t}function s(t){return async e=>t(e.req.raw)}export function createGraphApp(t){let r=new n,o=new e({allowedOrigin:i(t.allowedOrigin)}),p=s(o.fetch.bind(o)),a=t.rpc.serve(o);return r.post("/graph",p),r.post("/graph/*",p),r.options("/graph",p),r.options("/graph/*",p),{app:r,async dispose(){await a.dispose()}}}export function createHTTPPlugin(p){return a=>{let l,g,c,h,u=new n,f=t(),w=i(p?.allowedOrigin),d=p?.prefix??"/",m="/"===d?"":d.endsWith("/")?d.slice(0,-1):d,y=new Map;u.get(`${m}/health`,t=>t.json({status:"ok"})),u.get(`${m}/info`,t=>{let e={};for(let[t,r]of y)e[t]=r;return t.json({did:a.identity.id,protocols:e})});let P={listening:null,registerRoute(t,e,r){u[t.toLowerCase()](e,r)},registerProtocol(t,e){let r=`${m}/${t}`;y.set(t,r);let o=s(e);u.post(r,o),u.post(`${r}/*`,o),u.options(r,o),u.options(`${r}/*`,o)},getPort(){if(null==l)throw Error("HTTP server is not listening yet");return l},getURL(){if(null==g)throw Error("HTTP server is not listening yet");return g}},v=(async()=>{let t=p?.port??await o({port:4321}),n=new e({allowedOrigin:w});P.registerProtocol("graph",n.fetch.bind(n)),h=(await a.engine.getAPI("rpc")).serve(n),c=r({fetch:u.fetch,port:t},t=>{l=t.port,g=`http://localhost:${t.port}`,f.resolve()}),await f.promise})();return P.listening=v,{name:"http",api:P,async dispose(){await h?.dispose(),c?.close()}}}}
+import { ServerTransport } from '@enkaku/http-serve';
+import { serve } from '@hono/node-server';
+import { resolveAllowedOrigin } from '@kubun/http-util';
+import { defer } from '@sozai/async';
+import getPort from 'get-port';
+import { Hono } from 'hono';
+// ---- Constants ----
+const DEFAULT_PORT = 4321;
+/**
+ * Default maximum request body size (1 MiB), matching the Enkaku
+ * `ServerTransport` default. The transport is the real backstop — it reads the
+ * body with a streaming limit and rejects an oversized request with 413 before
+ * buffering it, guarding against memory-exhaustion bodies. Raise via the
+ * `bodyLimit` option to admit larger binary-state graph mutations, or lower it
+ * to tighten the cap.
+ */ const DEFAULT_BODY_LIMIT_BYTES = 1024 * 1024;
+// ---- Helpers ----
+function createProtocolHandler(fetch) {
+    return async (c)=>{
+        return fetch(c.req.raw);
+    };
+}
+/**
+ * Creates a standalone Hono app with graph protocol routes.
+ *
+ * Unlike createHTTPPlugin, this does NOT start an HTTP server or bind a port.
+ * The returned app is meant to be mounted on an existing Hono app via `parent.route(prefix, graphApp.app)`.
+ *
+ * The caller is responsible for:
+ * - Creating and awaiting the KubunEngine
+ * - Resolving the RPCPluginAPI via engine.getAPI('rpc')
+ * - Mounting the returned app and managing the HTTP server lifecycle
+ */ export function createGraphApp(options) {
+    const app = new Hono();
+    const allowedOrigin = resolveAllowedOrigin(options.allowedOrigin);
+    const transport = new ServerTransport({
+        allowedOrigin,
+        maxRequestBodySize: options.bodyLimit ?? DEFAULT_BODY_LIMIT_BYTES
+    });
+    const handler = createProtocolHandler(transport.fetch.bind(transport));
+    // @ts-expect-error: type instantiation too deep
+    const server = options.rpc.serve(transport);
+    app.post('/graph', handler);
+    app.post('/graph/*', handler);
+    app.options('/graph', handler);
+    app.options('/graph/*', handler);
+    return {
+        app,
+        async dispose () {
+            await server.dispose();
+        }
+    };
+}
+// ---- Plugin factory ----
+/**
+ * Creates the HTTP infrastructure plugin.
+ *
+ * Wraps a Hono app instance, binds it to a port using @hono/node-server,
+ * and serves Enkaku protocol handlers over HTTP via ServerTransport.
+ * Other plugins can register additional routes via the API.
+ */ export function createHTTPPlugin(options) {
+    return (params)=>{
+        const app = new Hono();
+        const listening = defer();
+        const allowedOrigin = resolveAllowedOrigin(options?.allowedOrigin);
+        const rawPrefix = options?.prefix ?? '/';
+        const normalizedPrefix = rawPrefix === '/' ? '' : rawPrefix.endsWith('/') ? rawPrefix.slice(0, -1) : rawPrefix;
+        let resolvedPort;
+        let resolvedURL;
+        // Protocol registry: name → resolved full path
+        const protocols = new Map();
+        // Eager setup: built-in routes under the prefix
+        app.get(`${normalizedPrefix}/health`, (c)=>c.json({
+                status: 'ok'
+            }));
+        app.get(`${normalizedPrefix}/info`, (c)=>{
+            const protocolsObj = {};
+            for (const [name, path] of protocols){
+                protocolsObj[name] = path;
+            }
+            return c.json({
+                did: params.identity.id,
+                protocols: protocolsObj
+            });
+        });
+        // API object -- getPort/getURL throw before the server is listening
+        const api = {
+            listening: null,
+            registerRoute (method, path, handler) {
+                const m = method.toLowerCase();
+                // Hono handler type is deeply generic — cast through never to avoid `any`
+                app[m](path, handler);
+            },
+            registerProtocol (name, fetch) {
+                const resolvedPath = `${normalizedPrefix}/${name}`;
+                protocols.set(name, resolvedPath);
+                const handler = createProtocolHandler(fetch);
+                app.post(resolvedPath, handler);
+                app.post(`${resolvedPath}/*`, handler);
+                app.options(resolvedPath, handler);
+                app.options(`${resolvedPath}/*`, handler);
+            },
+            getPort () {
+                if (resolvedPort == null) {
+                    throw new Error('HTTP server is not listening yet');
+                }
+                return resolvedPort;
+            },
+            getURL () {
+                if (resolvedURL == null) {
+                    throw new Error('HTTP server is not listening yet');
+                }
+                return resolvedURL;
+            }
+        };
+        // Start the HTTP server asynchronously
+        let httpServer;
+        let enkakuServer;
+        const listeningPromise = (async ()=>{
+            const port = options?.port ?? await getPort({
+                port: DEFAULT_PORT
+            });
+            // Create the ServerTransport and register it as the 'graph' protocol.
+            const transport = new ServerTransport({
+                allowedOrigin,
+                maxRequestBodySize: options?.bodyLimit ?? DEFAULT_BODY_LIMIT_BYTES
+            });
+            api.registerProtocol('graph', transport.fetch.bind(transport));
+            // Get handlers from plugin-rpc's API instead of the engine's merged handler map.
+            // This decouples plugin-http from the engine's handler merging mechanism.
+            const rpcPlugin = await params.engine.getAPI('rpc');
+            // @ts-expect-error: type instantiation too deep
+            enkakuServer = rpcPlugin.serve(transport);
+            httpServer = serve({
+                fetch: app.fetch,
+                port
+            }, (info)=>{
+                resolvedPort = info.port;
+                resolvedURL = `http://localhost:${info.port}`;
+                listening.resolve();
+            });
+            await listening.promise;
+        })();
+        api.listening = listeningPromise;
+        return {
+            name: 'http',
+            api,
+            async dispose () {
+                await enkakuServer?.dispose();
+                httpServer?.close();
+            }
+        };
+    };
+}

package/package.json

@@ -1,42 +1,43 @@
 {
   "name": "@kubun/plugin-http",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "license": "see LICENSE.md",
+  "sideEffects": false,
   "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "exports": {
     ".": "./lib/index.js"
   },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib/*",
     "LICENSE.md"
   ],
-  "sideEffects": false,
   "dependencies": {
-    "@enkaku/async": "^0.16.0",
-    "@enkaku/http-server-transport": "^0.16.0",
-    "@enkaku/protocol": "^0.16.0",
-    "@enkaku/server": "^0.16.0",
-    "@hono/node-server": "^2.0.4",
+    "@enkaku/http-serve": "^0.20.0",
+    "@enkaku/protocol": "^0.20.0",
+    "@enkaku/server": "^0.20.0",
+    "@hono/node-server": "^2.1.0",
+    "@sozai/async": "^0.2.1",
     "get-port": "^7.2.0",
-    "hono": "^4.12.23",
-    "@kubun/engine": "^0.10.0"
+    "hono": "^4.13.0",
+    "@kubun/engine": "^0.12.0",
+    "@kubun/http-util": "^0.12.0"
   },
   "devDependencies": {
-    "@enkaku/http-client-transport": "^0.16.0",
-    "@kubun/client": "^0.10.0",
-    "@kubun/plugin-rpc": "^0.10.0",
-    "@kubun/test-utils": "^0.10.0",
-    "@kubun/protocol": "^0.10.0"
+    "@enkaku/http-fetch": "^0.20.0",
+    "@kubun/plugin-rpc": "^0.12.0",
+    "@kubun/client": "^0.12.0",
+    "@kubun/protocol": "^0.12.0",
+    "@kubun/test-utils": "^0.12.0"
   },
   "scripts": {
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../swc.json --strip-leading-paths",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
-    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit -p tsconfig.test.json",
-    "test:unit": "vitest run",
-    "test": "pnpm run test:types && pnpm run test:unit"
+    "test:unit": "vitest run"
   }
 }