@lark-apaas/nestjs-capability 0.0.1-alpha.6 → 0.0.1-alpha.7

package/dist/index.js

@@ -179,6 +179,28 @@ import { Injectable as Injectable3, Logger as Logger2, Inject } from "@nestjs/co
 import { RequestContextService, PLATFORM_HTTP_CLIENT } from "@lark-apaas/nestjs-common";
 import * as fs from "fs";
 import * as path from "path";
+
+// src/utils/log-utils.ts
+var DEFAULT_MAX_LENGTH = 1e3;
+function truncateString(str, maxLength) {
+  if (str.length <= maxLength) {
+    return str;
+  }
+  return str.slice(0, maxLength) + `... [truncated, total ${str.length} chars]`;
+}
+__name(truncateString, "truncateString");
+function stringifyForLog(value, maxLength = DEFAULT_MAX_LENGTH) {
+  try {
+    const str = JSON.stringify(value, null, 2);
+    return truncateString(str, maxLength);
+  } catch {
+    const str = String(value);
+    return truncateString(str, maxLength);
+  }
+}
+__name(stringifyForLog, "stringifyForLog");
+
+// src/services/capability.service.ts
 function _ts_decorate3(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -219,15 +241,15 @@ var CapabilityService = class _CapabilityService {
     __name(this, "CapabilityService");
   }
   requestContextService;
-  httpClient;
+  platformHttpClient;
   pluginLoaderService;
   templateEngineService;
   logger = new Logger2(_CapabilityService.name);
   capabilities = /* @__PURE__ */ new Map();
   capabilitiesDir;
-  constructor(requestContextService, httpClient, pluginLoaderService, templateEngineService) {
+  constructor(requestContextService, platformHttpClient, pluginLoaderService, templateEngineService) {
     this.requestContextService = requestContextService;
-    this.httpClient = httpClient;
+    this.platformHttpClient = platformHttpClient;
     this.pluginLoaderService = pluginLoaderService;
     this.templateEngineService = templateEngineService;
     this.capabilitiesDir = path.join(process.cwd(), "server/capabilities");
@@ -315,20 +337,23 @@ var CapabilityService = class _CapabilityService {
   */
   async executeCall(config, actionName, input, contextOverride) {
     const startTime = Date.now();
+    const loggerContext = {
+      capability_id: config.id,
+      plugin_key: config.pluginKey,
+      action: actionName
+    };
     try {
       const pluginInstance = await this.pluginLoaderService.loadPlugin(config.pluginKey);
       if (!pluginInstance.hasAction(actionName)) {
         throw new ActionNotFoundError(config.pluginKey, actionName);
       }
-      const resolvedParams = this.templateEngineService.resolve(config.formValue, input);
+      const resolvedParams = config.formValue ? this.templateEngineService.resolve(config.formValue, input) : input;
       const context = this.buildActionContext(contextOverride);
       const isStream = pluginInstance.isStreamAction?.(actionName) ?? false;
-      this.logger.log({
-        message: "Executing capability",
-        capabilityId: config.id,
-        action: actionName,
-        pluginKey: config.pluginKey,
-        isStream
+      this.logger.log("Executing capability (call)", {
+        ...loggerContext,
+        is_stream: isStream,
+        input: stringifyForLog(input)
       });
       let result;
       if (isStream && pluginInstance.runStream) {
@@ -340,20 +365,17 @@ var CapabilityService = class _CapabilityService {
       } else {
         result = await pluginInstance.run(actionName, context, resolvedParams);
       }
-      this.logger.log({
-        message: "Capability executed successfully",
-        capabilityId: config.id,
-        action: actionName,
-        duration: Date.now() - startTime
+      this.logger.log("Capability (call) executed successfully", {
+        ...loggerContext,
+        duration_ms: Date.now() - startTime,
+        output: stringifyForLog(result)
       });
       return result;
     } catch (error) {
-      this.logger.error({
-        message: "Capability execution failed",
-        capabilityId: config.id,
-        action: actionName,
-        error: error instanceof Error ? error.message : String(error),
-        duration: Date.now() - startTime
+      this.logger.error("Capability (call) execution failed", {
+        ...loggerContext,
+        duration_ms: Date.now() - startTime,
+        error: error instanceof Error ? error.message : String(error)
       });
       throw error;
     }
@@ -365,40 +387,46 @@ var CapabilityService = class _CapabilityService {
   */
   async *executeCallStream(config, actionName, input, contextOverride) {
     const startTime = Date.now();
+    const loggerContext = {
+      capability_id: config.id,
+      plugin_key: config.pluginKey,
+      action: actionName
+    };
+    const chunks = [];
     try {
       const pluginInstance = await this.pluginLoaderService.loadPlugin(config.pluginKey);
       if (!pluginInstance.hasAction(actionName)) {
         throw new ActionNotFoundError(config.pluginKey, actionName);
       }
-      const resolvedParams = this.templateEngineService.resolve(config.formValue, input);
+      const resolvedParams = config.formValue ? this.templateEngineService.resolve(config.formValue, input) : input;
       const context = this.buildActionContext(contextOverride);
       const isStream = pluginInstance.isStreamAction?.(actionName) ?? false;
-      this.logger.log({
-        message: "Executing capability (stream)",
-        capabilityId: config.id,
-        action: actionName,
-        pluginKey: config.pluginKey,
-        isStream
+      this.logger.log("Executing capability (stream)", {
+        ...loggerContext,
+        is_stream: isStream,
+        input: stringifyForLog(input)
       });
       if (isStream && pluginInstance.runStream) {
-        yield* pluginInstance.runStream(actionName, context, resolvedParams);
+        for await (const chunk of pluginInstance.runStream(actionName, context, resolvedParams)) {
+          chunks.push(chunk);
+          yield chunk;
+        }
       } else {
         const result = await pluginInstance.run(actionName, context, resolvedParams);
+        chunks.push(result);
         yield result;
       }
-      this.logger.log({
-        message: "Capability stream completed",
-        capabilityId: config.id,
-        action: actionName,
-        duration: Date.now() - startTime
+      const aggregatedResult = pluginInstance.aggregate ? pluginInstance.aggregate(actionName, chunks) : chunks;
+      this.logger.log("Capability (stream) executed successfully", {
+        ...loggerContext,
+        duration_ms: Date.now() - startTime,
+        output: stringifyForLog(aggregatedResult)
       });
     } catch (error) {
-      this.logger.error({
-        message: "Capability stream execution failed",
-        capabilityId: config.id,
-        action: actionName,
-        error: error instanceof Error ? error.message : String(error),
-        duration: Date.now() - startTime
+      this.logger.error("Capability (stream) execution failed", {
+        ...loggerContext,
+        duration_ms: Date.now() - startTime,
+        error: error instanceof Error ? error.message : String(error)
       });
       throw error;
     }
@@ -410,27 +438,36 @@ var CapabilityService = class _CapabilityService {
   */
   async *executeCallStreamWithEvents(config, actionName, input, contextOverride) {
     const startTime = Date.now();
-    let chunkCount = 0;
+    const loggerContext = {
+      capability_id: config.id,
+      plugin_key: config.pluginKey,
+      action: actionName
+    };
+    const chunks = [];
     try {
       const pluginInstance = await this.pluginLoaderService.loadPlugin(config.pluginKey);
       if (!pluginInstance.hasAction(actionName)) {
         throw new ActionNotFoundError(config.pluginKey, actionName);
       }
-      const resolvedParams = this.templateEngineService.resolve(config.formValue, input);
+      const resolvedParams = config.formValue ? this.templateEngineService.resolve(config.formValue, input) : input;
       const context = this.buildActionContext(contextOverride);
-      this.logger.log({
-        message: "Executing capability (streamWithEvents)",
-        capabilityId: config.id,
-        action: actionName,
-        pluginKey: config.pluginKey
+      const isStream = pluginInstance.isStreamAction?.(actionName) ?? false;
+      this.logger.log("Executing capability (streamWithEvents)", {
+        ...loggerContext,
+        is_stream: isStream,
+        input: stringifyForLog(input)
       });
       if (pluginInstance.runStreamWithEvents) {
-        yield* pluginInstance.runStreamWithEvents(actionName, context, resolvedParams);
+        for await (const event of pluginInstance.runStreamWithEvents(actionName, context, resolvedParams)) {
+          if (event.type === "data") {
+            chunks.push(event.data);
+          }
+          yield event;
+        }
       } else {
-        const isStream = pluginInstance.isStreamAction?.(actionName) ?? false;
         if (isStream && pluginInstance.runStream) {
           for await (const chunk of pluginInstance.runStream(actionName, context, resolvedParams)) {
-            chunkCount++;
+            chunks.push(chunk);
             yield {
               type: "data",
               data: chunk
@@ -438,7 +475,7 @@ var CapabilityService = class _CapabilityService {
           }
         } else {
           const result = await pluginInstance.run(actionName, context, resolvedParams);
-          chunkCount = 1;
+          chunks.push(result);
           yield {
             type: "data",
             data: result
@@ -447,25 +484,22 @@ var CapabilityService = class _CapabilityService {
         yield {
           type: "done",
           metadata: {
-            chunks: chunkCount,
+            chunks: chunks.length,
             duration: Date.now() - startTime
           }
         };
       }
-      this.logger.log({
-        message: "Capability streamWithEvents completed",
-        capabilityId: config.id,
-        action: actionName,
-        duration: Date.now() - startTime,
-        chunks: chunkCount
+      const aggregatedResult = pluginInstance.aggregate ? pluginInstance.aggregate(actionName, chunks) : chunks;
+      this.logger.log("Capability (streamWithEvents) executed successfully", {
+        ...loggerContext,
+        duration_ms: Date.now() - startTime,
+        output: stringifyForLog(aggregatedResult)
       });
     } catch (error) {
-      this.logger.error({
-        message: "Capability streamWithEvents execution failed",
-        capabilityId: config.id,
-        action: actionName,
-        error: error instanceof Error ? error.message : String(error),
-        duration: Date.now() - startTime
+      this.logger.error("Capability (streamWithEvents) execution failed", {
+        ...loggerContext,
+        duration_ms: Date.now() - startTime,
+        error: error instanceof Error ? error.message : String(error)
       });
       yield {
         type: "error",
@@ -479,13 +513,14 @@ var CapabilityService = class _CapabilityService {
   buildActionContext(override) {
     return {
       logger: this.logger,
-      httpClient: this.httpClient,
+      platformHttpClient: this.platformHttpClient,
       userContext: override?.userContext ?? this.getUserContext()
     };
   }
   getUserContext() {
     const ctx = this.requestContextService.getContext();
     return {
+      appId: ctx?.appId ?? "",
       userId: ctx?.userId ?? "",
       tenantId: ctx?.tenantId ?? ""
     };
@@ -504,7 +539,7 @@ CapabilityService = _ts_decorate3([
 ], CapabilityService);
 
 // src/controllers/debug.controller.ts
-import { Controller, Post, Get, Param, Body, Res, HttpException, HttpStatus } from "@nestjs/common";
+import { Controller, Post, Get, Param, Body, Res, HttpException, HttpStatus, Logger as Logger3 } from "@nestjs/common";
 function _ts_decorate4(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -522,13 +557,14 @@ function _ts_param2(paramIndex, decorator) {
   };
 }
 __name(_ts_param2, "_ts_param");
-var DebugController = class {
+var DebugController = class _DebugController {
   static {
     __name(this, "DebugController");
   }
   capabilityService;
   pluginLoaderService;
   templateEngineService;
+  logger = new Logger3(_DebugController.name);
   constructor(capabilityService, pluginLoaderService, templateEngineService) {
     this.capabilityService = capabilityService;
     this.pluginLoaderService = pluginLoaderService;
@@ -633,45 +669,61 @@ var DebugController = class {
   }
   async debugStream(capabilityId, body, res) {
     const params = body.params ?? {};
+    const startTime = Date.now();
     res.setHeader("Content-Type", "text/event-stream");
     res.setHeader("Cache-Control", "no-cache");
     res.setHeader("Connection", "keep-alive");
     try {
       const config = this.getCapabilityConfig(capabilityId, body.capability);
       const action = await this.getActionName(config.pluginKey, body.action);
+      const loggerContext = {
+        capability_id: config.id,
+        plugin_key: config.pluginKey,
+        action
+      };
+      this.logger.log(`Executing capability (stream), input: ${stringifyForLog(params)}`, loggerContext);
       const capability = this.capabilityService.loadWithConfig(config);
       const eventStream = capability.callStreamWithEvents(action, params);
+      let pendingChunk = null;
+      const allChunks = [];
       for await (const event of eventStream) {
         switch (event.type) {
           case "data": {
-            const response = {
-              status_code: ErrorCodes.SUCCESS,
-              data: {
-                type: "content",
-                delta: {
-                  content: event.data
+            allChunks.push(event.data);
+            if (pendingChunk !== null) {
+              const response = {
+                status_code: ErrorCodes.SUCCESS,
+                data: {
+                  type: "content",
+                  delta: {
+                    content: pendingChunk
+                  }
                 }
-              }
-            };
-            res.write(`data: ${JSON.stringify(response)}
+              };
+              res.write(`data: ${JSON.stringify(response)}
 
 `);
+            }
+            pendingChunk = event.data;
             break;
           }
           case "done": {
-            const response = {
-              status_code: ErrorCodes.SUCCESS,
-              data: {
-                type: "content",
-                delta: {
-                  content: null
-                },
-                finished: true
-              }
-            };
-            res.write(`data: ${JSON.stringify(response)}
+            if (pendingChunk !== null) {
+              const response = {
+                status_code: ErrorCodes.SUCCESS,
+                data: {
+                  type: "content",
+                  delta: {
+                    content: pendingChunk
+                  },
+                  finished: true
+                }
+              };
+              res.write(`data: ${JSON.stringify(response)}
 
 `);
+            }
+            this.logger.log(`Capability (stream) executed successfully, duration: ${Date.now() - startTime}ms, chunks: ${allChunks.length}, result: ${stringifyForLog(allChunks)}`, loggerContext);
             res.end();
             return;
           }
@@ -694,6 +746,21 @@ var DebugController = class {
           }
         }
       }
+      if (pendingChunk !== null) {
+        const response = {
+          status_code: ErrorCodes.SUCCESS,
+          data: {
+            type: "content",
+            delta: {
+              content: pendingChunk
+            },
+            finished: true
+          }
+        };
+        res.write(`data: ${JSON.stringify(response)}
+
+`);
+      }
       res.end();
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
@@ -755,7 +822,7 @@ DebugController = _ts_decorate4([
 ], DebugController);
 
 // src/controllers/webhook.controller.ts
-import { Controller as Controller2, Get as Get2, Post as Post2, Param as Param2, Body as Body2, Res as Res2, HttpException as HttpException2, HttpStatus as HttpStatus2 } from "@nestjs/common";
+import { Controller as Controller2, Get as Get2, Post as Post2, Param as Param2, Body as Body2, Res as Res2, HttpException as HttpException2, HttpStatus as HttpStatus2, Logger as Logger4 } from "@nestjs/common";
 function _ts_decorate5(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -773,11 +840,12 @@ function _ts_param3(paramIndex, decorator) {
   };
 }
 __name(_ts_param3, "_ts_param");
-var WebhookController = class {
+var WebhookController = class _WebhookController {
   static {
     __name(this, "WebhookController");
   }
   capabilityService;
+  logger = new Logger4(_WebhookController.name);
   constructor(capabilityService) {
     this.capabilityService = capabilityService;
   }
@@ -830,43 +898,58 @@ var WebhookController = class {
     }
   }
   async executeStream(capabilityId, body, res) {
+    const startTime = Date.now();
+    const loggerContext = {
+      capability_id: capabilityId,
+      action: body.action
+    };
     res.setHeader("Content-Type", "text/event-stream");
     res.setHeader("Cache-Control", "no-cache");
     res.setHeader("Connection", "keep-alive");
     try {
+      this.logger.log(`Executing capability (stream), input: ${stringifyForLog(body.params)}`, loggerContext);
       const capability = this.capabilityService.load(capabilityId);
       const eventStream = capability.callStreamWithEvents(body.action, body.params);
+      let pendingChunk = null;
+      const allChunks = [];
       for await (const event of eventStream) {
         switch (event.type) {
           case "data": {
-            const response = {
-              status_code: ErrorCodes.SUCCESS,
-              data: {
-                type: "content",
-                delta: {
-                  content: event.data
+            allChunks.push(event.data);
+            if (pendingChunk !== null) {
+              const response = {
+                status_code: ErrorCodes.SUCCESS,
+                data: {
+                  type: "content",
+                  delta: {
+                    content: pendingChunk
+                  }
                 }
-              }
-            };
-            res.write(`data: ${JSON.stringify(response)}
+              };
+              res.write(`data: ${JSON.stringify(response)}
 
 `);
+            }
+            pendingChunk = event.data;
             break;
           }
           case "done": {
-            const response = {
-              status_code: ErrorCodes.SUCCESS,
-              data: {
-                type: "content",
-                delta: {
-                  content: null
-                },
-                finished: true
-              }
-            };
-            res.write(`data: ${JSON.stringify(response)}
+            if (pendingChunk !== null) {
+              const response = {
+                status_code: ErrorCodes.SUCCESS,
+                data: {
+                  type: "content",
+                  delta: {
+                    content: pendingChunk
+                  },
+                  finished: true
+                }
+              };
+              res.write(`data: ${JSON.stringify(response)}
 
 `);
+            }
+            this.logger.log(`Capability (stream) executed successfully, duration: ${Date.now() - startTime}ms, chunks: ${allChunks.length}, result: ${stringifyForLog(allChunks)}`, loggerContext);
             res.end();
             return;
           }
@@ -889,6 +972,22 @@ var WebhookController = class {
           }
         }
       }
+      if (pendingChunk !== null) {
+        const response = {
+          status_code: ErrorCodes.SUCCESS,
+          data: {
+            type: "content",
+            delta: {
+              content: pendingChunk
+            },
+            finished: true
+          }
+        };
+        res.write(`data: ${JSON.stringify(response)}
+
+`);
+      }
+      this.logger.log(`Capability (stream) executed successfully, duration: ${Date.now() - startTime}ms, chunks: ${allChunks.length}, result: ${stringifyForLog(allChunks)}`, loggerContext);
       res.end();
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
@@ -949,7 +1048,7 @@ WebhookController = _ts_decorate5([
 
 // src/capability.module.ts
 import { Module } from "@nestjs/common";
-import { RequestContextService as RequestContextService2, PLATFORM_HTTP_CLIENT as PLATFORM_HTTP_CLIENT2 } from "@lark-apaas/nestjs-common";
+import { CommonModule, RequestContextService as RequestContextService2, PLATFORM_HTTP_CLIENT as PLATFORM_HTTP_CLIENT2 } from "@lark-apaas/nestjs-common";
 function _ts_decorate6(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -976,6 +1075,9 @@ var CapabilityModule = class _CapabilityModule {
   static forRoot(options) {
     return {
       module: _CapabilityModule,
+      imports: [
+        CommonModule
+      ],
       controllers: getControllers(),
       providers: [
         {
@@ -1010,6 +1112,9 @@ var CapabilityModule = class _CapabilityModule {
 };
 CapabilityModule = _ts_decorate6([
   Module({
+    imports: [
+      CommonModule
+    ],
     controllers: getControllers(),
     providers: [
       CapabilityService,