feat(hono): add analytics, hub, and automation endpoints with request handling

hotlong · hotlong · commit a3a133fe829c · 2026-02-04T17:02:36.000+08:00
diff --git a/packages/adapters/hono/src/index.ts b/packages/adapters/hono/src/index.ts
@@ -102,7 +102,62 @@ export function createHonoApp(options: ObjectStackHonoOptions) {
     }
   });
 
-  // --- 5. Storage Endpoints ---
+  // --- 5. Analytics Endpoints ---
+  app.all(`${prefix}/analytics*`, async (c) => {
+    try {
+      const path = c.req.path.substring(c.req.path.indexOf('/analytics') + 10);
+      const method = c.req.method;
+      
+      let body = {};
+      if (method === 'POST') {
+          body = await c.req.json().catch(() => ({}));
+      }
+
+      const result = await dispatcher.handleAnalytics(path, method, body, { request: c.req.raw });
+      return normalizeResponse(c, result);
+    } catch (err: any) {
+      return c.json({ success: false, error: { message: err.message, code: err.statusCode || 500 } }, err.statusCode || 500);
+    }
+  });
+
+  // --- 6. Hub Endpoints ---
+  app.all(`${prefix}/hub*`, async (c) => {
+    try {
+      const path = c.req.path.substring(c.req.path.indexOf('/hub') + 4);
+      const method = c.req.method;
+      
+      let body = {};
+      if (method === 'POST' || method === 'PATCH' || method === 'PUT') {
+          body = await c.req.json().catch(() => ({}));
+      }
+      const query = c.req.query();
+
+      const result = await dispatcher.handleHub(path, method, body, query, { request: c.req.raw });
+      return normalizeResponse(c, result);
+    } catch (err: any) {
+      return c.json({ success: false, error: { message: err.message, code: err.statusCode || 500 } }, err.statusCode || 500);
+    }
+  });
+
+  // --- 7. Automation Endpoints ---
+  app.all(`${prefix}/automation*`, async (c) => {
+      try {
+        const path = c.req.path.substring(c.req.path.indexOf('/automation') + 11);
+        const method = c.req.method;
+        
+        let body = {};
+        if (method === 'POST') {
+            body = await c.req.json().catch(() => ({}));
+        }
+
+        const result = await dispatcher.handleAutomation(path, method, body, { request: c.req.raw });
+        return normalizeResponse(c, result);
+      } catch (err: any) {
+        return c.json({ success: false, error: { message: err.message, code: err.statusCode || 500 } }, err.statusCode || 500);
+      }
+  });
+
+  // --- 8. Storage Endpoints ---
   app.all(`${prefix}/storage*`, async (c) => {
     try {
       const path = c.req.path.substring(c.req.path.indexOf('/storage') + 8);
diff --git a/packages/plugins/plugin-hono-server/src/hono-plugin.ts b/packages/plugins/plugin-hono-server/src/hono-plugin.ts
@@ -507,6 +507,72 @@ export class HonoServerPlugin implements Plugin {
             priority: HonoServerPlugin.DISCOVERY_ENDPOINT_PRIORITY
         });
 
+        // Analytics Endpoints
+        endpoints.push(
+            {
+                id: 'analytics_query',
+                method: 'POST',
+                path: `${apiPath}/analytics/query`,
+                summary: 'Analytics Query',
+                description: 'Execute analytics query',
+                priority: HonoServerPlugin.DISCOVERY_ENDPOINT_PRIORITY
+            },
+            {
+                id: 'get_analytics_meta',
+                method: 'GET',
+                path: `${apiPath}/analytics/meta`,
+                summary: 'Analytics Metadata',
+                description: 'Get analytics cubes definitions',
+                priority: HonoServerPlugin.DISCOVERY_ENDPOINT_PRIORITY
+            }
+        );
+
+        // Automation Endpoints
+        endpoints.push(
+            {
+                id: 'automation_trigger',
+                method: 'POST',
+                path: `${apiPath}/automation/trigger/:trigger`,
+                summary: 'Trigger Automation',
+                description: 'Trigger a named automation',
+                parameters: [{
+                    name: 'trigger',
+                    in: 'path',
+                    required: true,
+                    schema: { type: 'string' }
+                }],
+                priority: HonoServerPlugin.DISCOVERY_ENDPOINT_PRIORITY
+            }
+        );
+
+        // Hub Endpoints
+        endpoints.push(
+            {
+                id: 'hub_list_spaces',
+                method: 'GET',
+                path: `${apiPath}/hub/spaces`,
+                summary: 'List Spaces',
+                description: 'List all Hub spaces',
+                priority: HonoServerPlugin.DISCOVERY_ENDPOINT_PRIORITY
+            },
+            {
+                id: 'hub_create_space',
+                method: 'POST',
+                path: `${apiPath}/hub/spaces`,
+                summary: 'Create Space',
+                description: 'Create a new Hub space',
+                priority: HonoServerPlugin.DISCOVERY_ENDPOINT_PRIORITY
+            },
+             {
+                id: 'hub_install_plugin',
+                method: 'POST',
+                path: `${apiPath}/hub/plugins/install`,
+                summary: 'Install Plugin',
+                description: 'Install a plugin from marketplace',
+                priority: HonoServerPlugin.DISCOVERY_ENDPOINT_PRIORITY
+            }
+        );
+
         // Register the API in the registry
         const apiEntry: ApiRegistryEntryInput = {
             id: 'objectstack_core_api',
@@ -798,6 +864,65 @@ export class HonoServerPlugin implements Plugin {
                     ctx.logger.warn('UI view not found', { object: req.params.object });
                     res.status(404).json({ error: e.message });
                 }
+            },
+            // Analytics
+            'analytics_query': async (req: any, res: any) => {
+                ctx.logger.info('Analytics query request');
+                try {
+                    const result = await p.analyticsQuery(req.body);
+                    res.json(result);
+                } catch (e: any) {
+                    ctx.logger.error('Analytics query failed', e);
+                    res.status(400).json({ error: e.message });
+                }
+            },
+            'get_analytics_meta': async (req: any, res: any) => {
+                 ctx.logger.info('Analytics meta request');
+                 try {
+                     const result = await p.getAnalyticsMeta({});
+                     res.json(result);
+                 } catch (e: any) {
+                     ctx.logger.error('Analytics meta failed', e);
+                     res.status(500).json({ error: e.message });
+                 }
+            },
+            // Automation
+            'automation_trigger': async (req: any, res: any) => {
+                const trigger = req.params.trigger;
+                ctx.logger.info('Automation trigger request', { trigger });
+                try {
+                    const result = await p.triggerAutomation({ trigger, payload: req.body });
+                    res.json(result);
+                } catch (e: any) {
+                     ctx.logger.error('Automation trigger failed', e, { trigger });
+                     res.status(500).json({ error: e.message });
+                }
+            },
+            // Hub
+            'hub_list_spaces': async (req: any, res: any) => {
+                 try {
+                     const result = await p.listSpaces({ ...req.query });
+                     res.json(result);
+                 } catch (e: any) {
+                     res.status(500).json({ error: e.message });
+                 }
+            },
+            'hub_create_space': async (req: any, res: any) => {
+                 try {
+                     const result = await p.createSpace(req.body);
+                     res.status(201).json(result);
+                 } catch (e: any) {
+                     res.status(500).json({ error: e.message });
+                 }
+            },
+            'hub_install_plugin': async (req: any, res: any) => {
+                const spaceId = req.params.space_id;
+                try {
+                    const result = await p.installPlugin({ spaceId, ...req.body });
+                    res.json(result);
+                } catch (e: any) {
+                    res.status(500).json({ error: e.message });
+                }
             }
         };
 
diff --git a/packages/runtime/src/http-dispatcher.ts b/packages/runtime/src/http-dispatcher.ts
@@ -425,6 +425,29 @@ export class HttpDispatcher {
         return { handled: false };
     }
 
+    /**
+     * Handles Automation requests
+     * path: sub-path after /automation/
+     */
+    async handleAutomation(path: string, method: string, body: any, context: HttpProtocolContext): Promise<HttpDispatcherResult> {
+        const automationService = this.getService(CoreServiceName.enum.automation);
+        if (!automationService) return { handled: false };
+
+        const m = method.toUpperCase();
+        const parts = path.replace(/^\/+/, '').split('/');
+        
+        // POST /automation/trigger/:name
+        if (parts[0] === 'trigger' && parts[1] && m === 'POST') {
+             const triggerName = parts[1];
+             if (typeof automationService.trigger === 'function') {
+                 const result = await automationService.trigger(triggerName, body, { request: context.request });
+                 return { handled: true, response: this.success(result) };
+             }
+        }
+        
+        return { handled: false };
+    }
+
     private getServicesMap(): Record<string, any> {
         if (this.kernel.services instanceof Map) {
             return Object.fromEntries(this.kernel.services);
@@ -473,6 +496,10 @@ export class HttpDispatcher {
              return this.handleStorage(cleanPath.substring(8), method, body, context); // body here is file/stream for upload
         }
         
+        if (cleanPath.startsWith('/automation')) {
+             return this.handleAutomation(cleanPath.substring(11), method, body, context);
+        }
+        
         if (cleanPath.startsWith('/analytics')) {
              return this.handleAnalytics(cleanPath.substring(10), method, body, context);
         }
diff --git a/packages/spec/src/api/hub.zod.ts b/packages/spec/src/api/hub.zod.ts
@@ -930,3 +930,20 @@ export const HubAPIContract = {
     },
   },
 } as const;
+
+/**
+ * Install Plugin Request
+ */
+export const InstallPluginRequestSchema = z.object({
+  spaceId: z.string().describe('Target Space ID'),
+  pluginId: z.string().describe('Plugin Package ID'),
+  version: z.string().optional().describe('Version requirement'),
+  config: z.record(z.any()).optional().describe('Plugin configuration'),
+});
+
+/**
+ * Install Plugin Response
+ */
+export const InstallPluginResponseSchema = BaseResponseSchema.extend({
+  data: z.any() // Returns installation status or installed instance
+});
diff --git a/packages/spec/src/api/protocol.zod.ts b/packages/spec/src/api/protocol.zod.ts
@@ -10,6 +10,25 @@ import {
   GetAnalyticsMetaRequestSchema, 
   AnalyticsMetadataResponseSchema 
 } from './analytics.zod';
+import {
+  ListSpacesRequestSchema,
+  SpaceResponseSchema,
+  CreateSpaceRequestSchema,
+  UpdateSpaceRequestSchema,
+  InstallPluginRequestSchema,
+  InstallPluginResponseSchema
+} from './hub.zod';
+
+export const AutomationTriggerRequestSchema = z.object({
+  trigger: z.string(),
+  payload: z.record(z.any())
+});
+
+export const AutomationTriggerResponseSchema = z.object({
+  success: z.boolean(),
+  jobId: z.string().optional(),
+  result: z.any().optional()
+});
 
 /**
  * ObjectStack Protocol - Zod Schema Definitions
@@ -387,6 +406,28 @@ export const ObjectStackProtocolSchema = z.object({
     output: z.promise(AnalyticsMetadataResponseSchema)
   }).describe('Get analytics metadata (cubes)'),
 
+  // Automation Operations
+  triggerAutomation: z.function({
+    input: z.tuple([AutomationTriggerRequestSchema]),
+    output: z.promise(AutomationTriggerResponseSchema)
+  }).describe('Trigger an automation flow or script'),
+
+  // Hub Operations
+  listSpaces: z.function({
+    input: z.tuple([ListSpacesRequestSchema]),
+    output: z.promise(z.any()) // TODO: Use ListSpacesResponseSchema when available/exported
+  }).describe('List Hub Spaces'),
+  
+  createSpace: z.function({
+    input: z.tuple([CreateSpaceRequestSchema]),
+    output: z.promise(SpaceResponseSchema)
+  }).describe('Create Hub Space'),
+
+  installPlugin: z.function({
+    input: z.tuple([InstallPluginRequestSchema]),
+    output: z.promise(InstallPluginResponseSchema)
+  }).describe('Install Plugin into Space'),
+
   // Data Operations
   findData: z.function({
     input: z.tuple([FindDataRequestSchema]),
@@ -457,6 +498,15 @@ export type AnalyticsResultResponse = z.infer<typeof AnalyticsResultResponseSche
 export type GetAnalyticsMetaRequest = z.infer<typeof GetAnalyticsMetaRequestSchema>;
 export type GetAnalyticsMetaResponse = z.infer<typeof AnalyticsMetadataResponseSchema>;
 
+export type AutomationTriggerRequest = z.infer<typeof AutomationTriggerRequestSchema>;
+export type AutomationTriggerResponse = z.infer<typeof AutomationTriggerResponseSchema>;
+
+export type ListSpacesRequest = z.infer<typeof ListSpacesRequestSchema>;
+export type CreateSpaceRequest = z.infer<typeof CreateSpaceRequestSchema>;
+export type SpaceResponse = z.infer<typeof SpaceResponseSchema>;
+export type InstallPluginRequest = z.infer<typeof InstallPluginRequestSchema>;
+export type InstallPluginResponse = z.infer<typeof InstallPluginResponseSchema>;
+
 export type FindDataRequest = z.input<typeof FindDataRequestSchema>;
 export type FindDataResponse = z.infer<typeof FindDataResponseSchema>;
 export type GetDataRequest = z.input<typeof GetDataRequestSchema>;
@@ -495,6 +545,12 @@ export interface IObjectStackProtocolLegacy {
   analyticsQuery(request: AnalyticsQueryRequest): Promise<AnalyticsResultResponse>;
   getAnalyticsMeta(request: GetAnalyticsMetaRequest): Promise<GetAnalyticsMetaResponse>;
 
+  triggerAutomation(request: AutomationTriggerRequest): Promise<AutomationTriggerResponse>;
+
+  listSpaces(request: ListSpacesRequest): Promise<any>;
+  createSpace(request: CreateSpaceRequest): Promise<SpaceResponse>;
+  installPlugin(request: InstallPluginRequest): Promise<InstallPluginResponse>;
+
   findData(request: FindDataRequest): Promise<FindDataResponse>;
   getData(request: GetDataRequest): Promise<GetDataResponse>;
   createData(request: CreateDataRequest): Promise<CreateDataResponse>;
