@zucker-framework/script 1.0.0

package/dist/index.mjs

@@ -0,0 +1,549 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/script-factory.ts
+import { Injectable, Logger } from "@nestjs/common";
+
+// src/sandbox.ts
+import vm from "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 = vm.createContext(sandbox);
+      vm.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 vm.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 exports = await getExports();
+        const fn = exports[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 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([
+  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
+import { createHash } from "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 createHash("sha1").update(str).digest("hex");
+  }
+  /** MD5 摘要（hex） */
+  md5Hex(str) {
+    if (str == null) return null;
+    return 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
+import { Module, Global } from "@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([
+  Global(),
+  Module({
+    providers: [
+      JavaScriptScriptFactory,
+      ExposedScriptRegistry
+    ],
+    exports: [
+      JavaScriptScriptFactory,
+      ExposedScriptRegistry
+    ]
+  })
+], ZuckerScriptModule);
+export {
+  CompositeExecutionContext,
+  DefaultExecutionContext,
+  ExposedScriptRegistry,
+  JavaScriptScriptFactory,
+  ScriptUtils,
+  ZuckerScriptModule,
+  bindInterface,
+  composeContexts,
+  createExecutionContext,
+  createSandbox,
+  scriptUtils
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@zucker-framework/script",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE",
+    "NOTICE",
+    "THIRD_PARTY_NOTICES"
+  ],
+  "dependencies": {
+    "@zucker-framework/core": "1.0.0"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^12.0.0",
+    "@nestjs/core": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.43"
+  },
+  "license": "Apache-2.0",
+  "author": "Lind",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Lind-pro/zucker-framework.git",
+    "directory": "packages/script"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "clean": "rm -rf dist",
+    "lint": "eslint src/"
+  }
+}