@tachybase/module-workflow 0.23.8

package/dist/server/instructions/CreateInstruction.js

@@ -0,0 +1,175 @@
+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 CreateInstruction_exports = {};
+__export(CreateInstruction_exports, {
+  CreateInstruction: () => CreateInstruction,
+  default: () => CreateInstruction_default
+});
+module.exports = __toCommonJS(CreateInstruction_exports);
+var import_data_source = require("@tachybase/data-source");
+var import_server = require("@tachybase/server");
+var import_utils = require("@tachybase/utils");
+var import_axios = __toESM(require("axios"));
+var import_form_data = __toESM(require("form-data"));
+var import_lodash = __toESM(require("lodash"));
+var import_mime_types = __toESM(require("mime-types"));
+var import__ = require(".");
+var import_constants = require("../constants");
+var import_utils2 = require("../utils");
+class CreateInstruction extends import__.Instruction {
+  async run(node, input, processor) {
+    const { collection, params: { appends = [], ...params } = {} } = node.config;
+    const [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(collection);
+    const { repository, filterTargetKey } = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+    const options = processor.getParsedValue(params, node.id);
+    const transaction = this.workflow.useDataSourceTransaction(dataSourceName, processor.transaction);
+    const c = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+    const fields = c.getFields();
+    const fieldNames = Object.keys(params.values);
+    const includesFields = fields.filter((field) => fieldNames.includes(field.options.name));
+    const userId = import_lodash.default.get(processor.getScope(node.id), "$context.user.id", "");
+    const token = this.workflow.app.authManager.jwt.sign({ userId });
+    const isJSON = (str) => {
+      try {
+        return JSON.parse(str);
+      } catch (e) {
+        return false;
+      }
+    };
+    const handleResource = async (resource) => {
+      const parseRes = isJSON(resource);
+      const config = {
+        method: "get",
+        url: resource,
+        responseType: "stream"
+      };
+      const form = new import_form_data.default();
+      if (resource.startsWith("data:")) {
+        const matches = resource.match(/^data:(.+);base64,(.+)$/);
+        if (matches) {
+          const contentType = matches[1];
+          const base64Data = matches[2];
+          const buffer = Buffer.from(base64Data, "base64");
+          const ext = import_mime_types.default.extension(contentType);
+          const filename = `${(0, import_utils.uid)()}.${ext}`;
+          form.append("file", buffer, {
+            filename,
+            contentType
+          });
+        } else {
+          throw new Error("Invalid data URL format");
+        }
+      } else if (parseRes) {
+        const { url: resourceUrl, params: resourceParams, headers: resourceHeaders, body: resourceBody } = parseRes;
+        config.url = resourceUrl;
+        config.params = resourceParams;
+        config.headers = resourceHeaders;
+        if (resourceHeaders["content-type"] === "multipart/form-data") {
+          const formData = new import_form_data.default();
+          Object.entries(resourceBody).forEach(([key, value]) => {
+            formData.append(key, value);
+          });
+          config.data = formData;
+        } else {
+          config.data = resourceBody;
+        }
+        const response = await (0, import_axios.default)(config);
+        const contentType = response.headers["content-type"];
+        const ext = import_mime_types.default.extension(contentType);
+        const filename = `${(0, import_utils.uid)()}.${ext}`;
+        form.append("file", response.data, {
+          filename,
+          contentType: response.headers["content-type"]
+        });
+      } else {
+        const response = await (0, import_axios.default)(config);
+        const contentType = response.headers["content-type"];
+        const ext = import_mime_types.default.extension(contentType);
+        const filename = `${(0, import_utils.uid)()}.${ext}`;
+        form.append("file", response.data, {
+          filename,
+          contentType: response.headers["content-type"]
+        });
+      }
+      const origin = import_server.Gateway.getInstance().runAtLoop;
+      const uploadResponse = await (0, import_axios.default)({
+        method: "post",
+        url: origin + "/api/attachments:create",
+        data: form,
+        headers: {
+          ...form.getHeaders(),
+          Authorization: "Bearer " + token
+        }
+      });
+      return uploadResponse.data.data;
+    };
+    for (const attachmentField of includesFields) {
+      if (attachmentField.options.interface === "attachment") {
+        const urls = options.values[attachmentField.options.name];
+        if (Array.isArray(urls)) {
+          for (const i in urls) {
+            urls[i] = await handleResource(urls[i]);
+          }
+        } else {
+          const url = options.values[attachmentField.options.name];
+          options.values[attachmentField.options.name] = await handleResource(url);
+        }
+      }
+    }
+    const created = await repository.create({
+      ...options,
+      context: {
+        stack: Array.from(new Set((processor.execution.context.stack ?? []).concat(processor.execution.id)))
+      },
+      transaction
+    });
+    let result = created;
+    if (created && appends.length) {
+      const includeFields = appends.reduce((set, field) => {
+        set.add(field.split(".")[0]);
+        set.add(field);
+        return set;
+      }, /* @__PURE__ */ new Set());
+      result = await repository.findOne({
+        filterByTk: created[filterTargetKey],
+        appends: Array.from(includeFields),
+        transaction
+      });
+    }
+    return {
+      // NOTE: get() for non-proxied instance (#380)
+      result: (0, import_utils2.toJSON)(result),
+      status: import_constants.JOB_STATUS.RESOLVED
+    };
+  }
+}
+var CreateInstruction_default = CreateInstruction;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreateInstruction
+});

