elit 3.1.6 → 3.1.8

package/dist/database.d.mts

@@ -0,0 +1,31 @@
+import vm from 'node:vm';
+
+interface DatabaseConfig {
+    dir?: string;
+    language?: 'ts' | 'js';
+    registerModules?: {
+        [key: string]: any;
+    };
+}
+declare class Database {
+    private _ctx;
+    private _registerModules;
+    private _config;
+    constructor(config: DatabaseConfig);
+    set config(config: DatabaseConfig);
+    private register;
+    plugin(moduleName: string, moduleContent: any): void;
+    private resolvePath;
+    private moduleLinker;
+    private vmRun;
+    /**
+     * Execute database code and return results
+     */
+    execute(code: string | Function, options?: vm.RunningCodeOptions | string): Promise<{
+        namespace: Object;
+        logs: any[];
+    }>;
+}
+declare function database(): Database;
+
+export { Database, type DatabaseConfig, database, database as default };

package/dist/database.d.ts

@@ -0,0 +1,30 @@
+import vm from "node:vm";
+export interface DatabaseConfig {
+    dir?: string;
+    language?: 'ts' | 'js';
+    registerModules?: {
+        [key: string]: any;
+    };
+}
+export declare class Database {
+    private _ctx;
+    private _registerModules;
+    private _config;
+    constructor(config: DatabaseConfig);
+    set config(config: DatabaseConfig);
+    private register;
+    plugin(moduleName: string, moduleContent: any): void;
+    private resolvePath;
+    private moduleLinker;
+    private vmRun;
+    /**
+     * Execute database code and return results
+     */
+    execute(code: string | Function, options?: vm.RunningCodeOptions | string): Promise<{
+        namespace: Object;
+        logs: any[];
+    }>;
+}
+export declare function database(): Database;
+export default database;
+//# sourceMappingURL=database.d.ts.map

package/dist/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AAMzB,MAAM,WAAW,cAAc;IAC3B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IACvB,eAAe,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC;CAC5C;AAED,qBAAa,QAAQ;IACjB,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,gBAAgB,CAAyB;IACjD,OAAO,CAAC,OAAO,CAEb;gBAEU,MAAM,EAAE,cAAc;IAMlC,IAAI,MAAM,CAAC,MAAM,EAAE,cAAc,EAEhC;IAED,OAAO,CAAC,QAAQ;IAMhB,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,GAAG;IAI7C,OAAO,CAAC,WAAW;YAwBL,YAAY;YA8BZ,KAAK;IAuInB;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,kBAAkB,GAAG,MAAM;;;;CAIlF;AAID,wBAAgB,QAAQ,aAIvB;AAED,eAAe,QAAQ,CAAC"}

package/dist/database.js

