elit 3.5.6 → 3.5.8

package/src/database.ts

@@ -1,1410 +0,0 @@
-import vm from "node:vm";
-import fs from "node:fs";
-import path from "node:path";
-import * as nodeModule from 'node:module';
-
-interface VMOptions {
-    language?: 'ts' | 'js';
-    registerModules?: { [key: string]: any };
-    dir?: string;
-}
-
-type VMModuleLoader = 'ts' | 'tsx' | 'js' | 'jsx';
-
-interface VMTranspileOptions {
-    filename?: string;
-    format?: 'cjs';
-    loader?: VMModuleLoader;
-}
-
-interface VMTransformResult {
-    code: string;
-}
-
-type StripTypeScriptTypes = (
-    code: string,
-    options?: {
-        mode?: 'strip' | 'transform';
-        sourceMap?: boolean;
-        sourceUrl?: string;
-    },
-) => string;
-
-const stripTypeScriptTypes = typeof (nodeModule as { stripTypeScriptTypes?: unknown }).stripTypeScriptTypes === 'function'
-    ? ((nodeModule as { stripTypeScriptTypes: StripTypeScriptTypes }).stripTypeScriptTypes)
-    : undefined;
-
-let cachedEsbuildTransformSync:
-    | ((code: string, options: { loader?: VMModuleLoader; format?: 'cjs' }) => { code: string })
-    | null
-    | undefined;
-
-function getEsbuildTransformSync() {
-    if (cachedEsbuildTransformSync !== undefined) {
-        return cachedEsbuildTransformSync;
-    }
-
-    if (typeof nodeModule.createRequire !== 'function') {
-        cachedEsbuildTransformSync = null;
-        return cachedEsbuildTransformSync;
-    }
-
-    try {
-        const requireFromApp = nodeModule.createRequire(path.join(process.cwd(), 'package.json'));
-        const esbuildModule = requireFromApp('esbuild') as {
-            transformSync?: (code: string, options: { loader?: VMModuleLoader; format?: 'cjs' }) => { code: string };
-        };
-
-        cachedEsbuildTransformSync = typeof esbuildModule?.transformSync === 'function'
-            ? esbuildModule.transformSync.bind(esbuildModule)
-            : null;
-    } catch {
-        cachedEsbuildTransformSync = null;
-    }
-
-    return cachedEsbuildTransformSync;
-}
-
-function parseModuleBindings(specifiers: string): Array<{ imported: string; local: string }> {
-    return specifiers
-        .split(',')
-        .map((entry) => entry.trim())
-        .filter((entry) => entry.length > 0)
-        .map((entry) => {
-            const [imported, local] = entry.split(/\s+as\s+/);
-            return {
-                imported: (imported || '').trim(),
-                local: (local || imported || '').trim(),
-            };
-        })
-        .filter((entry) => entry.imported.length > 0 && entry.local.length > 0);
-}
-
-function formatNamedImportBindings(specifiers: string): string {
-    return parseModuleBindings(specifiers)
-        .map(({ imported, local }) => imported === local ? imported : `${imported}: ${local}`)
-        .join(', ');
-}
-
-function formatNamedExportAssignments(specifiers: string): string {
-    return parseModuleBindings(specifiers)
-        .map(({ imported, local }) => `module.exports.${local} = ${imported};`)
-        .join('\n');
-}
-
-function stripTypescriptSource(source: string, filename: string): string {
-    if (!stripTypeScriptTypes) {
-        throw new Error('TypeScript database execution requires Node.js 22+ or the esbuild package.');
-    }
-
-    const originalEmitWarning = process.emitWarning;
-
-    try {
-        process.emitWarning = (((warning: string | Error, ...args: any[]) => {
-            if (typeof warning === 'string' && warning.includes('stripTypeScriptTypes')) {
-                return;
-            }
-
-            return (originalEmitWarning as any).call(process, warning, ...args);
-        }) as typeof process.emitWarning);
-
-        return stripTypeScriptTypes(source, {
-            mode: 'transform',
-            sourceUrl: filename,
-        });
-    } finally {
-        process.emitWarning = originalEmitWarning;
-    }
-}
-
-function isSimpleIdentifier(value: string): boolean {
-    return /^[A-Za-z_$][\w$]*$/.test(value);
-}
-
-function stripOptionalLineTerminator(value: string): string {
-    const trimmed = value.trim();
-    return trimmed.endsWith(';')
-        ? trimmed.slice(0, -1).trimEnd()
-        : trimmed;
-}
-
-function parseQuotedModulePath(value: string): string | null {
-    const trimmed = value.trim();
-    if (trimmed.length < 2) {
-        return null;
-    }
-
-    const quote = trimmed[0];
-    if ((quote !== '"' && quote !== "'") || trimmed[trimmed.length - 1] !== quote) {
-        return null;
-    }
-
-    return trimmed.slice(1, -1);
-}
-
-function getLineIndentation(line: string): string {
-    const match = line.match(/^\s*/);
-    return match?.[0] ?? '';
-}
-
-function rewriteImportLine(
-    line: string,
-    nextImportBinding: () => string,
-    resolveDefaultImport: (bindingName: string) => string,
-): string | null {
-    const indentation = getLineIndentation(line);
-    const trimmed = stripOptionalLineTerminator(line);
-    if (!trimmed.startsWith('import ')) {
-        return null;
-    }
-
-    const importBody = trimmed.slice('import '.length).trim();
-    const sideEffectModulePath = parseQuotedModulePath(importBody);
-    if (sideEffectModulePath !== null) {
-        return `${indentation}require(${JSON.stringify(sideEffectModulePath)});`;
-    }
-
-    const fromIndex = importBody.lastIndexOf(' from ');
-    if (fromIndex === -1) {
-        return null;
-    }
-
-    const clause = importBody.slice(0, fromIndex).trim();
-    const modulePath = parseQuotedModulePath(importBody.slice(fromIndex + 6));
-    if (!clause || modulePath === null) {
-        return null;
-    }
-
-    const buildDefaultImport = (defaultName: string): { bindingName: string; code: string } | null => {
-        if (!isSimpleIdentifier(defaultName)) {
-            return null;
-        }
-
-        const bindingName = nextImportBinding();
-        return {
-            bindingName,
-            code: [
-                `${indentation}const ${bindingName} = require(${JSON.stringify(modulePath)});`,
-                `${indentation}const ${defaultName} = ${resolveDefaultImport(bindingName)};`,
-            ].join('\n'),
-        };
-    };
-
-    if (clause.startsWith('* as ')) {
-        const namespaceName = clause.slice(5).trim();
-        return isSimpleIdentifier(namespaceName)
-            ? `${indentation}const ${namespaceName} = require(${JSON.stringify(modulePath)});`
-            : null;
-    }
-
-    if (clause.startsWith('{') && clause.endsWith('}')) {
-        const namedBindings = clause.slice(1, -1).trim();
-        return namedBindings.length > 0
-            ? `${indentation}const { ${formatNamedImportBindings(namedBindings)} } = require(${JSON.stringify(modulePath)});`
-            : null;
-    }
-
-    const commaIndex = clause.indexOf(',');
-    if (commaIndex !== -1) {
-        const defaultName = clause.slice(0, commaIndex).trim();
-        const remainder = clause.slice(commaIndex + 1).trim();
-        const defaultImport = buildDefaultImport(defaultName);
-        if (!defaultImport) {
-            return null;
-        }
-
-        if (remainder.startsWith('* as ')) {
-            const namespaceName = remainder.slice(5).trim();
-            if (!isSimpleIdentifier(namespaceName)) {
-                return null;
-            }
-
-            return `${defaultImport.code}\n${indentation}const ${namespaceName} = ${defaultImport.bindingName};`;
-        }
-
-        if (remainder.startsWith('{') && remainder.endsWith('}')) {
-            const namedBindings = remainder.slice(1, -1).trim();
-            if (!namedBindings) {
-                return null;
-            }
-
-            return `${defaultImport.code}\n${indentation}const { ${formatNamedImportBindings(namedBindings)} } = ${defaultImport.bindingName};`;
-        }
-
-        return null;
-    }
-
-    return buildDefaultImport(clause)?.code ?? null;
-}
-
-function rewriteExportLine(
-    line: string,
-    namedExports: Set<string>,
-    markDefaultExport: () => void,
-): string | null {
-    const trimmed = stripOptionalLineTerminator(line);
-    if (!trimmed.startsWith('export ')) {
-        return null;
-    }
-
-    const indentation = getLineIndentation(line);
-
-    if (trimmed.startsWith('export default ')) {
-        markDefaultExport();
-        return `${indentation}module.exports = ${trimmed.slice('export default '.length)}`;
-    }
-
-    const valueDeclarationMatch = /^export\s+(const|let|var)\s+([A-Za-z_$][\w$]*)\b/.exec(trimmed);
-    if (valueDeclarationMatch) {
-        namedExports.add(valueDeclarationMatch[2]);
-        return `${indentation}${trimmed.slice('export '.length)}`;
-    }
-
-    const asyncFunctionMatch = /^export\s+async\s+function\s+([A-Za-z_$][\w$]*)\b/.exec(trimmed);
-    if (asyncFunctionMatch) {
-        namedExports.add(asyncFunctionMatch[1]);
-        return `${indentation}${trimmed.slice('export '.length)}`;
-    }
-
-    const functionMatch = /^export\s+function\s+([A-Za-z_$][\w$]*)\b/.exec(trimmed);
-    if (functionMatch) {
-        namedExports.add(functionMatch[1]);
-        return `${indentation}${trimmed.slice('export '.length)}`;
-    }
-
-    const classMatch = /^export\s+class\s+([A-Za-z_$][\w$]*)\b/.exec(trimmed);
-    if (classMatch) {
-        namedExports.add(classMatch[1]);
-        return `${indentation}${trimmed.slice('export '.length)}`;
-    }
-
-    if (trimmed.startsWith('export {') && trimmed.endsWith('}')) {
-        const specifiers = trimmed.slice('export {'.length, -1).trim();
-        return specifiers.length > 0
-            ? `${indentation}${formatNamedExportAssignments(specifiers)}`
-            : null;
-    }
-
-    return null;
-}
-
-function rewriteModuleSyntaxToCommonJs(source: string): string {
-    let importCounter = 0;
-    let hasDefaultExport = false;
-    const namedExports = new Set<string>();
-
-    const nextImportBinding = () => `__vm_import_${importCounter++}`;
-    const resolveDefaultImport = (bindingName: string) => `${bindingName} && Object.prototype.hasOwnProperty.call(${bindingName}, "default") ? ${bindingName}.default : ${bindingName}`;
-    const code = source
-        .split(/\r?\n/)
-        .map((line) => rewriteImportLine(line, nextImportBinding, resolveDefaultImport)
-            ?? rewriteExportLine(line, namedExports, () => {
-                hasDefaultExport = true;
-            })
-            ?? line)
-        .join('\n');
-
-    const exportFooter = [...namedExports].map((name) => `module.exports.${name} = ${name};`);
-    if (hasDefaultExport) {
-        exportFooter.push('module.exports.default = module.exports;');
-    }
-
-    return exportFooter.length > 0
-        ? `${code.trimEnd()}\n${exportFooter.join('\n')}\n`
-        : code;
-}
-
-function transpileVmModule(source: string, options: VMTranspileOptions = {}): VMTransformResult {
-    const loader = options.loader || 'js';
-    const filename = options.filename || `virtual.${loader}`;
-
-    if (loader === 'tsx' || loader === 'jsx') {
-        const esbuildTransformSync = getEsbuildTransformSync();
-        if (!esbuildTransformSync) {
-            throw new Error(`JSX database execution requires the esbuild package (${filename}).`);
-        }
-
-        return esbuildTransformSync(source, {
-            loader,
-            format: options.format,
-        });
-    }
-
-    if (loader === 'ts') {
-        try {
-            return {
-                code: rewriteModuleSyntaxToCommonJs(stripTypescriptSource(source, filename)),
-            };
-        } catch (error) {
-            const esbuildTransformSync = getEsbuildTransformSync();
-            if (!esbuildTransformSync) {
-                throw error;
-            }
-
-            return esbuildTransformSync(source, {
-                loader,
-                format: options.format,
-            });
-        }
-    }
-
-    return {
-        code: rewriteModuleSyntaxToCommonJs(source),
-    };
-}
-
-class VM {
-    private transpiler: (code: string, options?: VMTranspileOptions) => VMTransformResult;
-    private ctx: vm.Context;
-    private registerModules: { [key: string]: any };
-    private DATABASE_DIR: string;
-    private SCRIPTDB_DIR: string;
-    private pkgScriptDB: { dependencies?: Record<string, string> } = {};
-    private language: 'ts' | 'js';
-    private _registerModules: { [key: string]: any };
-    private options: VMOptions;
-    constructor(options?: VMOptions) {
-        this.options = options || {};
-        // Set directories based on options or defaults
-        this.DATABASE_DIR = options?.dir || path.join(process.cwd(), 'databases');
-        this.SCRIPTDB_DIR = process.cwd();
-
-        // Ensure directories exist
-        if (!fs.existsSync(this.DATABASE_DIR)) {
-            fs.mkdirSync(this.DATABASE_DIR, { recursive: true });
-        }
-        if (!fs.existsSync(this.SCRIPTDB_DIR)) {
-            fs.mkdirSync(this.SCRIPTDB_DIR, { recursive: true });
-        }
-
-        // Load scriptdb workspace package.json if it exists
-        const pkgPath = path.join(this.SCRIPTDB_DIR, 'package.json');
-        if (fs.existsSync(pkgPath)) {
-            this.pkgScriptDB = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-        }
-        this.language = options?.language || 'ts';
-        this.transpiler = transpileVmModule;
-
-        this.registerModules = options?.registerModules || {};
-        this._registerModules = { ...this.registerModules };
-
-        // Add require function to initial context for fallback path
-        this._registerModules.require = ((moduleId: string) => this.createRequire(moduleId)).bind(this);
-
-        this.ctx = vm.createContext(this._registerModules);
-
-
-    }
-
-    register(context: { [key: string]: any }) {
-        this.registerModules = { ...this.registerModules, ...context };
-        this._registerModules = { ...this._registerModules, ...context };
-        // Always ensure our custom require function is present (with @db alias support)
-        // Store the original require if it exists in context
-        const originalRequire = context.require;
-        this._registerModules.require = ((moduleId: string) => {
-            // Try custom require first (handles @db aliases and database files)
-            try {
-                return this.createRequire(moduleId);
-            } catch (e) {
-                // Fall back to original require for node_modules
-                if (originalRequire && !moduleId.startsWith('@db/') && !moduleId.startsWith('./') && !moduleId.startsWith('../')) {
-                    return originalRequire(moduleId);
-                }
-                throw e;
-            }
-        }).bind(this);
-        // Update context with all modules including require
-        this.ctx = vm.createContext(this._registerModules);
-    }
-
-    private createRequire(moduleId: string): any {
-        // Validate moduleId
-        if (!moduleId) {
-            console.error('[createRequire] moduleId is undefined');
-            return {};
-        }
-
-        console.log('[createRequire] Loading module:', moduleId, 'from DATABASE_DIR:', this.DATABASE_DIR);
-
-        // Handle @db/ path alias
-        if (moduleId.startsWith('@db/')) {
-            const relativePath = moduleId.substring(4); // Remove '@db/'
-            moduleId = './' + relativePath;
-            console.log('[createRequire] Resolved @db/ alias to:', moduleId);
-        }
-
-        // Handle relative paths (e.g., './users')
-        if (moduleId.startsWith('./') || moduleId.startsWith('../')) {
-            const dbDir = this.DATABASE_DIR || process.cwd();
-            const fullPath = path.join(dbDir, moduleId);
-
-            console.log('[createRequire] Full path:', fullPath);
-
-            // Try to find the file with an extension
-            let actualPath: string | undefined = fullPath;
-            if (fs.existsSync(fullPath)) {
-                actualPath = fullPath;
-            } else {
-                const extensions = ['.ts', '.tsx', '.mts', '.cts', '.js', '.mjs', '.cjs'];
-                for (const ext of extensions) {
-                    if (fs.existsSync(fullPath + ext)) {
-                        actualPath = fullPath + ext;
-                        break;
-                    }
-                }
-            }
-
-            console.log('[createRequire] Actual path:', actualPath);
-
-            if (!actualPath || !fs.existsSync(actualPath)) {
-                console.log('[createRequire] File not found, throwing error');
-                throw new Error(`Module '${moduleId}' not found at ${fullPath}`);
-            }
-
-            // For ES module and TypeScript files, transpile the content into CommonJS for vm execution.
-            if (actualPath.endsWith('.ts') || actualPath.endsWith('.tsx') || actualPath.endsWith('.mts') || actualPath.endsWith('.cts') || actualPath.endsWith('.js') || actualPath.endsWith('.mjs')) {
-                const content = fs.readFileSync(actualPath, 'utf8');
-                const loader: VMModuleLoader = actualPath.endsWith('.ts') || actualPath.endsWith('.mts') || actualPath.endsWith('.cts')
-                    ? 'ts'
-                    : actualPath.endsWith('.tsx')
-                        ? 'tsx'
-                        : 'js';
-                const js = this.transpiler(content, {
-                    loader,
-                    format: 'cjs',
-                    filename: actualPath,
-                }).code;
-
-                // Create a wrapper object to capture the final exports
-                const moduleWrapper = { exports: {} };
-                const moduleContext = vm.createContext({
-                    ...this._registerModules,
-                    module: moduleWrapper,
-                    exports: moduleWrapper.exports,
-                });
-
-                vm.runInContext(js, moduleContext, { filename: actualPath });
-
-                console.log('[createRequire] Returning exports:', moduleWrapper.exports);
-                return moduleWrapper.exports;
-            }
-
-            // For CommonJS files, use standard require.
-            const result = require(actualPath);
-            console.log('[createRequire] Returning (JS):', result);
-            return result;
-        }
-
-        // For node_modules, use standard require
-        return require(moduleId);
-    }
-
-    resolvePath(fileList: any[], query: string) {
-        const aliases = { '@db': this.DATABASE_DIR };
-
-        let resolvedPath = query;
-        for (const [alias, target] of Object.entries(aliases)) {
-            if (resolvedPath.startsWith(alias + '/')) {
-                resolvedPath = resolvedPath.replace(alias, target);
-                break;
-            }
-        }
-
-        // Normalize path separators for cross-platform compatibility
-        resolvedPath = path.normalize(resolvedPath);
-
-        return fileList.find(file => {
-            const normalizedFile = path.normalize(file);
-            const fileWithoutExt = normalizedFile.replace(/\.[^/.]+$/, "");
-            return normalizedFile === resolvedPath ||
-                fileWithoutExt === resolvedPath ||
-                normalizedFile === resolvedPath + '.ts' ||
-                normalizedFile === resolvedPath + '.js';
-        });
-    }
-
-    async moduleLinker(specifier: any, referencingModule: any) {
-        console.log('[moduleLinker] Loading specifier:', specifier, 'from DATABASE_DIR:', this.DATABASE_DIR);
-
-        // Try database files first
-        const dbFiles = fs.readdirSync(this.DATABASE_DIR)
-            .filter(f => f.endsWith(".ts"))
-            .map(f => path.join(this.DATABASE_DIR, f));
-
-        console.log('[moduleLinker] Database files:', dbFiles);
-
-        const dbResult = this.resolvePath(dbFiles, specifier);
-        console.log('[moduleLinker] Resolved path:', dbResult);
-
-        if (dbResult) {
-            try {
-                const actualModule = await import(dbResult);
-                const exportNames = Object.keys(actualModule);
-                return new vm.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;
-            }
-        }
-
-        // Try workspace packages
-        const allowedPackages = Object.keys(this.pkgScriptDB.dependencies || {});
-        if (allowedPackages.includes(specifier)) {
-            try {
-                // Import from scriptdb workspace node_modules
-                const modulePath = path.join(this.SCRIPTDB_DIR, 'node_modules', specifier);
-                const actualModule = await import(modulePath);
-                const exportNames = Object.keys(actualModule);
-                return new vm.SyntheticModule(
-                    exportNames,
-                    function () {
-                        exportNames.forEach(key => {
-                            this.setExport(key, actualModule[key]);
-                        });
-                    },
-                    { identifier: specifier, context: referencingModule.context }
-                );
-            } catch (err) {
-                console.error(`Failed to load workspace module ${specifier}:`, err);
-                throw err;
-            }
-        }
-
-        throw new Error(`Module ${specifier} is not allowed or not found.`);
-    }
-
-    async run(code: string) {
-        const logs: any[] = [];
-
-        const customConsole = ['log', 'error', 'warn', 'info', 'debug', 'trace'].reduce((acc: any, type: any) => {
-            acc[type] = (...args: any[]) => logs.push({ type, args });
-            return acc;
-        }, {});
-
-        this.register({
-            console: customConsole
-        });
-
-        const systemModules = await SystemModuleResolver(this.options);
-        this.register(systemModules);
-
-        const js = this.transpiler(code, {
-            loader: this.language,
-            format: 'cjs',
-            filename: path.join(this.SCRIPTDB_DIR, `virtual-entry.${this.language}`),
-        }).code;
-        console.log('[run] Transpiled code:', js);
-
-        // Use SourceTextModule when the runtime provides it so module loading errors surface directly.
-        const SourceTextModule = (vm as any).SourceTextModule;
-        console.log('[run] SourceTextModule available:', typeof SourceTextModule === 'function');
-        if (typeof SourceTextModule === 'function') {
-            const mod = new SourceTextModule(js, { context: this.ctx, identifier: path.join(this.SCRIPTDB_DIR, 'virtual-entry.js') });
-            await mod.link(this.moduleLinker.bind(this));
-            await mod.evaluate();
-
-            return {
-                namespace: mod.namespace,
-                logs: logs
-            };
-        }
-
-        // Fallback: Pre-process imports and use vm.runInContext
-        let processedCode = js;
-
-        console.log('[run] Original transpiled code:', processedCode);
-
-        // esbuild converts: import { users } from './users'
-        // to: var import_users = require("./users");
-        // and uses: import_users.users
-        // But our module exports: exports.users = []
-        // So we need to convert import_users.users -> import_users
-
-        // First, convert static imports to require calls
-        processedCode = processedCode.replace(
-            /var\s+(\w+)\s+=\s+require\((['"])([^'"]+)\2\);/g,
-            (_match: string, varName: string, quote: string, modulePath: string) => {
-                return `const ${varName} = require(${quote}${modulePath}${quote});`;
-            }
-        );
-
-        // Convert any remaining static imports to require calls
-        processedCode = processedCode.replace(
-            /import\s+\{([^}]+)\}\s+from\s+(['"])([^'"]+)\2/g,
-            (_match: string, imports: string, quote: string, modulePath: string) => {
-                return `const { ${imports} } = require(${quote}${modulePath}${quote});`;
-            }
-        );
-
-        processedCode = processedCode.replace(
-            /import\s+(\w+)\s+from\s+(['"])([^'"]+)\2/g,
-            (_match: string, name: string, quote: string, modulePath: string) => {
-                return `const ${name} = require(${quote}${modulePath}${quote});`;
-            }
-        );
-
-        // Convert dynamic import() to require()
-        processedCode = processedCode.replace(/import\(([^)]+)\)/g, 'require($1)');
-
-        console.log('[run] Processed code:', processedCode);
-
-        console.log('[run] Context has require:', typeof this._registerModules.require);
-        console.log('[run] DATABASE_DIR:', this.DATABASE_DIR);
-
-        try {
-            const moduleWrapper = { exports: {} as any };
-            const initialExports = moduleWrapper.exports;
-            const originalModule = this._registerModules.module;
-            const originalExports = this._registerModules.exports;
-
-            this._registerModules.module = moduleWrapper;
-            this._registerModules.exports = moduleWrapper.exports;
-            this.ctx = vm.createContext(this._registerModules);
-
-            let result: any;
-            try {
-                result = vm.runInContext(processedCode, this.ctx, {
-                    filename: path.join(this.SCRIPTDB_DIR, 'virtual-entry.js')
-                });
-            } finally {
-                if (originalModule) {
-                    this._registerModules.module = originalModule;
-                } else {
-                    delete this._registerModules.module;
-                }
-
-                if (originalExports) {
-                    this._registerModules.exports = originalExports;
-                } else {
-                    delete this._registerModules.exports;
-                }
-
-                this.ctx = vm.createContext(this._registerModules);
-            }
-
-            const hasExplicitExports = moduleWrapper.exports !== initialExports
-                || (typeof initialExports === 'object' && initialExports !== null && Object.keys(initialExports).length > 0);
-
-            return {
-                namespace: hasExplicitExports ? moduleWrapper.exports : result,
-                logs: logs
-            };
-        } catch (e) {
-            console.log('[run] Error executing code:', e);
-            throw e;
-        }
-    }
-}
-
-function create(dbName: string, code: string | Function, options?: VMOptions): void {
-    const DIR = options?.dir || path.join(process.cwd(), 'databases');
-    const dbPath = path.join(DIR, `${dbName}.ts`);
-    // Prepare the export line
-    fs.appendFileSync(dbPath, code.toString(), 'utf8');
-}
-
-function read(dbName: string, options?: VMOptions): string {
-    const DIR = options?.dir || path.join(process.cwd(), 'databases');
-    const dbPath = path.join(DIR, `${dbName}.ts`);
-
-    if (!fs.existsSync(dbPath)) {
-        throw new Error(`Database '${dbName}' not found`);
-    }
-
-    return fs.readFileSync(dbPath, 'utf8');
-}
-
-function remove(dbName: string, fnName: string, options?: VMOptions) {
-    const DIR = options?.dir || path.join(process.cwd(), 'databases');
-    const dbPath = path.join(DIR, `${dbName}.ts`);
-    if (!fs.existsSync(dbPath)) return false;
-
-    // if no functionName provided -> remove the whole file (after backup)
-    if (!fnName) {
-        const bak = `${dbPath}.bak`;
-        try {
-            fs.copyFileSync(dbPath, bak);
-        } catch (e) {
-            // ignore backup errors
-        }
-        try {
-            fs.unlinkSync(dbPath);
-            return "Removed successfully";
-        } catch (e) {
-            return "Removed failed";
-        }
-    }
-
-    // create a backup before editing the file in-place
-    const bak = `${dbPath}.bak`;
-    try {
-        fs.copyFileSync(dbPath, bak);
-    } catch (e) {
-        // ignore backup errors but continue carefully
-    }
-
-    let src = fs.readFileSync(dbPath, "utf8");
-    const escaped = fnName.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
-
-    // regex to find a declaration of the named symbol (function, class, or var/const/let assignment)
-    const startRe = new RegExp(
-        `function\\s+${escaped}\\s*\\(|\\bclass\\s+${escaped}\\b|\\b(?:const|let|var)\\s+${escaped}\\s*=\\s*(?:function\\b|class\\b|\\(|\\{|\\[)`,
-        "m"
-    );
-
-    const startMatch = src.match(startRe);
-
-    if (startMatch) {
-        const startIdx = startMatch.index;
-
-        // find the first meaningful character after startIdx: {, [, or ; or newline
-        const len = src.length;
-        const idxCurly = src.indexOf("{", startIdx);
-        const idxBracket = src.indexOf("[", startIdx);
-        let braceOpen = -1;
-        if (idxCurly === -1) braceOpen = idxBracket;
-        else if (idxBracket === -1) braceOpen = idxCurly;
-        else braceOpen = Math.min(idxCurly, idxBracket);
-
-        if (braceOpen !== -1) {
-            const openingChar = src[braceOpen];
-            const closingChar = openingChar === "[" ? "]" : "}";
-            let i = braceOpen + 1;
-            let depth = 1;
-            while (i < len && depth > 0) {
-                const ch = src[i];
-                if (ch === openingChar) depth++;
-                else if (ch === closingChar) depth--;
-                i++;
-            }
-            let braceClose = i;
-            let endIdx = braceClose;
-            if (src.slice(braceClose, braceClose + 1) === ";")
-                endIdx = braceClose + 1;
-
-            const before = src.slice(0, startIdx);
-            const after = src.slice(endIdx);
-            src = before + after;
-        } else {
-            // fallback: remove until next semicolon or a blank line
-            const semi = src.indexOf(";", startIdx);
-            let endIdx = semi !== -1 ? semi + 1 : src.indexOf("\n\n", startIdx);
-            if (endIdx === -1) endIdx = len;
-            src = src.slice(0, startIdx) + src.slice(endIdx);
-        }
-    }
-
-    // remove any export const <name>: any = <name>; lines
-    const exportRe = new RegExp(
-        `export\\s+const\\s+${escaped}\\s*:\\s*any\\s*=\\s*${escaped}\\s*;?`,
-        "g"
-    );
-    src = src.replace(exportRe, "");
-
-    // tidy up multiple blank lines
-    src = src.replace(/\n{3,}/g, "\n\n");
-
-    fs.writeFileSync(dbPath, src, "utf8");
-
-    return `Removed ${fnName} from database ${dbName}.`;
-}
-
-function rename(oldName: string, newName: string, options?: VMOptions): string {
-    const DIR = options?.dir || path.join(process.cwd(), 'databases');
-    const oldPath = path.join(DIR, `${oldName}.ts`);
-    const newPath = path.join(DIR, `${newName}.ts`);
-
-    // Check if the source file exists
-    if (!fs.existsSync(oldPath)) {
-        return `Error: File '${oldName}.ts' does not exist in the database`;
-    }
-
-    // Check if the destination file already exists
-    if (fs.existsSync(newPath)) {
-        return `Error: File '${newName}.ts' already exists in the database`;
-    }
-
-    try {
-        // Rename the file
-        fs.renameSync(oldPath, newPath);
-        return `Successfully renamed '${oldName}.ts' to '${newName}.ts'`;
-    } catch (error) {
-        return `Error renaming file: ${error instanceof Error ? error.message : String(error)}`;
-    }
-}
-
-type DeclarationKind = "valueDecl" | "functionDecl" | "classDecl";
-type UpdateValue = unknown;
-
-interface DeclarationMatch {
-    kind: DeclarationKind;
-    start: number;
-    end: number;
-    exported: boolean;
-    prefixEnd?: number;
-}
-
-function escapeRegExp(value: string): string {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function findMatchingBlockEnd(source: string, openIndex: number): number {
-    let depth = 0;
-    let stringChar: string | null = null;
-
-    for (let index = openIndex; index < source.length; index += 1) {
-        const char = source[index];
-        const nextChar = source[index + 1];
-
-        if (stringChar) {
-            if (char === "\\") {
-                index += 1;
-                continue;
-            }
-
-            if (char === stringChar) {
-                stringChar = null;
-            }
-            continue;
-        }
-
-        if (char === "/" && nextChar === "/") {
-            index += 2;
-            while (index < source.length && source[index] !== "\n") {
-                index += 1;
-            }
-            continue;
-        }
-
-        if (char === "/" && nextChar === "*") {
-            index += 2;
-            while (index < source.length && !(source[index] === "*" && source[index + 1] === "/")) {
-                index += 1;
-            }
-            index += 1;
-            continue;
-        }
-
-        if (char === '"' || char === "'" || char === "`") {
-            stringChar = char;
-            continue;
-        }
-
-        if (char === "{") {
-            depth += 1;
-        } else if (char === "}") {
-            depth -= 1;
-            if (depth === 0) {
-                return index;
-            }
-        }
-    }
-
-    return source.length - 1;
-}
-
-function findInitializerEnd(source: string, startIndex: number): number {
-    let braceDepth = 0;
-    let bracketDepth = 0;
-    let parenDepth = 0;
-    let stringChar: string | null = null;
-
-    for (let index = startIndex; index < source.length; index += 1) {
-        const char = source[index];
-        const nextChar = source[index + 1];
-
-        if (stringChar) {
-            if (char === "\\") {
-                index += 1;
-                continue;
-            }
-
-            if (char === stringChar) {
-                stringChar = null;
-            }
-            continue;
-        }
-
-        if (char === "/" && nextChar === "/") {
-            index += 2;
-            while (index < source.length && source[index] !== "\n") {
-                index += 1;
-            }
-            continue;
-        }
-
-        if (char === "/" && nextChar === "*") {
-            index += 2;
-            while (index < source.length && !(source[index] === "*" && source[index + 1] === "/")) {
-                index += 1;
-            }
-            index += 1;
-            continue;
-        }
-
-        if (char === '"' || char === "'" || char === "`") {
-            stringChar = char;
-            continue;
-        }
-
-        if (char === "{") {
-            braceDepth += 1;
-        } else if (char === "}") {
-            braceDepth = Math.max(0, braceDepth - 1);
-        } else if (char === "[") {
-            bracketDepth += 1;
-        } else if (char === "]") {
-            bracketDepth = Math.max(0, bracketDepth - 1);
-        } else if (char === "(") {
-            parenDepth += 1;
-        } else if (char === ")") {
-            parenDepth = Math.max(0, parenDepth - 1);
-        } else if (char === ";" && braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) {
-            return index;
-        }
-    }
-
-    return source.length;
-}
-
-function looksLikeDeclarationSnippet(source: string): boolean {
-    const trimmed = source.trim();
-    return /^(?:export\s+)?(?:async\s+function\b|function\b|class\b|(?:const|let|var)\b)/.test(trimmed);
-}
-
-function replaceExistingBindingValue(source: string, bindingName: string, serializedValue: string): string | null {
-    const escapedName = escapeRegExp(bindingName);
-    const declarationRegex = new RegExp(`(?:export\\s+)?(?:const|let|var)\\s+${escapedName}(?:\\s*:\\s*[^=;]+)?\\s*=`, "m");
-    const declarationMatch = declarationRegex.exec(source);
-
-    if (!declarationMatch || declarationMatch.index === undefined) {
-        return null;
-    }
-
-    const equalsIndex = source.indexOf("=", declarationMatch.index);
-    if (equalsIndex === -1) {
-        return null;
-    }
-
-    const initializerEnd = findInitializerEnd(source, equalsIndex + 1);
-    const suffix = initializerEnd < source.length
-        ? source.slice(initializerEnd)
-        : ";";
-
-    return `${source.slice(0, equalsIndex + 1)} ${serializedValue}${suffix}`;
-}
-
-function buildDatabaseModuleSource(dbName: string, code: unknown, dbPath: string): string {
-    if (typeof code === "string") {
-        return code;
-    }
-
-    if (typeof code === "function") {
-        return code.toString();
-    }
-
-    const serializedValue = valueToCode(code, 0);
-
-    if (fs.existsSync(dbPath) && isIdentifier(dbName)) {
-        const existingSource = fs.readFileSync(dbPath, "utf8");
-        const updatedSource = replaceExistingBindingValue(existingSource, dbName, serializedValue);
-
-        if (updatedSource) {
-            return updatedSource;
-        }
-    }
-
-    if (isIdentifier(dbName)) {
-        return `const ${dbName} = ${serializedValue};\n\nexport { ${dbName} };\nexport default ${dbName};\n`;
-    }
-
-    return `const value = ${serializedValue};\n\nexport default value;\n`;
-}
-
-function toInitializerSource(code: UpdateValue): string {
-    if (typeof code === "function") {
-        return code.toString().trim();
-    }
-
-    if (typeof code === "string") {
-        const trimmed = code.trim();
-        if (
-            looksLikeDeclarationSnippet(trimmed) ||
-            /=>/.test(trimmed) ||
-            /^(?:\{|\[|\(|"|'|`|\d|-\d|true\b|false\b|null\b|undefined\b|new\b|await\b)/.test(trimmed)
-        ) {
-            return trimmed;
-        }
-
-        return valueToCode(code, 0);
-    }
-
-    return valueToCode(code, 0);
-}
-
-function shouldUseDeclarationSource(code: UpdateValue): code is string | Function {
-    return typeof code === "function" || (typeof code === "string" && looksLikeDeclarationSnippet(code));
-}
-
-function normalizeFunctionDeclaration(name: string, code: string): string {
-    const trimmed = code.trim().replace(/^export\s+/, "");
-
-    if (/^async\s+function\s+[A-Za-z_$][\w$]*/.test(trimmed)) {
-        return trimmed.replace(/^async\s+function\s+[A-Za-z_$][\w$]*/, `async function ${name}`);
-    }
-
-    if (/^async\s+function\s*\(/.test(trimmed)) {
-        return trimmed.replace(/^async\s+function\s*\(/, `async function ${name}(`);
-    }
-
-    if (/^function\s+[A-Za-z_$][\w$]*/.test(trimmed)) {
-        return trimmed.replace(/^function\s+[A-Za-z_$][\w$]*/, `function ${name}`);
-    }
-
-    if (/^function\s*\(/.test(trimmed)) {
-        return trimmed.replace(/^function\s*\(/, `function ${name}(`);
-    }
-
-    return `function ${name}() {\n${trimmed}\n}`;
-}
-
-function normalizeClassDeclaration(name: string, code: string): string {
-    const trimmed = code.trim().replace(/^export\s+/, "");
-
-    if (/^class\s+[A-Za-z_$][\w$]*/.test(trimmed)) {
-        return trimmed.replace(/^class\s+[A-Za-z_$][\w$]*/, `class ${name}`);
-    }
-
-    if (/^class(?:\s+extends\b|\s*\{)/.test(trimmed)) {
-        return trimmed.replace(/^class/, `class ${name}`);
-    }
-
-    return `class ${name} ${trimmed}`;
-}
-
-function findDeclaration(source: string, name: string): DeclarationMatch | null {
-    const escaped = escapeRegExp(name);
-    const matches: DeclarationMatch[] = [];
-
-    const valueRegex = new RegExp(`(?:export\\s+)?(?:const|let|var)\\s+${escaped}(?:\\s*:\\s*[^=;]+)?\\s*=`, "m");
-    const valueMatch = valueRegex.exec(source);
-    if (valueMatch && valueMatch.index !== undefined) {
-        const equalsIndex = source.indexOf("=", valueMatch.index);
-        if (equalsIndex !== -1) {
-            const initializerEnd = findInitializerEnd(source, equalsIndex + 1);
-            const end = initializerEnd < source.length && source[initializerEnd] === ";"
-                ? initializerEnd + 1
-                : initializerEnd;
-            matches.push({
-                kind: "valueDecl",
-                start: valueMatch.index,
-                end,
-                exported: /^\s*export\b/.test(valueMatch[0]),
-                prefixEnd: equalsIndex + 1,
-            });
-        }
-    }
-
-    const functionRegex = new RegExp(`(?:export\\s+)?(?:async\\s+)?function\\s+${escaped}\\s*\\(`, "m");
-    const functionMatch = functionRegex.exec(source);
-    if (functionMatch && functionMatch.index !== undefined) {
-        const braceOpen = source.indexOf("{", functionMatch.index);
-        if (braceOpen !== -1) {
-            const braceClose = findMatchingBlockEnd(source, braceOpen);
-            const end = braceClose + 1 < source.length && source[braceClose + 1] === ";"
-                ? braceClose + 2
-                : braceClose + 1;
-            matches.push({
-                kind: "functionDecl",
-                start: functionMatch.index,
-                end,
-                exported: /^\s*export\b/.test(functionMatch[0]),
-            });
-        }
-    }
-
-    const classRegex = new RegExp(`(?:export\\s+)?class\\s+${escaped}(?=\\s|\\{)`, "m");
-    const classMatch = classRegex.exec(source);
-    if (classMatch && classMatch.index !== undefined) {
-        const braceOpen = source.indexOf("{", classMatch.index);
-        if (braceOpen !== -1) {
-            const braceClose = findMatchingBlockEnd(source, braceOpen);
-            const end = braceClose + 1 < source.length && source[braceClose + 1] === ";"
-                ? braceClose + 2
-                : braceClose + 1;
-            matches.push({
-                kind: "classDecl",
-                start: classMatch.index,
-                end,
-                exported: /^\s*export\b/.test(classMatch[0]),
-            });
-        }
-    }
-
-    if (matches.length === 0) {
-        return null;
-    }
-
-    matches.sort((left, right) => left.start - right.start);
-    return matches[0];
-}
-
-function createStructuredReplacement(kind: Extract<DeclarationKind, "functionDecl" | "classDecl">, name: string, code: UpdateValue): string {
-    if (!shouldUseDeclarationSource(code)) {
-        return `const ${name} = ${toInitializerSource(code)};`;
-    }
-
-    const source = code.toString();
-    return kind === "functionDecl"
-        ? normalizeFunctionDeclaration(name, source)
-        : normalizeClassDeclaration(name, source);
-}
-
-function createDeclarationSnippet(name: string, code: UpdateValue): string {
-    if (typeof code === "function") {
-        const fnSource = code.toString().trim();
-        if (/^(?:async\s+)?function\b/.test(fnSource)) {
-            return `export ${normalizeFunctionDeclaration(name, fnSource)}`;
-        }
-
-        if (/^class\b/.test(fnSource)) {
-            return `export ${normalizeClassDeclaration(name, fnSource)}`;
-        }
-
-        return `export const ${name} = ${fnSource};`;
-    }
-
-    if (typeof code === "string") {
-        const trimmed = code.trim();
-        if (looksLikeDeclarationSnippet(trimmed)) {
-            return trimmed;
-        }
-    }
-
-    return `export const ${name} = ${toInitializerSource(code)};`;
-}
-
-function save(dbName: string, code: unknown, options?: VMOptions): void {
-    const DIR = options?.dir || path.join(process.cwd(), 'databases');
-    const dbPath = path.join(DIR, `${dbName}.ts`);
-
-    const fileContent = buildDatabaseModuleSource(dbName, code, dbPath);
-    fs.writeFileSync(dbPath, fileContent, 'utf8');
-}
-
-function update(dbName: string, fnName: string, code: UpdateValue, options?: VMOptions): string {
-    const DIR = options?.dir || path.join(process.cwd(), 'databases');
-    const dbPath = path.join(DIR, `${dbName}.ts`);
-
-    if (!fs.existsSync(dbPath)) {
-        try {
-            fs.writeFileSync(dbPath, '', 'utf8');
-        } catch {
-            return `Failed to create dbPath file: ${dbPath}`;
-        }
-    }
-
-    let src = fs.readFileSync(dbPath, 'utf8');
-    const originalSrc = src;
-
-    const declaration = findDeclaration(src, fnName);
-
-    if (declaration) {
-        if (declaration.kind === 'valueDecl' && declaration.prefixEnd !== undefined) {
-            const initializer = toInitializerSource(code);
-            src =
-                src.slice(0, declaration.start) +
-                src.slice(declaration.start, declaration.prefixEnd) +
-                ` ${initializer};` +
-                src.slice(declaration.end);
-        } else if (declaration.kind === 'functionDecl') {
-            const replacement = createStructuredReplacement('functionDecl', fnName, code);
-            src =
-                src.slice(0, declaration.start) +
-                `${declaration.exported ? 'export ' : ''}${replacement.replace(/^export\s+/, '')}` +
-                src.slice(declaration.end);
-        } else {
-            const replacement = createStructuredReplacement('classDecl', fnName, code);
-            src =
-                src.slice(0, declaration.start) +
-                `${declaration.exported ? 'export ' : ''}${replacement.replace(/^export\s+/, '')}` +
-                src.slice(declaration.end);
-        }
-    } else {
-        const snippet = createDeclarationSnippet(fnName, code);
-        const separator = src.trim().length > 0 ? '\n\n' : '';
-        src = `${src.trimEnd()}${separator}${snippet}\n`;
-    }
-
-    fs.writeFileSync(dbPath, src, 'utf8');
-
-    if (src === originalSrc) {
-        return `Saved ${fnName} to database ${dbName}.`;
-    }
-
-    return `Updated ${dbName} with ${fnName}.`;
-}
-
-function valueToCode(val: any, depth: number = 0): string {
-    const indentUnit = "    ";
-    const indent = indentUnit.repeat(depth);
-    const indentInner = indentUnit.repeat(depth + 1);
-
-    if (val === null) return "null";
-    const t = typeof val;
-    if (t === "string") return JSON.stringify(val);
-    if (t === "number" || t === "boolean") return String(val);
-    if (t === "function") return val.toString();
-    if (Array.isArray(val)) {
-        if (val.length === 0) return "[]";
-        const items = val.map((v) => valueToCode(v, depth + 1));
-        return (
-            "[\n" +
-            items.map((it) => indentInner + it).join(",\n") +
-            "\n" +
-            indent +
-            "]"
-        );
-    }
-    if (t === "object") {
-        const keys = Object.keys(val);
-        if (keys.length === 0) return "{}";
-        const entries = keys.map((k) => {
-            const keyPart = isIdentifier(k) ? k : JSON.stringify(k);
-            const v = valueToCode(val[k], depth + 1);
-            return indentInner + keyPart + ": " + v;
-        });
-        return "{\n" + entries.join(",\n") + "\n" + indent + "}";
-    }
-    return String(val);
-}
-
-function isIdentifier(key: any) {
-    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
-}
-
-async function SystemModuleResolver(customOptions?: VMOptions) {
-
-    const moduleRegistry = new Map<string, any>();
-
-    // Wrap functions to automatically pass customOptions when called from within VM
-    moduleRegistry.set("update", (dbName: string, fnName: string, code: unknown) =>
-        update(dbName, fnName, code, customOptions));
-    moduleRegistry.set("remove", (dbName: string, fnName: string) =>
-        remove(dbName, fnName, customOptions));
-    moduleRegistry.set("create", (dbName: string, code: string | Function) =>
-        create(dbName, code, customOptions));
-    moduleRegistry.set("save", (dbName: string, code: unknown) =>
-        save(dbName, code, customOptions));
-    moduleRegistry.set("read", (dbName: string) =>
-        read(dbName, customOptions));
-
-    const context: Record<string, any> = {
-        // Add require-like functionality
-        require: (moduleName: string) => {
-            const module = moduleRegistry.get(moduleName);
-            if (!module) {
-                throw new Error(`Module '${moduleName}' not found`);
-            }
-            // Return the default export if available, otherwise the module itself
-            return module.default || module;
-        },
-
-        // Add import functionality (simulated)
-        import: async (moduleName: string) => {
-            const module = moduleRegistry.get(moduleName);
-            if (!module) {
-                throw new Error(`Module '${moduleName}' not found`);
-            }
-            return {
-                default: module.default || module
-            };
-        }
-    };
-
-    for (const [name, moduleExports] of moduleRegistry) {
-        context[name] = moduleExports.default || moduleExports;
-    }
-
-    return context;
-}
-
-export class Database {
-    private vm: VM;
-    private options: VMOptions;
-
-    constructor(options?: VMOptions) {
-        this.options = {
-            language: 'ts',
-            registerModules: {},
-            ...options
-        };
-        this.vm = new VM(this.options);
-    }
-
-    register(context: { [key: string]: any }) {
-        this.vm.register(context);
-    }
-
-    async execute(code: string) {
-        return await this.vm.run(code);
-    }
-
-    // ===== Database Helper Methods =====
-
-    /**
-     * Create a new database file with the given code
-     */
-    create(dbName: string, code: string | Function): void {
-        return create(dbName, code, this.options);
-    }
-
-    /**
-     * Read the contents of a database file
-     */
-    read(dbName: string): string {
-        return read(dbName, this.options);
-    }
-
-    /**
-     * Remove a function or the entire database file
-     */
-    remove(dbName: string, fnName?: string): string | boolean {
-       return remove(dbName, fnName || "", this.options);
-    }
-
-    /**
-     * Rename a database file
-     */
-    rename(oldName: string, newName: string): string {
-       return rename(oldName, newName, this.options);
-    }
-
-    /**
-     * Save code to a database file (overwrites existing content)
-     */
-    save(dbName: string, code: unknown): void {
-        return save(dbName, code, this.options);
-    }
-
-    /**
-     * Update a function in a database file
-     */
-    update(dbName: string, fnName: string, code: unknown): string {
-        return update(dbName, fnName, code, this.options);
-    }
-}
-
-// Export Database class and keep helper functions for backward compatibility
-export { create, read, remove, rename, save, update };
-
-