@ricsam/isolate-client 0.1.9 → 0.1.11

package/README.md

@@ -85,7 +85,10 @@ const namespace = client.createNamespace("tenant-123");
 // Create a runtime in this namespace
 const runtime = await namespace.createRuntime({
   memoryLimitMB: 128,
-  moduleLoader: async (name) => loadModule(name),
+  moduleLoader: async (name, importer) => {
+    const code = loadModule(name);
+    return { code, resolveDir: importer.resolveDir };
+  },
 });
 
 console.log(runtime.reused); // false - first time
@@ -145,21 +148,29 @@ interface Namespace {
 
 ## Module Loader
 
-Register a custom module loader to handle dynamic `import()` calls:
+Register a custom module loader to handle dynamic `import()` calls. The loader receives the module specifier and importer info, and returns an object with the source code and `resolveDir` (used to resolve nested relative imports):
 
 ```typescript
 const runtime = await client.createRuntime({
-  moduleLoader: async (moduleName: string) => {
+  moduleLoader: async (moduleName: string, importer) => {
+    // importer.path = resolved path of importing module
+    // importer.resolveDir = directory for relative resolution
     if (moduleName === "@/db") {
-      return `
-        export async function getUser(id) {
-          const response = await fetch("/api/users/" + id);
-          return response.json();
-        }
-      `;
+      return {
+        code: `
+          export async function getUser(id) {
+            const response = await fetch("/api/users/" + id);
+            return response.json();
+          }
+        `,
+        resolveDir: "/modules",
+      };
     }
     if (moduleName === "@/config") {
-      return `export const API_KEY = "sk-xxx";`;
+      return {
+        code: `export const API_KEY = "sk-xxx";`,
+        resolveDir: "/modules",
+      };
     }
     throw new Error(`Unknown module: ${moduleName}`);
   },

package/dist/cjs/connection.cjs

@@ -1,7 +1,20 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
   var entry = __moduleCache.get(from), desc;
@@ -33,6 +46,7 @@ __export(exports_connection, {
 });
 module.exports = __toCommonJS(exports_connection);
 var import_node_net = require("node:net");
+var import_node_path = __toESM(require("node:path"));
 var import_isolate_protocol = require("@ricsam/isolate-protocol");
 var import_client = require("@ricsam/isolate-playwright/client");
 var DEFAULT_TIMEOUT = 30000;
@@ -421,6 +435,10 @@ async function createRuntime(state, options = {}, namespaceId) {
     callbacks.custom = registerCustomFunctions(state, options.customFunctions);
   }
   let playwrightHandler;
+  const browserConsoleLogs = [];
+  const networkRequests = [];
+  const networkResponses = [];
+  const pageListenerCleanups = [];
   if (options.playwright) {
     playwrightHandler = import_client.createPlaywrightHandler(options.playwright.page, {
       timeout: options.playwright.timeout,
@@ -432,65 +450,67 @@ async function createRuntime(state, options = {}, namespaceId) {
       const result2 = await playwrightHandler(op);
       return JSON.stringify(result2);
     });
-    const hasOnEvent = !!options.playwright.onEvent;
-    const hasConsoleHandler = options.playwright.console && options.console?.onEntry;
-    let browserConsoleLogCallbackId;
-    if (hasOnEvent || hasConsoleHandler) {
-      browserConsoleLogCallbackId = registerEventCallback(state, (entry) => {
-        const browserEntry = entry;
-        if (options.playwright.onEvent) {
-          options.playwright.onEvent({
-            type: "browserConsoleLog",
-            level: browserEntry.level,
-            stdout: browserEntry.stdout,
-            timestamp: browserEntry.timestamp
-          });
-        }
-        if (options.playwright.console && options.console?.onEntry) {
-          options.console.onEntry({
-            type: "browserOutput",
-            level: browserEntry.level,
-            stdout: browserEntry.stdout,
-            timestamp: browserEntry.timestamp
-          });
-        }
-      });
-    }
-    let networkRequestCallbackId;
-    if (hasOnEvent) {
-      networkRequestCallbackId = registerEventCallback(state, (info) => {
-        const reqInfo = info;
+    const page = options.playwright.page;
+    const onConsole = (msg) => {
+      const entry = {
+        level: msg.type(),
+        stdout: msg.text(),
+        timestamp: Date.now()
+      };
+      browserConsoleLogs.push(entry);
+      if (options.playwright.onEvent) {
+        options.playwright.onEvent({
+          type: "browserConsoleLog",
+          ...entry
+        });
+      }
+      if (options.playwright.console && options.console?.onEntry) {
+        options.console.onEntry({
+          type: "browserOutput",
+          ...entry
+        });
+      } else if (options.playwright.console) {
+        const prefix = entry.level === "error" ? "[browser:error]" : "[browser]";
+        console.log(prefix, entry.stdout);
+      }
+    };
+    const onRequest = (request2) => {
+      const info = {
+        url: request2.url(),
+        method: request2.method(),
+        headers: request2.headers(),
+        timestamp: Date.now()
+      };
+      networkRequests.push(info);
+      if (options.playwright.onEvent) {
         options.playwright.onEvent({
           type: "networkRequest",
-          url: reqInfo.url,
-          method: reqInfo.method,
-          headers: reqInfo.headers,
-          postData: reqInfo.postData,
-          resourceType: reqInfo.resourceType,
-          timestamp: reqInfo.timestamp
+          ...info
         });
-      });
-    }
-    let networkResponseCallbackId;
-    if (hasOnEvent) {
-      networkResponseCallbackId = registerEventCallback(state, (info) => {
-        const resInfo = info;
+      }
+    };
+    const onResponse = (response) => {
+      const info = {
+        url: response.url(),
+        status: response.status(),
+        headers: response.headers(),
+        timestamp: Date.now()
+      };
+      networkResponses.push(info);
+      if (options.playwright.onEvent) {
         options.playwright.onEvent({
           type: "networkResponse",
-          url: resInfo.url,
-          status: resInfo.status,
-          statusText: resInfo.statusText,
-          headers: resInfo.headers,
-          timestamp: resInfo.timestamp
+          ...info
         });
-      });
-    }
+      }
+    };
+    page.on("console", onConsole);
+    page.on("request", onRequest);
+    page.on("response", onResponse);
+    pageListenerCleanups.push(() => page.removeListener("console", onConsole), () => page.removeListener("request", onRequest), () => page.removeListener("response", onResponse));
     callbacks.playwright = {
       handlerCallbackId,
-      console: options.playwright.console && !options.console?.onEntry,
-      onBrowserConsoleLogCallbackId: browserConsoleLogCallbackId,
-      onNetworkRequestCallbackId: networkRequestCallbackId,
-      onNetworkResponseCallbackId: networkResponseCallbackId
+      console: options.playwright.console && !options.console?.onEntry
     };
   }
   let testEnvironmentOption;
@@ -748,29 +768,23 @@ async function createRuntime(state, options = {}, namespaceId) {
     }
   };
   const playwrightHandle = {
-    async getCollectedData() {
+    getCollectedData() {
       if (!playwrightEnabled) {
         throw new Error("Playwright not configured. Provide playwright.page in createRuntime options.");
       }
-      const reqId = state.nextRequestId++;
-      const req = {
-        type: import_isolate_protocol.MessageType.GET_COLLECTED_DATA,
-        requestId: reqId,
-        isolateId
+      return {
+        browserConsoleLogs: [...browserConsoleLogs],
+        networkRequests: [...networkRequests],
+        networkResponses: [...networkResponses]
       };
-      return sendRequest(state, req);
     },
-    async clearCollectedData() {
+    clearCollectedData() {
       if (!playwrightEnabled) {
         throw new Error("Playwright not configured. Provide playwright.page in createRuntime options.");
       }
-      const reqId = state.nextRequestId++;
-      const req = {
-        type: import_isolate_protocol.MessageType.CLEAR_COLLECTED_DATA,
-        requestId: reqId,
-        isolateId
-      };
-      await sendRequest(state, req);
+      browserConsoleLogs.length = 0;
+      networkRequests.length = 0;
+      networkResponses.length = 0;
     }
   };
   return {
@@ -797,6 +811,9 @@ async function createRuntime(state, options = {}, namespaceId) {
       await sendRequest(state, req);
     },
     dispose: async () => {
+      for (const cleanup of pageListenerCleanups) {
+        cleanup();
+      }
       isolateWsCallbacks.delete(isolateId);
       const reqId = state.nextRequestId++;
       const req = {
@@ -899,15 +916,15 @@ function registerFsCallbacks(state, callbacks) {
   const registrations = {};
   if (callbacks.readFile) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path) => {
-      const result = await callbacks.readFile(path);
+    state.callbacks.set(callbackId, async (path2) => {
+      const result = await callbacks.readFile(path2);
       return new Uint8Array(result);
     });
     registrations.readFile = { callbackId, name: "readFile", type: "async" };
   }
   if (callbacks.writeFile) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path, data) => {
+    state.callbacks.set(callbackId, async (path2, data) => {
       let buffer;
       if (data instanceof Uint8Array) {
         buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
@@ -918,42 +935,42 @@ function registerFsCallbacks(state, callbacks) {
       } else {
         buffer = new ArrayBuffer(0);
       }
-      await callbacks.writeFile(path, buffer);
+      await callbacks.writeFile(path2, buffer);
     });
     registrations.writeFile = { callbackId, name: "writeFile", type: "async" };
   }
   if (callbacks.unlink) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path) => {
-      await callbacks.unlink(path);
+    state.callbacks.set(callbackId, async (path2) => {
+      await callbacks.unlink(path2);
     });
     registrations.unlink = { callbackId, name: "unlink", type: "async" };
   }
   if (callbacks.readdir) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path) => {
-      return callbacks.readdir(path);
+    state.callbacks.set(callbackId, async (path2) => {
+      return callbacks.readdir(path2);
     });
     registrations.readdir = { callbackId, name: "readdir", type: "async" };
   }
   if (callbacks.mkdir) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path, options) => {
-      await callbacks.mkdir(path, options);
+    state.callbacks.set(callbackId, async (path2, options) => {
+      await callbacks.mkdir(path2, options);
     });
     registrations.mkdir = { callbackId, name: "mkdir", type: "async" };
   }
   if (callbacks.rmdir) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path) => {
-      await callbacks.rmdir(path);
+    state.callbacks.set(callbackId, async (path2) => {
+      await callbacks.rmdir(path2);
     });
     registrations.rmdir = { callbackId, name: "rmdir", type: "async" };
   }
   if (callbacks.stat) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path) => {
-      return callbacks.stat(path);
+    state.callbacks.set(callbackId, async (path2) => {
+      return callbacks.stat(path2);
     });
     registrations.stat = { callbackId, name: "stat", type: "async" };
   }
@@ -968,15 +985,13 @@ function registerFsCallbacks(state, callbacks) {
 }
 function registerModuleLoaderCallback(state, callback) {
   const callbackId = state.nextCallbackId++;
-  state.callbacks.set(callbackId, async (moduleName) => {
+  state.callbacks.set(callbackId, async (moduleName, importer) => {
     const specifier = moduleName;
-    const cached = state.moduleSourceCache.get(specifier);
-    if (cached !== undefined) {
-      return cached;
-    }
-    const source = await callback(specifier);
-    state.moduleSourceCache.set(specifier, source);
-    return source;
+    const importerInfo = importer;
+    const result = await callback(specifier, importerInfo);
+    const resolvedPath = import_node_path.default.posix.join(result.resolveDir, import_node_path.default.posix.basename(specifier));
+    state.moduleSourceCache.set(resolvedPath, result.code);
+    return result;
   });
   return { callbackId, name: "moduleLoader", type: "async" };
 }
@@ -1302,4 +1317,4 @@ async function sendBodyStream(state, streamId, body) {
   }
 }
 
-//# debugId=88982DC84A5B7DE464756E2164756E21
+//# debugId=F22B720CD1D2496764756E2164756E21