@objectstack/metadata 4.0.2 → 4.0.4

package/dist/node.js

@@ -1039,6 +1039,16 @@ var MetadataManager = class {
     this.registerLoader(dbLoader);
     this.logger.info("DatabaseLoader configured", { datasource: this.config.datasource, tableName });
   }
+  /**
+   * Set the realtime service for publishing metadata change events.
+   * Should be called after kernel resolves the realtime service.
+   *
+   * @param service - An IRealtimeService instance for event publishing
+   */
+  setRealtimeService(service) {
+    this.realtimeService = service;
+    this.logger.info("RealtimeService configured for metadata events");
+  }
   /**
    * Register a new metadata loader (data source)
    */
@@ -1051,7 +1061,9 @@ var MetadataManager = class {
   // ==========================================
   /**
    * Register/save a metadata item by type
-   * Stores in-memory registry and persists to writable loaders (if configured)
+   * Stores in-memory registry and persists to database-backed loaders only.
+   * FilesystemLoader (protocol 'file:') is read-only for static metadata and
+   * should not be written to during runtime registration.
    */
   async register(type, name, data) {
     if (!this.registry.has(type)) {
@@ -1059,10 +1071,29 @@ var MetadataManager = class {
     }
     this.registry.get(type).set(name, data);
     for (const loader of this.loaders.values()) {
-      if (loader.save) {
+      if (loader.save && loader.contract.protocol === "datasource:" && loader.contract.capabilities.write) {
         await loader.save(type, name, data);
       }
     }
+    if (this.realtimeService) {
+      const event = {
+        type: `metadata.${type}.created`,
+        object: type,
+        payload: {
+          metadataType: type,
+          name,
+          definition: data,
+          packageId: data?.packageId
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      try {
+        await this.realtimeService.publish(event);
+        this.logger.debug(`Published metadata.${type}.created event`, { name });
+      } catch (error) {
+        this.logger.warn(`Failed to publish metadata event`, { type, name, error });
+      }
+    }
   }
   /**
    * Get a metadata item by type and name.
@@ -1103,7 +1134,8 @@ var MetadataManager = class {
     return Array.from(items.values());
   }
   /**
-   * Unregister/remove a metadata item by type and name
+   * Unregister/remove a metadata item by type and name.
+   * Deletes from database-backed loaders only (same rationale as register()).
    */
   async unregister(type, name) {
     const typeStore = this.registry.get(type);
@@ -1114,6 +1146,7 @@ var MetadataManager = class {
       }
     }
     for (const loader of this.loaders.values()) {
+      if (loader.contract.protocol !== "datasource:" || !loader.contract.capabilities.write) continue;
       if (typeof loader.delete === "function") {
         try {
           await loader.delete(type, name);
@@ -1122,6 +1155,23 @@ var MetadataManager = class {
         }
       }
     }
+    if (this.realtimeService) {
+      const event = {
+        type: `metadata.${type}.deleted`,
+        object: type,
+        payload: {
+          metadataType: type,
+          name
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      try {
+        await this.realtimeService.publish(event);
+        this.logger.debug(`Published metadata.${type}.deleted event`, { name });
+      } catch (error) {
+        this.logger.warn(`Failed to publish metadata event`, { type, name, error });
+      }
+    }
   }
   /**
    * Check if a metadata item exists
@@ -2467,6 +2517,7 @@ var MetadataPlugin = class {
         watch: this.options.watch
       });
       ctx.registerService("metadata", this.manager);
+      console.log("[MetadataPlugin] Registered metadata service, has getRegisteredTypes:", typeof this.manager.getRegisteredTypes);
       try {
         ctx.getService("manifest").register({
           id: "com.objectstack.metadata",
@@ -2510,6 +2561,52 @@ var MetadataPlugin = class {
         totalItems: totalLoaded,
         registeredTypes: sortedTypes.length
       });
+      let driverBridged = false;
+      try {
+        const ql = ctx.getService("objectql");
+        if (ql) {
+          const tableName = this.manager["config"]?.tableName ?? "sys_metadata";
+          const driver = ql.getDriverForObject?.(tableName);
+          if (driver) {
+            ctx.logger.info("[MetadataPlugin] Bridging driver to MetadataManager via ObjectQL routing", {
+              tableName,
+              driver: driver.name
+            });
+            this.manager.setDatabaseDriver(driver);
+            driverBridged = true;
+          } else {
+            ctx.logger.debug("[MetadataPlugin] ObjectQL could not resolve driver for metadata table", { tableName });
+          }
+        }
+      } catch {
+      }
+      if (!driverBridged) {
+        try {
+          const services = ctx.getServices();
+          for (const [serviceName, service] of services) {
+            if (serviceName.startsWith("driver.") && service) {
+              ctx.logger.info("[MetadataPlugin] Bridging driver to MetadataManager (fallback: first driver)", {
+                driverService: serviceName
+              });
+              this.manager.setDatabaseDriver(service);
+              break;
+            }
+          }
+        } catch (e) {
+          ctx.logger.debug("[MetadataPlugin] No driver service found", { error: e.message });
+        }
+      }
+      try {
+        const realtimeService = ctx.getService("realtime");
+        if (realtimeService && typeof realtimeService === "object" && "publish" in realtimeService) {
+          ctx.logger.info("[MetadataPlugin] Bridging realtime service to MetadataManager for event publishing");
+          this.manager.setRealtimeService(realtimeService);
+        }
+      } catch (e) {
+        ctx.logger.debug("[MetadataPlugin] No realtime service found \u2014 metadata events will not be published", {
+          error: e.message
+        });
+      }
     };
     this.options = {
       watch: true,