@objectstack/runtime 4.0.2 → 4.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/runtime",
-  "version": "4.0.2",
+  "version": "4.0.4",
   "license": "Apache-2.0",
   "description": "ObjectStack Core Runtime & Query Engine",
   "type": "module",
@@ -15,14 +15,14 @@
   },
   "dependencies": {
     "zod": "^4.3.6",
-    "@objectstack/core": "4.0.2",
-    "@objectstack/rest": "4.0.2",
-    "@objectstack/spec": "4.0.2",
-    "@objectstack/types": "4.0.2"
+    "@objectstack/core": "4.0.4",
+    "@objectstack/rest": "4.0.4",
+    "@objectstack/spec": "4.0.4",
+    "@objectstack/types": "4.0.4"
   },
   "devDependencies": {
     "typescript": "^6.0.2",
-    "vitest": "^4.1.2"
+    "vitest": "^4.1.4"
   },
   "scripts": {
     "build": "tsup --config ../../tsup.config.ts",

package/src/app-plugin.ts

@@ -75,6 +75,15 @@ export class AppPlugin implements Plugin {
 
         ctx.logger.debug('Retrieved ObjectQL engine service', { appId });
 
+        // Configure datasourceMapping if provided in the stack definition
+        if (this.bundle.datasourceMapping && Array.isArray(this.bundle.datasourceMapping)) {
+            ctx.logger.info('Configuring datasource mapping rules', {
+                appId,
+                ruleCount: this.bundle.datasourceMapping.length
+            });
+            ql.setDatasourceMapping(this.bundle.datasourceMapping);
+        }
+
         const runtime = this.bundle.default || this.bundle;
         
         if (runtime && typeof runtime.onEnable === 'function') {

package/src/dispatcher-plugin.ts

@@ -22,6 +22,75 @@ interface RouteDefinition {
     handler: (req: any) => Promise<any>;
 }
 
+/**
+ * Register a single RouteDefinition on the HTTP server.
+ * Returns true if the route was successfully registered.
+ */
+function mountRouteOnServer(route: RouteDefinition, server: IHttpServer, routePath: string): boolean {
+    const handler = async (req: any, res: any) => {
+        try {
+            const result = await route.handler({
+                body: req.body,
+                params: req.params,
+                query: req.query,
+            });
+
+            if (result.stream && result.events) {
+                // SSE streaming response
+                res.status(result.status);
+
+                // Apply headers from the route result if available
+                if (result.headers) {
+                    for (const [k, v] of Object.entries(result.headers)) {
+                        res.header(k, String(v));
+                    }
+                } else {
+                    res.header('Content-Type', 'text/event-stream');
+                    res.header('Cache-Control', 'no-cache');
+                    res.header('Connection', 'keep-alive');
+                }
+
+                // Write the stream — events are pre-encoded SSE strings
+                if (typeof res.write === 'function' && typeof res.end === 'function') {
+                    for await (const event of result.events) {
+                        res.write(typeof event === 'string' ? event : `data: ${JSON.stringify(event)}\n\n`);
+                    }
+                    res.end();
+                } else {
+                    // Fallback: collect events into array
+                    const events = [];
+                    for await (const event of result.events) {
+                        events.push(event);
+                    }
+                    res.json({ events });
+                }
+            } else {
+                res.status(result.status);
+                if (result.body !== undefined) {
+                    res.json(result.body);
+                } else {
+                    res.end();
+                }
+            }
+        } catch (err: any) {
+            errorResponse(err, res);
+        }
+    };
+
+    const m = route.method.toLowerCase();
+    if (m === 'get' && typeof server.get === 'function') {
+        server.get(routePath, handler);
+        return true;
+    } else if (m === 'post' && typeof server.post === 'function') {
+        server.post(routePath, handler);
+        return true;
+    } else if (m === 'delete' && typeof server.delete === 'function') {
+        server.delete(routePath, handler);
+        return true;
+    }
+    return false;
+}
+
 /**
  * Send an HttpDispatcherResult through IHttpResponse.
  * Differentiates between handled, unhandled (404), and special results.
@@ -402,68 +471,33 @@ export function createDispatcherPlugin(config: DispatcherPluginConfig = {}): Plu
                     const routePath = route.path.startsWith('/api/v1')
                         ? route.path
                         : `${prefix}${route.path}`;
-
-                    const handler = async (req: any, res: any) => {
-                        try {
-                            const result = await route.handler({
-                                body: req.body,
-                                params: req.params,
-                                query: req.query,
-                            });
-
-                            if (result.stream && result.events) {
-                                // SSE streaming response
-                                res.status(result.status);
-
-                                // Apply headers from the route result if available
-                                if (result.headers) {
-                                    for (const [k, v] of Object.entries(result.headers)) {
-                                        res.header(k, v);
-                                    }
-                                } else {
-                                    res.header('Content-Type', 'text/event-stream');
-                                    res.header('Cache-Control', 'no-cache');
-                                    res.header('Connection', 'keep-alive');
-                                }
-
-                                // Write the stream — events are pre-encoded SSE strings
-                                if (typeof res.write === 'function' && typeof res.end === 'function') {
-                                    for await (const event of result.events) {
-                                        res.write(typeof event === 'string' ? event : `data: ${JSON.stringify(event)}\n\n`);
-                                    }
-                                    res.end();
-                                } else {
-                                    // Fallback: collect events into array
-                                    const events = [];
-                                    for await (const event of result.events) {
-                                        events.push(event);
-                                    }
-                                    res.json({ events });
-                                }
-                            } else {
-                                res.status(result.status);
-                                if (result.body !== undefined) {
-                                    res.json(result.body);
-                                } else {
-                                    res.end();
-                                }
-                            }
-                        } catch (err: any) {
-                            errorResponse(err, res);
-                        }
-                    };
-
-                    const m = route.method.toLowerCase();
-                    if (m === 'get' && typeof server.get === 'function') {
-                        server.get(routePath, handler);
-                    } else if (m === 'post' && typeof server.post === 'function') {
-                        server.post(routePath, handler);
-                    } else if (m === 'delete' && typeof server.delete === 'function') {
-                        server.delete(routePath, handler);
-                    }
+                    mountRouteOnServer(route, server, routePath);
                 }
                 ctx.logger.info(`[Dispatcher] Registered ${routes.length} AI routes`);
             });
+
+            // ── Fallback: recover routes cached before hook was registered ──
+            // If AIServicePlugin.start() ran before DispatcherPlugin.start()
+            // (possible when plugin start order differs from registration order),
+            // the 'ai:routes' trigger fires with no listener. The AIServicePlugin
+            // caches the routes on the kernel as __aiRoutes (see AIServicePlugin.start())
+            // as an internal cross-plugin protocol so we can recover them here.
+            // TODO: replace with a formal kernel.getCachedRoutes('ai') API in a future release.
+            const cachedRoutes = (kernel as any).__aiRoutes as RouteDefinition[] | undefined;
+            if (cachedRoutes && Array.isArray(cachedRoutes) && cachedRoutes.length > 0) {
+                let registered = 0;
+                for (const route of cachedRoutes) {
+                    const routePath = route.path.startsWith('/api/v1')
+                        ? route.path
+                        : `${prefix}${route.path}`;
+                    if (mountRouteOnServer(route, server, routePath)) {
+                        registered++;
+                    }
+                }
+                if (registered > 0) {
+                    ctx.logger.info(`[Dispatcher] Recovered ${registered} cached AI routes (hook timing fallback)`);
+                }
+            }
         },
     };
 }

package/src/http-dispatcher.root.test.ts

@@ -11,9 +11,6 @@ describe('HttpDispatcher Root Handling', () => {
         // Mock minimal Kernel structure
         kernel = {
             services: {},
-            broker: {
-                call: vi.fn(),
-            },
             context: {
                 getService: vi.fn(),
             }