@objectstack/metadata 4.0.2 → 4.0.3

package/dist/node.cjs

@@ -1086,6 +1086,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)
    */
@@ -1098,7 +1108,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)) {
@@ -1106,10 +1118,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.
@@ -1150,7 +1181,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);
@@ -1161,6 +1193,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);
@@ -1169,6 +1202,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
@@ -2514,6 +2564,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",
@@ -2557,6 +2608,33 @@ var MetadataPlugin = class {
         totalItems: totalLoaded,
         registeredTypes: sortedTypes.length
       });
+      try {
+        const services = ctx.getServices();
+        for (const [serviceName, service] of services) {
+          if (serviceName.startsWith("driver.") && service) {
+            ctx.logger.info("[MetadataPlugin] Bridging driver to MetadataManager for database-backed persistence", {
+              driverService: serviceName
+            });
+            this.manager.setDatabaseDriver(service);
+            break;
+          }
+        }
+      } catch (e) {
+        ctx.logger.debug("[MetadataPlugin] No driver service found \u2014 database metadata persistence not available", {
+          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,