@objectstack/runtime 4.0.2 → 4.0.3

package/dist/index.js

@@ -781,6 +781,7 @@ var AppPlugin = class {
 // src/http-dispatcher.ts
 import { getEnv, resolveLocale } from "@objectstack/core";
 import { CoreServiceName } from "@objectstack/spec/system";
+import { pluralToSingular } from "@objectstack/spec/shared";
 function randomUUID() {
   if (globalThis.crypto && typeof globalThis.crypto.randomUUID === "function") {
     return globalThis.crypto.randomUUID();
@@ -1065,18 +1066,66 @@ var HttpDispatcher = class {
     const broker = this.kernel.broker ?? null;
     const parts = path.replace(/^\/+/, "").split("/").filter(Boolean);
     if (parts[0] === "types") {
+      console.log("[HttpDispatcher] Attempting to resolve MetadataService...");
+      console.log("[HttpDispatcher] Available kernel methods:", {
+        hasGetServiceAsync: typeof this.kernel.getServiceAsync === "function",
+        hasGetService: typeof this.kernel.getService === "function",
+        hasContext: !!this.kernel.context,
+        hasContextGetService: typeof this.kernel.context?.getService === "function"
+      });
+      let metadataService = null;
+      if (typeof this.kernel.getServiceAsync === "function") {
+        try {
+          metadataService = await this.kernel.getServiceAsync("metadata");
+          console.log('[HttpDispatcher] kernel.getServiceAsync("metadata") returned:', !!metadataService);
+        } catch (e) {
+          console.log('[HttpDispatcher] kernel.getServiceAsync("metadata") failed:', e.message);
+        }
+      }
+      if (!metadataService && typeof this.kernel.getService === "function") {
+        try {
+          metadataService = await this.kernel.getService("metadata");
+          console.log('[HttpDispatcher] kernel.getService("metadata") returned:', !!metadataService);
+        } catch (e) {
+          console.log('[HttpDispatcher] kernel.getService("metadata") failed:', e.message);
+        }
+      }
+      if (!metadataService && this.kernel.context?.getService) {
+        try {
+          metadataService = await this.kernel.context.getService("metadata");
+          console.log('[HttpDispatcher] kernel.context.getService("metadata") returned:', !!metadataService);
+        } catch (e) {
+          console.log('[HttpDispatcher] kernel.context.getService("metadata") failed:', e.message);
+        }
+      }
+      console.log("[HttpDispatcher] Final metadataService:", !!metadataService, "has getRegisteredTypes:", typeof metadataService?.getRegisteredTypes);
+      if (metadataService && typeof metadataService.getRegisteredTypes === "function") {
+        try {
+          const types = await metadataService.getRegisteredTypes();
+          console.log("[HttpDispatcher] MetadataService.getRegisteredTypes() returned:", types);
+          return { handled: true, response: this.success({ types }) };
+        } catch (e) {
+          console.warn("[HttpDispatcher] MetadataService.getRegisteredTypes() failed:", e.message, e.stack);
+        }
+      } else {
+        console.log("[HttpDispatcher] MetadataService not available or missing getRegisteredTypes, falling back to protocol service");
+      }
       const protocol = await this.resolveService("protocol");
       if (protocol && typeof protocol.getMetaTypes === "function") {
         const result = await protocol.getMetaTypes({});
+        console.log("[HttpDispatcher] Protocol service returned types:", result);
         return { handled: true, response: this.success(result) };
       }
       if (broker) {
         try {
           const data = await broker.call("metadata.types", {}, { request: context.request });
+          console.log("[HttpDispatcher] Broker returned types:", data);
           return { handled: true, response: this.success(data) };
-        } catch {
+        } catch (e) {
+          console.log("[HttpDispatcher] Broker call failed:", e);
         }
       }
+      console.warn("[HttpDispatcher] Falling back to hardcoded defaults for metadata types");
       return { handled: true, response: this.success({ types: ["object", "app", "plugin"] }) };
     }
     if (parts.length === 3 && parts[2] === "published" && (!method || method === "GET")) {
@@ -1133,7 +1182,7 @@ var HttpDispatcher = class {
           }
           return { handled: true, response: this.error("Not found", 404) };
         }
-        const singularType = type.endsWith("s") ? type.slice(0, -1) : type;
+        const singularType = pluralToSingular(type);
         const protocol = await this.resolveService("protocol");
         if (protocol && typeof protocol.getMetaItem === "function") {
           try {
@@ -1165,6 +1214,18 @@ var HttpDispatcher = class {
         } catch {
         }
       }
+      const metadataService = await this.getService(CoreServiceName.enum.metadata);
+      if (metadataService && typeof metadataService.list === "function") {
+        try {
+          const items = await metadataService.list(typeOrName);
+          if (items && items.length > 0) {
+            return { handled: true, response: this.success({ type: typeOrName, items }) };
+          }
+        } catch (e) {
+          const sanitizedType = String(typeOrName).replace(/[\r\n\t]/g, "");
+          console.debug(`[HttpDispatcher] MetadataService.list() failed for type:`, sanitizedType, "error:", e.message);
+        }
+      }
       if (broker) {
         try {
           if (typeOrName === "objects") {
@@ -1931,6 +1992,64 @@ var HttpDispatcher = class {
 };
 
 // src/dispatcher-plugin.ts
+function mountRouteOnServer(route, server, routePath) {
+  const handler = async (req, res) => {
+    try {
+      const result = await route.handler({
+        body: req.body,
+        params: req.params,
+        query: req.query
+      });
+      if (result.stream && result.events) {
+        res.status(result.status);
+        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");
+        }
+        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)}
+
+`);
+          }
+          res.end();
+        } else {
+          const events = [];
+          for await (const event of result.events) {
+            events.push(event);
+          }
+          res.json({ events });
+        }
+      } else {
+        res.status(result.status);
+        if (result.body !== void 0) {
+          res.json(result.body);
+        } else {
+          res.end();
+        }
+      }
+    } catch (err) {
+      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;
+}
 function sendResult(result, res) {
   if (result.handled) {
     if (result.response) {
@@ -2225,61 +2344,23 @@ function createDispatcherPlugin(config = {}) {
         if (!server) return;
         for (const route of routes) {
           const routePath = route.path.startsWith("/api/v1") ? route.path : `${prefix}${route.path}`;
-          const handler = async (req, res) => {
-            try {
-              const result = await route.handler({
-                body: req.body,
-                params: req.params,
-                query: req.query
-              });
-              if (result.stream && result.events) {
-                res.status(result.status);
-                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");
-                }
-                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)}
-
-`);
-                  }
-                  res.end();
-                } else {
-                  const events = [];
-                  for await (const event of result.events) {
-                    events.push(event);
-                  }
-                  res.json({ events });
-                }
-              } else {
-                res.status(result.status);
-                if (result.body !== void 0) {
-                  res.json(result.body);
-                } else {
-                  res.end();
-                }
-              }
-            } catch (err) {
-              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`);
       });
+      const cachedRoutes = kernel.__aiRoutes;
+      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)`);
+        }
+      }
     }
   };
 }