@tachybase/module-workflow 1.6.0 → 1.6.1

package/dist/server/actions/workflows.js

@@ -44,30 +44,30 @@ var import_server = require("@tego/server");
 var import_Plugin = __toESM(require("../Plugin"));
 var import_utils = require("../utils");
 var import_workflows = require("./workflows.helpers");
-async function listExtended(context, next) {
+async function listExtended(ctx, next) {
   var _a;
-  await import_server.actions.list(context, next);
-  if (((_a = context.body) == null ? void 0 : _a.rows) && Array.isArray(context.body.rows) && context.body.rows.length > 0) {
-    const workflows = context.body.rows;
+  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 = context.body.rows[index];
+      const row = ctx.body.rows[index];
       if (!row) continue;
       const workflowData = (0, import_workflows.getWorkflowData)(workflow);
-      const executedTime = await (0, import_workflows.getLatestExecutedTimeForWorkflow)(context, workflowData == null ? void 0 : workflowData.id, workflowData == null ? void 0 : workflowData.key);
+      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)(context, workflowData == null ? void 0 : workflowData.key);
+      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)(context, workflow, workflowData == null ? void 0 : workflowData.key);
+      const categories = await (0, import_workflows.getCategoriesForWorkflow)(ctx, workflow, workflowData == null ? void 0 : workflowData.key);
       (0, import_workflows.setCategories)(row, categories);
     }
   }
-  return context;
+  return ctx;
 }
-async function update(context, next) {
-  const repository = import_server.utils.getRepositoryFromParams(context);
-  const { filterByTk, values } = context.action.params;
-  context.action.mergeParams({
+async function update(ctx, next) {
+  const repository = import_server.utils.getRepositoryFromParams(ctx);
+  const { filterByTk, values } = ctx.action.params;
+  ctx.action.mergeParams({
     whitelist: [
       "title",
       "description",
@@ -86,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,
@@ -112,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
@@ -120,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 ? {
@@ -147,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({
@@ -204,58 +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
   });
   if (!workflow) {
-    return context.throw(404, "Workflow not found");
+    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, transaction: context.transaction },
-    context.db
+    { httpContext: ctx, transaction: ctx.transaction },
+    ctx.db
   );
   if (!execution) {
-    context.state.messages.push({
-      message: context.t("Failed to create execution", { ns: "workflow" })
+    ctx.state.messages.push({
+      message: ctx.t("Failed to create execution", { ns: "workflow" })
     });
-    return context.throw(500, "Failed to create execution");
+    return ctx.throw(500, "Failed to create execution");
   }
-  context.state.messages.push({
-    message: context.t("Test execution ended", { ns: "workflow" })
+  ctx.state.messages.push({
+    message: ctx.t("Test execution ended", { ns: "workflow" })
   });
-  context.body = 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);
@@ -315,30 +315,30 @@ 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 {
@@ -346,36 +346,36 @@ async function retry(context, next) {
       plugin,
       workflow,
       execution.context,
-      { httpContext: context, transaction: context.transaction },
-      context.db
+      { httpContext: ctx, transaction: ctx.transaction },
+      ctx.db
     );
     if (!newExecution) {
-      context.state.messages.push({
-        message: context.t("Failed to create execution", { ns: "workflow" })
+      ctx.state.messages.push({
+        message: ctx.t("Failed to create execution", { ns: "workflow" })
       });
-      context.body = {
-        error: context.t("Failed to create execution", { ns: "workflow" })
+      ctx.body = {
+        error: ctx.t("Failed to create execution", { ns: "workflow" })
       };
       return await next();
     }
-    context.state.messages.push({ message: context.t("Execute ended", { ns: "workflow" }) });
-    context.body = newExecution;
+    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
@@ -384,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(

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;