@nocobase/plugin-workflow-manual 0.17.0-alpha.4

package/dist/server/ManualInstruction.js

@@ -0,0 +1,150 @@
+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 ManualInstruction_exports = {};
+__export(ManualInstruction_exports, {
+  default: () => ManualInstruction_default
+});
+module.exports = __toCommonJS(ManualInstruction_exports);
+var import_utils = require("@nocobase/utils");
+var import_plugin_workflow = require("@nocobase/plugin-workflow");
+var import_forms = __toESM(require("./forms"));
+const MULTIPLE_ASSIGNED_MODE = {
+  SINGLE: Symbol("single"),
+  ALL: Symbol("all"),
+  ANY: Symbol("any"),
+  ALL_PERCENTAGE: Symbol("all percentage"),
+  ANY_PERCENTAGE: Symbol("any percentage")
+};
+const Modes = {
+  [MULTIPLE_ASSIGNED_MODE.SINGLE]: {
+    getStatus(distribution, assignees) {
+      const done = distribution.find((item) => item.status !== import_plugin_workflow.JOB_STATUS.PENDING && item.count > 0);
+      return done ? done.status : null;
+    }
+  },
+  [MULTIPLE_ASSIGNED_MODE.ALL]: {
+    getStatus(distribution, assignees) {
+      const resolved = distribution.find((item) => item.status === import_plugin_workflow.JOB_STATUS.RESOLVED);
+      if (resolved && resolved.count === assignees.length) {
+        return import_plugin_workflow.JOB_STATUS.RESOLVED;
+      }
+      const rejected = distribution.find((item) => item.status < import_plugin_workflow.JOB_STATUS.PENDING);
+      if (rejected && rejected.count) {
+        return rejected.status;
+      }
+      return null;
+    }
+  },
+  [MULTIPLE_ASSIGNED_MODE.ANY]: {
+    getStatus(distribution, assignees) {
+      const resolved = distribution.find((item) => item.status === import_plugin_workflow.JOB_STATUS.RESOLVED);
+      if (resolved && resolved.count) {
+        return import_plugin_workflow.JOB_STATUS.RESOLVED;
+      }
+      const rejectedCount = distribution.reduce(
+        (count, item) => item.status < import_plugin_workflow.JOB_STATUS.PENDING ? count + item.count : count,
+        0
+      );
+      if (rejectedCount === assignees.length) {
+        return import_plugin_workflow.JOB_STATUS.REJECTED;
+      }
+      return null;
+    }
+  }
+};
+function getMode(mode) {
+  switch (true) {
+    case mode === 1:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ALL];
+    case mode === -1:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ANY];
+    case mode > 0:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ALL_PERCENTAGE];
+    case mode < 0:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ANY_PERCENTAGE];
+    default:
+      return Modes[MULTIPLE_ASSIGNED_MODE.SINGLE];
+  }
+}
+class ManualInstruction_default extends import_plugin_workflow.Instruction {
+  constructor(plugin) {
+    super(plugin);
+    this.plugin = plugin;
+    (0, import_forms.default)(this);
+  }
+  formTypes = new import_utils.Registry();
+  async run(node, prevJob, processor) {
+    const { mode, ...config } = node.config;
+    const assignees = [...new Set(processor.getParsedValue(config.assignees, node.id) || [])];
+    const job = await processor.saveJob({
+      status: import_plugin_workflow.JOB_STATUS.PENDING,
+      result: mode ? [] : null,
+      nodeId: node.id,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    const UserJobModel = processor.options.plugin.db.getModel("users_jobs");
+    await UserJobModel.bulkCreate(
+      assignees.map((userId) => ({
+        userId,
+        jobId: job.id,
+        nodeId: node.id,
+        executionId: job.executionId,
+        workflowId: node.workflowId,
+        status: import_plugin_workflow.JOB_STATUS.PENDING
+      })),
+      {
+        transaction: processor.transaction
+      }
+    );
+    return job;
+  }
+  async resume(node, job, processor) {
+    var _a;
+    const { assignees = [], mode } = node.config;
+    const UserJobModel = processor.options.plugin.db.getModel("users_jobs");
+    const distribution = await UserJobModel.count({
+      where: {
+        jobId: job.id
+      },
+      group: ["status"],
+      transaction: processor.transaction
+    });
+    const submitted = distribution.reduce(
+      (count, item) => item.status !== import_plugin_workflow.JOB_STATUS.PENDING ? count + item.count : count,
+      0
+    );
+    const status = job.status || (getMode(mode).getStatus(distribution, assignees) ?? import_plugin_workflow.JOB_STATUS.PENDING);
+    const result = mode ? (submitted || 0) / assignees.length : ((_a = job.latestUserJob) == null ? void 0 : _a.result) ?? job.result;
+    processor.logger.debug(`manual resume job and next status: ${status}`);
+    job.set({
+      status,
+      result
+    });
+    return job;
+  }
+}

package/dist/server/Plugin.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from '@nocobase/server';
+import WorkflowPlugin from '@nocobase/plugin-workflow';
+export default class extends Plugin {
+    workflow: WorkflowPlugin;
+    load(): Promise<void>;
+}

package/dist/server/Plugin.js

@@ -0,0 +1,73 @@
+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 Plugin_exports = {};
+__export(Plugin_exports, {
+  default: () => Plugin_default
+});
+module.exports = __toCommonJS(Plugin_exports);
+var import_server = require("@nocobase/server");
+var import_actions = __toESM(require("@nocobase/actions"));
+var import_plugin_workflow = require("@nocobase/plugin-workflow");
+var import_jobs = __toESM(require("./collecions/jobs"));
+var import_users = __toESM(require("./collecions/users"));
+var import_users_jobs = __toESM(require("./collecions/users_jobs"));
+var import_actions2 = require("./actions");
+var import_ManualInstruction = __toESM(require("./ManualInstruction"));
+class Plugin_default extends import_server.Plugin {
+  workflow;
+  async load() {
+    this.app.db.collection(import_users_jobs.default);
+    this.app.db.extendCollection(import_users.default);
+    this.app.db.extendCollection(import_jobs.default);
+    this.app.resource({
+      name: "users_jobs",
+      actions: {
+        list: {
+          filter: {
+            $or: [
+              {
+                "workflow.enabled": true
+              },
+              {
+                "workflow.enabled": false,
+                status: {
+                  $ne: import_plugin_workflow.JOB_STATUS.PENDING
+                }
+              }
+            ]
+          },
+          handler: import_actions.default.list
+        },
+        submit: import_actions2.submit
+      }
+    });
+    const workflowPlugin = this.app.getPlugin("workflow");
+    this.workflow = workflowPlugin;
+    workflowPlugin.instructions.register("manual", new import_ManualInstruction.default(workflowPlugin));
+  }
+}

package/dist/server/actions.d.ts

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

package/dist/server/actions.js

@@ -0,0 +1,94 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var actions_exports = {};
+__export(actions_exports, {
+  submit: () => submit
+});
+module.exports = __toCommonJS(actions_exports);
+var import_actions = require("@nocobase/actions");
+var import_plugin_workflow = require("@nocobase/plugin-workflow");
+async function submit(context, next) {
+  var _a, _b, _c;
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { filterByTk, values } = context.action.params;
+  const { currentUser } = context.state;
+  if (!currentUser) {
+    return context.throw(401);
+  }
+  const plugin = context.app.pm.get("workflow");
+  const instruction = plugin.instructions.get("manual");
+  const userJob = await repository.findOne({
+    filterByTk,
+    // filter: {
+    //   userId: currentUser?.id
+    // },
+    appends: ["job", "node", "execution", "workflow"],
+    context
+  });
+  if (!userJob) {
+    return context.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_plugin_workflow.JOB_STATUS.PENDING || userJob.job.status !== import_plugin_workflow.JOB_STATUS.PENDING || userJob.execution.status !== import_plugin_workflow.EXECUTION_STATUS.STARTED || !userJob.workflow.enabled || !actionKey || (actionItem == null ? void 0 : actionItem.status) == null) {
+    return context.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);
+  if (!assignees.includes(currentUser.id) || userJob.userId !== currentUser.id) {
+    return context.throw(403);
+  }
+  const presetValues = processor.getParsedValue(actionItem.values ?? {}, userJob.nodeId, {
+    // @deprecated
+    currentUser: currentUser.toJSON(),
+    // @deprecated
+    currentRecord: values.result[formKey],
+    // @deprecated
+    currentTime: /* @__PURE__ */ new Date(),
+    $user: currentUser.toJSON(),
+    $nForm: values.result[formKey],
+    $nDate: {
+      now: /* @__PURE__ */ new Date()
+    }
+  });
+  userJob.set({
+    status: actionItem.status,
+    result: actionItem.status > import_plugin_workflow.JOB_STATUS.PENDING ? { [formKey]: Object.assign(values.result[formKey], presetValues), _: actionKey } : Object.assign(userJob.result ?? {}, values.result)
+  });
+  const handler = instruction.formTypes.get(forms[formKey].type);
+  if (handler && userJob.status) {
+    await handler.call(instruction, userJob, forms[formKey], processor);
+  }
+  await userJob.save({ transaction: processor.transaction });
+  await processor.exit();
+  context.body = userJob;
+  context.status = 202;
+  await next();
+  userJob.job.execution = userJob.execution;
+  userJob.job.latestUserJob = userJob;
+  processor.logger.info(`manual node (${userJob.nodeId}) action trigger execution (${userJob.execution.id}) to resume`);
+  plugin.resume(userJob.job);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  submit
+});

package/dist/server/collecions/jobs.d.ts

@@ -0,0 +1,19 @@
+declare const _default: {
+    name: string;
+    fields: ({
+        type: string;
+        name: string;
+        through: string;
+        target?: undefined;
+        foreignKey?: undefined;
+        onDelete?: undefined;
+    } | {
+        type: string;
+        name: string;
+        target: string;
+        foreignKey: string;
+        onDelete: string;
+        through?: undefined;
+    })[];
+};
+export default _default;

package/dist/server/collecions/jobs.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jobs_exports = {};
+__export(jobs_exports, {
+  default: () => jobs_default
+});
+module.exports = __toCommonJS(jobs_exports);
+var jobs_default = {
+  name: "jobs",
+  fields: [
+    {
+      type: "belongsToMany",
+      name: "users",
+      through: "users_jobs"
+    },
+    {
+      type: "hasMany",
+      name: "usersJobs",
+      target: "users_jobs",
+      foreignKey: "jobId",
+      onDelete: "CASCADE"
+    }
+  ]
+};

package/dist/server/collecions/users.d.ts

@@ -0,0 +1,15 @@
+declare const _default: {
+    name: string;
+    fields: ({
+        type: string;
+        name: string;
+        through: string;
+        target?: undefined;
+    } | {
+        type: string;
+        name: string;
+        target: string;
+        through?: undefined;
+    })[];
+};
+export default _default;

package/dist/server/collecions/users.js

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var users_exports = {};
+__export(users_exports, {
+  default: () => users_default
+});
+module.exports = __toCommonJS(users_exports);
+var users_default = {
+  name: "users",
+  fields: [
+    {
+      type: "belongsToMany",
+      name: "jobs",
+      through: "users_jobs"
+    },
+    {
+      type: "hasMany",
+      name: "usersJobs",
+      target: "users_jobs"
+    }
+  ]
+};

package/dist/server/collecions/users_jobs.d.ts

@@ -0,0 +1,3 @@
+import { CollectionOptions } from '@nocobase/database';
+declare const _default: CollectionOptions;
+export default _default;

package/dist/server/collecions/users_jobs.js

@@ -0,0 +1,70 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var users_jobs_exports = {};
+__export(users_jobs_exports, {
+  default: () => users_jobs_default
+});
+module.exports = __toCommonJS(users_jobs_exports);
+var users_jobs_default = {
+  namespace: "workflow.executionLogs",
+  name: "users_jobs",
+  duplicator: "optional",
+  fields: [
+    {
+      type: "bigInt",
+      name: "id",
+      primaryKey: true,
+      autoIncrement: true
+    },
+    {
+      type: "belongsTo",
+      name: "job",
+      target: "jobs",
+      foreignKey: "jobId",
+      primaryKey: false
+    },
+    {
+      type: "belongsTo",
+      name: "user",
+      target: "users",
+      foreignKey: "userId",
+      primaryKey: false
+    },
+    {
+      type: "belongsTo",
+      name: "execution"
+    },
+    {
+      type: "belongsTo",
+      name: "node",
+      target: "flow_nodes"
+    },
+    {
+      type: "belongsTo",
+      name: "workflow"
+    },
+    {
+      type: "integer",
+      name: "status"
+    },
+    {
+      type: "jsonb",
+      name: "result"
+    }
+  ]
+};

package/dist/server/forms/create.d.ts

@@ -0,0 +1,5 @@
+import { Processor } from '@nocobase/plugin-workflow';
+import ManualInstruction from '../ManualInstruction';
+export default function (this: ManualInstruction, instance: any, { collection }: {
+    collection: any;
+}, processor: Processor): Promise<void>;

package/dist/server/forms/create.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var create_exports = {};
+__export(create_exports, {
+  default: () => create_default
+});
+module.exports = __toCommonJS(create_exports);
+async function create_default(instance, { collection }, processor) {
+  const repo = this.plugin.db.getRepository(collection);
+  if (!repo) {
+    throw new Error(`collection ${collection} for create data on manual node not found`);
+  }
+  const { _, ...form } = instance.result;
+  const [values] = Object.values(form);
+  await repo.create({
+    values: {
+      ...values ?? {},
+      createdBy: instance.userId,
+      updatedBy: instance.userId
+    },
+    context: {
+      executionId: processor.execution.id
+    },
+    transaction: processor.transaction
+  });
+}

package/dist/server/forms/index.d.ts

@@ -0,0 +1,6 @@
+import { Processor } from '@nocobase/plugin-workflow';
+import ManualInstruction from '../ManualInstruction';
+export type FormHandler = (this: ManualInstruction, instance: any, formConfig: any, processor: Processor) => Promise<void>;
+export default function ({ formTypes }: {
+    formTypes: any;
+}): void;

package/dist/server/forms/index.js

@@ -0,0 +1,38 @@
+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 forms_exports = {};
+__export(forms_exports, {
+  default: () => forms_default
+});
+module.exports = __toCommonJS(forms_exports);
+var import_create = __toESM(require("./create"));
+var import_update = __toESM(require("./update"));
+function forms_default({ formTypes }) {
+  formTypes.register("create", import_create.default);
+  formTypes.register("update", import_update.default);
+}

package/dist/server/forms/update.d.ts

@@ -0,0 +1,6 @@
+import { Processor } from '@nocobase/plugin-workflow';
+import ManualInstruction from '../ManualInstruction';
+export default function (this: ManualInstruction, instance: any, { collection, filter }: {
+    collection: any;
+    filter?: {};
+}, processor: Processor): Promise<void>;

package/dist/server/forms/update.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var update_exports = {};
+__export(update_exports, {
+  default: () => update_default
+});
+module.exports = __toCommonJS(update_exports);
+async function update_default(instance, { collection, filter = {} }, processor) {
+  const repo = this.plugin.db.getRepository(collection);
+  if (!repo) {
+    throw new Error(`collection ${collection} for update data on manual node not found`);
+  }
+  const { _, ...form } = instance.result;
+  const [values] = Object.values(form);
+  await repo.update({
+    filter: processor.getParsedValue(filter, instance.nodeId),
+    values: {
+      ...values ?? {},
+      updatedBy: instance.userId
+    },
+    context: {
+      executionId: processor.execution.id
+    },
+    transaction: processor.transaction
+  });
+}

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export { default } from './Plugin';