@zucker-framework/script 1.0.0

package/dist/index.js

@@ -0,0 +1,588 @@
+"use strict";
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CompositeExecutionContext: () => CompositeExecutionContext,
+  DefaultExecutionContext: () => DefaultExecutionContext,
+  ExposedScriptRegistry: () => ExposedScriptRegistry,
+  JavaScriptScriptFactory: () => JavaScriptScriptFactory,
+  ScriptUtils: () => ScriptUtils,
+  ZuckerScriptModule: () => ZuckerScriptModule,
+  bindInterface: () => bindInterface,
+  composeContexts: () => composeContexts,
+  createExecutionContext: () => createExecutionContext,
+  createSandbox: () => createSandbox,
+  scriptUtils: () => scriptUtils
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/script-factory.ts
+var import_common = require("@nestjs/common");
+
+// src/sandbox.ts
+var import_node_vm = __toESM(require("vm"));
+var BLOCKED_GLOBALS = [
+  "process",
+  "require",
+  "module",
+  "exports",
+  "__filename",
+  "__dirname",
+  "globalThis",
+  "global",
+  "root",
+  "GLOBAL",
+  "setTimeout",
+  "setInterval",
+  "setImmediate",
+  "clearTimeout",
+  "clearInterval",
+  "clearImmediate",
+  "queueMicrotask"
+];
+function createSandbox(options) {
+  return {
+    execute(code, context = {}) {
+      const sandbox = {
+        ...context,
+        console: {
+          log: /* @__PURE__ */ __name((...args) => console.log("[sandbox]", ...args), "log"),
+          warn: /* @__PURE__ */ __name((...args) => console.warn("[sandbox]", ...args), "warn"),
+          error: /* @__PURE__ */ __name((...args) => console.error("[sandbox]", ...args), "error")
+        },
+        require: createRestrictedRequire(options.allowedModules)
+      };
+      for (const key of BLOCKED_GLOBALS) {
+        sandbox[key] = void 0;
+      }
+      const vmContext = import_node_vm.default.createContext(sandbox);
+      import_node_vm.default.runInContext(`(function() {
+          var ObjProto = Object.getPrototypeOf({});
+          var FuncProto = Object.getPrototypeOf(function(){});
+          Object.defineProperty(ObjProto, 'constructor', { value: undefined, writable: false, configurable: false });
+          Object.defineProperty(FuncProto, 'constructor', { value: undefined, writable: false, configurable: false });
+        })()`, vmContext, {
+        timeout: 1e3
+      });
+      const wrappedCode = `(function(__args) { ${code} })(typeof __args !== 'undefined' ? __args : [])`;
+      return import_node_vm.default.runInContext(wrappedCode, vmContext, {
+        timeout: options.timeout,
+        filename: "sandbox-script.js"
+      });
+    }
+  };
+}
+__name(createSandbox, "createSandbox");
+function createRestrictedRequire(allowedModules) {
+  if (allowedModules.length === 0) return void 0;
+  return (moduleName) => {
+    if (!allowedModules.includes(moduleName)) {
+      throw new Error(`Module not allowed in sandbox: ${moduleName}`);
+    }
+    return require(moduleName);
+  };
+}
+__name(createRestrictedRequire, "createRestrictedRequire");
+
+// src/interface-binding.ts
+function bindInterface(script, interfaceKeys) {
+  let cachedExports = null;
+  const getExports = /* @__PURE__ */ __name(async () => {
+    if (!cachedExports) {
+      const result = await script.call();
+      if (typeof result !== "object" || result === null) {
+        throw new Error("Script must return an object with methods");
+      }
+      cachedExports = result;
+    }
+    return cachedExports;
+  }, "getExports");
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (!interfaceKeys.includes(prop)) {
+        return void 0;
+      }
+      return async (...args) => {
+        const exports2 = await getExports();
+        const fn = exports2[prop];
+        if (typeof fn !== "function") {
+          throw new Error(`Script does not export method: ${prop}`);
+        }
+        return fn(...args);
+      };
+    }
+  });
+}
+__name(bindInterface, "bindInterface");
+
+// src/script-factory.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var JavaScriptScriptFactory = class _JavaScriptScriptFactory {
+  static {
+    __name(this, "JavaScriptScriptFactory");
+  }
+  logger = new import_common.Logger(_JavaScriptScriptFactory.name);
+  defaultOptions = {
+    timeout: 5e3,
+    allowedModules: []
+  };
+  accessControl = {
+    allowedModules: /* @__PURE__ */ new Set(),
+    deniedPatterns: /* @__PURE__ */ new Set([
+      "*"
+    ]),
+    allowedPatterns: /* @__PURE__ */ new Set()
+  };
+  setDefaultOptions(options) {
+    this.defaultOptions = {
+      ...this.defaultOptions,
+      ...options
+    };
+  }
+  /** 添加允许的模块 — 对齐 jetlinks allows() */
+  allowModule(moduleName) {
+    this.accessControl.allowedModules.add(moduleName);
+  }
+  /** 移除允许的模块 — 对齐 jetlinks denies() */
+  denyModule(moduleName) {
+    this.accessControl.allowedModules.delete(moduleName);
+  }
+  /** 添加允许的模式（正则） — 对齐 jetlinks allowsPattern() */
+  allowPattern(pattern) {
+    this.accessControl.allowedPatterns.add(pattern);
+  }
+  /** 添加拒绝的模式（正则） — 对齐 jetlinks deniesPattern() */
+  denyPattern(pattern) {
+    this.accessControl.deniedPatterns.add(pattern);
+  }
+  /** 检查模块是否被拒绝 — 对齐 jetlinks isDenied() */
+  isDenied(moduleName) {
+    if (this.accessControl.allowedModules.has(moduleName)) {
+      return false;
+    }
+    for (const pattern of this.accessControl.allowedPatterns) {
+      if (new RegExp(pattern).test(moduleName)) {
+        return false;
+      }
+    }
+    if (this.accessControl.deniedPatterns.has("*")) {
+      return true;
+    }
+    for (const pattern of this.accessControl.deniedPatterns) {
+      if (new RegExp(pattern).test(moduleName)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+  * 将脚本返回值转换为纯 JS 类型 — 对齐 jetlinks AbstractScriptFactory.convertToJavaType()。
+  * 确保 Map、Set 等非 JSON 安全类型被转为 POJO/Array。
+  */
+  convertToJavaType(data) {
+    if (data === void 0 || data === null) {
+      return data;
+    }
+    if (data instanceof Map) {
+      const obj = {};
+      for (const [key, value] of data) {
+        obj[String(key)] = this.convertToJavaType(value);
+      }
+      return obj;
+    }
+    if (data instanceof Set) {
+      return Array.from(data).map((v) => this.convertToJavaType(v));
+    }
+    if (Array.isArray(data)) {
+      return data.map((v) => this.convertToJavaType(v));
+    }
+    return data;
+  }
+  async compile(script) {
+    return this.compileExpose(script, {});
+  }
+  async compileExpose(script, expose) {
+    this.logger.debug(`Compiling script: ${script.name}`);
+    const allowedModules = Array.from(this.accessControl.allowedModules);
+    const sandboxOptions = {
+      ...this.defaultOptions,
+      name: script.name,
+      allowedModules: [
+        ...this.defaultOptions.allowedModules,
+        ...allowedModules
+      ]
+    };
+    return {
+      call: /* @__PURE__ */ __name(async (...args) => {
+        const sandbox = createSandbox(sandboxOptions);
+        return sandbox.execute(script.content, {
+          ...expose,
+          __args: args
+        });
+      }, "call"),
+      callWithContext: /* @__PURE__ */ __name(async (context, ...args) => {
+        const sandbox = createSandbox(sandboxOptions);
+        return sandbox.execute(script.content, {
+          ...expose,
+          ...context,
+          __args: args
+        });
+      }, "callWithContext"),
+      callWithExecutionContext: /* @__PURE__ */ __name(async (execCtx) => {
+        const sandbox = createSandbox(sandboxOptions);
+        return sandbox.execute(script.content, {
+          ...expose,
+          ...execCtx.toRecord()
+        });
+      }, "callWithExecutionContext")
+    };
+  }
+  async bind(script, context) {
+    return this.compileExpose(script, context);
+  }
+  async createProxy(script, interfaceKeys) {
+    const compiled = await this.compile(script);
+    return bindInterface(compiled, interfaceKeys);
+  }
+};
+JavaScriptScriptFactory = _ts_decorate([
+  (0, import_common.Injectable)()
+], JavaScriptScriptFactory);
+
+// src/exposed-script.ts
+var ExposedScriptRegistry = class {
+  static {
+    __name(this, "ExposedScriptRegistry");
+  }
+  methods = /* @__PURE__ */ new Map();
+  register(name, fn) {
+    this.methods.set(name, fn);
+  }
+  unregister(name) {
+    this.methods.delete(name);
+  }
+  getExposedMethods() {
+    const result = {};
+    for (const [name, fn] of this.methods) {
+      result[name] = fn;
+    }
+    return result;
+  }
+  has(name) {
+    return this.methods.has(name);
+  }
+  getNames() {
+    return Array.from(this.methods.keys());
+  }
+};
+
+// src/execution-context.ts
+var DefaultExecutionContext = class {
+  static {
+    __name(this, "DefaultExecutionContext");
+  }
+  layers;
+  selfLayer;
+  constructor(...contexts) {
+    this.layers = contexts.map((c) => c);
+    this.selfLayer = /* @__PURE__ */ new Map();
+  }
+  getAttribute(name) {
+    for (const layer of this.layers) {
+      if (layer instanceof Map) {
+        if (layer.has(name)) return layer.get(name);
+      } else {
+        if (name in layer) return layer[name];
+      }
+    }
+    if (this.selfLayer.has(name)) return this.selfLayer.get(name);
+    return void 0;
+  }
+  setAttribute(name, value) {
+    this.selfLayer.set(name, value);
+  }
+  removeAttribute(name) {
+    const existing = this.selfLayer.get(name);
+    this.selfLayer.delete(name);
+    return existing;
+  }
+  hasAttribute(name) {
+    for (const layer of this.layers) {
+      if (layer instanceof Map) {
+        if (layer.has(name)) return true;
+      } else {
+        if (name in layer) return true;
+      }
+    }
+    return this.selfLayer.has(name);
+  }
+  merge(other) {
+    return new CompositeExecutionContext(this, other);
+  }
+  toRecord() {
+    const result = {};
+    for (const entry of this.selfLayer.entries()) {
+      result[entry[0]] = entry[1];
+    }
+    for (let i = this.layers.length - 1; i >= 0; i--) {
+      const layer = this.layers[i];
+      if (layer instanceof Map) {
+        for (const entry of layer.entries()) {
+          result[entry[0]] = entry[1];
+        }
+      } else {
+        Object.assign(result, layer);
+      }
+    }
+    return result;
+  }
+};
+var CompositeExecutionContext = class {
+  static {
+    __name(this, "CompositeExecutionContext");
+  }
+  contexts;
+  constructor(...contexts) {
+    this.contexts = [
+      ...contexts
+    ];
+  }
+  getAttribute(name) {
+    for (const ctx of this.contexts) {
+      if (ctx.hasAttribute(name)) {
+        return ctx.getAttribute(name);
+      }
+    }
+    return void 0;
+  }
+  setAttribute(name, value) {
+    if (this.contexts.length > 0) {
+      this.contexts[this.contexts.length - 1].setAttribute(name, value);
+    }
+  }
+  removeAttribute(name) {
+    for (const ctx of this.contexts) {
+      if (ctx.hasAttribute(name)) {
+        return ctx.removeAttribute(name);
+      }
+    }
+    return void 0;
+  }
+  hasAttribute(name) {
+    return this.contexts.some((ctx) => ctx.hasAttribute(name));
+  }
+  merge(other) {
+    this.contexts = [
+      ...this.contexts,
+      other
+    ];
+    return this;
+  }
+  toRecord() {
+    const result = {};
+    for (let i = this.contexts.length - 1; i >= 0; i--) {
+      Object.assign(result, this.contexts[i].toRecord());
+    }
+    return result;
+  }
+};
+function createExecutionContext(...contexts) {
+  return new DefaultExecutionContext(...contexts);
+}
+__name(createExecutionContext, "createExecutionContext");
+function composeContexts(...contexts) {
+  return new CompositeExecutionContext(...contexts);
+}
+__name(composeContexts, "composeContexts");
+
+// src/script-utils.ts
+var import_node_crypto = require("crypto");
+var ScriptUtils = class {
+  static {
+    __name(this, "ScriptUtils");
+  }
+  /** 当前时间戳（毫秒） */
+  now() {
+    return Date.now();
+  }
+  /** 格式化当前时间 */
+  nowFormatted(format) {
+    const d = /* @__PURE__ */ new Date();
+    if (!format) return d.toISOString();
+    return format.replace("yyyy", String(d.getFullYear())).replace("MM", String(d.getMonth() + 1).padStart(2, "0")).replace("dd", String(d.getDate()).padStart(2, "0")).replace("HH", String(d.getHours()).padStart(2, "0")).replace("mm", String(d.getMinutes()).padStart(2, "0")).replace("ss", String(d.getSeconds()).padStart(2, "0"));
+  }
+  /** 创建新的 Map（对象） */
+  newMap() {
+    return {};
+  }
+  /** 创建新的数组 */
+  newList() {
+    return [];
+  }
+  /** 序列化为 JSON 字符串 */
+  toJsonString(obj) {
+    return JSON.stringify(obj);
+  }
+  /** 解析 JSON 字符串 */
+  parseJson(json) {
+    return JSON.parse(json);
+  }
+  /** 转换为 Java/原生类型（identity in JS） */
+  toJavaType(obj) {
+    return obj;
+  }
+  /** 求最大值（支持数组、嵌套集合） */
+  max(...params) {
+    let maxVal = void 0;
+    for (let param of params) {
+      if (param && typeof param === "object" && !Array.isArray(param)) {
+        param = Object.values(param);
+      }
+      if (Array.isArray(param)) {
+        param = this.max(...param);
+      }
+      if (maxVal === void 0) {
+        maxVal = param;
+        continue;
+      }
+      if (Number(param) > Number(maxVal)) {
+        maxVal = param;
+      }
+    }
+    return maxVal;
+  }
+  /** 求最小值（支持数组、嵌套集合） */
+  min(...params) {
+    let minVal = void 0;
+    for (let param of params) {
+      if (param && typeof param === "object" && !Array.isArray(param)) {
+        param = Object.values(param);
+      }
+      if (Array.isArray(param)) {
+        param = this.min(...param);
+      }
+      if (minVal === void 0) {
+        minVal = param;
+        continue;
+      }
+      if (Number(param) < Number(minVal)) {
+        minVal = param;
+      }
+    }
+    return minVal;
+  }
+  /** SHA1 摘要（hex） */
+  sha1Hex(str) {
+    if (str == null) return null;
+    return (0, import_node_crypto.createHash)("sha1").update(str).digest("hex");
+  }
+  /** MD5 摘要（hex） */
+  md5Hex(str) {
+    if (str == null) return null;
+    return (0, import_node_crypto.createHash)("md5").update(str).digest("hex");
+  }
+  /** 创建指定大小的 Buffer */
+  newByteArray(size) {
+    return Buffer.alloc(size);
+  }
+  /** 创建指定大小的 Int32 数组 — 对齐 jetlinks Utils.newIntArray() */
+  newIntArray(size) {
+    return new Int32Array(size);
+  }
+  /** 创建指定大小的 BigInt64 数组 — 对齐 jetlinks Utils.newLongArray() */
+  newLongArray(size) {
+    return new BigInt64Array(size);
+  }
+};
+var scriptUtils = new ScriptUtils();
+
+// src/script.module.ts
+var import_common2 = require("@nestjs/common");
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+var ZuckerScriptModule = class {
+  static {
+    __name(this, "ZuckerScriptModule");
+  }
+};
+ZuckerScriptModule = _ts_decorate2([
+  (0, import_common2.Global)(),
+  (0, import_common2.Module)({
+    providers: [
+      JavaScriptScriptFactory,
+      ExposedScriptRegistry
+    ],
+    exports: [
+      JavaScriptScriptFactory,
+      ExposedScriptRegistry
+    ]
+  })
+], ZuckerScriptModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompositeExecutionContext,
+  DefaultExecutionContext,
+  ExposedScriptRegistry,
+  JavaScriptScriptFactory,
+  ScriptUtils,
+  ZuckerScriptModule,
+  bindInterface,
+  composeContexts,
+  createExecutionContext,
+  createSandbox,
+  scriptUtils
+});