Merge pull request #81 from thutasann/develop

thutasann · web-flow · commit 983c64d72a77 · 2025-08-20T13:32:06.000+08:00
feat: support module import
diff --git a/README.md b/README.md
@@ -113,10 +113,18 @@ const result = await go(
   async () => {
     const fs = require('node:fs');
     const crypto = require('node:crypto');
+    const moment = (await import('moment')).default;
+
+    const moment_res = {
+      version: moment.version,
+      now: moment().format(),
+      isValid: moment().isValid(),
+    };
 
     return {
       fileExists: fs.existsSync('/tmp/test'),
       randomBytes: crypto.randomBytes(4).toString('hex'),
+      ...moment_res,
     };
   },
   [],
diff --git a/examples/core/goroutines/helpers/sleep.js b/examples/core/goroutines/helpers/sleep.js
@@ -0,0 +1,7 @@
+function js_sleep(duration) {
+  return new Promise(resolve => {
+    setTimeout(resolve, duration);
+  });
+}
+
+export default js_sleep;
diff --git a/examples/core/goroutines/moment-import-test.js b/examples/core/goroutines/moment-import-test.js
@@ -22,10 +22,10 @@ async function testMomentImports() {
     console.log('\n1. Testing basic moment import...');
     const result1 = await go(
       async () => {
-        const moment = require('moment');
-        const sleep = require('./helpers/sleep.cjs');
+        const moment = (await import('moment')).default;
 
-        await sleep(1000);
+        const { sleep } = await import('gonex');
+        await sleep(300);
         console.log('Moment imported successfully in worker thread');
         return {
           version: moment.version,
@@ -42,8 +42,10 @@ async function testMomentImports() {
     console.log('\n2. Testing moment with date formatting...');
     const result2 = await go(
       async () => {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
         const moment = require('moment');
+        const sleep = (await import('./helpers/sleep.cjs')).default;
+
+        await sleep(300);
         console.log('Moment imported for date formatting');
 
         const now = moment();
@@ -59,6 +61,46 @@ async function testMomentImports() {
     );
     console.log('Moment formatting result:', result2);
 
+    // Test 3: Lodash Import Testing
+    console.log('\n3. Testing lodash import...');
+    const result3 = await go(
+      async () => {
+        const lodash = (await import('lodash')).default;
+        const sleep = (await import('./helpers/sleep.js')).default;
+
+        await sleep(300);
+        console.log('Lodash imported successfully');
+        return {
+          isArray: lodash.isArray([1, 2, 3]),
+          capitalize: lodash.capitalize('hello'),
+        };
+      },
+      [],
+      { useWorkerThreads: true }
+    );
+    console.log('Lodash result:', result3);
+
+    // Test 4: chalk import testing
+    console.log('\n4. Testing chalk import...');
+    const result4 = await go(
+      async () => {
+        const chalk = (await import('chalk')).default;
+        console.log('Chalk imported successfully');
+        console.log(chalk.red('Hello, world!'));
+        console.log(chalk.green('Hello, world!'));
+        console.log(chalk.blue('Hello, world!'));
+
+        return {
+          red: chalk.red('Hello, world!'),
+          green: chalk.green('Hello, world!'),
+          blue: chalk.blue('Hello, world!'),
+        };
+      },
+      [],
+      { useWorkerThreads: true }
+    );
+    console.log('Chalk result:', result4);
+
     console.log('\nAll moment import tests completed successfully!');
   } catch (error) {
     console.error('Test failed:', error);
diff --git a/examples/core/goroutines/simple-import-test.js b/examples/core/goroutines/simple-import-test.js
@@ -19,7 +19,7 @@ async function testSimpleImports() {
     console.log('\n1. Testing function with Node.js built-in module...');
     const result1 = await go(
       async () => {
-        const fs = await import('node:fs');
+        const fs = (await import('node:fs')).default;
         console.log('FS module imported successfully in worker thread');
         return {
           existsSync: typeof fs.existsSync === 'function',
@@ -35,7 +35,7 @@ async function testSimpleImports() {
     console.log('\n2. Testing function with path module...');
     const result2 = await go(
       async () => {
-        const path = await import('node:path');
+        const path = (await import('node:path')).default;
         console.log('Path module imported successfully');
         return {
           join: typeof path.join === 'function',
@@ -52,7 +52,7 @@ async function testSimpleImports() {
     console.log('\n3. Testing function with crypto module...');
     const result3 = await go(
       async () => {
-        const crypto = await import('node:crypto');
+        const crypto = (await import('node:crypto')).default;
         console.log('Crypto module imported successfully');
         return {
           randomBytes: typeof crypto.randomBytes === 'function',
@@ -70,14 +70,14 @@ async function testSimpleImports() {
     const result4 = await go(
       async moduleName => {
         console.log(`Attempting to import: ${moduleName}`);
-        const module = await import(moduleName);
+        const module = (await import(moduleName)).default;
         return {
           moduleName,
           success: true,
           exports: Object.keys(module),
         };
       },
-      ['node:fs'],
+      ['node:fs', 'node:path', 'node:crypto'],
       { useWorkerThreads: true }
     );
     console.log('Dynamic import result:', result4);
diff --git a/src/core/worker/helpers/execution.ts b/src/core/worker/helpers/execution.ts
@@ -85,14 +85,21 @@ export function createEnhancedRequire(
               path.resolve('${currentWorkingDir}', id),
               path.resolve(process.cwd(), id),
               path.resolve('${userProjectDir}', id),
-              path.resolve('${userProjectDir}', 'examples', id),
-              path.resolve('${userProjectDir}', 'examples', 'core', 'goroutines', id),
               path.resolve('${currentWorkingDir}', 'core', 'goroutines', id),
             ];
             
             for (const modulePath of possiblePaths) {
               try {
-                return originalRequire(modulePath);
+                const module = originalRequire(modulePath);
+                // Apply smart proxy for .default access
+                return new Proxy(module, {
+                  get(target, prop) {
+                    if (prop === 'default') {
+                      return target.default !== undefined ? target.default : target;
+                    }
+                    return target[prop];
+                  }
+                });
               } catch (localError) {
                 // Continue to next path
               }
@@ -104,16 +111,23 @@ export function createEnhancedRequire(
           // For npm packages, try node_modules directories in this order:
           const possibleNodeModulesPaths = [
             path.resolve('${userProjectDir}', 'node_modules', id),
-            path.resolve('${userProjectDir}', 'examples', 'node_modules', id),
             path.resolve('${currentWorkingDir}', 'node_modules', id),
             path.resolve('${currentWorkingDir}', '..', 'node_modules', id),
             path.resolve('${currentWorkingDir}', '..', '..', 'node_modules', id),
-            path.resolve('${currentWorkingDir}', '..', '..', 'examples', 'node_modules', id),
           ];
           
           for (const modulePath of possibleNodeModulesPaths) {
             try {
-              return originalRequire(modulePath);
+              const module = originalRequire(modulePath);
+              // Apply smart proxy for .default access
+              return new Proxy(module, {
+                get(target, prop) {
+                  if (prop === 'default') {
+                    return target.default !== undefined ? target.default : target;
+                  }
+                  return target[prop];
+                }
+              });
             } catch (moduleError) {
               // Continue to next path
             }
@@ -125,6 +139,24 @@ export function createEnhancedRequire(
     `;
 }
 
+/**
+ * Transform import() calls to use our custom import function
+ * This preserves the await import() syntax while making it work in worker threads
+ */
+function transformImportCalls(userFunction: string): string {
+  // Replace await import('module') with await customImport('module')
+  // This regex matches: await import('module') or await import("module")
+  let transformed = userFunction;
+
+  // Replace import() calls with customImport() calls
+  transformed = transformed.replace(
+    /await\s+import\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g,
+    'await customImport("$1")'
+  );
+
+  return transformed;
+}
+
 /**
  * Create execution environment code
  */
@@ -133,12 +165,11 @@ export function createExecutionEnvironment(
   userProjectDir: string,
   userFunction: string
 ): string {
-  const enhancedRequire = createEnhancedRequire(
-    currentWorkingDir,
-    userProjectDir
-  );
   const contextProxy = createContextProxy();
 
+  // Transform import() calls to require() calls
+  const transformedFunction = transformImportCalls(userFunction);
+
   return `
       (async function(...args) {
         // Ensure essential globals are available
@@ -311,14 +342,105 @@ export function createExecutionEnvironment(
           });
         };
         
-        // Set up module resolution
-        ${enhancedRequire}
+
+        
+        // Create a custom import function that works in worker threads
+        // This mimics the behavior of ES module dynamic imports
+        var customImport = async function(id) {
+          const path = require('path');
+          
+          // Handle Node.js built-in modules (node:fs, node:path, etc.)
+          if (id.startsWith('node:')) {
+            const moduleName = id.substring(5); // Remove 'node:' prefix
+            try {
+              const module = require(moduleName);
+              // For built-in modules, return { default: module, ...module }
+              return { default: module, ...module };
+            } catch (error) {
+              throw new Error('Built-in module not found: ' + moduleName);
+            }
+          }
+          
+          // Handle local files (relative paths)
+          if (id.startsWith('./') || id.startsWith('../') || id.endsWith('.js')) {
+            const possiblePaths = [
+              path.resolve('${currentWorkingDir}', id),
+              path.resolve(process.cwd(), id),
+              path.resolve('${userProjectDir}', id),
+              path.resolve('${currentWorkingDir}', 'core', 'goroutines', id),
+            ];
+            
+            for (const modulePath of possiblePaths) {
+              try {
+                // For .js files, try to use dynamic import first (ES modules)
+                if (id.endsWith('.js')) {
+                  try {
+                    // Use dynamic import for ES modules
+                    const module = await import(modulePath);
+                    return module;
+                  } catch (importError) {
+                    // If dynamic import fails, fall back to require (CommonJS)
+                    const module = require(modulePath);
+                    if (module.default === undefined) {
+                      return { default: module, ...module };
+                    } else {
+                      return { default: module.default, ...module };
+                    }
+                  }
+                } else {
+                  // For .cjs files, use require (CommonJS)
+                  const module = require(modulePath);
+                  if (module.default === undefined) {
+                    return { default: module, ...module };
+                  } else {
+                    return { default: module.default, ...module };
+                  }
+                }
+              } catch (localError) {
+                // Continue to next path
+              }
+            }
+            
+            throw new Error('Module not found: ' + id);
+          }
+          
+          // For npm packages, try node_modules directories in this order:
+          const possibleNodeModulesPaths = [
+            path.resolve('${userProjectDir}', 'node_modules', id),
+            path.resolve('${currentWorkingDir}', 'node_modules', id),
+            path.resolve('${currentWorkingDir}', '..', 'node_modules', id),
+            path.resolve('${currentWorkingDir}', '..', '..', 'node_modules', id),
+          ];
+          
+          for (const modulePath of possibleNodeModulesPaths) {
+            try {
+              const module = require(modulePath);
+              // Always return an object with default property for consistency
+              // This supports both: await import('moment') and (await import('moment')).default
+              if (module.default === undefined) {
+                // CommonJS module - return { default: module, ...module }
+                return { default: module, ...module };
+              } else {
+                // ES module - return { default: module.default, ...module }
+                return { default: module.default, ...module };
+              }
+            } catch (moduleError) {
+              // Continue to next path
+            }
+          }
+          
+          throw new Error('Package not found: ' + id);
+        };
+        
+        // Make the custom import function available globally
+        // Users can call customImport('moment') instead of import('moment')
+        globalThis.customImport = customImport;
         
         // Resolve function arguments and handle context objects
         ${contextProxy}
         
-        // Create the user function
-        ${userFunction}
+        // Create the user function (with transformed import calls)
+        ${transformedFunction}
         
         // Execute the function with the resolved arguments
         return await fn(...resolvedArgs);
diff --git a/src/core/worker/worker-thread-manager.ts b/src/core/worker/worker-thread-manager.ts
@@ -1,5 +1,5 @@
 import os from 'os';
-import { join } from 'path';
+import path, { join } from 'path';
 import { Worker } from 'worker_threads';
 import type {
   MessageHandlers,
@@ -318,9 +318,11 @@ export class WorkerThreadManager {
    */
   private async createWorker(workerId: number): Promise<void> {
     // Get the user's project directory (where the go() function is called from)
+    // Use process.cwd() to get the actual working directory where the user ran the code
     const userProjectDir = process.cwd();
 
     // Get the current working directory for resolving relative imports
+    // This should be the user's project directory, not the dist directory
     const currentWorkingDir = process.cwd();
 
     const worker = new Worker(join(__dirname, './worker.js'), {
@@ -329,6 +331,15 @@ export class WorkerThreadManager {
         userProjectDir, // Pass the user's project directory
         currentWorkingDir, // Pass the current working directory
       },
+      env: {
+        ...process.env,
+        ['NODE_PATH']: [
+          path.join(userProjectDir, 'node_modules'),
+          process.env['NODE_PATH'],
+        ]
+          .filter(Boolean)
+          .join(path.delimiter),
+      },
     });
 
     // Set higher max listeners to prevent warnings