package/dist/server/instructions/DestroyInstruction.d.ts

@@ -0,0 +1,10 @@
+import { Instruction } from '.';
+import type Processor from '../Processor';
+import type { FlowNodeModel } from '../types';
+export declare class DestroyInstruction extends Instruction {
+    run(node: FlowNodeModel, input: any, processor: Processor): Promise<{
+        result: any;
+        status: 1;
+    }>;
+}
+export default DestroyInstruction;

package/dist/server/instructions/DestroyInstruction.js

@@ -0,0 +1,50 @@
+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 DestroyInstruction_exports = {};
+__export(DestroyInstruction_exports, {
+  DestroyInstruction: () => DestroyInstruction,
+  default: () => DestroyInstruction_default
+});
+module.exports = __toCommonJS(DestroyInstruction_exports);
+var import_data_source = require("@tachybase/data-source");
+var import__ = require(".");
+var import_constants = require("../constants");
+class DestroyInstruction extends import__.Instruction {
+  async run(node, input, processor) {
+    const { collection, params = {} } = node.config;
+    const [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(collection);
+    const { repository } = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+    const options = processor.getParsedValue(params, node.id);
+    const result = await repository.destroy({
+      ...options,
+      context: {
+        stack: Array.from(new Set((processor.execution.context.stack ?? []).concat(processor.execution.id)))
+      },
+      transaction: this.workflow.useDataSourceTransaction(dataSourceName, processor.transaction)
+    });
+    return {
+      result,
+      status: import_constants.JOB_STATUS.RESOLVED
+    };
+  }
+}
+var DestroyInstruction_default = DestroyInstruction;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DestroyInstruction
+});

package/dist/server/instructions/EndInstruction.d.ts

@@ -0,0 +1,6 @@
+import Instruction from '.';
+import Processor from '../Processor';
+import { FlowNodeModel } from '../types';
+export default class extends Instruction {
+    run(node: FlowNodeModel, prevJob: any, processor: Processor): Promise<any>;
+}

package/dist/server/instructions/EndInstruction.js

