@tachybase/module-workflow 0.23.8

package/dist/server/actions/nodes.js

@@ -0,0 +1,322 @@
+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 nodes_exports = {};
+__export(nodes_exports, {
+  create: () => create,
+  destroy: () => destroy,
+  moveDown: () => moveDown,
+  moveUp: () => moveUp,
+  update: () => update
+});
+module.exports = __toCommonJS(nodes_exports);
+var import_actions = require("@tachybase/actions");
+var import_database = require("@tachybase/database");
+async function create(context, next) {
+  const { db } = context;
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { whitelist, blacklist, updateAssociationValues, values, associatedIndex: workflowId } = context.action.params;
+  context.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");
+    }
+    const instance = await repository.create({
+      values,
+      whitelist,
+      blacklist,
+      updateAssociationValues,
+      context,
+      transaction
+    });
+    if (!instance.upstreamId) {
+      const previousHead = await repository.findOne({
+        filter: {
+          id: {
+            $ne: instance.id
+          },
+          upstreamId: null
+        },
+        transaction
+      });
+      if (previousHead) {
+        await previousHead.setUpstream(instance, { transaction });
+        await instance.setDownstream(previousHead, { transaction });
+        instance.set("downstream", previousHead);
+      }
+      return instance;
+    }
+    const upstream = await instance.getUpstream({ transaction });
+    if (instance.branchIndex == null) {
+      const downstream = await upstream.getDownstream({ transaction });
+      if (downstream) {
+        await downstream.setUpstream(instance, { transaction });
+        await instance.setDownstream(downstream, { transaction });
+        instance.set("downstream", downstream);
+      }
+      await upstream.update(
+        {
+          downstreamId: instance.id
+        },
+        { transaction }
+      );
+      upstream.set("downstream", instance);
+    } else {
+      const [downstream] = await upstream.getBranches({
+        where: {
+          id: {
+            [import_database.Op.ne]: instance.id
+          },
+          branchIndex: instance.branchIndex
+        },
+        transaction
+      });
+      if (downstream) {
+        await downstream.update(
+          {
+            upstreamId: instance.id,
+            branchIndex: null
+          },
+          { transaction }
+        );
+        await instance.setDownstream(downstream, { transaction });
+        instance.set("downstream", downstream);
+      }
+    }
+    instance.set("upstream", upstream);
+    return instance;
+  });
+  await next();
+}
+function searchBranchNodes(nodes, from) {
+  const branchHeads = nodes.filter((item) => item.upstreamId === from.id && item.branchIndex != null);
+  return branchHeads.reduce(
+    (flatten, head) => flatten.concat(searchBranchDownstreams(nodes, head)),
+    []
+  );
+}
+function searchBranchDownstreams(nodes, from) {
+  let result = [];
+  for (let search = from; search; search = search.downstream) {
+    result = [...result, search, ...searchBranchNodes(nodes, search)];
+  }
+  return result;
+}
+async function destroy(context, next) {
+  const { db } = context;
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { filterByTk } = context.action.params;
+  const fields = ["id", "upstreamId", "downstreamId", "branchIndex"];
+  const instance = await repository.findOne({
+    filterByTk,
+    fields: [...fields, "workflowId"],
+    appends: ["upstream", "downstream", "workflow"]
+  });
+  if (instance.workflow.executed) {
+    context.throw(400, "Nodes in executed workflow could not be deleted");
+  }
+  await db.sequelize.transaction(async (transaction) => {
+    const { upstream, downstream } = instance.get();
+    if (upstream && upstream.downstreamId === instance.id) {
+      await upstream.update(
+        {
+          downstreamId: instance.downstreamId
+        },
+        { transaction }
+      );
+    }
+    if (downstream) {
+      await downstream.update(
+        {
+          upstreamId: instance.upstreamId,
+          branchIndex: instance.branchIndex
+        },
+        { transaction }
+      );
+    }
+    const nodes = await repository.find({
+      filter: {
+        workflowId: instance.workflowId
+      },
+      fields,
+      transaction
+    });
+    const nodesMap = /* @__PURE__ */ new Map();
+    nodes.forEach((item) => {
+      nodesMap.set(item.id, item);
+    });
+    nodes.forEach((item) => {
+      if (item.upstreamId) {
+        item.upstream = nodesMap.get(item.upstreamId);
+      }
+      if (item.downstreamId) {
+        item.downstream = nodesMap.get(item.downstreamId);
+      }
+    });
+    const branchNodes = searchBranchNodes(nodes, nodesMap.get(instance.id));
+    await repository.destroy({
+      filterByTk: [instance.id, ...branchNodes.map((item) => item.id)],
+      transaction
+    });
+  });
+  context.body = instance;
+  await next();
+}
+async function update(context, next) {
+  const { db } = context;
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { filterByTk, values, whitelist, blacklist, filter, updateAssociationValues } = context.action.params;
+  context.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");
+    }
+    return repository.update({
+      filterByTk,
+      values,
+      whitelist,
+      blacklist,
+      filter,
+      updateAssociationValues,
+      context,
+      transaction
+    });
+  });
+  await next();
+}
+async function moveUp(context, next) {
+  const { db } = context;
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { filterByTk } = context.action.params;
+  const fields = ["id", "upstreamId", "downstreamId", "branchIndex", "key"];
+  const instance = await repository.findOne({
+    filterByTk,
+    fields: [...fields, "workflowId"],
+    appends: ["upstream", "downstream", "workflow"]
+  });
+  if (instance.workflow.executed) {
+    context.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");
+    }
+    const upUpStreamId = upstream.upstreamId;
+    const upStreamId = upstream.id;
+    if (upUpStreamId) {
+      await repository.update({
+        filterByTk: upUpStreamId,
+        values: {
+          downstreamId: instance.id
+        },
+        transaction
+      });
+    }
+    await upstream.update(
+      {
+        downstreamId: instance.downstreamId,
+        upstreamId: instance.id
+      },
+      { transaction }
+    );
+    await instance.update(
+      {
+        downstreamId: instance.upstreamId,
+        upstreamId: upUpStreamId
+      },
+      {
+        transaction
+      }
+    );
+    if (downstream) {
+      await downstream.update(
+        {
+          upstreamId: upStreamId
+        },
+        {
+          transaction
+        }
+      );
+    }
+  });
+  context.body = instance;
+  await next();
+}
+async function moveDown(context, next) {
+  const { db } = context;
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { filterByTk } = context.action.params;
+  const fields = ["id", "upstreamId", "downstreamId", "branchIndex", "key"];
+  const instance = await repository.findOne({
+    filterByTk,
+    fields: [...fields, "workflowId"],
+    appends: ["upstream", "downstream", "workflow"]
+  });
+  if (instance.workflow.executed) {
+    context.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");
+    }
+    if (upstream) {
+      await upstream.update({
+        downstreamId: instance.downstreamId
+      }, {
+        transaction
+      });
+    }
+    await downstream.update({
+      upstreamId: instance.upstreamId,
+      downstreamId: instance.id
+    }, {
+      transaction
+    });
+    await instance.update({
+      downstreamId: downDownstreamId,
+      upstreamId: downstream.id
+    }, {
+      transaction
+    });
+    if (downDownstreamId) {
+      await repository.update({
+        filterByTk: downDownstreamId,
+        values: {
+          upstreamId: instance.id
+        },
+        transaction
+      });
+    }
+  });
+  context.body = instance;
+  await next();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create,
+  destroy,
+  moveDown,
+  moveUp,
+  update
+});

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

