@objectstack/runtime 4.0.3 → 4.0.4

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @objectstack/runtime@4.0.3 build /home/runner/work/framework/framework/packages/runtime
+> @objectstack/runtime@4.0.4 build /home/runner/work/framework/framework/packages/runtime
 > tsup --config ../../tsup.config.ts
 
 CLI Building entry: src/index.ts
@@ -10,13 +10,13 @@
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js     98.02 KB
-ESM dist/index.js.map 212.66 KB
-ESM ⚡️ Build success in 153ms
-CJS dist/index.cjs     100.63 KB
-CJS dist/index.cjs.map 212.72 KB
-CJS ⚡️ Build success in 153ms
+CJS dist/index.cjs     97.58 KB
+CJS dist/index.cjs.map 206.05 KB
+CJS ⚡️ Build success in 196ms
+ESM dist/index.js     94.96 KB
+ESM dist/index.js.map 205.98 KB
+ESM ⚡️ Build success in 200ms
 DTS Build start
-DTS ⚡️ Build success in 3771ms
-DTS dist/index.d.ts  26.00 KB
-DTS dist/index.d.cts 26.00 KB
+DTS ⚡️ Build success in 3990ms
+DTS dist/index.d.ts  25.96 KB
+DTS dist/index.d.cts 25.96 KB

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @objectstack/runtime
 
+## 4.0.4
+
+### Patch Changes
+
+- Updated dependencies [326b66b]
+  - @objectstack/spec@4.0.4
+  - @objectstack/core@4.0.4
+  - @objectstack/rest@4.0.4
+  - @objectstack/types@4.0.4
+
 ## 4.0.3
 
 ### Patch Changes

package/dist/index.cjs

@@ -665,6 +665,13 @@ var AppPlugin = class {
         return;
       }
       ctx.logger.debug("Retrieved ObjectQL engine service", { appId });
+      if (this.bundle.datasourceMapping && Array.isArray(this.bundle.datasourceMapping)) {
+        ctx.logger.info("Configuring datasource mapping rules", {
+          appId,
+          ruleCount: this.bundle.datasourceMapping.length
+        });
+        ql.setDatasourceMapping(this.bundle.datasourceMapping);
+      }
       const runtime = this.bundle.default || this.bundle;
       if (runtime && typeof runtime.onEnable === "function") {
         ctx.logger.info("Executing runtime.onEnable", {
@@ -840,7 +847,7 @@ function randomUUID() {
   });
 }
 var HttpDispatcher = class {
-  // Casting to any to access dynamic props like broker, services, graphql
+  // Casting to any to access dynamic props like services, graphql
   constructor(kernel) {
     this.kernel = kernel;
   }
@@ -874,11 +881,73 @@ var HttpDispatcher = class {
       }
     };
   }