@@ -0,0 +1,47 @@
+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 EndInstruction_exports = {};
+__export(EndInstruction_exports, {
+  default: () => EndInstruction_default
+});
+module.exports = __toCommonJS(EndInstruction_exports);
+var import__ = __toESM(require("."));
+var import_constants = require("../constants");
+class EndInstruction_default extends import__.default {
+  async run(node, prevJob, processor) {
+    const { endStatus = import_constants.JOB_STATUS.RESOLVED } = node.config;
+    await processor.saveJob({
+      result: (prevJob == null ? void 0 : prevJob.result) ?? null,
+      status: endStatus,
+      nodeId: node.id,
+      nodeKey: node.key,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    return processor.exit(endStatus);
+  }
+}

package/dist/server/instructions/QueryInstruction.d.ts

@@ -0,0 +1,13 @@
+import { Instruction } from '.';
+import type Processor from '../Processor';
+import type { FlowNodeModel } from '../types';
+export declare class QueryInstruction extends Instruction {
+    run(node: FlowNodeModel, input: any, processor: Processor): Promise<{
+        result: any;
+        status: -1;
+    } | {
+        result: any;
+        status: 1;
+    }>;
+}
+export default QueryInstruction;

package/dist/server/instructions/QueryInstruction.js

@@ -0,0 +1,78 @@
+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 QueryInstruction_exports = {};
+__export(QueryInstruction_exports, {
+  QueryInstruction: () => QueryInstruction,
+  default: () => QueryInstruction_default
+});
+module.exports = __toCommonJS(QueryInstruction_exports);
+var import_actions = require("@tachybase/actions");
+var import_data_source = require("@tachybase/data-source");
+var import__ = require(".");
+var import_constants = require("../constants");
+var import_utils = require("../utils");
+class QueryInstruction extends import__.Instruction {
+  async run(node, input, processor) {
+    const { collection, multiple, isTree, params = {}, failOnEmpty = false } = node.config;
+    const otherOptions = {};
+    if (isTree) {
+      otherOptions.tree = true;
+    }
+    const [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(collection);
+    const { repository } = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+    const {
+      page = import_actions.DEFAULT_PAGE,
+      pageSize = import_actions.DEFAULT_PER_PAGE,
+      sort = [],
+      ...options
+    } = processor.getParsedValue(params, node.id);
+    const appends = options.appends ? Array.from(
+      options.appends.reduce((set, field) => {
+        set.add(field.split(".")[0]);
+        set.add(field);
+        return set;
+      }, /* @__PURE__ */ new Set())
+    ) : options.appends;
+    const result = await (multiple ? repository.find : repository.findOne).call(repository, {
+      ...options,
+      ...otherOptions,
+      ...import_actions.utils.pageArgsToLimitArgs(page, pageSize),
+      sort: sort.filter((item) => item.field).map((item) => {
+        var _a;
+        return `${((_a = item.direction) == null ? void 0 : _a.toLowerCase()) === "desc" ? "-" : ""}${item.field}`;
+      }),
+      appends,
+      transaction: this.workflow.useDataSourceTransaction(dataSourceName, processor.transaction)
+    });
+    if (failOnEmpty && (multiple ? !result.length : !result)) {
+      return {
+        result,
+        status: import_constants.JOB_STATUS.FAILED
+      };
+    }
+    return {
+      result: (0, import_utils.toJSON)(result),
+      status: import_constants.JOB_STATUS.RESOLVED
+    };
+  }
+}
+var QueryInstruction_default = QueryInstruction;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QueryInstruction
+});

package/dist/server/instructions/UpdateInstruction.d.ts

@@ -0,0 +1,10 @@
+import { Instruction } from '.';
+import type Processor from '../Processor';
+import type { FlowNodeModel } from '../types';
+export declare class UpdateInstruction extends Instruction {
+    run(node: FlowNodeModel, input: any, processor: Processor): Promise<{
+        result: any;
+        status: 1;
+    }>;
+}
+export default UpdateInstruction;

package/dist/server/instructions/UpdateInstruction.js

@@ -0,0 +1,159 @@
+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 UpdateInstruction_exports = {};
+__export(UpdateInstruction_exports, {
+  UpdateInstruction: () => UpdateInstruction,
+  default: () => UpdateInstruction_default
+});
+module.exports = __toCommonJS(UpdateInstruction_exports);
+var import_data_source = require("@tachybase/data-source");
+var import_server = require("@tachybase/server");
+var import_utils = require("@tachybase/utils");
+var import_axios = __toESM(require("axios"));
+var import_form_data = __toESM(require("form-data"));
+var import_lodash = __toESM(require("lodash"));
+var import_mime_types = __toESM(require("mime-types"));
+var import__ = require(".");
+var import_constants = require("../constants");
+class UpdateInstruction extends import__.Instruction {
+  async run(node, input, processor) {
+    const { collection, params = {} } = node.config;
+    const [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(collection);
+    const { repository } = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+    const options = processor.getParsedValue(params, node.id);
+    const c = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+    const fields = c.getFields();
+    const fieldNames = Object.keys(params.values);
+    const includesFields = fields.filter((field) => fieldNames.includes(field.options.name));
+    const userId = import_lodash.default.get(processor.getScope(node.id), "$context.user.id", "");
+    const token = this.workflow.app.authManager.jwt.sign({ userId });
+    const isJSON = (str) => {
+      try {
+        return JSON.parse(str);
+      } catch (e) {
+        return false;
+      }
+    };
+    const handleResource = async (resource) => {
+      const parseRes = isJSON(resource);
+      const config = {
+        method: "get",
+        url: resource,
+        responseType: "stream"
+      };
+      const form = new import_form_data.default();
+      if (resource.startsWith("data:")) {
+        const matches = resource.match(/^data:(.+);base64,(.+)$/);
+        if (matches) {
+          const contentType = matches[1];
+          const base64Data = matches[2];
+          const buffer = Buffer.from(base64Data, "base64");
+          const ext = import_mime_types.default.extension(contentType);
+          const filename = `${(0, import_utils.uid)()}.${ext}`;
+          form.append("file", buffer, {
+            filename,
+            contentType
+          });
+        } else {
+          throw new Error("Invalid data URL format");
+        }
+      } else if (parseRes) {
+        const { url: resourceUrl, params: resourceParams, headers: resourceHeaders, body: resourceBody } = parseRes;
+        config.url = resourceUrl;
+        config.params = resourceParams;
+        config.headers = resourceHeaders;
+        if (resourceHeaders["content-type"] === "multipart/form-data") {
+          const formData = new import_form_data.default();
+          Object.entries(resourceBody).forEach(([key, value]) => {
+            formData.append(key, value);
+          });
+          config.data = formData;
+        } else {
+          config.data = resourceBody;
+        }
+        const response = await (0, import_axios.default)(config);
+        const contentType = response.headers["content-type"];
+        const ext = import_mime_types.default.extension(contentType);
+        const filename = `${(0, import_utils.uid)()}.${ext}`;
+        form.append("file", response.data, {
+          filename,
+          contentType: response.headers["content-type"]
+        });
+      } else {
+        const response = await (0, import_axios.default)(config);
+        const contentType = response.headers["content-type"];
+        const ext = import_mime_types.default.extension(contentType);
+        const filename = `${(0, import_utils.uid)()}.${ext}`;
+        form.append("file", response.data, {
+          filename,
+          contentType: response.headers["content-type"]
+        });
+      }
+      const origin = import_server.Gateway.getInstance().runAtLoop;
+      const uploadResponse = await (0, import_axios.default)({
+        method: "post",
+        url: origin + "/api/attachments:create",
+        data: form,
+        headers: {
+          ...form.getHeaders(),
+          Authorization: "Bearer " + token
+        }
+      });
+      return uploadResponse.data.data;
+    };
+    for (const attachmentField of includesFields) {
+      if (attachmentField.options.interface === "attachment") {
+        const urls = options.values[attachmentField.options.name];
+        if (Array.isArray(urls)) {
+          for (const i in urls) {
+            urls[i] = await handleResource(urls[i]);
+          }
+        } else {
+          const url = options.values[attachmentField.options.name];
+          options.values[attachmentField.options.name] = [await handleResource(url)];
+        }
+      }
+    }
+    const result = await repository.update({
+      ...options,
+      context: {
+        stack: Array.from(new Set((processor.execution.context.stack ?? []).concat(processor.execution.id)))
+      },
+      transaction: this.workflow.useDataSourceTransaction(dataSourceName, processor.transaction)
+    });
+    return {
+      result: result.length ?? result,
+      status: import_constants.JOB_STATUS.RESOLVED
+    };
+  }
+}
+var UpdateInstruction_default = UpdateInstruction;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UpdateInstruction
+});

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