@@ -0,0 +1,10 @@
+import { Context, Next } from '@tachybase/actions';
+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>;
+export declare function trigger(ctx: Context, next: Next): Promise<void>;

package/dist/server/actions/workflows.js

@@ -0,0 +1,347 @@
+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_exports = {};
+__export(workflows_exports, {
+  destroy: () => destroy,
+  dump: () => dump,
+  load: () => load,
+  retry: () => retry,
+  revision: () => revision,
+  sync: () => sync,
+  test: () => test,
+  trigger: () => trigger,
+  update: () => update
+});
+module.exports = __toCommonJS(workflows_exports);
+var import_actions = __toESM(require("@tachybase/actions"));
+var import_database = require("@tachybase/database");
+var import_Plugin = __toESM(require("../Plugin"));
+async function update(context, next) {
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { filterByTk, values } = context.action.params;
+  context.action.mergeParams({
+    whitelist: ["title", "description", "enabled", "triggerTitle", "config", "options", "type", "sync", "tags"]
+  });
+  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 import_actions.default.update(context, next);
+}
+async function destroy(context, next) {
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { filterByTk, filter } = context.action.params;
+  await context.db.sequelize.transaction(async (transaction) => {
+    const items = await repository.find({
+      filterByTk,
+      filter,
+      fields: ["id", "key", "current"],
+      transaction
+    });
+    const ids = new Set(items.map((item) => item.id));
+    const keysSet = new Set(items.filter((item) => item.current).map((item) => item.key));
+    const revisions = await repository.find({
+      filter: {
+        key: Array.from(keysSet),
+        current: { [import_database.Op.not]: true }
+      },
+      fields: ["id"],
+      transaction
+    });
+    revisions.forEach((item) => ids.add(item.id));
+    context.body = await repository.destroy({
+      filterByTk: Array.from(ids),
+      individualHooks: true,
+      transaction
+    });
+  });
+  next();
+}
+async function dump(context, next) {
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { filterByTk, filter = {}, values = {} } = context.action.params;
+  context.body = await context.db.sequelize.transaction(async (transaction) => {
+    const origin = await repository.findOne({
+      filterByTk,
+      filter,
+      appends: ["nodes"],
+      context,
+      transaction
+    });
+    const revisionData = filter.key ? {
+      key: filter.key,
+      title: origin.title,
+      triggerTitle: origin.triggerTitle,
+      allExecuted: origin.allExecuted,
+      sync: origin.sync,
+      initAt: origin.initAt
+    } : values;
+    const dumpOne = {
+      ...origin.toJSON(),
+      ...revisionData
+    };
+    return dumpOne;
+  });
+  await next();
+}
+async function load(context, next) {
+  const plugin = context.app.getPlugin(import_Plugin.default);
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { values = {} } = context.action.params;
+  context.body = await context.db.sequelize.transaction(async (transaction) => {
+    const origin = values.workflow;
+    const trigger2 = plugin.triggers.get(origin.type);
+    const instance = await repository.create({
+      values: {
+        title: values.title,
+        description: origin.description,
+        type: origin.type,
+        triggerTitle: origin.triggerTitle,
+        allExecuted: origin.allExecuted,
+        sync: origin.sync,
+        initAt: origin.initAt,
+        config: typeof trigger2.duplicateConfig === "function" ? await trigger2.duplicateConfig(origin, { transaction }) : origin.config
+      },
+      transaction
+    });
+    const originalNodesMap = /* @__PURE__ */ new Map();
+    origin.nodes.forEach((node) => {
+      originalNodesMap.set(node.id, node);
+    });
+    const oldToNew = /* @__PURE__ */ new Map();
+    const newToOld = /* @__PURE__ */ new Map();
+    for await (const node of origin.nodes) {
+      const instruction = plugin.instructions.get(node.type);
+      const newNode = await instance.createNode(
+        {
+          type: node.type,
+          key: node.key,
+          config: typeof instruction.duplicateConfig === "function" ? await instruction.duplicateConfig(node, { transaction }) : node.config,
+          title: node.title,
+          branchIndex: node.branchIndex
+        },
+        { transaction }
+      );
+      oldToNew.set(node.id, newNode);
+      newToOld.set(newNode.id, node);
+    }
+    for await (const [oldId, newNode] of oldToNew.entries()) {
+      const oldNode = originalNodesMap.get(oldId);
+      const newUpstream = oldNode.upstreamId ? oldToNew.get(oldNode.upstreamId) : null;
+      const newDownstream = oldNode.downstreamId ? oldToNew.get(oldNode.downstreamId) : null;
+      await newNode.update(
+        {
+          upstreamId: (newUpstream == null ? void 0 : newUpstream.id) ?? null,
+          downstreamId: (newDownstream == null ? void 0 : newDownstream.id) ?? null
+        },
+        { transaction }
+      );
+    }
+    return instance;
+  });
+  await next();
+}
+async function test(context, next) {
+  const plugin = context.app.getPlugin(import_Plugin.default);
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { filterByTk, filter = {}, values = {} } = context.action.params;
+  if (!context.state) {
+    context.state = {};
+  }
+  if (!context.state.messages) {
+    context.state.messages = [];
+  }
+  const workflow = await repository.findOne({
+    filterByTk,
+    filter,
+    appends: ["nodes"],
+    context
+  });
+  const result = await plugin.trigger(
+    workflow,
+    {
+      data: {
+        ...values.data,
+        user: context.state.currentUse
+      }
+    },
+    { httpContext: context }
+  );
+  context.app.logger.info(result);
+  context.state.messages.push({ message: "testing" });
+  context.body = "here???";
+}
+async function revision(context, next) {
+  const plugin = context.app.getPlugin(import_Plugin.default);
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { filterByTk, filter = {}, values = {} } = context.action.params;
+  context.body = await context.db.sequelize.transaction(async (transaction) => {
+    const origin = await repository.findOne({
+      filterByTk,
+      filter,
+      appends: ["nodes"],
+      context,
+      transaction
+    });
+    const trigger2 = plugin.triggers.get(origin.type);
+    const revisionData = filter.key ? {
+      key: filter.key,
+      title: origin.title,
+      triggerTitle: origin.triggerTitle,
+      allExecuted: origin.allExecuted,
+      sync: origin.sync,
+      initAt: origin.initAt
+    } : values;
+    const instance = await repository.create({
+      values: {
+        title: `${origin.title} copy`,
+        description: origin.description,
+        ...revisionData,
+        type: origin.type,
+        config: typeof trigger2.duplicateConfig === "function" ? await trigger2.duplicateConfig(origin, { transaction }) : origin.config
+      },
+      transaction
+    });
+    const originalNodesMap = /* @__PURE__ */ new Map();
+    origin.nodes.forEach((node) => {
+      originalNodesMap.set(node.id, node);
+    });
+    const oldToNew = /* @__PURE__ */ new Map();
+    const newToOld = /* @__PURE__ */ new Map();
+    for await (const node of origin.nodes) {
+      const instruction = plugin.instructions.get(node.type);
+      const newNode = await instance.createNode(
+        {
+          type: node.type,
+          key: node.key,
+          config: typeof instruction.duplicateConfig === "function" ? await instruction.duplicateConfig(node, { transaction }) : node.config,
+          title: node.title,
+          branchIndex: node.branchIndex
+        },
+        { transaction }
+      );
+      oldToNew.set(node.id, newNode);
+      newToOld.set(newNode.id, node);
+    }
+    for await (const [oldId, newNode] of oldToNew.entries()) {
+      const oldNode = originalNodesMap.get(oldId);
+      const newUpstream = oldNode.upstreamId ? oldToNew.get(oldNode.upstreamId) : null;
+      const newDownstream = oldNode.downstreamId ? oldToNew.get(oldNode.downstreamId) : null;
+      await newNode.update(
+        {
+          upstreamId: (newUpstream == null ? void 0 : newUpstream.id) ?? null,
+          downstreamId: (newDownstream == null ? void 0 : newDownstream.id) ?? null
+        },
+        { transaction }
+      );
+    }
+    return instance;
+  });
+  await next();
+}
+async function retry(context, next) {
+  const plugin = context.app.getPlugin(import_Plugin.default);
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { filterByTk, filter = {}, values = {} } = context.action.params;
+  const ExecutionRepo = context.db.getRepository("executions");
+  if (!context.state) {
+    context.state = {};
+  }
+  if (!context.state.messages) {
+    context.state.messages = [];
+  }
+  const workflow = await repository.findOne({
+    filterByTk,
+    filter,
+    appends: ["nodes"],
+    context
+  });
+  const execution = await ExecutionRepo.findOne({
+    filter: { key: workflow.key },
+    sort: ["-createdAt"]
+  });
+  if (!execution) {
+    context.state.messages.push({ message: "No execution records found for this workflow." });
+  }
+  const executionId = execution.id;
+  const result = await plugin.trigger(workflow, execution.context, { httpContext: context });
+  context.app.logger.info(result);
+  context.state.messages.push({ message: "Execute successfully" });
+  context.body = { executionId };
+  await next();
+}
+async function sync(context, next) {
+  const plugin = context.app.getPlugin(import_Plugin.default);
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { filterByTk, filter = {} } = context.action.params;
+  const workflows = await repository.find({
+    filterByTk,
+    filter
+  });
+  workflows.forEach((workflow) => {
+    plugin.toggle(workflow, false);
+    plugin.toggle(workflow);
+  });
+  context.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 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(
+      workflow,
+      {
+        data: {
+          updateData,
+          httpContext: ctx,
+          user: (_b = ctx == null ? void 0 : ctx.auth) == null ? void 0 : _b.user
+        }
+      },
+      { httpContext: ctx }
+    );
+  } else {
+    await next();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  destroy,
+  dump,
+  load,
+  retry,
+  revision,
+  sync,
+  test,
+  trigger,
+  update
+});

package/dist/server/collections/1-users_jobs.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@tachybase/database").CollectionOptions;
+export default _default;