@objectstack/metadata 4.1.1 → 4.2.0

package/dist/node.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,155 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/routes/hmr-routes.ts
+var hmr_routes_exports = {};
+__export(hmr_routes_exports, {
+  registerMetadataHmrRoutes: () => registerMetadataHmrRoutes
+});
+function registerMetadataHmrRoutes(app, manager, options = {}) {
+  const routePath = options.path ?? "/api/v1/dev/metadata-events";
+  const listeners = /* @__PURE__ */ new Set();
+  const broadcast = (evt) => {
+    for (const l of listeners) {
+      try {
+        l(evt);
+      } catch {
+      }
+    }
+  };
+  let fsHookInstalled = false;
+  const installFsHooks = async () => {
+    if (fsHookInstalled) return;
+    const mgr = manager;
+    if (typeof mgr.subscribe !== "function") {
+      fsHookInstalled = true;
+      return;
+    }
+    const types = await manager.getRegisteredTypes();
+    for (const type of types) {
+      mgr.subscribe(type, (evt) => {
+        const ts = typeof evt.timestamp === "string" ? Date.parse(evt.timestamp) : evt.timestamp ?? Date.now();
+        broadcast({
+          kind: "metadata-change",
+          type: evt.type ?? "changed",
+          metadataType: evt.metadataType ?? type,
+          name: evt.name ?? "",
+          path: evt.path,
+          timestamp: Number.isFinite(ts) ? ts : Date.now()
+        });
+      });
+    }
+    fsHookInstalled = true;
+  };
+  installFsHooks().catch(() => {
+  });
+  let onPostReload = null;
+  app.get(routePath, async (c) => {
+    await installFsHooks().catch(() => {
+    });
+    const types = await manager.getRegisteredTypes().catch(() => []);
+    const stream = new ReadableStream({
+      async start(controller) {
+        const enc = new TextEncoder();
+        let closed = false;
+        const safeEnqueue = (chunk) => {
+          if (closed) return;
+          try {
+            controller.enqueue(enc.encode(chunk));
+          } catch {
+            closed = true;
+          }
+        };
+        const listener = (evt) => {
+          if (closed) return;
+          const eventName = evt.kind === "reload" ? "reload" : "metadata-change";
+          safeEnqueue(`event: ${eventName}
+data: ${JSON.stringify(evt)}
+
+`);
+        };
+        listeners.add(listener);
+        safeEnqueue(`event: ready
+data: ${JSON.stringify({ types, timestamp: Date.now() })}
+
+`);
+        const heartbeat = setInterval(() => {
+          safeEnqueue(`: ping ${Date.now()}
+
+`);
+        }, 15e3);
+        const cleanup = () => {
+          if (closed) return;
+          closed = true;
+          clearInterval(heartbeat);
+          listeners.delete(listener);
+          try {
+            controller.close();
+          } catch {
+          }
+        };
+        const signal = c.req?.raw?.signal;
+        if (signal) {
+          if (signal.aborted) cleanup();
+          else signal.addEventListener("abort", cleanup, { once: true });
+        }
+      }
+    });
+    return new Response(stream, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream; charset=utf-8",
+        "Cache-Control": "no-cache, no-transform",
+        "Connection": "keep-alive",
+        "X-Accel-Buffering": "no"
+      }
+    });
+  });
+  app.post(routePath, async (c) => {
+    let body = {};
+    try {
+      const ct = c.req?.header?.("content-type") ?? "";
+      if (typeof c.req?.json === "function" && ct.includes("json")) {
+        body = await c.req.json();
+      }
+    } catch {
+    }
+    try {
+      if (onPostReload) await onPostReload(body);
+    } catch (e) {
+      return new Response(
+        JSON.stringify({ ok: false, error: e?.message ?? "reload handler failed" }),
+        { status: 500, headers: { "Content-Type": "application/json" } }
+      );
+    }
+    const reason = body.reason ?? "manual-trigger";
+    broadcast({
+      kind: "reload",
+      reason,
+      changed: body.changed,
+      timestamp: Date.now()
+    });
+    return new Response(
+      JSON.stringify({ ok: true, listeners: listeners.size, reason }),
+      { status: 200, headers: { "Content-Type": "application/json" } }
+    );
+  });
+  return {
+    broadcastReload(reason, changed) {
+      broadcast({ kind: "reload", reason, changed, timestamp: Date.now() });
+    },
+    setOnPostReload(fn) {
+      onPostReload = fn;
+    },
+    listenerCount: () => listeners.size
+  };
+}
+var init_hmr_routes = __esm({
+  "src/routes/hmr-routes.ts"() {
+    "use strict";
+  }
+});
+
 // src/node.ts
 var node_exports = {};
 __export(node_exports, {
@@ -1820,6 +1972,21 @@ var _MetadataManager = class _MetadataManager {
       unsubscribe: () => this.removeWatchCallback(type, wrappedCallback)
     };
   }
+  /**
+   * Subscribe to raw metadata watch events for a given type.
+   *
+   * Unlike `watchService` (which maps to the IMetadataService contract and
+   * drops fields like `path`/`timestamp`), this returns the raw
+   * `MetadataWatchEvent` produced by the underlying watcher — useful for
+   * developer-facing tooling such as the HMR SSE endpoint that wants the
+   * source file path and original timestamp.
+   *
+   * @returns An unsubscribe function.
+   */
+  subscribe(type, callback) {
+    this.addWatchCallback(type, callback);
+    return () => this.removeWatchCallback(type, callback);
+  }
   // ==========================================
   // Import / Export
   // ==========================================
@@ -2835,6 +3002,33 @@ var MetadataPlugin = class {
           error: e.message
         });
       }
+      try {
+        const httpServer = ctx.getService("http-server") ?? ctx.getService("http.server");
+        if (httpServer && typeof httpServer.getRawApp === "function") {
+          const { registerMetadataHmrRoutes: registerMetadataHmrRoutes2 } = await Promise.resolve().then(() => (init_hmr_routes(), hmr_routes_exports));
+          const hub = registerMetadataHmrRoutes2(httpServer.getRawApp(), this.manager);
+          hub.setOnPostReload(async (body = {}) => {
+            const src2 = this.options.artifactSource;
+            if (src2?.mode === "local-file") {
+              try {
+                await this._loadFromLocalFile(ctx, src2.path, src2.fetchTimeoutMs);
+                ctx.logger.info("[MetadataPlugin] artifact reloaded via HMR POST", {
+                  path: src2.path,
+                  reason: body?.reason
+                });
+              } catch (e) {
+                ctx.logger.warn("[MetadataPlugin] artifact reload failed", { error: e?.message });
+                throw e;
+              }
+            }
+          });
+          console.log("[MetadataPlugin] HMR endpoint registered at /api/v1/dev/metadata-events");
+        } else {
+          console.log("[MetadataPlugin] HTTP server with getRawApp() not available \u2014 skipping HMR endpoint");
+        }
+      } catch (e) {
+        console.warn("[MetadataPlugin] Failed to register HMR endpoint", e?.message);
+      }
     };
     this.options = {
       watch: true,