fix: resolve async factory services in dispatcher and all framework adapters

ROADMAP.md

@@ -123,7 +123,7 @@ This strategy ensures rapid iteration while maintaining a clear path to producti
 | `z.unknown()` in extensibility fields | ✅ Justified | `properties`, `children`, `context`, `options`, `body` — inherently dynamic extensibility points |
 | DashboardWidget discriminated union by type | 🔴 | Planned — chart/metric/pivot subtypes with type-specific required fields |
 | CI lint rule rejecting new `z.any()` | 🔴 | Planned — eslint or custom lint rule to block `z.any()` additions |
-| Dispatcher async `getService` bug fix | ✅ | All `getService`/`getObjectQLService` calls in `http-dispatcher.ts` now properly `await` async service factories. Covers `handleAnalytics`, `handleAuth`, `handleStorage`, `handleAutomation`, `handleMetadata`, `handleUi`, `handlePackages`. 20 new tests for async/sync/error scenarios. |
+| Dispatcher async `getService` bug fix | ✅ | All `getService`/`getObjectQLService` calls in `http-dispatcher.ts` now properly `await` async service factories. Covers `handleAnalytics`, `handleAuth`, `handleStorage`, `handleAutomation`, `handleMetadata`, `handleUi`, `handlePackages`. All 7 framework adapters (Express, Fastify, Hono, Next.js, SvelteKit, NestJS, Nuxt) updated to use `getServiceAsync()` for auth service resolution. |
 
 ---
 

packages/adapters/express/src/index.ts