@@ -0,0 +1,440 @@
+"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 __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/database.ts
+var database_exports = {};
+__export(database_exports, {
+  Database: () => Database,
+  database: () => database,
+  default: () => database_default
+});
+module.exports = __toCommonJS(database_exports);
+var import_node_vm = __toESM(require("vm"));
+
+// src/runtime.ts
+var runtime = (() => {
+  if (typeof Deno !== "undefined") return "deno";
+  if (typeof Bun !== "undefined") return "bun";
+  return "node";
+})();
+var isNode = runtime === "node";
+var isBun = runtime === "bun";
+var isDeno = runtime === "deno";
+
+// src/path.ts
+function getSeparator(isWin) {
+  return isWin ? "\\" : "/";
+}
+function getCwd() {
+  if (isNode || isBun) {
+    return process.cwd();
+  } else if (isDeno) {
+    return Deno.cwd();
+  }
+  return "/";
+}
+function findLastSeparator(path2) {
+  return Math.max(path2.lastIndexOf("/"), path2.lastIndexOf("\\"));
+}
+function createPathOps(isWin) {
+  return {
+    sep: getSeparator(isWin),
+    delimiter: isWin ? ";" : ":",
+    normalize: (path2) => normalizePath(path2, isWin),
+    join: (...paths) => joinPaths(paths, isWin),
+    resolve: (...paths) => resolvePaths(paths, isWin),
+    isAbsolute: (path2) => isWin ? isAbsoluteWin(path2) : isAbsolutePosix(path2),
+    relative: (from, to) => relativePath(from, to, isWin),
+    dirname: (path2) => getDirname(path2, isWin),
+    basename: (path2, ext) => getBasename(path2, ext, isWin),
+    extname: (path2) => getExtname(path2),
+    parse: (path2) => parsePath(path2, isWin),
+    format: (pathObject) => formatPath(pathObject, isWin)
+  };
+}
+function isAbsolutePosix(path2) {
+  return path2.length > 0 && path2[0] === "/";
+}
+function isAbsoluteWin(path2) {
+  const len = path2.length;
+  if (len === 0) return false;
+  const code = path2.charCodeAt(0);
+  if (code === 47 || code === 92) {
+    return true;
+  }
+  if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
+    if (len > 2 && path2.charCodeAt(1) === 58) {
+      const code2 = path2.charCodeAt(2);
+      if (code2 === 47 || code2 === 92) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var isWindows = (() => {
+  if (isNode) {
+    return process.platform === "win32";
+  } else if (isDeno) {
+    return Deno.build.os === "windows";
+  }
+  return typeof process !== "undefined" && process.platform === "win32";
+})();
+var posix = createPathOps(false);
+var win32 = createPathOps(true);
+function normalizePath(path2, isWin) {
+  if (path2.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  const isAbsolute = isWin ? isAbsoluteWin(path2) : isAbsolutePosix(path2);
+  const trailingSeparator = path2[path2.length - 1] === separator || isWin && path2[path2.length - 1] === "/";
+  let normalized = path2.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
+  const parts = normalized.split(separator);
+  const result = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === "" || part === ".") {
+      if (i === 0 && isAbsolute) result.push("");
+      continue;
+    }
+    if (part === "..") {
+      if (result.length > 0 && result[result.length - 1] !== "..") {
+        if (!(result.length === 1 && result[0] === "")) {
+          result.pop();
+        }
+      } else if (!isAbsolute) {
+        result.push("..");
+      }
+    } else {
+      result.push(part);
+    }
+  }
+  let final = result.join(separator);
+  if (final.length === 0) {
+    return isAbsolute ? separator : ".";
+  }
+  if (trailingSeparator && final[final.length - 1] !== separator) {
+    final += separator;
+  }
+  return final;
+}
+function joinPaths(paths, isWin) {
+  if (paths.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  let joined = "";
+  for (let i = 0; i < paths.length; i++) {
+    const path2 = paths[i];
+    if (path2 && path2.length > 0) {
+      if (joined.length === 0) {
+        joined = path2;
+      } else {
+        joined += separator + path2;
+      }
+    }
+  }
+  if (joined.length === 0) return ".";
+  return normalizePath(joined, isWin);
+}
+function resolvePaths(paths, isWin) {
+  const separator = getSeparator(isWin);
+  let resolved = "";
+  let isAbsolute = false;
+  for (let i = paths.length - 1; i >= 0 && !isAbsolute; i--) {
+    const path2 = paths[i];
+    if (path2 && path2.length > 0) {
+      resolved = path2 + (resolved.length > 0 ? separator + resolved : "");
+      isAbsolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
+    }
+  }
+  if (!isAbsolute) {
+    const cwd = getCwd();
+    resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
+  }
+  return normalizePath(resolved, isWin);
+}
+function relativePath(from, to, isWin) {
+  from = resolvePaths([from], isWin);
+  to = resolvePaths([to], isWin);
+  if (from === to) return "";
+  const separator = getSeparator(isWin);
+  const fromParts = from.split(separator).filter((p) => p.length > 0);
+  const toParts = to.split(separator).filter((p) => p.length > 0);
+  let commonLength = 0;
+  const minLength = Math.min(fromParts.length, toParts.length);
+  for (let i = 0; i < minLength; i++) {
+    if (fromParts[i] === toParts[i]) {
+      commonLength++;
+    } else {
+      break;
+    }
+  }
+  const upCount = fromParts.length - commonLength;
+  const result = [];
+  for (let i = 0; i < upCount; i++) {
+    result.push("..");
+  }
+  for (let i = commonLength; i < toParts.length; i++) {
+    result.push(toParts[i]);
+  }
+  return result.join(separator) || ".";
+}
+function getDirname(path2, isWin) {
+  if (path2.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  const normalized = normalizePath(path2, isWin);
+  const lastSepIndex = normalized.lastIndexOf(separator);
+  if (lastSepIndex === -1) return ".";
+  if (lastSepIndex === 0) return separator;
+  return normalized.slice(0, lastSepIndex);
+}
+function getBasename(path2, ext, isWin) {
+  if (path2.length === 0) return "";
+  const lastSepIndex = isWin ? findLastSeparator(path2) : path2.lastIndexOf("/");
+  let base = lastSepIndex === -1 ? path2 : path2.slice(lastSepIndex + 1);
+  if (ext && base.endsWith(ext)) {
+    base = base.slice(0, base.length - ext.length);
+  }
+  return base;
+}
+function getExtname(path2) {
+  const lastDotIndex = path2.lastIndexOf(".");
+  const lastSepIndex = findLastSeparator(path2);
+  if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path2.length - 1) {
+    return "";
+  }
+  return path2.slice(lastDotIndex);
+}
+function parsePath(path2, isWin) {
+  let root = "";
+  if (isWin) {
+    if (path2.length >= 2 && path2[1] === ":") {
+      root = path2.slice(0, 2);
+      if (path2.length > 2 && (path2[2] === "\\" || path2[2] === "/")) {
+        root += "\\";
+      }
+    } else if (path2[0] === "\\" || path2[0] === "/") {
+      root = "\\";
+    }
+  } else {
+    if (path2[0] === "/") {
+      root = "/";
+    }
+  }
+  const dir = getDirname(path2, isWin);
+  const base = getBasename(path2, void 0, isWin);
+  const ext = getExtname(path2);
+  const name = ext ? base.slice(0, base.length - ext.length) : base;
+  return { root, dir, base, ext, name };
+}
+function formatPath(pathObject, isWin) {
+  const separator = getSeparator(isWin);
+  const dir = pathObject.dir || pathObject.root || "";
+  const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir) return base;
+  if (dir === pathObject.root) return dir + base;
+  return dir + separator + base;
+}
+function resolve(...paths) {
+  return resolvePaths(paths, isWindows);
+}
+
+// src/database.ts
+var import_node_path = __toESM(require("path"));
+var import_node_fs = __toESM(require("fs"));
+var esbuild = __toESM(require("esbuild"));
+var Database = class {
+  constructor(config) {
+    this._config = {
+      dir: resolve(process.cwd(), "databases")
+    };
+    this._config = { ...this._config, ...config };
+    this._registerModules = config.registerModules || {};
+    this._ctx = import_node_vm.default.createContext(this._registerModules);
+  }
+  set config(config) {
+    this._config = { ...this._config, ...config };
+  }
+  register(context) {
+    this._registerModules = { ...this._registerModules, ...context };
+    this._ctx = import_node_vm.default.createContext(this._registerModules);
+  }
+  plugin(moduleName, moduleContent) {
+    this.register({ [moduleName]: moduleContent });
+  }
+  resolvePath(fileList, query) {
+    const aliases = { "@db": this._config.dir || resolve(process.cwd(), "databases") };
+    let resolvedPath = query;
+    for (const [alias, target] of Object.entries(aliases)) {
+      if (resolvedPath.startsWith(alias + "/")) {
+        resolvedPath = resolvedPath.replace(alias, target);
+        break;
+      }
+    }
+    resolvedPath = import_node_path.default.normalize(resolvedPath);
+    return fileList.find((file) => {
+      const normalizedFile = import_node_path.default.normalize(file);
+      const fileWithoutExt = normalizedFile.replace(/\.[^/.]+$/, "");
+      return normalizedFile === resolvedPath || fileWithoutExt === resolvedPath || normalizedFile === resolvedPath + ".ts" || normalizedFile === resolvedPath + ".js";
+    });
+  }
+  async moduleLinker(specifier, referencingModule) {
+    const dbFiles = import_node_fs.default.readdirSync(this._config.dir || resolve(process.cwd(), "databases")).filter((f) => f.endsWith(".ts")).map((f) => import_node_path.default.join(this._config.dir || resolve(process.cwd(), "databases"), f));
+    const dbResult = this.resolvePath(dbFiles, specifier);
+    if (dbResult) {
+      try {
+        const actualModule = await import(dbResult);
+        const exportNames = Object.keys(actualModule);
+        return new import_node_vm.default.SyntheticModule(
+          exportNames,
+          function() {
+            exportNames.forEach((key) => {
+              this.setExport(key, actualModule[key]);
+            });
+          },
+          { identifier: specifier, context: referencingModule.context }
+        );
+      } catch (err) {
+        console.error(`Failed to load database module ${specifier}:`, err);
+        throw err;
+      }
+    }
+    throw new Error(`Module ${specifier} is not allowed or not found.`);
+  }
+  async vmRun(code, _options) {
+    const logs = [];
+    const customConsole = ["log", "error", "warn", "info", "debug", "trace"].reduce((acc, type) => {
+      acc[type] = (...args) => logs.push({ type, args });
+      return acc;
+    }, {});
+    this.register({
+      console: customConsole
+    });
+    let stringCode;
+    if (typeof code === "function") {
+      const funcStr = code.toString();
+      if (funcStr.includes("=>")) {
+        const arrowIndex = funcStr.indexOf("=>");
+        let start = arrowIndex + 2;
+        while (start < funcStr.length && funcStr[start] === " ") start++;
+        if (funcStr[start] === "{") start++;
+        let end = funcStr.lastIndexOf("}");
+        if (start < end) {
+          stringCode = funcStr.substring(start, end);
+        } else {
+          stringCode = funcStr.substring(start);
+        }
+      } else if (funcStr.includes("function")) {
+        const funcIndex = funcStr.indexOf("function");
+        let start = funcIndex + 8;
+        while (start < funcStr.length && funcStr[start] === " ") start++;
+        if (funcStr[start] === "(") start++;
+        if (start < funcStr.length && funcStr[start] !== "(") {
+          while (start < funcStr.length && funcStr[start] !== " " && funcStr[start] !== "(") start++;
+        }
+        if (funcStr[start] === "(") start++;
+        while (start < funcStr.length && funcStr[start] === " ") start++;
+        if (funcStr[start] === "{") start++;
+        const end = funcStr.lastIndexOf("}");
+        if (start < end) {
+          stringCode = funcStr.substring(start, end);
+        } else {
+          stringCode = funcStr.substring(start);
+        }
+      } else {
+        stringCode = funcStr;
+      }
+      stringCode = stringCode.trim();
+      let importPos = 0;
+      while ((importPos = stringCode.indexOf("import(", importPos)) !== -1) {
+        const fromPos = stringCode.indexOf(".from(", importPos);
+        if (fromPos === -1) break;
+        const quoteStart = stringCode.indexOf("(", fromPos + 7) + 1;
+        if (quoteStart === -1) break;
+        const quoteChar = stringCode[quoteStart];
+        if (quoteChar !== '"' && quoteChar !== "'") break;
+        const quoteEnd = stringCode.indexOf(quoteChar, quoteStart + 1);
+        if (quoteEnd === -1) break;
+        const modulePath = stringCode.substring(quoteStart + 1, quoteEnd);
+        const importArgEnd = fromPos - 1;
+        const importArgStart = importPos + 7;
+        const trimmed = stringCode.substring(importArgStart, importArgEnd).trim();
+        let replacement;
+        if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+          const inner = trimmed.slice(1, -1).trim();
+          replacement = `import { ${inner} } from "${modulePath}"`;
+        } else {
+          replacement = `import ${trimmed} from "${modulePath}"`;
+        }
+        const before = stringCode.substring(0, importPos);
+        const after = stringCode.substring(quoteEnd + 2);
+        stringCode = before + replacement + after;
+      }
+      const lines = stringCode.split("\n");
+      const trimmedLines = lines.map((line) => line.trim());
+      stringCode = trimmedLines.join("\n").trim();
+    } else {
+      stringCode = code;
+    }
+    const result = await esbuild.build({
+      stdin: {
+        contents: stringCode,
+        loader: this._config.language || "ts"
+      },
+      format: "esm",
+      target: "es2020",
+      write: false,
+      bundle: false,
+      sourcemap: false
+    });
+    const js = result.outputFiles[0].text;
+    const mod = new import_node_vm.default.SourceTextModule(js, { context: this._ctx, identifier: import_node_path.default.join(this._config.dir || resolve(process.cwd(), "databases"), "virtual-entry.js") });
+    await mod.link(this.moduleLinker.bind(this));
+    await mod.evaluate();
+    return {
+      namespace: mod.namespace,
+      logs
+    };
+  }
+  /**
+   * Execute database code and return results
+   */
+  async execute(code, options) {
+    return await this.vmRun(code, options);
+  }
+};
+function database() {
+  return new Database({
+    dir: resolve(process.cwd(), "databases")
+  });
+}
+var database_default = database;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Database,
+  database
+});