-  ensureBroker() {
-    if (!this.kernel.broker) {
-      throw { statusCode: 500, message: "Kernel Broker not available" };
-    }
-    return this.kernel.broker;
+  /**
+   * Direct data service dispatch — replaces broker.call('data.*').
+   * Tries protocol service first (supports expand/populate), falls back to ObjectQL.
+   */
+  async callData(action, params) {
+    const protocol = await this.resolveService("protocol");
+    const qlService = await this.getObjectQLService();
+    const ql = qlService ?? await this.resolveService("objectql");
+    if (action === "create") {
+      if (ql) {
+        const res = await ql.insert(params.object, params.data);
+        const record = { ...params.data, ...res };
+        return { object: params.object, id: record.id, record };
+      }
+      throw { statusCode: 503, message: "Data service not available" };
+    }
+    if (action === "get") {
+      if (protocol && typeof protocol.getData === "function") {
+        return await protocol.getData({ object: params.object, id: params.id, expand: params.expand, select: params.select });
+      }
+      if (ql) {
+        let all = await ql.find(params.object);
+        if (!all) all = [];
+        const match = all.find((i) => i.id === params.id);
+        return match ? { object: params.object, id: params.id, record: match } : null;
+      }
+      throw { statusCode: 503, message: "Data service not available" };
+    }
+    if (action === "update") {
+      if (ql && params.id) {
+        let all = await ql.find(params.object);
+        if (all && all.value) all = all.value;
+        if (!all) all = [];
+        const existing = all.find((i) => i.id === params.id);
+        if (!existing) throw new Error("[ObjectStack] Not Found");
+        await ql.update(params.object, params.data, { where: { id: params.id } });
+        return { object: params.object, id: params.id, record: { ...existing, ...params.data } };
+      }
+      throw { statusCode: 503, message: "Data service not available" };
+    }
+    if (action === "delete") {
+      if (ql) {
+        await ql.delete(params.object, { where: { id: params.id } });
+        return { object: params.object, id: params.id, deleted: true };
+      }
+      throw { statusCode: 503, message: "Data service not available" };
+    }
+    if (action === "query" || action === "find") {
+      if (protocol && typeof protocol.findData === "function") {
+        const query = params.query || (() => {
+          const { object, ...rest } = params;
+          return rest;
+        })();
+        return await protocol.findData({ object: params.object, query });
+      }
+      if (ql) {
+        let all = await ql.find(params.object);
+        if (!Array.isArray(all) && all && all.value) all = all.value;
+        if (!all) all = [];
+        return { object: params.object, records: all, total: all.length };
+      }
+      throw { statusCode: 503, message: "Data service not available" };
+    }
+    if (action === "batch") {
+      return { object: params.object, results: [] };
+    }
+    throw { statusCode: 400, message: `Unknown data action: ${action}` };
   }
   /**
    * Generates the discovery JSON response for the API root.
@@ -1042,18 +1111,6 @@ var HttpDispatcher = class {
       return { handled: true, result: response };
     }
     const normalizedPath = path.replace(/^\/+/, "");
-    if (normalizedPath === "login" && method.toUpperCase() === "POST") {
-      try {
-        const broker = this.ensureBroker();
-        const data = await broker.call("auth.login", body, { request: context.request });
-        return { handled: true, response: { status: 200, body: data } };
-      } catch (error) {
-        const statusCode = error?.statusCode ?? error?.status;
-        if (statusCode !== 500 || !error?.message?.includes("Broker not available")) {
-          throw error;
-        }
-      }
-    }
     return this.mockAuthFallback(normalizedPath, method, body);
   }
   /**
@@ -1109,70 +1166,23 @@ var HttpDispatcher = class {
    * Standard: /metadata/:type/:name
    * Fallback for backward compat: /metadata (all objects), /metadata/:objectName (get object)
    */
-  async handleMetadata(path, context, method, body, query) {
-    const broker = this.kernel.broker ?? null;
+  async handleMetadata(path, _context, method, body, query) {
     const parts = path.replace(/^\/+/, "").split("/").filter(Boolean);
     if (parts[0] === "types") {
-      console.log("[HttpDispatcher] Attempting to resolve MetadataService...");
-      console.log("[HttpDispatcher] Available kernel methods:", {
-        hasGetServiceAsync: typeof this.kernel.getServiceAsync === "function",
-        hasGetService: typeof this.kernel.getService === "function",
-        hasContext: !!this.kernel.context,
-        hasContextGetService: typeof this.kernel.context?.getService === "function"
-      });
-      let metadataService = null;
-      if (typeof this.kernel.getServiceAsync === "function") {
-        try {
-          metadataService = await this.kernel.getServiceAsync("metadata");
-          console.log('[HttpDispatcher] kernel.getServiceAsync("metadata") returned:', !!metadataService);
-        } catch (e) {
-          console.log('[HttpDispatcher] kernel.getServiceAsync("metadata") failed:', e.message);
-        }
-      }
-      if (!metadataService && typeof this.kernel.getService === "function") {
-        try {
-          metadataService = await this.kernel.getService("metadata");
-          console.log('[HttpDispatcher] kernel.getService("metadata") returned:', !!metadataService);
-        } catch (e) {
-          console.log('[HttpDispatcher] kernel.getService("metadata") failed:', e.message);
-        }
-      }
-      if (!metadataService && this.kernel.context?.getService) {
-        try {
-          metadataService = await this.kernel.context.getService("metadata");
-          console.log('[HttpDispatcher] kernel.context.getService("metadata") returned:', !!metadataService);
-        } catch (e) {
-          console.log('[HttpDispatcher] kernel.context.getService("metadata") failed:', e.message);
-        }
-      }
-      console.log("[HttpDispatcher] Final metadataService:", !!metadataService, "has getRegisteredTypes:", typeof metadataService?.getRegisteredTypes);
+      const metadataService = await this.resolveService("metadata");
       if (metadataService && typeof metadataService.getRegisteredTypes === "function") {
         try {
           const types = await metadataService.getRegisteredTypes();
-          console.log("[HttpDispatcher] MetadataService.getRegisteredTypes() returned:", types);
           return { handled: true, response: this.success({ types }) };
         } catch (e) {
-          console.warn("[HttpDispatcher] MetadataService.getRegisteredTypes() failed:", e.message, e.stack);
+          console.warn("[HttpDispatcher] MetadataService.getRegisteredTypes() failed:", e.message);
         }
-      } else {
-        console.log("[HttpDispatcher] MetadataService not available or missing getRegisteredTypes, falling back to protocol service");
       }
       const protocol = await this.resolveService("protocol");
       if (protocol && typeof protocol.getMetaTypes === "function") {
         const result = await protocol.getMetaTypes({});
-        console.log("[HttpDispatcher] Protocol service returned types:", result);
         return { handled: true, response: this.success(result) };
       }
-      if (broker) {
-        try {
-          const data = await broker.call("metadata.types", {}, { request: context.request });
-          console.log("[HttpDispatcher] Broker returned types:", data);
-          return { handled: true, response: this.success(data) };
-        } catch (e) {
-          console.log("[HttpDispatcher] Broker call failed:", e);
-        }
-      }
-      console.warn("[HttpDispatcher] Falling back to hardcoded defaults for metadata types");
       return { handled: true, response: this.success({ types: ["object", "app", "plugin"] }) };
     }
     if (parts.length === 3 && parts[2] === "published" && (!method || method === "GET")) {
@@ -1183,12 +1193,12 @@ var HttpDispatcher = class {
         if (data === void 0) return { handled: true, response: this.error("Not found", 404) };
         return { handled: true, response: this.success(data) };
       }
-      if (broker) {
+      const metaSvc = await this.resolveService("metadata");
+      if (metaSvc && typeof metaSvc.getPublished === "function") {
         try {
-          const data = await broker.call("metadata.getPublished", { type, name }, { request: context.request });
-          return { handled: true, response: this.success(data) };
-        } catch (e) {
-          return { handled: true, response: this.error(e.message, 404) };
+          const fallbackData = await metaSvc.getPublished(type, name);
+          if (fallbackData !== void 0) return { handled: true, response: this.success(fallbackData) };
+        } catch {
         }
       }
       return { handled: true, response: this.error("Not found", 404) };
@@ -1206,9 +1216,10 @@ var HttpDispatcher = class {
             return { handled: true, response: this.error(e.message, 400) };
           }
         }
-        if (broker) {
+        const metaSvc = await this.resolveService("metadata");
+        if (metaSvc && typeof metaSvc.saveItem === "function") {
           try {
-            const data = await broker.call("metadata.saveItem", { type, name, item: body }, { request: context.request });
+            const data = await metaSvc.saveItem(type, name, body);
             return { handled: true, response: this.success(data) };
           } catch (e) {
             return { handled: true, response: this.error(e.message || "Save not supported", 501) };
@@ -1218,10 +1229,6 @@ var HttpDispatcher = class {
       }
       try {
         if (type === "objects" || type === "object") {
-          if (broker) {
-            const data = await broker.call("metadata.getObject", { objectName: name }, { request: context.request });
-            return { handled: true, response: this.success(data) };
-          }
           const qlService = await this.getObjectQLService();
           if (qlService?.registry) {
             const data = qlService.registry.getObject(name);
@@ -1238,10 +1245,13 @@ var HttpDispatcher = class {
           } catch (e) {
           }
         }
-        if (broker) {
-          const method2 = `metadata.get${this.capitalize(singularType)}`;
-          const data = await broker.call(method2, { name }, { request: context.request });
-          return { handled: true, response: this.success(data) };
+        const metaSvc = await this.resolveService("metadata");
+        if (metaSvc && typeof metaSvc.getItem === "function") {
+          try {
+            const data = await metaSvc.getItem(singularType, name);
+            if (data) return { handled: true, response: this.success(data) };
+          } catch {
+          }
         }
         return { handled: true, response: this.error("Not found", 404) };
       } catch (e) {
@@ -1264,7 +1274,10 @@ var HttpDispatcher = class {
       const metadataService = await this.getService(import_system.CoreServiceName.enum.metadata);
       if (metadataService && typeof metadataService.list === "function") {
         try {
-          const items = await metadataService.list(typeOrName);
+          let items = await metadataService.list(typeOrName);
+          if (packageId && items && items.length > 0) {
+            items = items.filter((item) => item?._packageId === packageId);
+          }
           if (items && items.length > 0) {
             return { handled: true, response: this.success({ type: typeOrName, items }) };
           }
@@ -1273,25 +1286,6 @@ var HttpDispatcher = class {
           console.debug(`[HttpDispatcher] MetadataService.list() failed for type:`, sanitizedType, "error:", e.message);
         }
       }
-      if (broker) {
-        try {
-          if (typeOrName === "objects") {
-            const data2 = await broker.call("metadata.objects", { packageId }, { request: context.request });
-            return { handled: true, response: this.success(data2) };
-          }
-          const data = await broker.call(`metadata.${typeOrName}`, { packageId }, { request: context.request });
-          if (data !== null && data !== void 0) {
-            return { handled: true, response: this.success(data) };
-          }
-        } catch {
-        }
-        try {
-          const data = await broker.call("metadata.getObject", { objectName: typeOrName }, { request: context.request });
-          return { handled: true, response: this.success(data) };
-        } catch (e) {
-          return { handled: true, response: this.error(e.message, 404) };
-        }
-      }
       const qlService = await this.getObjectQLService();
       if (qlService?.registry) {
         if (typeOrName === "objects") {
@@ -1308,18 +1302,19 @@ var HttpDispatcher = class {
       return { handled: true, response: this.error("Not found", 404) };
     }
     if (parts.length === 0) {
+      const metadataService = await this.resolveService("metadata");
+      if (metadataService && typeof metadataService.getRegisteredTypes === "function") {
+        try {
+          const types = await metadataService.getRegisteredTypes();
+          return { handled: true, response: this.success({ types }) };
+        } catch {
+        }
+      }
       const protocol = await this.resolveService("protocol");
       if (protocol && typeof protocol.getMetaTypes === "function") {
         const result = await protocol.getMetaTypes({});
         return { handled: true, response: this.success(result) };
       }
-      if (broker) {
-        try {
-          const data = await broker.call("metadata.types", {}, { request: context.request });
-          return { handled: true, response: this.success(data) };
-        } catch {
-        }
-      }
       return { handled: true, response: this.success({ types: ["object", "app", "plugin"] }) };
     }
     return { handled: false };
@@ -1328,8 +1323,7 @@ var HttpDispatcher = class {
    * Handles Data requests
    * path: sub-path after /data/ (e.g. "contacts", "contacts/123", "contacts/query")
    */
-  async handleData(path, method, body, query, context) {
-    const broker = this.ensureBroker();
+  async handleData(path, method, body, query, _context) {
     const parts = path.replace(/^\/+/, "").split("/");
     const objectName = parts[0];
     if (!objectName) {
@@ -1339,11 +1333,11 @@ var HttpDispatcher = class {
     if (parts.length > 1) {
       const action = parts[1];
       if (action === "query" && m === "POST") {
-        const result = await broker.call("data.query", { object: objectName, ...body }, { request: context.request });
+        const result = await this.callData("query", { object: objectName, ...body });
         return { handled: true, response: this.success(result) };
       }
       if (action === "batch" && m === "POST") {
-        const result = await broker.call("data.batch", { object: objectName, ...body }, { request: context.request });
+        const result = await this.callData("batch", { object: objectName, ...body });
         return { handled: true, response: this.success(result) };
       }
       if (parts.length === 2 && m === "GET") {
@@ -1352,17 +1346,17 @@ var HttpDispatcher = class {
         const allowedParams = {};
         if (select != null) allowedParams.select = select;
         if (expand != null) allowedParams.expand = expand;
-        const result = await broker.call("data.get", { object: objectName, id, ...allowedParams }, { request: context.request });
+        const result = await this.callData("get", { object: objectName, id, ...allowedParams });
         return { handled: true, response: this.success(result) };
       }
       if (parts.length === 2 && m === "PATCH") {
         const id = parts[1];
-        const result = await broker.call("data.update", { object: objectName, id, data: body }, { request: context.request });
+        const result = await this.callData("update", { object: objectName, id, data: body });
         return { handled: true, response: this.success(result) };
       }
       if (parts.length === 2 && m === "DELETE") {
         const id = parts[1];
-        const result = await broker.call("data.delete", { object: objectName, id }, { request: context.request });
+        const result = await this.callData("delete", { object: objectName, id });
         return { handled: true, response: this.success(result) };
       }
     } else {
@@ -1389,11 +1383,11 @@ var HttpDispatcher = class {
           normalized.offset = normalized.skip;
           delete normalized.skip;
         }
-        const result = await broker.call("data.query", { object: objectName, query: normalized }, { request: context.request });
+        const result = await this.callData("query", { object: objectName, query: normalized });
         return { handled: true, response: this.success(result) };
       }
       if (m === "POST") {
-        const result = await broker.call("data.create", { object: objectName, data: body }, { request: context.request });
+        const result = await this.callData("create", { object: objectName, data: body });
         const res = this.success(result);
         res.status = 201;
         return { handled: true, response: res };
@@ -1495,18 +1489,14 @@ var HttpDispatcher = class {
    * - POST   /packages/:id/publish → publish a package (metadata snapshot)
    * - POST   /packages/:id/revert  → revert a package to last published state
    * 
-   * Uses ObjectQL SchemaRegistry directly (via the 'objectql' service)
-   * with broker fallback for backward compatibility.
+   * Uses ObjectQL SchemaRegistry directly (via the 'objectql' service).
    */
-  async handlePackages(path, method, body, query, context) {
+  async handlePackages(path, method, body, query, _context) {
     const m = method.toUpperCase();
     const parts = path.replace(/^\/+/, "").split("/").filter(Boolean);
     const qlService = await this.getObjectQLService();
     const registry = qlService?.registry;
     if (!registry) {
-      if (this.kernel.broker) {
-        return this.handlePackagesViaBroker(parts, m, body, query, context);
-      }
       return { handled: true, response: this.error("Package service not available", 503) };
     }
     try {
@@ -1545,10 +1535,6 @@ var HttpDispatcher = class {
           const result = await metadataService.publishPackage(id, body || {});
           return { handled: true, response: this.success(result) };
         }
-        if (this.kernel.broker) {
-          const result = await this.kernel.broker.call("metadata.publishPackage", { packageId: id, ...body }, { request: context.request });
-          return { handled: true, response: this.success(result) };
-        }
         return { handled: true, response: this.error("Metadata service not available", 503) };
       }
       if (parts.length === 2 && parts[1] === "revert" && m === "POST") {
@@ -1558,10 +1544,6 @@ var HttpDispatcher = class {
           await metadataService.revertPackage(id);
           return { handled: true, response: this.success({ success: true }) };
         }
-        if (this.kernel.broker) {
-          await this.kernel.broker.call("metadata.revertPackage", { packageId: id }, { request: context.request });
-          return { handled: true, response: this.success({ success: true }) };
-        }
         return { handled: true, response: this.error("Metadata service not available", 503) };
       }
       if (parts.length === 1 && m === "GET") {
@@ -1581,47 +1563,6 @@ var HttpDispatcher = class {
     }
     return { handled: false };
   }
-  /**
-   * Fallback: handle packages via broker (for backward compatibility)
-   */
-  async handlePackagesViaBroker(parts, m, body, query, context) {
-    const broker = this.kernel.broker;
-    try {
-      if (parts.length === 0 && m === "GET") {
-        const result = await broker.call("package.list", query || {}, { request: context.request });
-        return { handled: true, response: this.success(result) };
-      }
-      if (parts.length === 0 && m === "POST") {
-        const result = await broker.call("package.install", body, { request: context.request });
-        const res = this.success(result);
-        res.status = 201;
-        return { handled: true, response: res };
-      }
-      if (parts.length === 2 && parts[1] === "enable" && m === "PATCH") {
-        const id = decodeURIComponent(parts[0]);
-        const result = await broker.call("package.enable", { id }, { request: context.request });
-        return { handled: true, response: this.success(result) };
-      }
-      if (parts.length === 2 && parts[1] === "disable" && m === "PATCH") {
-        const id = decodeURIComponent(parts[0]);
-        const result = await broker.call("package.disable", { id }, { request: context.request });
-        return { handled: true, response: this.success(result) };
-      }
-      if (parts.length === 1 && m === "GET") {
-        const id = decodeURIComponent(parts[0]);
-        const result = await broker.call("package.get", { id }, { request: context.request });
-        return { handled: true, response: this.success(result) };
-      }
-      if (parts.length === 1 && m === "DELETE") {
-        const id = decodeURIComponent(parts[0]);
-        const result = await broker.call("package.uninstall", { id }, { request: context.request });
-        return { handled: true, response: this.success(result) };
-      }
-    } catch (e) {
-      return { handled: true, response: this.error(e.message, e.statusCode || 500) };
-    }
-    return { handled: false };
-  }
   /**
    * Handles Storage requests
    * path: sub-path after /storage/
@@ -1830,9 +1771,6 @@ var HttpDispatcher = class {
     }
     return null;
   }
-  capitalize(s) {
-    return s.charAt(0).toUpperCase() + s.slice(1);
-  }
   /**
    * Handle AI service routes (/ai/chat, /ai/models, /ai/conversations, etc.)
    * Resolves the AI service and its built-in route handlers, then dispatches.
@@ -1969,10 +1907,12 @@ var HttpDispatcher = class {
       return this.handleAI(cleanPath, method, body, query, context);
     }
     if (cleanPath === "/openapi.json" && method === "GET") {
-      const broker = this.ensureBroker();
       try {
-        const result2 = await broker.call("metadata.generateOpenApi", {}, { request: context.request });
-        return { handled: true, response: this.success(result2) };
+        const metaSvc = await this.resolveService("metadata");
+        if (metaSvc && typeof metaSvc.generateOpenApi === "function") {
+          const result2 = await metaSvc.generateOpenApi({});
+          return { handled: true, response: this.success(result2) };
+        }
       } catch (e) {
       }
     }
@@ -1987,37 +1927,48 @@ var HttpDispatcher = class {
    * Handles Custom API Endpoints defined in metadata
    */
   async handleApiEndpoint(path, method, body, query, context) {
-    const broker = this.ensureBroker();
     try {
-      const endpoint = await broker.call("metadata.matchEndpoint", { path, method });
+      const metaSvc = await this.resolveService("metadata");
+      if (!metaSvc || typeof metaSvc.matchEndpoint !== "function") {
+        return { handled: false };
+      }
+      const endpoint = await metaSvc.matchEndpoint({ path, method });
       if (endpoint) {
         if (endpoint.type === "flow") {
-          const result = await broker.call("automation.runFlow", {
+          const automationSvc = await this.resolveService("automation");
+          if (!automationSvc || typeof automationSvc.runFlow !== "function") {
+            return { handled: true, response: this.error("Automation service not available", 503) };
+          }
+          const result = await automationSvc.runFlow({
             flowId: endpoint.target,
             inputs: { ...query, ...body, _request: context.request }
           });
           return { handled: true, response: this.success(result) };
         }
         if (endpoint.type === "script") {
-          const result = await broker.call("automation.runScript", {
+          const automationSvc = await this.resolveService("automation");
+          if (!automationSvc || typeof automationSvc.runScript !== "function") {
+            return { handled: true, response: this.error("Automation service not available", 503) };
+          }
+          const result = await automationSvc.runScript({
             scriptName: endpoint.target,
             context: { ...query, ...body, request: context.request }
-          }, { request: context.request });
+          });
           return { handled: true, response: this.success(result) };
         }
         if (endpoint.type === "object_operation") {
           if (endpoint.objectParams) {
             const { object, operation } = endpoint.objectParams;
             if (operation === "find") {
-              const result = await broker.call("data.query", { object, query }, { request: context.request });
+              const result = await this.callData("query", { object, query });
               return { handled: true, response: this.success(result.records, { total: result.total }) };
             }
             if (operation === "get" && query.id) {
-              const result = await broker.call("data.get", { object, id: query.id }, { request: context.request });
+              const result = await this.callData("get", { object, id: query.id });
               return { handled: true, response: this.success(result) };
             }
             if (operation === "create") {
-              const result = await broker.call("data.create", { object, data: body }, { request: context.request });
+              const result = await this.callData("create", { object, data: body });
               return { handled: true, response: this.success(result) };
             }
           }