@tachybase/module-workflow 0.23.8

package/dist/server/features/request/RequestInstruction.js

@@ -0,0 +1,183 @@
+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 RequestInstruction_exports = {};
+__export(RequestInstruction_exports, {
+  default: () => RequestInstruction_default
+});
+module.exports = __toCommonJS(RequestInstruction_exports);
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+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("../..");
+async function downloadToStream(resourceUrl, Headers, param, body) {
+  try {
+    const response = await (0, import_axios.default)({
+      method: "GET",
+      url: resourceUrl,
+      headers: Headers,
+      params: param,
+      data: body,
+      responseType: "stream"
+    });
+    const ext = import_mime_types.default.extension(Headers["Content-Type"]);
+    let tempFileName;
+    do {
+      tempFileName = `${(0, import_utils.uid)()}.${ext}`;
+    } while (import_fs.default.existsSync(tempFileName));
+    const tempFilePath = import_path.default.join(import_os.default.tmpdir(), tempFileName);
+    const writeStream = import_fs.default.createWriteStream(tempFilePath);
+    response.data.pipe(writeStream);
+    return new Promise((resolve, reject) => {
+      writeStream.on("finish", () => {
+        resolve(import_fs.default.createReadStream(tempFilePath));
+      });
+      writeStream.on("error", (error) => {
+        import_fs.default.unlinkSync(tempFilePath);
+        reject(error);
+      });
+    });
+  } catch (error) {
+    console.error("\u4E0B\u8F7D\u6587\u4EF6\u65F6\u51FA\u9519:", error);
+    throw error;
+  }
+}
+async function request(config, context) {
+  var _a;
+  const { token, origin } = context;
+  const { method = "POST", needAuthorization = true, data, timeout = 5e3 } = config;
+  const originUrl = ((_a = config.url) == null ? void 0 : _a.trim()) || "";
+  const url = originUrl.startsWith("http") ? originUrl : `${origin}${originUrl}`;
+  let headers = (config.headers ?? []).reduce((result, header) => {
+    return Object.assign(result, { [header.name]: header.value });
+  }, {});
+  const params = (config.params ?? []).reduce(
+    (result, param) => Object.assign(result, { [param.name]: param.value }),
+    {}
+  );
+  const requestParams = {
+    url,
+    method,
+    headers,
+    params,
+    data,
+    timeout
+  };
+  if (needAuthorization) {
+    requestParams.headers = {
+      Authorization: "Bearer " + token,
+      ...headers
+    };
+  }
+  if (headers["Content-Type"] === "multipart/form-data") {
+    const formData = new import_form_data.default();
+    for (const [key, value] of Object.entries(data)) {
+      if (key === "file") {
+        let { url: resourceUrl, params: resourceParams, headers: resourceHeader, body: resourceBody } = data[key];
+        resourceUrl = (resourceUrl == null ? void 0 : resourceUrl.trim()) || "";
+        if (resourceHeader["Content-Type"] === "multipart/form-data" && resourceBody) {
+          const formData2 = new import_form_data.default();
+          Object.entries(resourceBody).forEach(([key2, value2]) => {
+            formData2.append(key2, value2);
+          });
+          config.data = formData2;
+        } else {
+          config.data = resourceBody;
+        }
+        const stream = await downloadToStream(resourceUrl, resourceHeader, resourceParams, resourceBody);
+        formData.append("file", stream);
+        headers = { ...formData.getHeaders() };
+      } else {
+        formData.append(key, data[key]);
+      }
+    }
+    requestParams.data = formData;
+  } else {
+    headers["Content-Type"] = "application/json";
+  }
+  return import_axios.default.request(requestParams);
+}
+class RequestInstruction_default extends import__.Instruction {
+  async run(node, prevJob, processor) {
+    const userId = import_lodash.default.get(processor.getScope(node.id), "$context.user.id", "");
+    const origin = import_server.Gateway.getInstance().runAtLoop;
+    const token = this.workflow.app.authManager.jwt.sign({ userId });
+    const context = { token, origin };
+    const config = processor.getParsedValue(node.config, node.id);
+    const { workflow } = processor.execution;
+    const sync = this.workflow.isWorkflowSync(workflow);
+    if (sync) {
+      try {
+        const response = await request(config, context);
+        return {
+          status: import__.JOB_STATUS.RESOLVED,
+          result: response.data
+        };
+      } catch (error) {
+        return {
+          status: import__.JOB_STATUS.FAILED,
+          result: error.isAxiosError ? error.toJSON() : error.message
+        };
+      }
+    }
+    const job = await processor.saveJob({
+      status: import__.JOB_STATUS.PENDING,
+      nodeId: node.id,
+      nodeKey: node.key,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    request(config, context).then((response) => {
+      job.set({
+        status: import__.JOB_STATUS.RESOLVED,
+        result: response.data
+      });
+    }).catch((error) => {
+      job.set({
+        status: import__.JOB_STATUS.FAILED,
+        result: error.isAxiosError ? error.toJSON() : error.message
+      });
+    }).finally(() => {
+      processor.logger.info(`request (#${node.id}) response received, status: ${job.get("status")}`);
+      this.workflow.resume(job);
+    });
+    processor.logger.info(`request (#${node.id}) sent to "${config.url}", waiting for response...`);
+    return processor.exit();
+  }
+  async resume(node, job, processor) {
+    const { ignoreFail } = node.config;
+    if (ignoreFail) {
+      job.set("status", import__.JOB_STATUS.RESOLVED);
+    }
+    return job;
+  }
+}

package/dist/server/features/response/Plugin.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from '@tachybase/server';
+export declare class PluginResponse extends Plugin {
+    load(): Promise<void>;
+}

package/dist/server/features/response/Plugin.js

@@ -0,0 +1,45 @@
+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, {
+  PluginResponse: () => PluginResponse
+});
+module.exports = __toCommonJS(Plugin_exports);
+var import_server = require("@tachybase/server");
+var import_Plugin = __toESM(require("../../Plugin"));
+var import_ResponseMessageInstruction = require("./ResponseMessageInstruction");
+class PluginResponse extends import_server.Plugin {
+  async load() {
+    const workflowPlugin = this.app.pm.get(import_Plugin.default);
+    workflowPlugin.registerInstruction("response-message", import_ResponseMessageInstruction.ResponseInstruction);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginResponse
+});

package/dist/server/features/response/ResponseMessageInstruction.d.ts

@@ -0,0 +1,7 @@
+import Instruction from '../../instructions';
+export declare class ResponseInstruction extends Instruction {
+    run(node: any, prevJob: any, processor: any): Promise<{
+        status: 1;
+        result: any;
+    }>;
+}

package/dist/server/features/response/ResponseMessageInstruction.js

@@ -0,0 +1,57 @@
+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 ResponseMessageInstruction_exports = {};
+__export(ResponseMessageInstruction_exports, {
+  ResponseInstruction: () => ResponseInstruction
+});
+module.exports = __toCommonJS(ResponseMessageInstruction_exports);
+var import_constants = require("../../constants");
+var import_instructions = __toESM(require("../../instructions"));
+class ResponseInstruction extends import_instructions.default {
+  async run(node, prevJob, processor) {
+    const { httpContext } = processor.options;
+    if (!httpContext.state) {
+      httpContext.state = {};
+    }
+    if (!httpContext.state.messages) {
+      httpContext.state.messages = [];
+    }
+    const message = processor.getParsedValue(node.config.message, node.id);
+    if (message) {
+      httpContext.state.messages.push({ message });
+    }
+    return {
+      status: import_constants.JOB_STATUS.RESOLVED,
+      result: message
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ResponseInstruction
+});

package/dist/server/features/response/index.d.ts

@@ -0,0 +1 @@
+export * from './Plugin';

package/dist/server/features/response/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var response_exports = {};
+module.exports = __toCommonJS(response_exports);
+__reExport(response_exports, require("./Plugin"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./Plugin")
+});

package/dist/server/features/script/index.d.ts

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

package/dist/server/features/script/index.js

@@ -0,0 +1,33 @@
+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 script_exports = {};
+__export(script_exports, {
+  default: () => import_plugin.default
+});
+module.exports = __toCommonJS(script_exports);
+var import_plugin = __toESM(require("./plugin"));

package/dist/server/features/script/plugin.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from '@tachybase/server';
+export declare class PluginWorkflowDataMappingServer extends Plugin {
+    load(): Promise<void>;
+}
+export default PluginWorkflowDataMappingServer;

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

@@ -0,0 +1,48 @@
+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, {
+  PluginWorkflowDataMappingServer: () => PluginWorkflowDataMappingServer,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_server = require("@tachybase/server");
+var import__ = __toESM(require("../.."));
+var import_constants = require("../../../common/constants");
+var import_script = require("./script.instruction");
+class PluginWorkflowDataMappingServer extends import_server.Plugin {
+  async load() {
+    const pluginWorkflow = this.app.pm.get(import__.default);
+    pluginWorkflow.registerInstruction(import_constants.NAMESPACE_INSTRUCTION_DATA_MAPPING, import_script.ScriptInstruction);
+  }
+}
+var plugin_default = PluginWorkflowDataMappingServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginWorkflowDataMappingServer
+});

package/dist/server/features/script/script.instruction.d.ts

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

package/dist/server/features/script/script.instruction.js

@@ -0,0 +1,212 @@
+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 script_instruction_exports = {};
+__export(script_instruction_exports, {
+  ScriptInstruction: () => ScriptInstruction
+});
+module.exports = __toCommonJS(script_instruction_exports);
+var import_node_crypto = __toESM(require("node:crypto"));
+var import_node_vm = require("node:vm");
+var import_utils = require("@tachybase/utils");
+var import_core = require("@babel/core");
+var import_jsonata = __toESM(require("jsonata"));
+var import_lodash = __toESM(require("lodash"));
+var import_qrcode = __toESM(require("qrcode"));
+var import__ = require("../..");
+class ScriptInstruction extends import__.Instruction {
+  async run(node, input, processor) {
+    const { sourceArray, type, code = "", model } = node.config;
+    let data = {};
+    switch (sourceArray.length) {
+      case 0: {
+        data = {};
+        break;
+      }
+      case 1: {
+        const keyName = sourceArray[0]["keyName"];
+        const sourcePath = sourceArray[0]["sourcePath"];
+        const rawData = processor.getParsedValue(sourcePath, node.id);
+        if (keyName) {
+          data = {
+            [keyName]: rawData
+          };
+        } else {
+          data = rawData;
+        }
+        break;
+      }
+      default: {
+        data = sourceArray.reduce(
+          (cookedData, { keyName, sourcePath }) => ({
+            ...cookedData,
+            [keyName]: processor.getParsedValue(sourcePath, node.id)
+          }),
+          {}
+        );
+      }
+    }
+    try {
+      let result = {};
+      switch (type) {
+        case "jsonata":
+          result = await convertByJSONata(code, data);
+          break;
+        case "js":
+          result = await convertByJsCode(code, data);
+          break;
+        case "ts":
+          result = await convertByTsCode(code, data, processor);
+          break;
+        default:
+      }
+      if (typeof result === "object" && result && (model == null ? void 0 : model.length)) {
+        if (Array.isArray(result)) {
+          result = result.map((item) => mapModel(item, model));
+        } else {
+          result = mapModel(result, model);
+        }
+      }
+      return {
+        result,
+        status: import__.JOB_STATUS.RESOLVED
+      };
+    } catch (err) {
+      return {
+        result: err.toString(),
+        status: import__.JOB_STATUS.ERROR
+      };
+    }
+  }
+}
+async function convertByJSONata(code, data) {
+  const engine = (expression, data2) => (0, import_jsonata.default)(expression).evaluate(data2);
+  const result = await engine(code, data);
+  return result;
+}
+async function convertByJsCode(code, data) {
+  const ctx = {
+    data,
+    body: {}
+  };
+  await evalSimulate(code, {
+    ctx,
+    lib: {
+      log: console.log,
+      JSON,
+      qrcode: import_qrcode.default,
+      crypto: import_node_crypto.default,
+      jsonata: import_jsonata.default,
+      dayjs: import_utils.dayjs
+    }
+  });
+  return ctx.body;
+}
+async function convertByTsCode(code, data, processor) {
+  const options = processor.options;
+  const app = processor.options.plugin.app;
+  const compiledCode = (0, import_core.transform)(code, {
+    sourceType: "module",
+    filename: "a.tsx",
+    presets: [
+      [
+        "@babel/preset-env",
+        {
+          modules: "commonjs",
+          targets: {
+            node: "current"
+          }
+        }
+      ],
+      "@babel/preset-react",
+      "@babel/preset-typescript"
+    ]
+  }).code;
+  const script = new import_node_vm.Script(compiledCode);
+  const defaultFunction = async (event, context) => {
+    return {};
+  };
+  const contextRequire = function(moduleName) {
+    if (moduleName === "@tachybase/utils/client") {
+      return require.call(this, "@tachybase/utils");
+    }
+    if (moduleName === "@tachybase/module-pdf/client") {
+      return require.call(this, "@tachybase/module-pdf");
+    }
+    if (moduleName === "@react-pdf/renderer") {
+      return require.call(this, "@tachybase/module-pdf");
+    }
+    if (app.modules[moduleName]) {
+      return app.modules[moduleName];
+    }
+    return require.call(this, moduleName);
+  };
+  Object.assign(contextRequire, require);
+  const sandbox = {
+    module: {},
+    exports: { default: defaultFunction },
+    require: contextRequire,
+    console
+  };
+  (0, import_node_vm.createContext)(sandbox);
+  try {
+    script.runInContext(sandbox);
+  } catch (error) {
+    app.logger.error("Cloud Component ", { error });
+  }
+  const func = sandbox.exports.default;
+  const result = await func(data, {
+    ...options
+  });
+  return result;
+}
+function mapModel(data, model) {
+  if (typeof data !== "object" || data === null) {
+    throw new Error("Invalid data: data should be a non-null object");
+  }
+  const result = model.reduce((acc, { path, alias }) => {
+    const key = alias ?? path.replace(/\./g, "_");
+    const value = import_lodash.default.get(data, path);
+    acc[key] = value;
+    return acc;
+  }, {});
+  return result;
+}
+async function evalSimulate(jsCode, { ctx, lib }) {
+  const AsyncFunction = async function() {
+  }.constructor;
+  return await new AsyncFunction("$root", `with($root) { ${jsCode}; }`)({
+    ctx,
+    // 允许用户覆盖，这个时候可以使用 _ctx
+    __ctx: ctx,
+    lib
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ScriptInstruction
+});

package/dist/server/features/sql/Plugin.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from '@tachybase/server';
+export declare class PluginSql extends Plugin {
+    load(): Promise<void>;
+}