feat(adapters): integrate HttpDispatcher for enhanced request handling in Hono and NestJS adapters

Author: hotlong

packages/adapters/hono/src/index.ts

@@ -1,6 +1,6 @@
 import { Hono } from 'hono';
 import { cors } from 'hono/cors';
-import { type ObjectKernel } from '@objectstack/runtime';
+import { type ObjectKernel, HttpDispatcher } from '@objectstack/runtime';
 
 export interface ObjectStackHonoOptions {
   kernel: ObjectKernel;
@@ -15,6 +15,7 @@ export function createHonoApp(options: ObjectStackHonoOptions) {
   const app = new Hono();
   const { prefix = '/api' } = options;
   const kernel = options.kernel as any;
+  const dispatcher = new HttpDispatcher(options.kernel);
 
   app.use('*', cors());
 
@@ -43,60 +44,37 @@ export function createHonoApp(options: ObjectStackHonoOptions) {
 
   // --- 0. Discovery Endpoint ---
   app.get(prefix, (c) => {
-    // Check capabilities based on registered services
-    const services = (kernel as any).services || {};
-    const hasGraphQL = !!(services['graphql'] || (kernel as any).graphql); // Kernel often has direct graphql support
-    const hasSearch = !!services['search'];
-    const hasWebSockets = !!services['realtime'];
-    const hasFiles = !!(services['file-storage'] || services['storage']?.supportsFiles);
-
-    return c.json({
-      name: 'ObjectOS',
-      version: '1.0.0',
-      environment: process.env.NODE_ENV || 'development',
-      routes: {
-        data: `${prefix}/data`,
-        metadata: `${prefix}/metadata`,
-        auth: `${prefix}/auth`,
-        graphql: hasGraphQL ? `${prefix}/graphql` : undefined,
-        storage: hasFiles ? `${prefix}/storage` : undefined,
-      },
-      features: {
-        graphql: hasGraphQL,
-        search: hasSearch,
-        websockets: hasWebSockets,
-        files: hasFiles,
-      },
-    });
+    return c.json(dispatcher.getDiscoveryInfo(prefix));
   });
 
   // --- 1. Auth (Generic Auth Handler) ---
   app.all(`${prefix}/auth/*`, async (c) => {
-    // 1. Try to use generic Auth Service if available
-    const authService = (kernel as any).getService?.('auth') || (kernel as any).services?.['auth'];
-    if (authService && authService.handler) {
-      return authService.handler(c.req.raw);
-    }
-
-    // 2. Fallback to Legacy Auth Spec (only for login)
-    if (c.req.path.endsWith('/login') && c.req.method === 'POST') {
-      return errorHandler(c, async () => {
-        const body = await c.req.json();
-        const data = await kernel.broker.call('auth.login', body, { request: c.req.raw });
-        return c.json(data);
-      });
+    // subpath from /api/auth/login -> login
+    const path = c.req.path.substring(c.req.path.indexOf('/auth/') + 6);
+    
+    try {
+      const result = await dispatcher.handleAuth(path, c.req.method, await c.req.parseBody().catch(() => ({})), { request: c.req.raw });
+      
+      if (result.handled) {
+        if (result.response) {
+             return c.json(result.response.body, result.response.status as any, result.response.headers);
+        }
+        if (result.result) {
+             // If handler returns a response object
+             return result.result;
+        }
+      }
+      return c.json({ success: false, error: { message: 'Auth provider not configured', code: 404 } }, 404);
+    } catch (err: any) {
+      return c.json({ success: false, error: { message: err.message, code: err.statusCode || 500 } }, err.statusCode || 500);
     }
-
-    return c.json({ success: false, error: { message: 'Auth provider not configured', code: 404 } }, 404);
   });
 
   // --- 2. GraphQL ---
   app.post(`${prefix}/graphql`, async (c) => {
     return errorHandler(c, async () => {
-      const { query, variables } = await c.req.json();
-      const result = await kernel.graphql(query, variables, {
-        request: c.req.raw,
-      });
+      const body = await c.req.json();
+      const result = await dispatcher.handleGraphQL(body, { request: c.req.raw });
       return c.json(result);
     });
   });

packages/adapters/nestjs/src/index.ts

@@ -14,18 +14,22 @@ export const ConnectReq = createParamDecorator(
 
 @Injectable()
 export class ObjectStackService {
-  constructor(@Inject(OBJECT_KERNEL) private readonly kernel: any) {}
+  public dispatcher: HttpDispatcher;
 
-  getKernel() {
-    return this.kernel;
+  constructor(@Inject(OBJECT_KERNEL) private readonly kernel: ObjectKernel) {
+    this.dispatcher = new HttpDispatcher(kernel);
   }
 
-  async executeGraphQL(query: string, variables: any, request: any) {
-    return this.kernel.graphql(query, variables, { request });
+  getKernel() {
+    return this.kernel;
   }
 
   async call(action: string, params: any, request: any) {
-    return this.kernel.broker.call(action, params, { request });
+    const k = this.kernel as any;
+    if (k.broker) {
+        return k.broker.call(action, params, { request });
+    }
+    throw new Error('Kernel Broker not available');
   }
 }
 
@@ -42,66 +46,57 @@ export class ObjectStackController {
   // --- Discovery Endpoint ---
   @Get()
   discovery() {
-    const prefix = '/api'; // NestJS controller is mapped to 'api'
-    const kernel = this.service.getKernel() as any;
-    const services = kernel.services || {};
-    const hasGraphQL = !!(services['graphql'] || kernel.graphql);
-    // NestJS adapter doesn't expose services map directly but we have access to kernel
-    // We can try to guess or use safe default
-    
-    return {
-      name: 'ObjectOS',
-      version: '1.0.0',
-      environment: process.env.NODE_ENV || 'development',
-      routes: {
-        data: `${prefix}/data`,
-        metadata: `${prefix}/metadata`,
-        auth: `${prefix}/auth`,
-        graphql: hasGraphQL ? `${prefix}/graphql` : undefined,
-        storage: `${prefix}/storage`, // NestJS implementation below
-      },
-      features: {
-        graphql: hasGraphQL,
-        search: false,
-        websockets: false, // NestJS Gateway is separate usually
-        files: true, // Implemented below
-      },
-    };
+    return this.service.dispatcher.getDiscoveryInfo('/api');
   }
 
   @Post('graphql')
   async graphql(@Body() body: any, @Req() req: any) {
-    const { query, variables } = body;
-    return this.service.executeGraphQL(query, variables, req);
+    return this.service.dispatcher.handleGraphQL(body, { request: req });
   }
 
   // Auth (Generic Auth Handler)
   @All('auth/*')
   async auth(@Req() req: any, @Res() res: any, @Body() body: any) {
-    const kernel = this.service.getKernel() as any;
-    const authService = kernel.getService?.('auth') || kernel.services?.['auth'];
-    
-    if (authService && authService.handler) {
-       const response = await authService.handler(req, res);
-       
-       if (response instanceof Response) {
-           res.status(response.status);
-           response.headers.forEach((v, k) => res.setHeader(k, v));
-           const text = await response.text();
-           res.send(text);
-           return;
-       }
-       
-       return response;
-    }
-    
-    // Fallback: Legacy login
-    if (req.path.endsWith('/login') && req.method === 'POST') {
-       const result = await this.service.call('auth.login', body, req);
-       return res.json(result);
+    try {
+        const path = req.params[0] || req.url.split('/auth/')[1]?.split('?')[0] || '';
+
+        const result = await this.service.dispatcher.handleAuth(path, req.method, body, { request: req, response: res });
+        
+        if (result.handled) {
+            if (result.response) {
+                 res.status(result.response.status);
+                 if (result.response.headers) {
+                     Object.entries(result.response.headers).forEach(([k, v]) => res.setHeader(k, v));
+                 }
+                 return res.json(result.response.body);
+            }
+            if (result.result) {
+               const response = result.result;
+               // If response is a standard Response object
+               if (response && typeof response.status === 'number' && typeof response.text === 'function') {
+                    res.status(response.status);
+                    if (response.headers && typeof response.headers.forEach === 'function') {
+                        response.headers.forEach((v: string, k: string) => res.setHeader(k, v));
+                    }
+                    const text = await response.text();
+                    res.send(text);
+                    return;
+               }
+               return res.status(200).json(response);
+            }
+        }
+        
+        return res.status(404).json({ success: false, error: { message: 'Auth provider not configured', code: 404 } });
+        
+    } catch (err: any) {
+        return res.status(err.statusCode || 500).json({ 
+            success: false, 
+            error: { 
+                message: err.message || 'Internal Server Error', 
+                code: err.statusCode || 500
+            } 
+        });
     }
-    
-    return res.status(404).json({ success: false, error: { message: 'Auth provider not configured', code: 404 } });
   }
 
   // Metadata

packages/adapters/nextjs/src/index.ts

@@ -1,5 +1,5 @@
 import { NextRequest, NextResponse } from 'next/server';
-import { type ObjectKernel } from '@objectstack/runtime';
+import { type ObjectKernel, HttpDispatcher } from '@objectstack/runtime';
 
 export interface NextAdapterOptions {
   kernel: ObjectKernel;
@@ -12,85 +12,46 @@ export interface NextAdapterOptions {
  */
 export function createRouteHandler(options: NextAdapterOptions) {
   const kernel = options.kernel as any;
+  const dispatcher = new HttpDispatcher(options.kernel);
 
   const success = (data: any, meta?: any) => NextResponse.json({ success: true, data, meta });
   const error = (msg: string, code: number = 500) => NextResponse.json({ success: false, error: { message: msg, code } }, { status: code });
 
   return async function handler(req: NextRequest, { params }: { params: { objectstack: string[] } }) {
-    const segments = params.objectstack || [];
+    const resolvedParams = await Promise.resolve(params);
+    const segments = resolvedParams.objectstack || [];
     const method = req.method;
 
-    // Parse path: /api/...segments...
-    // e.g., /api/graphql
-    // /api/metadata
-    // /api/data/contacts/query
-
     // --- 0. Discovery Endpoint ---
     if (segments.length === 0 && method === 'GET') {
-      const prefix = options.prefix || '/api';
-      const services = (kernel as any).services || {};
-      const hasGraphQL = !!(services['graphql'] || (kernel as any).graphql);
-      const hasSearch = !!services['search'];
-      const hasWebSockets = !!services['realtime'];
-      const hasFiles = !!(services['file-storage'] || services['storage']?.supportsFiles);
-
-      return NextResponse.json({
-        name: 'ObjectOS',
-        version: '1.0.0',
-        environment: process.env.NODE_ENV || 'development',
-        routes: {
-          data: `${prefix}/data`,
-          metadata: `${prefix}/metadata`,
-          auth: `${prefix}/auth`,
-          graphql: hasGraphQL ? `${prefix}/graphql` : undefined,
-          storage: hasFiles ? `${prefix}/storage` : undefined,
-        },
-        features: {
-          graphql: hasGraphQL,
-          search: hasSearch,
-          websockets: hasWebSockets,
-          files: hasFiles,
-        },
-      });
+      return NextResponse.json(dispatcher.getDiscoveryInfo(options.prefix || '/api'));
     }
 
     // --- 1. Auth (Generic Auth Handler) ---
     if (segments[0] === 'auth') {
-       const authService = (kernel as any).getService?.('auth') || (kernel as any).services?.['auth'];
-       if (authService && authService.handler) {
-          return authService.handler(req);
-       }
-       
-       // Fallback for /api/auth/login
-       if (segments[1] === 'login' && method === 'POST') {
-          try {
-             // Clone request body because it might be consumed by handler above? No, we checked availability.
-             const body = await req.json();
-             const data = await kernel.broker.call('auth.login', body, { request: req });
-             return NextResponse.json(data);
-          } catch (e: any) {
-             return error(e.message, e.statusCode || 500);
-          }
+       const subPath = segments.slice(1).join('/');
+       try {
+           const body = method === 'POST' ? await req.json().catch(() => ({})) : {};
+           const result = await dispatcher.handleAuth(subPath, method, body, { request: req });
+           if (result.handled) {
+                if (result.response) {
+                    return NextResponse.json(result.response.body, { status: result.response.status });
+                }
+                if (result.result) return result.result;
+           }
+           return error('Auth provider not configured', 404);
+       } catch (e: any) {
+           return error(e.message, e.statusCode || 500);
        }
-       return error('Auth provider not configured', 404);
     }
 
     try {
         const rawRequest = req;
 
-        // 0. Auth
-        if (segments[0] === 'auth') {
-            if (segments[1] === 'login' && method === 'POST') {
-                const body = await req.json() as any;
-                const data = await kernel.broker.call('auth.login', body, { request: rawRequest });
-                return NextResponse.json(data);
-            }
-        }
-
         // 1. GraphQL
         if (segments[0] === 'graphql' && method === 'POST') {
-            const body = await req.json() as any;
-            const result = await kernel.graphql(body.query, body.variables, { request: rawRequest });
+            const body = await req.json();
+            const result = await dispatcher.handleGraphQL(body, { request: rawRequest });
             return NextResponse.json(result);
         }
 
@@ -142,7 +103,7 @@ export function createRouteHandler(options: NextAdapterOptions) {
             if (segments.length === 2 && method === 'POST') {
                 const body = await req.json();
                 const data = await kernel.broker.call('data.create', { object: objectName, data: body }, { request: rawRequest });
-                return success(data); // 201 not easy with helper, but ok
+                return success(data);
             }
 
             // GET /data/:objectName/:id