@objectstack/runtime 1.0.11 → 1.1.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @objectstack/runtime@1.0.11 build /home/runner/work/spec/spec/packages/runtime
+> @objectstack/runtime@1.1.0 build /home/runner/work/spec/spec/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
-CJS dist/index.cjs     51.30 KB
-CJS dist/index.cjs.map 116.83 KB
-CJS ⚡️ Build success in 109ms
-ESM dist/index.js     49.57 KB
-ESM dist/index.js.map 116.73 KB
-ESM ⚡️ Build success in 114ms
+ESM dist/index.js     60.52 KB
+ESM dist/index.js.map 140.22 KB
+ESM ⚡️ Build success in 139ms
+CJS dist/index.cjs     62.25 KB
+CJS dist/index.cjs.map 140.32 KB
+CJS ⚡️ Build success in 141ms
 DTS Build start
-DTS ⚡️ Build success in 7833ms
-DTS dist/index.d.ts  17.82 KB
-DTS dist/index.d.cts 17.82 KB
+DTS ⚡️ Build success in 8009ms
+DTS dist/index.d.ts  19.53 KB
+DTS dist/index.d.cts 19.53 KB

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @objectstack/runtime
 
+## 1.0.12
+
+### Patch Changes
+
+- chore: add Vercel deployment configs, simplify console runtime configuration
+- Updated dependencies
+  - @objectstack/spec@1.0.12
+  - @objectstack/core@1.0.12
+  - @objectstack/types@1.0.12
+
 ## 1.0.11
 
 ### Patch Changes

package/dist/index.cjs

