@objectstack/objectql 4.0.3 → 4.0.4

package/dist/index.mjs

@@ -696,7 +696,10 @@ var ObjectStackProtocolImplementation = class {
       const services = this.getServicesRegistry?.();
       const metadataService = services?.get("metadata");
       if (metadataService && typeof metadataService.list === "function") {
-        const runtimeItems = await metadataService.list(request.type);
+        let runtimeItems = await metadataService.list(request.type);
+        if (packageId && runtimeItems && runtimeItems.length > 0) {
+          runtimeItems = runtimeItems.filter((item) => item?._packageId === packageId);
+        }
         if (runtimeItems && runtimeItems.length > 0) {
           const itemMap = /* @__PURE__ */ new Map();
           for (const item of items) {
@@ -1515,6 +1518,10 @@ var _ObjectQL = class _ObjectQL {
   constructor(hostContext = {}) {
     this.drivers = /* @__PURE__ */ new Map();
     this.defaultDriver = null;
+    // Datasource mapping rules (imported from defineStack)
+    this.datasourceMapping = [];
+    // Package manifests registry (for defaultDatasource lookup)
+    this.manifests = /* @__PURE__ */ new Map();
     // Per-object hooks with priority support
     this.hooks = /* @__PURE__ */ new Map([
       ["beforeFind", []],
@@ -1712,6 +1719,9 @@ var _ObjectQL = class _ObjectQL {
     const id = manifest.id || manifest.name;
     const namespace = manifest.namespace;
     this.logger.debug("Registering package manifest", { id, namespace });
+    if (id) {
+      this.manifests.set(id, manifest);
+    }
     SchemaRegistry.installPackage(manifest);
     this.logger.debug("Installed Package", { id: manifest.id, name: manifest.name, namespace });
     if (manifest.objects) {
@@ -1966,27 +1976,99 @@ var _ObjectQL = class _ObjectQL {
   }
   /**
    * Helper to get the target driver
+   *
+   * Resolution priority (first match wins):
+   * 1. Object's explicit `datasource` field (if not 'default')
+   * 2. DatasourceMapping rules (namespace/package/pattern matching)
+   * 3. Package's `defaultDatasource` from manifest
+   * 4. Global default driver
    */
   getDriver(objectName) {
     const object = SchemaRegistry.getObject(objectName);
-    if (object) {
-      const datasourceName = object.datasource || "default";
-      if (datasourceName === "default") {
-        if (this.defaultDriver && this.drivers.has(this.defaultDriver)) {
-          return this.drivers.get(this.defaultDriver);
-        }
-      } else {
-        if (this.drivers.has(datasourceName)) {
-          return this.drivers.get(datasourceName);
+    if (object?.datasource && object.datasource !== "default") {
+      if (this.drivers.has(object.datasource)) {
+        return this.drivers.get(object.datasource);
+      }
+      throw new Error(`[ObjectQL] Datasource '${object.datasource}' configured for object '${objectName}' is not registered.`);
+    }
+    const mappedDatasource = this.resolveDatasourceFromMapping(objectName, object);
+    if (mappedDatasource && this.drivers.has(mappedDatasource)) {
+      this.logger.debug("Resolved datasource from mapping", {
+        object: objectName,
+        datasource: mappedDatasource
+      });
+      return this.drivers.get(mappedDatasource);
+    }
+    const fqn = object?.name || objectName;
+    const owner = SchemaRegistry.getObjectOwner(fqn);
+    if (owner?.packageId) {
+      const manifest = this.manifests.get(owner.packageId);
+      if (manifest?.defaultDatasource && manifest.defaultDatasource !== "default") {
+        if (this.drivers.has(manifest.defaultDatasource)) {
+          this.logger.debug("Resolved datasource from package manifest", {
+            object: objectName,
+            package: owner.packageId,
+            datasource: manifest.defaultDatasource
+          });
+          return this.drivers.get(manifest.defaultDatasource);
         }
-        throw new Error(`[ObjectQL] Datasource '${datasourceName}' configured for object '${objectName}' is not registered.`);
       }
     }
-    if (this.defaultDriver) {
+    if (this.defaultDriver && this.drivers.has(this.defaultDriver)) {
       return this.drivers.get(this.defaultDriver);
     }
     throw new Error(`[ObjectQL] No driver available for object '${objectName}'`);
   }
+  /**
+   * Resolve datasource from mapping rules
+   *
+   * Rules are evaluated in order (or by priority if specified).
+   * First matching rule wins.
+   */
+  resolveDatasourceFromMapping(objectName, object) {
+    if (!this.datasourceMapping || this.datasourceMapping.length === 0) {
+      return null;
+    }
+    const sortedRules = [...this.datasourceMapping].sort((a, b) => {
+      const aPriority = a.priority ?? 1e3;
+      const bPriority = b.priority ?? 1e3;
+      return aPriority - bPriority;
+    });
+    for (const rule of sortedRules) {
+      if (rule.namespace && object?.namespace === rule.namespace) {
+        return rule.datasource;
+      }
+      if (rule.package && object?.packageId === rule.package) {
+        return rule.datasource;
+      }
+      if (rule.objectPattern && this.matchPattern(objectName, rule.objectPattern)) {
+        return rule.datasource;
+      }
+      if (rule.default) {
+        return rule.datasource;
+      }
+    }
+    return null;
+  }
+  /**
+   * Simple glob pattern matching
+   * Supports * (any chars) and ? (single char)
+   */
+  matchPattern(objectName, pattern) {
+    const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(objectName);
+  }
+  /**
+   * Set datasource mapping rules
+   * Called by ObjectQLPlugin during bootstrap
+   */
+  setDatasourceMapping(rules) {
+    this.datasourceMapping = rules;
+    this.logger.info("Datasource mapping rules configured", {
+      ruleCount: rules.length
+    });
+  }
   /**
    * Initialize the engine and all registered drivers
    */