@@ -0,0 +1,23 @@
+import { Transactionable } from '@tachybase/database';
+import type Plugin from '../Plugin';
+import type Processor from '../Processor';
+import type { FlowNodeModel } from '../types';
+export interface IJob {
+    status: number;
+    result?: unknown;
+    [key: string]: unknown;
+}
+export type InstructionResult = IJob | Promise<IJob> | null;
+export type Runner = (node: FlowNodeModel, input: any, processor: Processor) => InstructionResult;
+export type InstructionInterface = {
+    run: Runner;
+    resume?: Runner;
+    getScope?: (node: FlowNodeModel, data: any, processor: Processor) => any;
+    duplicateConfig?: (node: FlowNodeModel, options: Transactionable) => object | Promise<object>;
+};
+export declare abstract class Instruction implements InstructionInterface {
+    workflow: Plugin;
+    constructor(workflow: Plugin);
+    abstract run(node: FlowNodeModel, input: any, processor: Processor): InstructionResult;
+}
+export default Instruction;

package/dist/server/instructions/index.js

@@ -0,0 +1,33 @@
+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 instructions_exports = {};
+__export(instructions_exports, {
+  Instruction: () => Instruction,
+  default: () => instructions_default
+});
+module.exports = __toCommonJS(instructions_exports);
+class Instruction {
+  constructor(workflow) {
+    this.workflow = workflow;
+  }
+}
+var instructions_default = Instruction;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Instruction
+});

