@tachybase/module-workflow 1.5.1 → 1.6.1

package/dist/server/actions/workflows.js

@@ -29,6 +29,7 @@ var workflows_exports = {};
 __export(workflows_exports, {
   destroy: () => destroy,
   dump: () => dump,
+  listExtended: () => listExtended,
   load: () => load,
   moveWorkflow: () => moveWorkflow,
   retry: () => retry,
@@ -41,10 +42,32 @@ __export(workflows_exports, {
 module.exports = __toCommonJS(workflows_exports);
 var import_server = require("@tego/server");
 var import_Plugin = __toESM(require("../Plugin"));
-async function update(context, next) {
-  const repository = import_server.utils.getRepositoryFromParams(context);
-  const { filterByTk, values } = context.action.params;
-  context.action.mergeParams({
+var import_utils = require("../utils");
+var import_workflows = require("./workflows.helpers");
+async function listExtended(ctx, next) {
+  var _a;
+  await import_server.actions.list(ctx, next);
+  if (((_a = ctx.body) == null ? void 0 : _a.rows) && Array.isArray(ctx.body.rows) && ctx.body.rows.length > 0) {
+    const workflows = ctx.body.rows;
+    for (let index = 0; index < workflows.length; index++) {
+      const workflow = workflows[index];
+      const row = ctx.body.rows[index];
+      if (!row) continue;
+      const workflowData = (0, import_workflows.getWorkflowData)(workflow);
+      const executedTime = await (0, import_workflows.getLatestExecutedTimeForWorkflow)(ctx, workflowData == null ? void 0 : workflowData.id, workflowData == null ? void 0 : workflowData.key);
+      (0, import_workflows.setLatestExecutedTime)(row, executedTime);
+      const eventSourceName = await (0, import_workflows.getEventSourceNameForWorkflow)(ctx, workflowData == null ? void 0 : workflowData.key);
+      (0, import_workflows.setEventSourceName)(row, eventSourceName);
+      const categories = await (0, import_workflows.getCategoriesForWorkflow)(ctx, workflow, workflowData == null ? void 0 : workflowData.key);
+      (0, import_workflows.setCategories)(row, categories);
+    }
+  }
+  return ctx;
+}
+async function update(ctx, next) {
+  const repository = import_server.utils.getRepositoryFromParams(ctx);
+  const { filterByTk, values } = ctx.action.params;
+  ctx.action.mergeParams({
     whitelist: [
       "title",
       "description",
@@ -63,15 +86,15 @@ async function update(context, next) {
   if (Object.keys(values).includes("config")) {
     const workflow = await repository.findById(filterByTk);
     if (workflow.get("executed")) {
-      return context.throw(400, "config of executed workflow can not be updated");
+      return ctx.throw(400, "config of executed workflow can not be updated");
     }
   }
-  return import_server.actions.update(context, next);
+  return import_server.actions.update(ctx, next);
 }
-async function destroy(context, next) {
-  const repository = import_server.utils.getRepositoryFromParams(context);
-  const { filterByTk, filter } = context.action.params;
-  await context.db.sequelize.transaction(async (transaction) => {
+async function destroy(ctx, next) {
+  const repository = import_server.utils.getRepositoryFromParams(ctx);
+  const { filterByTk, filter } = ctx.action.params;
+  await ctx.db.sequelize.transaction(async (transaction) => {
     const items = await repository.find({
       filterByTk,
       filter,
@@ -89,7 +112,7 @@ async function destroy(context, next) {
       transaction
     });
     revisions.forEach((item) => ids.add(item.id));
-    context.body = await repository.destroy({
+    ctx.body = await repository.destroy({
       filterByTk: Array.from(ids),
       individualHooks: true,
       transaction
@@ -97,15 +120,15 @@ async function destroy(context, next) {
   });
   next();
 }
-async function dump(context, next) {
-  const repository = import_server.utils.getRepositoryFromParams(context);
-  const { filterByTk, filter = {}, values = {} } = context.action.params;
-  context.body = await context.db.sequelize.transaction(async (transaction) => {
+async function dump(ctx, next) {
+  const repository = import_server.utils.getRepositoryFromParams(ctx);
+  const { filterByTk, filter = {}, values = {} } = ctx.action.params;
+  ctx.body = await ctx.db.sequelize.transaction(async (transaction) => {
     const origin = await repository.findOne({
       filterByTk,
       filter,
       appends: ["nodes"],
-      context,
+      context: ctx,
       transaction
     });
     const revisionData = filter.key ? {
@@ -124,11 +147,11 @@ async function dump(context, next) {
   });
   await next();
 }
-async function load(context, next) {
-  const plugin = context.app.getPlugin(import_Plugin.default);
-  const repository = import_server.utils.getRepositoryFromParams(context);
-  const { values = {} } = context.action.params;
-  context.body = await context.db.sequelize.transaction(async (transaction) => {
+async function load(ctx, next) {
+  const plugin = ctx.tego.pm.get(import_Plugin.default);
+  const repository = import_server.utils.getRepositoryFromParams(ctx);
+  const { values = {} } = ctx.action.params;
+  ctx.body = await ctx.db.sequelize.transaction(async (transaction) => {
     const origin = values.workflow;
     const trigger2 = plugin.triggers.get(origin.type);
     const instance = await repository.create({
@@ -181,47 +204,58 @@ async function load(context, next) {
   });
   await next();
 }
-async function test(context, next) {
+async function test(ctx, next) {
   var _a;
-  const plugin = context.app.getPlugin(import_Plugin.default);
-  const repository = import_server.utils.getRepositoryFromParams(context);
-  const { filterByTk, filter = {}, values = {} } = context.action.params;
-  if (!context.state) {
-    context.state = {};
+  const plugin = ctx.tego.pm.get(import_Plugin.default);
+  const repository = import_server.utils.getRepositoryFromParams(ctx);
+  const { filterByTk, filter = {}, values = {} } = ctx.action.params;
+  if (!ctx.state) {
+    ctx.state = {};
   }
-  if (!context.state.messages) {
-    context.state.messages = [];
+  if (!ctx.state.messages) {
+    ctx.state.messages = [];
   }
   const workflow = await repository.findOne({
     filterByTk,
     filter,
     appends: ["nodes"],
-    context
+    context: ctx
   });
-  const result = await plugin.trigger(
+  if (!workflow) {
+    return ctx.throw(404, "Workflow not found");
+  }
+  const execution = await (0, import_utils.triggerWorkflowAndGetExecution)(
+    plugin,
     workflow,
     {
       data: values.data || {},
-      user: ((_a = context == null ? void 0 : context.state) == null ? void 0 : _a.currentUser) || {}
+      user: ((_a = ctx == null ? void 0 : ctx.state) == null ? void 0 : _a.currentUser) || {}
     },
-    { httpContext: context }
+    { httpContext: ctx, transaction: ctx.transaction },
+    ctx.db
   );
-  context.app.logger.info(result);
-  context.state.messages.push({
-    message: context.t("Test execution ended", { ns: "workflow" })
+  if (!execution) {
+    ctx.state.messages.push({
+      message: ctx.t("Failed to create execution", { ns: "workflow" })
+    });
+    return ctx.throw(500, "Failed to create execution");
+  }
+  ctx.state.messages.push({
+    message: ctx.t("Test execution ended", { ns: "workflow" })
   });
-  context.body = result.execution;
+  ctx.body = execution;
+  await next();
 }
-async function revision(context, next) {
-  const plugin = context.app.getPlugin(import_Plugin.default);
-  const repository = import_server.utils.getRepositoryFromParams(context);
-  const { filterByTk, filter = {}, values = {} } = context.action.params;
-  context.body = await context.db.sequelize.transaction(async (transaction) => {
+async function revision(ctx, next) {
+  const plugin = ctx.tego.pm.get(import_Plugin.default);
+  const repository = import_server.utils.getRepositoryFromParams(ctx);
+  const { filterByTk, filter = {}, values = {} } = ctx.action.params;
+  ctx.body = await ctx.db.sequelize.transaction(async (transaction) => {
     const origin = await repository.findOne({
       filterByTk,
       filter,
       appends: ["nodes"],
-      context,
+      context: ctx,
       transaction
     });
     const trigger2 = plugin.triggers.get(origin.type);
@@ -281,53 +315,67 @@ async function revision(context, next) {
   });
   await next();
 }
-async function retry(context, next) {
-  const plugin = context.app.getPlugin(import_Plugin.default);
-  const repository = import_server.utils.getRepositoryFromParams(context);
-  const { filterByTk, filter = {}, values = {} } = context.action.params;
-  const ExecutionRepo = context.db.getRepository("executions");
-  if (!context.state) {
-    context.state = {};
+async function retry(ctx, next) {
+  const plugin = ctx.tego.pm.get(import_Plugin.default);
+  const repository = import_server.utils.getRepositoryFromParams(ctx);
+  const { filterByTk, filter = {}, values = {} } = ctx.action.params;
+  const ExecutionRepo = ctx.db.getRepository("executions");
+  if (!ctx.state) {
+    ctx.state = {};
   }
-  if (!context.state.messages) {
-    context.state.messages = [];
+  if (!ctx.state.messages) {
+    ctx.state.messages = [];
   }
   const workflow = await repository.findOne({
     filterByTk,
     filter,
     appends: ["nodes"],
-    context
+    context: ctx
   });
   const execution = await ExecutionRepo.findOne({
     filter: { key: workflow.key },
     sort: ["-createdAt"]
   });
   if (!execution) {
-    context.state.messages.push({
-      message: context.t("No execution records found for this workflow.", { ns: "workflow" })
+    ctx.state.messages.push({
+      message: ctx.t("No execution records found for this workflow.", { ns: "workflow" })
     });
   }
   try {
-    const result = await plugin.trigger(workflow, execution.context, { httpContext: context });
-    context.app.logger.info(result);
-    context.state.messages.push({ message: context.t("Execute ended", { ns: "workflow" }) });
-    context.body = result.execution;
+    const newExecution = await (0, import_utils.triggerWorkflowAndGetExecution)(
+      plugin,
+      workflow,
+      execution.context,
+      { httpContext: ctx, transaction: ctx.transaction },
+      ctx.db
+    );
+    if (!newExecution) {
+      ctx.state.messages.push({
+        message: ctx.t("Failed to create execution", { ns: "workflow" })
+      });
+      ctx.body = {
+        error: ctx.t("Failed to create execution", { ns: "workflow" })
+      };
+      return await next();
+    }
+    ctx.state.messages.push({ message: ctx.t("Execute ended", { ns: "workflow" }) });
+    ctx.body = newExecution;
   } catch (error) {
-    context.app.logger.error(`Failed to retry execution ${execution.id}: ${error.message}`);
-    context.state.messages.push({
-      message: context.t("Failed to retry execution", { ns: "workflow" }),
+    ctx.tego.logger.error(`Failed to retry execution ${execution.id}: ${error.message}`);
+    ctx.state.messages.push({
+      message: ctx.t("Failed to retry execution", { ns: "workflow" }),
       error: error.message
     });
-    context.body = {
+    ctx.body = {
       error: error.message
     };
   }
   await next();
 }
-async function sync(context, next) {
-  const plugin = context.app.getPlugin(import_Plugin.default);
-  const repository = import_server.utils.getRepositoryFromParams(context);
-  const { filterByTk, filter = {} } = context.action.params;
+async function sync(ctx, next) {
+  const plugin = ctx.tego.pm.get(import_Plugin.default);
+  const repository = import_server.utils.getRepositoryFromParams(ctx);
+  const { filterByTk, filter = {} } = ctx.action.params;
   const workflows = await repository.find({
     filterByTk,
     filter
@@ -336,13 +384,13 @@ async function sync(context, next) {
     plugin.toggle(workflow, false);
     plugin.toggle(workflow);
   });
-  context.status = 204;
+  ctx.status = 204;
   await next();
 }
 async function trigger(ctx, next) {
   var _a, _b;
   if (!ctx.action.params.triggerWorkflows) {
-    const plugin = ctx.app.getPlugin(import_Plugin.default);
+    const plugin = ctx.tego.getPlugin(import_Plugin.default);
     const workflow = await ctx.db.getRepository("workflows").findById(ctx.action.params.filterByTk);
     const updateData = JSON.parse(decodeURIComponent(((_a = ctx.action.params) == null ? void 0 : _a.updateData) || ""));
     plugin.trigger(
@@ -428,6 +476,7 @@ async function moveWorkflow(ctx, next) {
 0 && (module.exports = {
   destroy,
   dump,
+  listExtended,
   load,
   moveWorkflow,
   retry,

package/dist/server/features/interception/RequestInterceptionTrigger.d.ts

@@ -4,7 +4,7 @@ import Trigger from '../../triggers';
 export declare class RequestInterceptionTrigger extends Trigger {
     static TYPE: string;
     sync: boolean;
-    middleware: (context: Context, next: Next) => Promise<never>;
+    middleware: (ctx: Context, next: Next) => Promise<never>;
     constructor(workflow: PluginWorkflowServer);
     on(): void;
     off(): void;

package/dist/server/features/interception/RequestInterceptionTrigger.js

@@ -46,13 +46,13 @@ const _RequestInterceptionTrigger = class _RequestInterceptionTrigger extends im
   constructor(workflow) {
     super(workflow);
     this.sync = true;
-    this.middleware = async (context, next) => {
+    this.middleware = async (ctx, next) => {
       const {
         resourceName,
         actionName,
         params: { filterByTk, filter, values, triggerWorkflows = "" }
-      } = context.action;
-      const dataSourceHeader = context.get("x-data-source");
+      } = ctx.action;
+      const dataSourceHeader = ctx.get("x-data-source");
       const jointCollectionName = (0, import_server.joinCollectionName)(dataSourceHeader, resourceName);
       const triggerWorkflowsMap = /* @__PURE__ */ new Map();
       const triggerWorkflowsArray = [];
@@ -89,18 +89,18 @@ const _RequestInterceptionTrigger = class _RequestInterceptionTrigger extends im
         const processor = await this.workflow.trigger(
           workflow,
           {
-            user: context.state.currentUser,
-            roleName: context.state.currentRole,
+            user: ctx.state.currentUser,
+            roleName: ctx.state.currentRole,
             params: {
               filterByTk,
               filter,
               values
             }
           },
-          { httpContext: context }
+          { httpContext: ctx }
         );
         if (!processor) {
-          return context.throw(500);
+          return ctx.throw(500);
         }
         const { lastSavedJob, nodesMap } = processor;
         const lastNode = nodesMap.get(lastSavedJob == null ? void 0 : lastSavedJob.nodeId);
@@ -112,17 +112,17 @@ const _RequestInterceptionTrigger = class _RequestInterceptionTrigger extends im
         }
         if (processor.execution.status < import_constants.EXECUTION_STATUS.STARTED) {
           if ((lastNode == null ? void 0 : lastNode.type) !== "end") {
-            return context.throw(
+            return ctx.throw(
               500,
-              context.t("Workflow on your action failed, please contact the administrator", { ns: "workflow" })
+              ctx.t("Workflow on your action failed, please contact the administrator", { ns: "workflow" })
             );
           }
           const err = new RequestInterceptionError("Request is intercepted by workflow");
           err.status = 400;
-          err.messages = context.state.messages;
-          return context.throw(err.status, err);
+          err.messages = ctx.state.messages;
+          return ctx.throw(err.status, err);
         }
-        return context.throw(500, "Workflow on your action hangs, please contact the administrator");
+        return ctx.throw(500, "Workflow on your action hangs, please contact the administrator");
       }
       await next();
     };

package/dist/server/features/manual/actions.d.ts

@@ -1,2 +1,2 @@
 import { Context } from '@tego/server';
-export declare function submit(context: Context, next: any): Promise<never>;
+export declare function submit(ctx: Context, next: any): Promise<never>;

package/dist/server/features/manual/actions.js

@@ -32,15 +32,15 @@ __export(actions_exports, {
 module.exports = __toCommonJS(actions_exports);
 var import_server = require("@tego/server");
 var import__ = __toESM(require("../.."));
-async function submit(context, next) {
+async function submit(ctx, next) {
   var _a, _b, _c;
-  const repository = import_server.utils.getRepositoryFromParams(context);
-  const { filterByTk, values } = context.action.params;
-  const { currentUser } = context.state;
+  const repository = import_server.utils.getRepositoryFromParams(ctx);
+  const { filterByTk, values } = ctx.action.params;
+  const { currentUser } = ctx.state;
   if (!currentUser) {
-    return context.throw(401);
+    return ctx.throw(401);
   }
-  const plugin = context.app.getPlugin(import__.default);
+  const plugin = ctx.tego.pm.get(import__.default);
   const instruction = plugin.instructions.get("manual");
   const userJob = await repository.findOne({
     filterByTk,
@@ -48,24 +48,24 @@ async function submit(context, next) {
     //   userId: currentUser?.id
     // },
     appends: ["job", "node", "execution", "workflow"],
-    context
+    context: ctx
   });
   if (!userJob) {
-    return context.throw(404);
+    return ctx.throw(404);
   }
   const { forms = {} } = userJob.node.config;
   const [formKey] = Object.keys(values.result ?? {}).filter((key) => key !== "_");
   const actionKey = (_a = values.result) == null ? void 0 : _a._;
   const actionItem = (_c = (_b = forms[formKey]) == null ? void 0 : _b.actions) == null ? void 0 : _c.find((item) => item.key === actionKey);
   if (userJob.status !== import__.JOB_STATUS.PENDING || userJob.job.status !== import__.JOB_STATUS.PENDING || userJob.execution.status !== import__.EXECUTION_STATUS.STARTED || !userJob.workflow.enabled || !actionKey || (actionItem == null ? void 0 : actionItem.status) == null) {
-    return context.throw(400);
+    return ctx.throw(400);
   }
   userJob.execution.workflow = userJob.workflow;
   const processor = plugin.createProcessor(userJob.execution);
   await processor.prepare();
   const assignees = processor.getParsedValue(userJob.node.config.assignees ?? [], userJob.nodeId).flat().filter(Boolean);
   if (!assignees.includes(currentUser.id) || userJob.userId !== currentUser.id) {
-    return context.throw(403);
+    return ctx.throw(403);
   }
   const presetValues = processor.getParsedValue(actionItem.values ?? {}, userJob.nodeId, {
     // @deprecated
@@ -90,8 +90,8 @@ async function submit(context, next) {
   }
   await userJob.save();
   await processor.exit();
-  context.body = userJob;
-  context.status = 202;
+  ctx.body = userJob;
+  ctx.status = 202;
   await next();
   userJob.job.execution = userJob.execution;
   userJob.job.latestUserJob = userJob;

package/dist/server/features/notice/actions.js

@@ -26,37 +26,37 @@ var import_constants = require("../common/constants");
 var import_workflowNotice = require("./collections/workflowNotice");
 var import_constants2 = require("./constants");
 const workflows = {
-  async listWorkflowNoticeFlows(context, next) {
-    context.action.mergeParams({
+  async listWorkflowNoticeFlows(ctx, next) {
+    ctx.action.mergeParams({
       filter: {
         type: import_constants.NOTICE_INSTRUCTION_NAMESPACE,
         enabled: true
       }
     });
-    return import_server.actions.list(context, next);
+    return import_server.actions.list(ctx, next);
   }
 };
 const workflowNotice = {
-  async listCentralized(context, next) {
-    const centralizedNoticeFlow = await context.db.getRepository(import_workflowNotice.COLLECTION_WORKFLOWS_NAME).find({
+  async listCentralized(ctx, next) {
+    const centralizedNoticeFlow = await ctx.db.getRepository(import_workflowNotice.COLLECTION_WORKFLOWS_NAME).find({
       filter: {
         "config.centralized": true
       },
       fields: ["id"]
     });
-    context.action.mergeParams({
+    ctx.action.mergeParams({
       filter: {
         workflowId: centralizedNoticeFlow.map((item) => item.id)
       }
     });
-    return import_server.actions.list(context, next);
+    return import_server.actions.list(ctx, next);
   },
-  async submit(context, next) {
-    const repository = import_server.utils.getRepositoryFromParams(context);
-    const { filterByTk, values } = context.action.params;
-    const { currentUser } = context.state;
+  async submit(ctx, next) {
+    const repository = import_server.utils.getRepositoryFromParams(ctx);
+    const { filterByTk, values } = ctx.action.params;
+    const { currentUser } = ctx.state;
     if (!currentUser) {
-      return context.throw(401);
+      return ctx.throw(401);
     }
     const workflowNotice2 = await repository.findOne({
       filterByTk,
@@ -64,13 +64,13 @@ const workflowNotice = {
         userId: currentUser == null ? void 0 : currentUser.id
       },
       appends: ["job", "node", "execution", "workflow"],
-      context
+      context: ctx
     });
     if (!workflowNotice2) {
-      return context.throw(404);
+      return ctx.throw(404);
     }
     if (!workflowNotice2.workflow.enabled || workflowNotice2.execution.status || workflowNotice2.job.status || workflowNotice2.status !== import_constants2.NOTICE_ACTION_STATUS.PENDING || !(workflowNotice2.node.config.actions ?? []).includes(values.status)) {
-      return context.throw(400);
+      return ctx.throw(400);
     }
     await workflowNotice2.update({
       status: values.status
@@ -79,13 +79,13 @@ const workflowNotice = {
       //   summary: workflowNotice.approval.summary,
       //   collectionName: workflowNotice.approval.collectionName,
     });
-    context.body = workflowNotice2.get();
-    context.status = 202;
+    ctx.body = workflowNotice2.get();
+    ctx.status = 202;
     await next();
     workflowNotice2.execution.workflow = workflowNotice2.workflow;
     workflowNotice2.job.execution = workflowNotice2.execution;
     workflowNotice2.job.latestUserJob = workflowNotice2.get();
-    const workflow = context.app.getPlugin(import__.PluginWorkflow);
+    const workflow = ctx.tego.pm.get(import__.PluginWorkflow);
     const processor = workflow.createProcessor(workflowNotice2.execution);
     processor.logger.info(
       `notice node (${workflowNotice2.nodeId}) action trigger execution (${workflowNotice2.execution.id}) to resume`
@@ -94,7 +94,7 @@ const workflowNotice = {
   }
 };
 function init({ app }) {
-  app.actions({
+  app.resourcer.registerActions({
     ...make(import_workflowNotice.COLLECTION_WORKFLOWS_NAME, workflows),
     ...make(import_constants.COLLECTION_NOTICE_NAME, workflowNotice)
   });

package/dist/server/features/notice/plugin.js

@@ -59,9 +59,6 @@ class PluginWorkflowNoticeServer extends import_server.Plugin {
         plugin: this
       }
     });
-    await db.import({
-      directory: import_node_path.default.resolve(__dirname, "collections")
-    });
     (0, import_actions.init)(this);
     this.app.acl.allow(import_workflowNotice.COLLECTION_WORKFLOWS_NAME, ["listWorkflowNoticeFlows"], "loggedIn");
     this.app.acl.allow(import_constants.COLLECTION_NOTICE_NAME, ["get", "list", "listCentralized", "submit"], "loggedIn");

package/dist/server/features/omni-trigger/CustomActionTrigger.d.ts

@@ -3,8 +3,8 @@ import Trigger from '../../triggers';
 export declare class OmniTrigger extends Trigger {
     static TYPE: string;
     constructor(workflow: any);
-    triggerAction: (context: any, next: any) => Promise<any>;
-    middleware: (context: Context, next: Next) => Promise<any>;
+    triggerAction: (ctx: any, next: any) => Promise<any>;
+    middleware: (ctx: Context, next: Next) => Promise<any>;
     private trigger;
     on(): void;
     off(): void;