@@ -272,6 +272,7 @@ var RestServer = class {
         apiPath: api.apiPath,
         enableCrud: api.enableCrud ?? true,
         enableMetadata: api.enableMetadata ?? true,
+        enableUi: api.enableUi ?? true,
         enableBatch: api.enableBatch ?? true,
         enableDiscovery: api.enableDiscovery ?? true,
         documentation: api.documentation,
@@ -337,6 +338,9 @@ var RestServer = class {
     if (this.config.api.enableMetadata) {
       this.registerMetadataEndpoints(basePath);
     }
+    if (this.config.api.enableUi) {
+      this.registerUiEndpoints(basePath);
+    }
     if (this.config.api.enableCrud) {
       this.registerCrudEndpoints(basePath);
     }
@@ -362,6 +366,9 @@ var RestServer = class {
             if (this.config.api.enableMetadata) {
               discovery.endpoints.metadata = `${basePath}${this.config.metadata.prefix}`;
             }
+            if (this.config.api.enableUi) {
+              discovery.endpoints.ui = `${basePath}/ui`;
+            }
             if (discovery.endpoints.auth) {
               discovery.endpoints.auth = `${basePath}/auth`;
             }
@@ -407,7 +414,8 @@ var RestServer = class {
         path: `${metaPath}/:type`,
         handler: async (req, res) => {
           try {
-            const items = await this.protocol.getMetaItems({ type: req.params.type });
+            const packageId = req.query?.package || void 0;
+            const items = await this.protocol.getMetaItems({ type: req.params.type, packageId });
             res.json(items);
           } catch (error) {
             res.status(404).json({ error: error.message });
@@ -491,6 +499,35 @@ var RestServer = class {
       }
     });
   }
+  /**
+   * Register UI endpoints
+   */
+  registerUiEndpoints(basePath) {
+    const uiPath = `${basePath}/ui`;
+    this.routeManager.register({
+      method: "GET",
+      path: `${uiPath}/view/:object/:type`,
+      handler: async (req, res) => {
+        try {
+          if (this.protocol.getUiView) {
+            const view = await this.protocol.getUiView({
+              object: req.params.object,
+              type: req.params.type
+            });
+            res.json(view);
+          } else {
+            res.status(501).json({ error: "UI View resolution not supported by protocol implementation" });
+          }
+        } catch (error) {
+          res.status(404).json({ error: error.message });
+        }
+      },
+      metadata: {
+        summary: "Resolve UI View for object",
+        tags: ["ui"]
+      }
+    });
+  }
   /**
    * Register CRUD endpoints for data operations
    */
@@ -879,17 +916,31 @@ var AppPlugin = class {
       } else {
         ctx.logger.debug("No runtime.onEnable function found", { appId });
       }
+      const seedDatasets = [];
+      if (Array.isArray(this.bundle.data)) {
+        seedDatasets.push(...this.bundle.data);
+      }
       const manifest = this.bundle.manifest || this.bundle;
       if (manifest && Array.isArray(manifest.data)) {
-        ctx.logger.info(`[AppPlugin] Found initial data for ${appId}`, { count: manifest.data.length });
-        for (const dataset of manifest.data) {
+        seedDatasets.push(...manifest.data);
+      }
+      const namespace = (this.bundle.manifest || this.bundle)?.namespace;
+      const RESERVED_NS = /* @__PURE__ */ new Set(["base", "system"]);
+      const toFQN = (name) => {
+        if (name.includes("__") || !namespace || RESERVED_NS.has(namespace)) return name;
+        return `${namespace}__${name}`;
+      };
+      if (seedDatasets.length > 0) {
+        ctx.logger.info(`[AppPlugin] Found ${seedDatasets.length} seed datasets for ${appId}`);
+        for (const dataset of seedDatasets) {
           if (dataset.object && Array.isArray(dataset.records)) {
-            ctx.logger.info(`[Seeder] Seeding ${dataset.records.length} records for ${dataset.object}`);
+            const objectFQN = toFQN(dataset.object);
+            ctx.logger.info(`[Seeder] Seeding ${dataset.records.length} records for ${objectFQN}`);
             for (const record of dataset.records) {
               try {
-                await ql.insert(dataset.object, record);
+                await ql.insert(objectFQN, record);
               } catch (err) {
-                ctx.logger.warn(`[Seeder] Failed to insert ${dataset.object} record:`, { error: err.message });
+                ctx.logger.warn(`[Seeder] Failed to insert ${objectFQN} record:`, { error: err.message });
               }
             }
           }
@@ -1050,19 +1101,25 @@ var HttpDispatcher = class {
     const hasFiles = !!(services[import_system.CoreServiceName.enum["file-storage"]] || services["storage"]?.supportsFiles);
     const hasAnalytics = !!services[import_system.CoreServiceName.enum.analytics];
     const hasHub = !!services[import_system.CoreServiceName.enum.hub];
+    const routes = {
+      data: `${prefix}/data`,
+      metadata: `${prefix}/meta`,
+      packages: `${prefix}/packages`,
+      auth: `${prefix}/auth`,
+      ui: `${prefix}/ui`,
+      graphql: hasGraphQL ? `${prefix}/graphql` : void 0,
+      storage: hasFiles ? `${prefix}/storage` : void 0,
+      analytics: hasAnalytics ? `${prefix}/analytics` : void 0,
+      hub: hasHub ? `${prefix}/hub` : void 0,
+      automation: `${prefix}/automation`
+    };
     return {
       name: "ObjectOS",
       version: "1.0.0",
       environment: (0, import_core2.getEnv)("NODE_ENV", "development"),
-      routes: {
-        data: `${prefix}/data`,
-        metadata: `${prefix}/meta`,
-        auth: `${prefix}/auth`,
-        graphql: hasGraphQL ? `${prefix}/graphql` : void 0,
-        storage: hasFiles ? `${prefix}/storage` : void 0,
-        analytics: hasAnalytics ? `${prefix}/analytics` : void 0,
-        hub: hasHub ? `${prefix}/hub` : void 0
-      },
+      routes,
+      endpoints: routes,
+      // Alias for backward compatibility with some clients
       features: {
         graphql: hasGraphQL,
         search: hasSearch,
@@ -1115,11 +1172,21 @@ var HttpDispatcher = class {
    * Standard: /metadata/:type/:name
    * Fallback for backward compat: /metadata (all objects), /metadata/:objectName (get object)
    */
-  async handleMetadata(path, context, method, body) {
+  async handleMetadata(path, context, method, body, query) {
     const broker = this.ensureBroker();
     const parts = path.replace(/^\/+/, "").split("/").filter(Boolean);
     if (parts[0] === "types") {
-      return { handled: true, response: this.success({ types: ["objects", "apps", "plugins"] }) };
+      const protocol = this.kernel?.context?.getService ? this.kernel.context.getService("protocol") : null;
+      if (protocol && typeof protocol.getMetaTypes === "function") {
+        const result = await protocol.getMetaTypes({});
+        return { handled: true, response: this.success(result) };
+      }
+      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"] }) };
+      }
     }
     if (parts.length === 2) {
       const [type, name] = parts;
@@ -1141,11 +1208,21 @@ var HttpDispatcher = class {
         }
       }
       try {
-        if (type === "objects") {
+        if (type === "objects" || type === "object") {
           const data2 = await broker.call("metadata.getObject", { objectName: name }, { request: context.request });
           return { handled: true, response: this.success(data2) };
         }
-        const data = await broker.call(`metadata.get${this.capitalize(type.slice(0, -1))}`, { name }, { request: context.request });
+        const singularType = type.endsWith("s") ? type.slice(0, -1) : type;
+        const protocol = this.kernel?.context?.getService ? this.kernel.context.getService("protocol") : null;
+        if (protocol && typeof protocol.getMetaItem === "function") {
+          try {
+            const data2 = await protocol.getMetaItem({ type: singularType, name });
+            return { handled: true, response: this.success(data2) };
+          } catch (e) {
+          }
+        }
+        const method2 = `metadata.get${this.capitalize(singularType)}`;
+        const data = await broker.call(method2, { name }, { request: context.request });
         return { handled: true, response: this.success(data) };
       } catch (e) {
         return { handled: true, response: this.error(e.message, 404) };
@@ -1153,20 +1230,47 @@ var HttpDispatcher = class {
     }
     if (parts.length === 1) {
       const typeOrName = parts[0];
-      if (["objects", "apps", "plugins"].includes(typeOrName)) {
+      const packageId = query?.package || void 0;
+      const protocol = this.kernel?.context?.getService ? this.kernel.context.getService("protocol") : null;
+      if (protocol && typeof protocol.getMetaItems === "function") {
+        try {
+          const data = await protocol.getMetaItems({ type: typeOrName, packageId });
+          if (data && (data.items !== void 0 || Array.isArray(data))) {
+            return { handled: true, response: this.success(data) };
+          }
+        } catch {
+        }
+      }
+      try {
         if (typeOrName === "objects") {
-          const data3 = await broker.call("metadata.objects", {}, { request: context.request });
-          return { handled: true, response: this.success(data3) };
+          const data2 = await broker.call("metadata.objects", { packageId }, { request: context.request });
+          return { handled: true, response: this.success(data2) };
         }
-        const data2 = await broker.call(`metadata.${typeOrName}`, {}, { 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 data = await broker.call("metadata.getObject", { objectName: typeOrName }, { request: context.request });
-      return { handled: true, response: this.success(data) };
     }
     if (parts.length === 0) {
-      const data = await broker.call("metadata.objects", {}, { request: context.request });
-      return { handled: true, response: this.success(data) };
+      const protocol = this.kernel?.context?.getService ? this.kernel.context.getService("protocol") : null;
+      if (protocol && typeof protocol.getMetaTypes === "function") {
+        const result = await protocol.getMetaTypes({});
+        return { handled: true, response: this.success(result) };
+      }
+      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 };
   }
@@ -1186,7 +1290,7 @@ var HttpDispatcher = class {
       const action = parts[1];
       if (action === "query" && m === "POST") {
         const result = await broker.call("data.query", { object: objectName, ...body }, { request: context.request });
-        return { handled: true, response: this.success(result.data, { count: result.count, limit: body.limit, skip: body.skip }) };
+        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 });
@@ -1194,27 +1298,27 @@ var HttpDispatcher = class {
       }
       if (parts.length === 2 && m === "GET") {
         const id = parts[1];
-        const data = await broker.call("data.get", { object: objectName, id, ...query }, { request: context.request });
-        return { handled: true, response: this.success(data) };
+        const result = await broker.call("data.get", { object: objectName, id, ...query }, { request: context.request });
+        return { handled: true, response: this.success(result) };
       }
       if (parts.length === 2 && m === "PATCH") {
         const id = parts[1];
-        const data = await broker.call("data.update", { object: objectName, id, data: body }, { request: context.request });
-        return { handled: true, response: this.success(data) };
+        const result = await broker.call("data.update", { object: objectName, id, data: body }, { request: context.request });
+        return { handled: true, response: this.success(result) };
       }
       if (parts.length === 2 && m === "DELETE") {
         const id = parts[1];
-        await broker.call("data.delete", { object: objectName, id }, { request: context.request });
-        return { handled: true, response: this.success({ id, deleted: true }) };
+        const result = await broker.call("data.delete", { object: objectName, id }, { request: context.request });
+        return { handled: true, response: this.success(result) };
       }
     } else {
       if (m === "GET") {
         const result = await broker.call("data.query", { object: objectName, filters: query }, { request: context.request });
-        return { handled: true, response: this.success(result.data, { count: result.count }) };
+        return { handled: true, response: this.success(result) };
       }
       if (m === "POST") {
-        const data = await broker.call("data.create", { object: objectName, data: body }, { request: context.request });
-        const res = this.success(data);
+        const result = await broker.call("data.create", { object: objectName, data: body }, { request: context.request });
+        const res = this.success(result);
         res.status = 201;
         return { handled: true, response: res };
       }
@@ -1244,6 +1348,118 @@ var HttpDispatcher = class {
     }
     return { handled: false };
   }
+  /**
+   * Handles Package Management requests
+   * 
+   * REST Endpoints:
+   * - GET    /packages          → list all installed packages
+   * - GET    /packages/:id      → get a specific package
+   * - POST   /packages          → install a new package
+   * - DELETE  /packages/:id      → uninstall a package
+   * - PATCH  /packages/:id/enable  → enable a package
+   * - PATCH  /packages/:id/disable → disable a package
+   * 
+   * Uses ObjectQL SchemaRegistry directly (via the 'objectql' service)
+   * with broker fallback for backward compatibility.
+   */
+  async handlePackages(path, method, body, query, context) {
+    const m = method.toUpperCase();
+    const parts = path.replace(/^\/+/, "").split("/").filter(Boolean);
+    const qlService = 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 {
+      if (parts.length === 0 && m === "GET") {
+        let packages = registry.getAllPackages();
+        if (query?.status) {
+          packages = packages.filter((p) => p.status === query.status);
+        }
+        if (query?.type) {
+          packages = packages.filter((p) => p.manifest?.type === query.type);
+        }
+        return { handled: true, response: this.success({ packages, total: packages.length }) };
+      }
+      if (parts.length === 0 && m === "POST") {
+        const pkg = registry.installPackage(body.manifest || body, body.settings);
+        const res = this.success(pkg);
+        res.status = 201;
+        return { handled: true, response: res };
+      }
+      if (parts.length === 2 && parts[1] === "enable" && m === "PATCH") {
+        const id = decodeURIComponent(parts[0]);
+        const pkg = registry.enablePackage(id);
+        if (!pkg) return { handled: true, response: this.error(`Package '${id}' not found`, 404) };
+        return { handled: true, response: this.success(pkg) };
+      }
+      if (parts.length === 2 && parts[1] === "disable" && m === "PATCH") {
+        const id = decodeURIComponent(parts[0]);
+        const pkg = registry.disablePackage(id);
+        if (!pkg) return { handled: true, response: this.error(`Package '${id}' not found`, 404) };
+        return { handled: true, response: this.success(pkg) };
+      }
+      if (parts.length === 1 && m === "GET") {
+        const id = decodeURIComponent(parts[0]);
+        const pkg = registry.getPackage(id);
+        if (!pkg) return { handled: true, response: this.error(`Package '${id}' not found`, 404) };
+        return { handled: true, response: this.success(pkg) };
+      }
+      if (parts.length === 1 && m === "DELETE") {
+        const id = decodeURIComponent(parts[0]);
+        const success = registry.uninstallPackage(id);
+        if (!success) return { handled: true, response: this.error(`Package '${id}' not found`, 404) };
+        return { handled: true, response: this.success({ success: true }) };
+      }
+    } catch (e) {
+      return { handled: true, response: this.error(e.message, e.statusCode || 500) };
+    }
+    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 Hub requests
    * path: sub-path after /hub/
@@ -1343,6 +1559,29 @@ var HttpDispatcher = class {
     }
     return { handled: false };
   }
+  /**
+   * Handles UI requests
+   * path: sub-path after /ui/
+   */
+  async handleUi(path, query, _context) {
+    const parts = path.replace(/^\/+/, "").split("/").filter(Boolean);
+    if (parts[0] === "view" && parts[1]) {
+      const objectName = parts[1];
+      const type = parts[2] || query?.type || "list";
+      const protocol = this.kernel?.context?.getService ? this.kernel.context.getService("protocol") : null;
+      if (protocol && typeof protocol.getUiView === "function") {
+        try {
+          const result = await protocol.getUiView({ object: objectName, type });
+          return { handled: true, response: this.success(result) };
+        } catch (e) {
+          return { handled: true, response: this.error(e.message, 500) };
+        }
+      } else {
+        return { handled: true, response: this.error("Protocol service not available", 503) };
+      }
+    }
+    return { handled: false };
+  }
   /**
    * Handles Automation requests
    * path: sub-path after /automation/
@@ -1374,6 +1613,29 @@ var HttpDispatcher = class {
     const services = this.getServicesMap();
     return services[name];
   }
+  /**
+   * Get the ObjectQL service which provides access to SchemaRegistry.
+   * Tries multiple access patterns since kernel structure varies.
+   */
+  getObjectQLService() {
+    if (typeof this.kernel.getService === "function") {
+      try {
+        const svc = this.kernel.getService("objectql");
+        if (svc?.registry) return svc;
+      } catch {
+      }
+    }
+    if (this.kernel?.context?.getService) {
+      try {
+        const svc = this.kernel.context.getService("objectql");
+        if (svc?.registry) return svc;
+      } catch {
+      }
+    }
+    const services = this.getServicesMap();
+    if (services["objectql"]?.registry) return services["objectql"];
+    return null;
+  }
   capitalize(s) {
     return s.charAt(0).toUpperCase() + s.slice(1);
   }
@@ -1383,11 +1645,18 @@ var HttpDispatcher = class {
    */
   async dispatch(method, path, body, query, context) {
     const cleanPath = path.replace(/\/$/, "");
+    if (cleanPath === "" && method === "GET") {
+      const info = this.getDiscoveryInfo("");
+      return {
+        handled: true,
+        response: this.success(info)
+      };
+    }
     if (cleanPath.startsWith("/auth")) {
       return this.handleAuth(cleanPath.substring(5), method, body, context);
     }
     if (cleanPath.startsWith("/meta")) {
-      return this.handleMetadata(cleanPath.substring(5), context);
+      return this.handleMetadata(cleanPath.substring(5), context, method, body, query);
     }
     if (cleanPath.startsWith("/data")) {
       return this.handleData(cleanPath.substring(5), method, body, query, context);
@@ -1398,6 +1667,9 @@ var HttpDispatcher = class {
     if (cleanPath.startsWith("/storage")) {
       return this.handleStorage(cleanPath.substring(8), method, body, context);
     }
+    if (cleanPath.startsWith("/ui")) {
+      return this.handleUi(cleanPath.substring(3), query, context);
+    }
     if (cleanPath.startsWith("/automation")) {
       return this.handleAutomation(cleanPath.substring(11), method, body, context);
     }
@@ -1407,6 +1679,9 @@ var HttpDispatcher = class {
     if (cleanPath.startsWith("/hub")) {
       return this.handleHub(cleanPath.substring(4), method, body, query, context);
     }
+    if (cleanPath.startsWith("/packages")) {
+      return this.handlePackages(cleanPath.substring(9), method, body, query, context);
+    }
     if (cleanPath === "/openapi.json" && method === "GET") {
       const broker = this.ensureBroker();
       try {