package/dist/server/migrations/20241118104303-add-initAt.d.ts

@@ -0,0 +1,6 @@
+import { Migration } from '@tachybase/server';
+export default class extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20241118104303-add-initAt.js

@@ -0,0 +1,47 @@
+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 add_initAt_exports = {};
+__export(add_initAt_exports, {
+  default: () => add_initAt_default
+});
+module.exports = __toCommonJS(add_initAt_exports);
+var import_server = require("@tachybase/server");
+var import_sequelize = require("sequelize");
+var import_constants = require("../constants");
+class add_initAt_default extends import_server.Migration {
+  on = "afterLoad";
+  // 'beforeLoad' or 'afterLoad'
+  appVersion = "<0.22.38";
+  async up() {
+    const result = await this.app.db.sequelize.query(
+      `
+      WITH min_created_at AS (
+        SELECT key, MIN("createdAt") AS min_created_at
+        FROM ${import_constants.COLLECTION_WORKFLOWS_NAME}
+        GROUP BY key
+      )
+      UPDATE ${import_constants.COLLECTION_WORKFLOWS_NAME} AS wf
+      SET "initAt" = min_created_at.min_created_at
+      FROM min_created_at
+      WHERE wf.key = min_created_at.key
+    `,
+      { type: import_sequelize.QueryTypes.UPDATE }
+    );
+    this.app.logger.info(`collection [${import_constants.COLLECTION_WORKFLOWS_NAME}] update ${result[1]} rows`);
+  }
+}

package/dist/server/migrations/20241206122842-add-createdBy.d.ts

@@ -0,0 +1,6 @@
+import { Migration } from '@tachybase/server';
+export default class extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+}