@tachybase/module-workflow 1.5.1 → 1.6.1

package/dist/server/actions/nodes.js

@@ -21,25 +21,27 @@ __export(nodes_exports, {
   destroy: () => destroy,
   moveDown: () => moveDown,
   moveUp: () => moveUp,
+  syncRemoteCode: () => syncRemoteCode,
   update: () => update
 });
 module.exports = __toCommonJS(nodes_exports);
 var import_server = require("@tego/server");
-async function create(context, next) {
-  const { db } = context;
-  const repository = import_server.utils.getRepositoryFromParams(context);
-  const { whitelist, blacklist, updateAssociationValues, values, associatedIndex: workflowId } = context.action.params;
-  context.body = await db.sequelize.transaction(async (transaction) => {
+var import_get_remote_code_fetcher = require("../utils/get-remote-code-fetcher");
+async function create(ctx, next) {
+  const { db } = ctx;
+  const repository = import_server.utils.getRepositoryFromParams(ctx);
+  const { whitelist, blacklist, updateAssociationValues, values, associatedIndex: workflowId } = ctx.action.params;
+  ctx.body = await db.sequelize.transaction(async (transaction) => {
     const workflow = await repository.getSourceModel(transaction);
     if (workflow.executed) {
-      context.throw(400, "Node could not be created in executed workflow");
+      ctx.throw(400, "Node could not be created in executed workflow");
     }
     const instance = await repository.create({
       values,
       whitelist,
       blacklist,
       updateAssociationValues,
-      context,
+      context: ctx,
       transaction
     });
     if (!instance.upstreamId) {
@@ -115,10 +117,10 @@ function searchBranchDownstreams(nodes, from) {
   }
   return result;
 }
-async function destroy(context, next) {
-  const { db } = context;
-  const repository = import_server.utils.getRepositoryFromParams(context);
-  const { filterByTk } = context.action.params;
+async function destroy(ctx, next) {
+  const { db } = ctx;
+  const repository = import_server.utils.getRepositoryFromParams(ctx);
+  const { filterByTk } = ctx.action.params;
   const fields = ["id", "upstreamId", "downstreamId", "branchIndex"];
   const instance = await repository.findOne({
     filterByTk,
@@ -126,7 +128,7 @@ async function destroy(context, next) {
     appends: ["upstream", "downstream", "workflow"]
   });
   if (instance.workflow.executed) {
-    context.throw(400, "Nodes in executed workflow could not be deleted");
+    ctx.throw(400, "Nodes in executed workflow could not be deleted");
   }
   await db.sequelize.transaction(async (transaction) => {
     const { upstream, downstream } = instance.get();
@@ -172,21 +174,21 @@ async function destroy(context, next) {
       transaction
     });
   });
-  context.body = instance;
+  ctx.body = instance;
   await next();
 }
-async function update(context, next) {
-  const { db } = context;
-  const repository = import_server.utils.getRepositoryFromParams(context);
-  const { filterByTk, values, whitelist, blacklist, filter, updateAssociationValues } = context.action.params;
-  context.body = await db.sequelize.transaction(async (transaction) => {
+async function update(ctx, next) {
+  const { db } = ctx;
+  const repository = import_server.utils.getRepositoryFromParams(ctx);
+  const { filterByTk, values, whitelist, blacklist, filter, updateAssociationValues } = ctx.action.params;
+  ctx.body = await db.sequelize.transaction(async (transaction) => {
     const { workflow } = await repository.findOne({
       filterByTk,
       appends: ["workflow.executed"],
       transaction
     });
     if (workflow.executed) {
-      context.throw(400, "Nodes in executed workflow could not be reconfigured");
+      ctx.throw(400, "Nodes in executed workflow could not be reconfigured");
     }
     return repository.update({
       filterByTk,
@@ -195,16 +197,16 @@ async function update(context, next) {
       blacklist,
       filter,
       updateAssociationValues,
-      context,
+      context: ctx,
       transaction
     });
   });
   await next();
 }
-async function moveUp(context, next) {
-  const { db } = context;
-  const repository = import_server.utils.getRepositoryFromParams(context);
-  const { filterByTk } = context.action.params;
+async function moveUp(ctx, next) {
+  const { db } = ctx;
+  const repository = import_server.utils.getRepositoryFromParams(ctx);
+  const { filterByTk } = ctx.action.params;
   const fields = ["id", "upstreamId", "downstreamId", "branchIndex", "key"];
   const instance = await repository.findOne({
     filterByTk,
@@ -212,12 +214,12 @@ async function moveUp(context, next) {
     appends: ["upstream", "downstream", "workflow"]
   });
   if (instance.workflow.executed) {
-    context.throw(400, "Nodes in executed workflow could not be deleted");
+    ctx.throw(400, "Nodes in executed workflow could not be deleted");
   }
   await db.sequelize.transaction(async (transaction) => {
     const { upstream, downstream } = instance.get();
     if (!upstream) {
-      context.throw(400, "First node could not be moved up");
+      ctx.throw(400, "First node could not be moved up");
     }
     const upUpStreamId = upstream.upstreamId;
     const upStreamId = upstream.id;
@@ -257,13 +259,13 @@ async function moveUp(context, next) {
       );
     }
   });
-  context.body = instance;
+  ctx.body = instance;
   await next();
 }
-async function moveDown(context, next) {
-  const { db } = context;
-  const repository = import_server.utils.getRepositoryFromParams(context);
-  const { filterByTk } = context.action.params;
+async function moveDown(ctx, next) {
+  const { db } = ctx;
+  const repository = import_server.utils.getRepositoryFromParams(ctx);
+  const { filterByTk } = ctx.action.params;
   const fields = ["id", "upstreamId", "downstreamId", "branchIndex", "key"];
   const instance = await repository.findOne({
     filterByTk,
@@ -271,13 +273,13 @@ async function moveDown(context, next) {
     appends: ["upstream", "downstream", "workflow"]
   });
   if (instance.workflow.executed) {
-    context.throw(400, "Nodes in executed workflow could not be deleted");
+    ctx.throw(400, "Nodes in executed workflow could not be deleted");
   }
   await db.sequelize.transaction(async (transaction) => {
     const { upstream, downstream } = instance.get();
     const downDownstreamId = downstream.downstreamId;
     if (!downstream) {
-      context.throw(400, "Last node could not be moved up");
+      ctx.throw(400, "Last node could not be moved up");
     }
     if (upstream) {
       await upstream.update(
@@ -317,14 +319,138 @@ async function moveDown(context, next) {
       });
     }
   });
-  context.body = instance;
+  ctx.body = instance;
   await next();
 }
+async function syncRemoteCode(ctx, next) {
+  var _a;
+  const params = ctx.action.params.values || ctx.action.params || {};
+  const { codeUrl, codeType, codeBranch = "main", codeAuthType, codeAuthToken, codeAuthUsername, nodeId } = params;
+  if (!codeUrl || !codeType) {
+    ctx.throw(400, "codeUrl and codeType are required");
+  }
+  try {
+    const remoteCodeFetcher = (0, import_get_remote_code_fetcher.getRemoteCodeFetcher)(ctx.app);
+    if (codeType === "git" && !remoteCodeFetcher) {
+      ctx.throw(500, "WorkflowRemoteCodeFetcher service is required for Git type.");
+      return;
+    }
+    ctx.logger.info(
+      `Syncing remote code (force refresh): ${codeUrl} (type: ${codeType}, branch: ${codeBranch || "main"})`
+    );
+    if (!remoteCodeFetcher) {
+      if (codeType === "cdn") {
+        const http = require("node:http");
+        const https = require("node:https");
+        const { URL } = require("node:url");
+        const urlObj = new URL(codeUrl);
+        const client = urlObj.protocol === "https:" ? https : http;
+        const code = await new Promise((resolve, reject) => {
+          const headers = {
+            "User-Agent": "TegoWorkflow/1.0"
+          };
+          if (codeAuthType === "token" && codeAuthToken) {
+            headers["Authorization"] = `Bearer ${codeAuthToken}`;
+          } else if (codeAuthType === "basic" && codeAuthUsername && codeAuthToken) {
+            const credentials = Buffer.from(`${codeAuthUsername}:${codeAuthToken}`).toString("base64");
+            headers["Authorization"] = `Basic ${credentials}`;
+          }
+          const request = client.get(
+            {
+              hostname: urlObj.hostname,
+              port: urlObj.port || (urlObj.protocol === "https:" ? 443 : 80),
+              path: urlObj.pathname + urlObj.search,
+              headers,
+              timeout: 1e4
+            },
+            (res) => {
+              if (res.statusCode !== 200) {
+                reject(new Error(`Failed to fetch: HTTP ${res.statusCode}`));
+                return;
+              }
+              let data = "";
+              res.on("data", (chunk) => {
+                data += chunk;
+              });
+              res.on("end", () => {
+                resolve(data);
+              });
+            }
+          );
+          request.on("error", reject);
+          request.on("timeout", () => {
+            request.destroy();
+            reject(new Error("Request timeout"));
+          });
+        });
+        ctx.body = {
+          code
+        };
+      } else {
+        ctx.throw(500, `Unsupported code type: ${codeType}. RemoteCodeFetcher service is required.`);
+        return;
+      }
+    } else {
+      const code = await remoteCodeFetcher.fetchCode(
+        codeUrl,
+        codeType,
+        codeBranch || "main",
+        // 使用配置的分支，默认为 'main'
+        void 0,
+        // codePath - 使用默认值
+        codeAuthType,
+        codeAuthToken,
+        codeAuthUsername
+      );
+      ctx.body = {
+        code
+      };
+    }
+    if (nodeId && ((_a = ctx.body) == null ? void 0 : _a.code)) {
+      try {
+        const repository = ctx.db.getRepository("flow_nodes");
+        const node = await repository.findOne({
+          filterByTk: nodeId
+        });
+        if (node) {
+          const currentConfig = node.get("config") || {};
+          const config = JSON.parse(JSON.stringify(currentConfig));
+          const syncTime = (/* @__PURE__ */ new Date()).toISOString();
+          config.lastSyncTime = syncTime;
+          config.codeCache = {
+            content: ctx.body.code,
+            timestamp: Date.now()
+          };
+          await repository.update({
+            filterByTk: nodeId,
+            values: {
+              config
+            }
+          });
+        }
+      } catch (error) {
+        ctx.logger.warn("Failed to update lastSyncTime and codeCache", {
+          error: error instanceof Error ? error.message : String(error),
+          nodeId
+        });
+      }
+    }
+    await next();
+  } catch (error) {
+    ctx.logger.error("Failed to sync remote code", {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0,
+      params
+    });
+    ctx.throw(500, `Failed to fetch remote code: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   create,
   destroy,
   moveDown,
   moveUp,
+  syncRemoteCode,
   update
 });

package/dist/server/actions/workflows.d.ts

@@ -1,11 +1,20 @@
 import { Context, Next } from '@tego/server';
-export declare function update(context: Context, next: any): Promise<void>;
-export declare function destroy(context: Context, next: any): Promise<void>;
-export declare function dump(context: Context, next: Next): Promise<void>;
-export declare function load(context: Context, next: Next): Promise<void>;
-export declare function test(context: Context, next: Next): Promise<void>;
-export declare function revision(context: Context, next: Next): Promise<void>;
-export declare function retry(context: Context, next: Next): Promise<void>;
-export declare function sync(context: Context, next: any): Promise<void>;
+/**
+ * 扩展的 list action，在返回工作流列表时附加额外字段
+ * - latestExecutedTime: 最新执行时间（UTC ISO 格式）
+ * - eventSourceName: 关联的事件源名称
+ * - category: 分类信息数组
+ *
+ * 使用 listExtended 作为 action 名称，避免覆盖默认的 list，便于后续扩展
+ */
+export declare function listExtended(ctx: Context, next: Next): Promise<Context>;
+export declare function update(ctx: Context, next: any): Promise<void>;
+export declare function destroy(ctx: Context, next: any): Promise<void>;
+export declare function dump(ctx: Context, next: Next): Promise<void>;
+export declare function load(ctx: Context, next: Next): Promise<void>;
+export declare function test(ctx: Context, next: Next): Promise<never>;
+export declare function revision(ctx: Context, next: Next): Promise<void>;
+export declare function retry(ctx: Context, next: Next): Promise<any>;
+export declare function sync(ctx: Context, next: any): Promise<void>;
 export declare function trigger(ctx: Context, next: Next): Promise<void>;
 export declare function moveWorkflow(ctx: Context, next: Next): Promise<void>;

package/dist/server/actions/workflows.helpers.d.ts

@@ -0,0 +1,55 @@
+import { Context } from '@tego/server';
+/**
+ * 获取工作流的实际数据（处理 Model 和 JSON 两种格式）
+ */
+export declare function getWorkflowData(workflow: any): {
+    id?: number;
+    key?: string;
+};
+/**
+ * 查询单个工作流的最新执行时间
+ * @param ctx 上下文对象
+ * @param workflowId 工作流 ID（优先使用，可利用外键索引）
+ * @param workflowKey 工作流 Key（备用）
+ * @returns UTC ISO 格式的时间字符串，如果不存在则返回 null
+ */
+export declare function getLatestExecutedTimeForWorkflow(ctx: Context, workflowId?: number, workflowKey?: string): Promise<string | null>;
+/**
+ * 为工作流对象设置最新执行时间
+ * 支持 Model 和普通对象两种格式
+ */
+export declare function setLatestExecutedTime(row: any, executedTime: string | null): void;
+/**
+ * 查询单个工作流关联的事件源名称
+ * @param ctx 上下文对象
+ * @param workflowKey 工作流 Key
+ * @returns 事件源名称，如果不存在则返回 null
+ */
+export declare function getEventSourceNameForWorkflow(ctx: Context, workflowKey?: string): Promise<string | null>;
+/**
+ * 为工作流对象设置事件源名称
+ * 支持 Model 和普通对象两种格式
+ */
+export declare function setEventSourceName(row: any, eventSourceName: string | null): void;
+/**
+ * 查询单个工作流的分类信息
+ * 优先从 workflow 对象中获取已加载的分类数据（通过 appends），如果不存在则查询数据库
+ * @param ctx 上下文对象
+ * @param workflow 工作流对象（可能包含已加载的分类数据）
+ * @param workflowKey 工作流 Key（用于查询数据库）
+ * @returns 分类信息数组，格式：{ id, name, color? }[]
+ */
+export declare function getCategoriesForWorkflow(ctx: Context, workflow?: any, workflowKey?: string): Promise<Array<{
+    id: number;
+    name: string;
+    color?: string;
+}> | null>;
+/**
+ * 为工作流对象设置分类信息
+ * 支持 Model 和普通对象两种格式
+ */
+export declare function setCategories(row: any, categories: Array<{
+    id: number;
+    name: string;
+    color?: string;
+}> | null): void;

package/dist/server/actions/workflows.helpers.js

@@ -0,0 +1,167 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workflows_helpers_exports = {};
+__export(workflows_helpers_exports, {
+  getCategoriesForWorkflow: () => getCategoriesForWorkflow,
+  getEventSourceNameForWorkflow: () => getEventSourceNameForWorkflow,
+  getLatestExecutedTimeForWorkflow: () => getLatestExecutedTimeForWorkflow,
+  getWorkflowData: () => getWorkflowData,
+  setCategories: () => setCategories,
+  setEventSourceName: () => setEventSourceName,
+  setLatestExecutedTime: () => setLatestExecutedTime
+});
+module.exports = __toCommonJS(workflows_helpers_exports);
+var import_dayjs = __toESM(require("dayjs"));
+function getWorkflowData(workflow) {
+  return workflow && typeof workflow.toJSON === "function" ? workflow.toJSON() : workflow;
+}
+async function getLatestExecutedTimeForWorkflow(ctx, workflowId, workflowKey) {
+  if (!workflowId && !workflowKey) {
+    return null;
+  }
+  try {
+    const ExecutionRepo = ctx.db.getRepository("executions");
+    const filter = {};
+    if (workflowId) {
+      filter.workflowId = workflowId;
+    } else if (workflowKey) {
+      filter.key = workflowKey;
+    }
+    const latestExecution = await ExecutionRepo.findOne({
+      filter,
+      fields: ["id", "key", "createdAt", "workflowId"],
+      sort: ["-createdAt"],
+      context: ctx
+    });
+    return (latestExecution == null ? void 0 : latestExecution.createdAt) ? (0, import_dayjs.default)(latestExecution.createdAt).utc().toISOString() : null;
+  } catch (error) {
+    ctx.log.error("Failed to fetch latest executed time:", error);
+    return null;
+  }
+}
+function setLatestExecutedTime(row, executedTime) {
+  row.latestExecutedTime = executedTime;
+  if (row && typeof row.setDataValue === "function") {
+    row.setDataValue("latestExecutedTime", executedTime);
+  }
+}
+async function getEventSourceNameForWorkflow(ctx, workflowKey) {
+  if (!workflowKey) {
+    return null;
+  }
+  try {
+    const WebhookRepo = ctx.db.getRepository("webhooks");
+    const eventSource = await WebhookRepo.findOne({
+      filter: { workflowKey },
+      fields: ["id", "name"],
+      context: ctx
+    });
+    return (eventSource == null ? void 0 : eventSource.name) || null;
+  } catch (error) {
+    ctx.log.error("Failed to fetch event source name:", error);
+    return null;
+  }
+}
+function setEventSourceName(row, eventSourceName) {
+  row.eventSourceName = eventSourceName;
+  if (row && typeof row.setDataValue === "function") {
+    row.setDataValue("eventSourceName", eventSourceName);
+  }
+}
+async function getCategoriesForWorkflow(ctx, workflow, workflowKey) {
+  var _a;
+  if (workflow) {
+    const workflowData = workflow && typeof workflow.toJSON === "function" ? workflow.toJSON() : workflow;
+    if ((workflowData == null ? void 0 : workflowData.category) && Array.isArray(workflowData.category)) {
+      return workflowData.category.map((cat) => {
+        const data = cat && typeof cat.toJSON === "function" ? cat.toJSON() : cat;
+        return {
+          id: data == null ? void 0 : data.id,
+          name: data == null ? void 0 : data.name,
+          color: data == null ? void 0 : data.color
+        };
+      });
+    }
+  }
+  const key = workflowKey || workflow && ((_a = getWorkflowData(workflow)) == null ? void 0 : _a.key);
+  if (!key) {
+    return null;
+  }
+  try {
+    const WorkflowCategoryRepo = ctx.db.getRepository("workflowCategory");
+    const CategoryRepo = ctx.db.getRepository("workflowCategories");
+    const workflowCategories = await WorkflowCategoryRepo.find({
+      filter: { workflowKey: key },
+      fields: ["categoryId"],
+      context: ctx
+    });
+    if (!workflowCategories || workflowCategories.length === 0) {
+      return [];
+    }
+    const categoryIds = workflowCategories.map((wc) => {
+      const data = wc && typeof wc.toJSON === "function" ? wc.toJSON() : wc;
+      return data == null ? void 0 : data.categoryId;
+    }).filter(Boolean);
+    if (categoryIds.length === 0) {
+      return [];
+    }
+    const categories = await CategoryRepo.find({
+      filter: { id: categoryIds },
+      fields: ["id", "name", "color"],
+      sort: ["sort"],
+      context: ctx
+    });
+    return categories.map((cat) => {
+      const data = cat && typeof cat.toJSON === "function" ? cat.toJSON() : cat;
+      return {
+        id: data == null ? void 0 : data.id,
+        name: data == null ? void 0 : data.name,
+        color: data == null ? void 0 : data.color
+      };
+    });
+  } catch (error) {
+    ctx.log.error("Failed to fetch categories:", error);
+    return null;
+  }
+}
+function setCategories(row, categories) {
+  row.category = categories || [];
+  if (row && typeof row.setDataValue === "function") {
+    row.setDataValue("category", categories || []);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCategoriesForWorkflow,
+  getEventSourceNameForWorkflow,
+  getLatestExecutedTimeForWorkflow,
+  getWorkflowData,
+  setCategories,
+  setEventSourceName,
+  setLatestExecutedTime
+});