@@ -81,10 +81,18 @@ export function createExpressRouter(options: ExpressAdapterOptions): Router {
       const path = (req.params as any).path;
       const method = req.method;
 
-      // Try AuthPlugin service first
-      const authService = typeof options.kernel.getService === 'function'
-        ? options.kernel.getService<AuthService>('auth')
-        : null;
+      // Try AuthPlugin service first (prefer async to support factory-based services)
+      let authService: AuthService | null = null;
+      try {
+        if (typeof options.kernel.getServiceAsync === 'function') {
+          authService = await options.kernel.getServiceAsync<AuthService>('auth');
+        } else if (typeof options.kernel.getService === 'function') {
+          authService = options.kernel.getService<AuthService>('auth');
+        }
+      } catch {
+        // Service not registered — fall through to dispatcher
+        authService = null;
+      }
 
       if (authService && typeof authService.handleRequest === 'function') {
         const protocol = req.protocol || 'http';

packages/adapters/fastify/src/index.ts

@@ -84,10 +84,18 @@ export async function objectStackPlugin(fastify: FastifyInstance, options: Fasti
       const path = request.url.substring(`${prefix}/auth/`.length).split('?')[0];
       const method = request.method;
 
-      // Try AuthPlugin service first
-      const authService = typeof options.kernel.getService === 'function'
-        ? options.kernel.getService<AuthService>('auth')
-        : null;
+      // Try AuthPlugin service first (prefer async to support factory-based services)
+      let authService: AuthService | null = null;
+      try {
+        if (typeof options.kernel.getServiceAsync === 'function') {
+          authService = await options.kernel.getServiceAsync<AuthService>('auth');
+        } else if (typeof options.kernel.getService === 'function') {
+          authService = options.kernel.getService<AuthService>('auth');
+        }
+      } catch {
+        // Service not registered — fall through to dispatcher
+        authService = null;
+      }
 
       if (authService && typeof authService.handleRequest === 'function') {
         const protocol = request.protocol || 'http';

packages/adapters/hono/src/hono.test.ts

@@ -198,6 +198,43 @@ describe('createHonoApp', () => {
       expect(res.status).toBe(200);
       expect(mockDispatcher.handleAuth).toHaveBeenCalled();
     });
+
+    it('uses kernel.getServiceAsync("auth") when available (async factory)', async () => {
+      const mockHandleRequest = vi.fn().mockResolvedValue(
+        new Response(JSON.stringify({ user: { id: '2' } }), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        }),
+      );
+      const kernelWithAsyncAuth = {
+        ...mockKernel,
+        getServiceAsync: vi.fn().mockResolvedValue({ handleRequest: mockHandleRequest }),
+      };
+      const authApp = createHonoApp({ kernel: kernelWithAsyncAuth });
+      const res = await authApp.request('/api/auth/sign-in/email', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email: 'a@b.com', password: 'pass' }),
+      });
+      expect(res.status).toBe(200);
+      expect(kernelWithAsyncAuth.getServiceAsync).toHaveBeenCalledWith('auth');
+      expect(mockHandleRequest).toHaveBeenCalled();
+    });
+
+    it('falls back to dispatcher when getServiceAsync throws (async factory error)', async () => {
+      const kernelWithFailingAsync = {
+        ...mockKernel,
+        getServiceAsync: vi.fn().mockRejectedValue(new Error("Service 'auth' not found")),
+      };
+      const authApp = createHonoApp({ kernel: kernelWithFailingAsync });
+      const res = await authApp.request('/api/auth/login', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email: 'a@b.com' }),
+      });
+      expect(res.status).toBe(200);
+      expect(mockDispatcher.handleAuth).toHaveBeenCalled();
+    });
   });
 
   describe('GraphQL Endpoint', () => {

packages/adapters/hono/src/index.ts

@@ -87,10 +87,18 @@ export function createHonoApp(options: ObjectStackHonoOptions): Hono {
       const path = c.req.path.substring(`${prefix}/auth/`.length);
       const method = c.req.method;
 
-      // Try AuthPlugin service first (preferred path)
-      const authService = typeof options.kernel.getService === 'function'
-        ? options.kernel.getService<AuthService>('auth')
-        : null;
+      // Try AuthPlugin service first (prefer async to support factory-based services)
+      let authService: AuthService | null = null;
+      try {
+        if (typeof options.kernel.getServiceAsync === 'function') {
+          authService = await options.kernel.getServiceAsync<AuthService>('auth');
+        } else if (typeof options.kernel.getService === 'function') {
+          authService = options.kernel.getService<AuthService>('auth');
+        }
+      } catch {
+        // Service not registered — fall through to dispatcher
+        authService = null;
+      }
 
       if (authService && typeof authService.handleRequest === 'function') {
         const response = await authService.handleRequest(c.req.raw);

packages/adapters/nestjs/src/index.ts

@@ -113,11 +113,19 @@ export class ObjectStackController {
   @All('auth/*')
   async auth(@Req() req: any, @Res() res: any, @Body() body: any) {
     try {
-        // Try AuthPlugin service first (preferred path)
+        // Try AuthPlugin service first (prefer async to support factory-based services)
         const kernel = this.service.getKernel();
-        const authService = typeof kernel.getService === 'function'
-          ? kernel.getService<AuthService>('auth')
-          : null;
+        let authService: AuthService | null = null;
+        try {
+          if (typeof kernel.getServiceAsync === 'function') {
+            authService = await kernel.getServiceAsync<AuthService>('auth');
+          } else if (typeof kernel.getService === 'function') {
+            authService = kernel.getService<AuthService>('auth');
+          }
+        } catch {
+          // Service not registered — fall through to legacy dispatcher
+          authService = null;
+        }
 
         if (authService && typeof authService.handleRequest === 'function') {
           // Construct a Web standard Request from the Express/Fastify request

packages/adapters/nextjs/src/index.ts

@@ -68,10 +68,18 @@ export function createRouteHandler(options: NextAdapterOptions) {
 
         // --- 1. Auth ---
         if (segments[0] === 'auth') {
-           // Try AuthPlugin service first (preferred path)
-           const authService = typeof options.kernel.getService === 'function'
-             ? options.kernel.getService<AuthService>('auth')
-             : null;
+           // Try AuthPlugin service first (prefer async to support factory-based services)
+           let authService: AuthService | null = null;
+           try {
+             if (typeof options.kernel.getServiceAsync === 'function') {
+               authService = await options.kernel.getServiceAsync<AuthService>('auth');
+             } else if (typeof options.kernel.getService === 'function') {
+               authService = options.kernel.getService<AuthService>('auth');
+             }
+           } catch {
+             // Service not registered — fall through to dispatcher
+             authService = null;
+           }
 
            if (authService && typeof authService.handleRequest === 'function') {
              const response = await authService.handleRequest(req);

packages/adapters/nextjs/src/nextjs.test.ts

@@ -213,6 +213,37 @@ describe('createRouteHandler', () => {
       expect(res.status).toBe(500);
       expect(res.body.success).toBe(false);
     });
+
+    it('uses kernel.getServiceAsync("auth") when available (async factory)', async () => {
+      const mockHandleRequest = vi.fn().mockResolvedValue(
+        new Response(JSON.stringify({ user: { id: '2' } }), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        }),
+      );
+      const kernelWithAsyncAuth = {
+        ...mockKernel,
+        getServiceAsync: vi.fn().mockResolvedValue({ handleRequest: mockHandleRequest }),
+      };
+      const handler = createRouteHandler({ kernel: kernelWithAsyncAuth });
+      const req = makeReq('http://localhost/api/auth/sign-in/email', 'POST', { email: 'a@b.com', password: 'pass' });
+      const res = await handler(req, { params: { objectstack: ['auth', 'sign-in', 'email'] } });
+      expect(res.status).toBe(200);
+      expect(kernelWithAsyncAuth.getServiceAsync).toHaveBeenCalledWith('auth');
+      expect(mockHandleRequest).toHaveBeenCalled();
+    });
+
+    it('falls back to dispatcher when getServiceAsync throws', async () => {
+      const kernelWithFailingAsync = {
+        ...mockKernel,
+        getServiceAsync: vi.fn().mockRejectedValue(new Error("Service 'auth' not found")),
+      };
+      const handler = createRouteHandler({ kernel: kernelWithFailingAsync });
+      const req = makeReq('http://localhost/api/auth/login', 'POST', { email: 'a@b.com' });
+      const res = await handler(req, { params: { objectstack: ['auth', 'login'] } });
+      expect(res.status).toBe(200);
+      expect(mockDispatcher.handleAuth).toHaveBeenCalled();
+    });
   });
 
   describe('GraphQL Endpoint', () => {

packages/adapters/nuxt/src/index.ts

@@ -104,10 +104,18 @@ export function createH3Router(options: NuxtAdapterOptions): Router {
         const path = urlPath.substring(`${prefix}/auth/`.length).split('?')[0];
         const method = event.method;
 
-        // Try AuthPlugin service first
-        const authService = typeof options.kernel.getService === 'function'
-          ? options.kernel.getService<AuthService>('auth')
-          : null;
+        // Try AuthPlugin service first (prefer async to support factory-based services)
+        let authService: AuthService | null = null;
+        try {
+          if (typeof options.kernel.getServiceAsync === 'function') {
+            authService = await options.kernel.getServiceAsync<AuthService>('auth');
+          } else if (typeof options.kernel.getService === 'function') {
+            authService = options.kernel.getService<AuthService>('auth');
+          }
+        } catch {
+          // Service not registered — fall through to dispatcher
+          authService = null;
+        }
 
         if (authService && typeof authService.handleRequest === 'function') {
           const host = event.node.req.headers.host || 'localhost';

packages/adapters/sveltekit/src/index.ts

@@ -108,10 +108,18 @@ export function createRequestHandler(options: SvelteKitAdapterOptions) {
       if (segments[0] === 'auth') {
         const subPath = segments.slice(1).join('/');
 
-        // Try AuthPlugin service first
-        const authService = typeof options.kernel.getService === 'function'
-          ? options.kernel.getService<AuthService>('auth')
-          : null;
+        // Try AuthPlugin service first (prefer async to support factory-based services)
+        let authService: AuthService | null = null;
+        try {
+          if (typeof options.kernel.getServiceAsync === 'function') {
+            authService = await options.kernel.getServiceAsync<AuthService>('auth');
+          } else if (typeof options.kernel.getService === 'function') {
+            authService = options.kernel.getService<AuthService>('auth');
+          }
+        } catch {
+          // Service not registered — fall through to dispatcher
+          authService = null;
+        }
 
         if (authService && typeof authService.handleRequest === 'function') {
           return await authService.handleRequest(request);

packages/adapters/sveltekit/src/sveltekit.test.ts

@@ -119,6 +119,37 @@ describe('createRequestHandler', () => {
       expect(kernelWithAuth.getService).toHaveBeenCalledWith('auth');
       expect(mockHandleRequest).toHaveBeenCalled();
     });
+
+    it('uses kernel.getServiceAsync("auth") when available (async factory)', async () => {
+      const mockHandleRequest = vi.fn().mockResolvedValue(
+        new Response(JSON.stringify({ user: { id: '2' } }), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        }),
+      );
+      const kernelWithAsyncAuth = {
+        ...mockKernel,
+        getServiceAsync: vi.fn().mockResolvedValue({ handleRequest: mockHandleRequest }),
+      };
+      const authHandler = createRequestHandler({ kernel: kernelWithAsyncAuth });
+      const event = makeEvent('http://localhost/api/auth/sign-in/email', 'POST', { email: 'a@b.com' });
+      const res = await authHandler(event);
+      expect(res.status).toBe(200);
+      expect(kernelWithAsyncAuth.getServiceAsync).toHaveBeenCalledWith('auth');
+      expect(mockHandleRequest).toHaveBeenCalled();
+    });
+
+    it('falls back to dispatcher when getServiceAsync throws', async () => {
+      const kernelWithFailingAsync = {
+        ...mockKernel,
+        getServiceAsync: vi.fn().mockRejectedValue(new Error("Service 'auth' not found")),
+      };
+      const authHandler = createRequestHandler({ kernel: kernelWithFailingAsync });
+      const event = makeEvent('http://localhost/api/auth/login', 'POST', { email: 'a@b.com' });
+      const res = await authHandler(event);
+      expect(res.status).toBe(200);
+      expect(mockDispatcher.handleAuth).toHaveBeenCalled();
+    });
   });
 
   describe('GraphQL', () => {