@objectstack/metadata 4.0.2 → 4.0.4

package/README.md

@@ -28,7 +28,7 @@ It implements the **`IMetadataService`** contract from `@objectstack/spec` and a
 │  │ (files)      │  │   (HTTP)     │  │   (test)          │  │
 │  └─────────────┘  └──────────────┘  └───────────────────┘  │
 │  ┌──────────────────────────────────────────────────────┐   │
-│  │ DatabaseLoader (planned — datasource-backed storage) │   │
+│  │ DatabaseLoader (datasource-backed storage)          │   │
 │  └──────────────────────────────────────────────────────┘   │
 ├─────────────────────────────────────────────────────────────┤
 │                    Serializer Layer                          │
@@ -61,7 +61,7 @@ Loaders are pluggable data sources that know how to read/write metadata from dif
 | `FilesystemLoader`  | `file:`        | ✅   | ✅    | ✅    | Implemented  |
 | `MemoryLoader`      | `memory:`      | ✅   | ✅    | ❌    | Implemented  |
 | `RemoteLoader`      | `http:`        | ✅   | ✅    | ❌    | Implemented  |
-| `DatabaseLoader`    | `datasource:`  | ✅   | ✅    | ✅    | Planned      |
+| `DatabaseLoader`    | `datasource:`  | ✅   | ✅    | ❌    | Implemented  |
 
 ### 3. Serializers
 

package/dist/index.cjs

@@ -1084,6 +1084,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)
    */
@@ -1096,7 +1106,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)) {
@@ -1104,10 +1116,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.
@@ -1148,7 +1179,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);
@@ -1159,6 +1191,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);
@@ -1167,6 +1200,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
@@ -2512,6 +2562,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",
@@ -2555,6 +2606,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,