edge-functions 5.2.0 → 5.3.0-stage.2

package/dist/{chunk-ENG7UVEB.js → chunk-4JJITWIU.js}

@@ -1,5 +1,4 @@
 // lib/env/runtime.ts
-import { EdgeRuntime } from "edge-runtime";
 import {
   fetchContext,
   FetchEventContext,
@@ -13,6 +12,337 @@ import {
   cryptoContext,
   promisesContext
 } from "azion/bundler/polyfills";
+
+// lib/env/edge-vm/edge-vm.ts
+import { load as loadPrimitives } from "@edge-runtime/primitives/dist/load.js";
+import { runInContext } from "vm";
+
+// lib/env/edge-vm/vm.ts
+import { resolve } from "path";
+import { pathToFileURL } from "url";
+import vm from "node:vm";
+var VM = class {
+  context;
+  constructor(options = {}) {
+    const context = vm.createContext(
+      {},
+      {
+        name: "Edge Runtime",
+        codeGeneration: options.codeGeneration ?? {
+          strings: false,
+          wasm: true
+        }
+      }
+    );
+    this.context = options.extend?.(context) ?? context;
+  }
+  /**
+   * Allows to run arbitrary code within the VM.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  evaluate(code) {
+    return vm.runInContext(code, this.context, {
+      importModuleDynamically: async (specifier) => {
+        try {
+          const fileUrl = pathToFileURL(resolve(specifier)).href;
+          return await import(fileUrl);
+        } catch (err) {
+          if (process.env.DEBUG) {
+            console.warn(
+              ">>> [edge-runtime] dynamic import failed, returning empty module:",
+              specifier
+            );
+          }
+          const mod = new vm.SourceTextModule("export default {}", { context: this.context });
+          await mod.link(() => {
+            return new vm.SourceTextModule("export {}", { context: this.context });
+          });
+          await mod.evaluate();
+          return mod;
+        }
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+  }
+};
+
+// lib/env/edge-vm/edge-vm.ts
+var unhandledRejectionHandlers;
+var uncaughtExceptionHandlers;
+var EdgeVM = class extends VM {
+  dispatchFetch;
+  constructor(options) {
+    super({
+      ...options,
+      extend: (context) => {
+        return options?.extend ? options.extend(addPrimitives(context)) : addPrimitives(context);
+      }
+    });
+    Object.defineProperty(this.context, "__onUnhandledRejectionHandlers", {
+      set: registerUnhandledRejectionHandlers,
+      configurable: false,
+      enumerable: false
+    });
+    Object.defineProperty(this, "__rejectionHandlers", {
+      get: () => unhandledRejectionHandlers,
+      configurable: false,
+      enumerable: false
+    });
+    Object.defineProperty(this.context, "__onErrorHandlers", {
+      set: registerUncaughtExceptionHandlers,
+      configurable: false,
+      enumerable: false
+    });
+    Object.defineProperty(this, "__errorHandlers", {
+      get: () => uncaughtExceptionHandlers,
+      configurable: false,
+      enumerable: false
+    });
+    this.evaluate(getDefineEventListenersCode());
+    this.dispatchFetch = this.evaluate(getDispatchFetchCode());
+    for (const name of transferableConstructors) {
+      patchInstanceOf(name, this.context);
+    }
+    if (options?.initialCode) {
+      this.evaluate(options.initialCode);
+    }
+  }
+};
+var transferableConstructors = [
+  "Object",
+  "Array",
+  "RegExp",
+  "Uint8Array",
+  "ArrayBuffer",
+  "Error",
+  "SyntaxError",
+  "TypeError"
+];
+function patchInstanceOf(item, ctx) {
+  const evail = eval;
+  ctx[Symbol.for(`node:${item}`)] = evail(item);
+  return runInContext(
+    `
+      globalThis.${item} = new Proxy(${item}, {
+        get(target, prop, receiver) {
+          if (prop === Symbol.hasInstance && receiver === globalThis.${item}) {
+            const nodeTarget = globalThis[Symbol.for('node:${item}')];
+            if (nodeTarget) {
+              return function(instance) {
+                return instance instanceof target || instance instanceof nodeTarget;
+              };
+            } else {
+              throw new Error('node target must exist')
+            }
+          }
+
+          return Reflect.get(target, prop, receiver);
+        }
+      })
+    `,
+    ctx
+  );
+}
+function registerUnhandledRejectionHandlers(handlers) {
+  if (!unhandledRejectionHandlers) {
+    process.on("unhandledRejection", function invokeRejectionHandlers(reason, promise) {
+      unhandledRejectionHandlers.forEach((handler) => handler({ reason, promise }));
+    });
+  }
+  unhandledRejectionHandlers = handlers;
+}
+function registerUncaughtExceptionHandlers(handlers) {
+  if (!uncaughtExceptionHandlers) {
+    process.on("uncaughtException", function invokeErrorHandlers(error) {
+      uncaughtExceptionHandlers.forEach((handler) => handler(error));
+    });
+  }
+  uncaughtExceptionHandlers = handlers;
+}
+function getDefineEventListenersCode() {
+  return `
+    Object.defineProperty(self, '__listeners', {
+      configurable: false,
+      enumerable: false,
+      value: {},
+      writable: true,
+    })
+
+    function __conditionallyUpdatesHandlerList(eventType) {
+      if (eventType === 'unhandledrejection') {
+        self.__onUnhandledRejectionHandlers = self.__listeners[eventType];
+      } else if (eventType === 'error') {
+        self.__onErrorHandlers = self.__listeners[eventType];
+      }
+    }
+
+    function addEventListener(type, handler) {
+      const eventType = type.toLowerCase();
+      if (eventType === 'fetch' && self.__listeners.fetch) {
+        throw new TypeError('You can register just one "fetch" event listener');
+      }
+
+      self.__listeners[eventType] = self.__listeners[eventType] || [];
+      self.__listeners[eventType].push(handler);
+      __conditionallyUpdatesHandlerList(eventType);
+    }
+
+    function removeEventListener(type, handler) {
+      const eventType = type.toLowerCase();
+      if (self.__listeners[eventType]) {
+        self.__listeners[eventType] = self.__listeners[eventType].filter(item => {
+          return item !== handler;
+        });
+
+        if (self.__listeners[eventType].length === 0) {
+          delete self.__listeners[eventType];
+        }
+      }
+      __conditionallyUpdatesHandlerList(eventType);
+    }
+  `;
+}
+function getDispatchFetchCode() {
+  return `(async function dispatchFetch(input, init) {
+    const request = new Request(input, init);
+    const event = new FetchEvent(request);
+    if (!self.__listeners.fetch) {
+      throw new Error("No fetch event listeners found");
+    }
+
+    const getResponse = ({ response, error }) => {
+     if (error || !response || !(response instanceof Response)) {
+        console.error(error ? error.toString() : 'The event listener did not respond')
+        response = new Response(null, {
+          statusText: 'Internal Server Error',
+          status: 500
+        })
+      }
+
+      response.waitUntil = () => Promise.all(event.awaiting);
+
+      if (response.status < 300 || response.status >= 400 ) {
+        response.headers.delete('content-encoding');
+        response.headers.delete('transform-encoding');
+        response.headers.delete('content-length');
+      }
+
+      return response;
+    }
+
+    try {
+      await self.__listeners.fetch[0].call(event, event)
+    } catch (error) {
+      return getResponse({ error })
+    }
+
+    return Promise.resolve(event.response)
+      .then(response => getResponse({ response }))
+      .catch(error => getResponse({ error }))
+  })`;
+}
+function addPrimitives(context) {
+  defineProperty(context, "self", { enumerable: true, value: context });
+  defineProperty(context, "globalThis", { value: context });
+  defineProperty(context, "Symbol", { value: Symbol });
+  defineProperty(context, "clearInterval", { value: clearInterval });
+  defineProperty(context, "clearTimeout", { value: clearTimeout });
+  defineProperty(context, "queueMicrotask", { value: queueMicrotask });
+  defineProperty(context, "EdgeRuntime", { value: "edge-runtime" });
+  const transferables = getTransferablePrimitivesFromContext(context);
+  defineProperties(context, {
+    exports: loadPrimitives({
+      ...transferables,
+      WeakRef: runInContext(`WeakRef`, context)
+    }),
+    enumerable: ["crypto"],
+    nonenumerable: [
+      // Crypto
+      "Crypto",
+      "CryptoKey",
+      "SubtleCrypto",
+      // Fetch APIs
+      "fetch",
+      "File",
+      "FormData",
+      "Headers",
+      "Request",
+      "Response",
+      "WebSocket",
+      // Structured Clone
+      "structuredClone",
+      // Blob
+      "Blob",
+      // URL
+      "URL",
+      "URLSearchParams",
+      "URLPattern",
+      // AbortController
+      "AbortController",
+      "AbortSignal",
+      "DOMException",
+      // Streams
+      "ReadableStream",
+      "ReadableStreamBYOBReader",
+      "ReadableStreamDefaultReader",
+      "TextDecoderStream",
+      "TextEncoderStream",
+      "TransformStream",
+      "WritableStream",
+      "WritableStreamDefaultWriter",
+      // Encoding
+      "atob",
+      "btoa",
+      "TextEncoder",
+      "TextDecoder",
+      // Events
+      "Event",
+      "EventTarget",
+      "FetchEvent",
+      "PromiseRejectionEvent",
+      // Console
+      "console",
+      // Timers
+      "setTimeout",
+      "setInterval"
+    ]
+  });
+  return context;
+}
+function defineProperty(obj, prop, attrs) {
+  Object.defineProperty(obj, prop, {
+    configurable: attrs.configurable ?? false,
+    enumerable: attrs.enumerable ?? false,
+    value: attrs.value,
+    writable: attrs.writable ?? true
+  });
+}
+function defineProperties(context, options) {
+  for (const property of options.enumerable ?? []) {
+    if (!options.exports[property]) {
+      throw new Error(`Attempt to export a nullable value for "${property}"`);
+    }
+    defineProperty(context, property, {
+      enumerable: true,
+      value: options.exports[property]
+    });
+  }
+  for (const property of options.nonenumerable ?? []) {
+    if (!options.exports[property]) {
+      throw new Error(`Attempt to export a nullable value for "${property}"`);
+    }
+    defineProperty(context, property, {
+      value: options.exports[property]
+    });
+  }
+}
+function getTransferablePrimitivesFromContext(context) {
+  const keys = transferableConstructors.join(",");
+  const stringifedObject = `({${keys}})`;
+  return runInContext(stringifedObject, context);
+}
+
+// lib/env/runtime.ts
 function runtime(code, isFirewallEvent = false) {
   const extend = (context) => {
     context.RESERVED_FETCH = context.fetch.bind(context);
@@ -34,7 +364,7 @@ function runtime(code, isFirewallEvent = false) {
     context.Promise.withResolvers = promisesContext;
     return context;
   };
-  const edgeRuntime = new EdgeRuntime({
+  const edgeRuntime = new EdgeVM({
     extend,
     initialCode: code,
     codeGeneration: {
@@ -55,7 +385,7 @@ import { readFile, writeFile, access } from "fs/promises";
 import { constants } from "fs";
 
 // lib/constants.ts
-import { join, resolve } from "path";
+import { join, resolve as resolve2 } from "path";
 import { readFileSync } from "fs";
 import { getAbsoluteDirPath } from "azion/utils/node";
 import { tmpdir } from "os";
@@ -93,7 +423,7 @@ var BUNDLER = {
   IS_DEBUG: process.env.DEBUG === "true",
   TEMP_DIR: (projectID) => join(tmpdir(), ".azion", projectID),
   get ROOT_PATH() {
-    return resolve(BUNDLER.LIB_DIR, ".");
+    return resolve2(BUNDLER.LIB_DIR, ".");
   },
   get PACKAGE_JSON() {
     return JSON.parse(readFileSync(`${BUNDLER.ROOT_PATH}/package.json`, "utf8"));
@@ -262,7 +592,7 @@ var cleanDirectory = async (dirs) => {
 };
 
 // lib/commands/build/modules/config/utils.ts
-import { join as join4, basename, dirname, extname, resolve as resolve2 } from "path";
+import { join as join4, basename, dirname, extname, resolve as resolve3 } from "path";
 var generateTimestamp = () => {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10).replace(/-/g, "");
 };
@@ -278,7 +608,7 @@ var createPathEntriesMap = async ({
     const base = basename(entryPath, extname(entryPath));
     const dir = dirname(entryPath);
     const tempFileName = `azion-${base}-${timestamp}.temp.${ext}`;
-    const tempPath = resolve2(dir, tempFileName);
+    const tempPath = resolve3(dir, tempFileName);
     const finalExt = bundler === "webpack" ? ".js" : "";
     const devSuffix = production ? "" : ".dev";
     let finalPath;
@@ -751,14 +1081,15 @@ addEventListener('firewall', (event) => {
     await firewallHandler(request, env, ctx);
   })().catch(console.error);
 });`,
-  fetchHandler: `
-const fetchHandler = handlers.fetch;
-addEventListener('fetch', (event) => {${contextSetup}
-  
+  fetchHandler: (isProduction) => `
+${isProduction ? "export default module;" : `
+    const fetchHandler = handlers.fetch;
+  addEventListener('fetch', (event) => {${contextSetup}
   event.respondWith((async () => {
     return fetchHandler(request, env, ctx);
   })());
-});`,
+});`}
+`,
   fallbackHandler: (entrypointPath) => {
     const baseImport = `
 import module from '${entrypointPath}';
@@ -808,7 +1139,7 @@ var detectHandlers = async (entrypointPath) => {
     };
   }
 };
-var generateWorkerEventHandler = async (entrypointPath) => {
+var generateWorkerEventHandler = async (entrypointPath, isProduction) => {
   const { hasFirewall, hasFetch } = await detectHandlers(entrypointPath);
   if (!hasFirewall && !hasFetch) {
     return `// No fetch or firewall handlers found in: ${entrypointPath}
@@ -819,7 +1150,7 @@ console.warn('No Edge Function handlers found. File will run as-is.');`;
   }
   const parts = [WORKER_TEMPLATES.baseImport(entrypointPath)];
   if (hasFirewall) parts.push(WORKER_TEMPLATES.firewallHandler);
-  if (hasFetch) parts.push(WORKER_TEMPLATES.fetchHandler);
+  if (hasFetch) parts.push(WORKER_TEMPLATES.fetchHandler(isProduction));
   return parts.join("\n");
 };
 var generateLegacyWrapper = (entrypointPath) => {
@@ -900,7 +1231,7 @@ var processWorkerCode = async (originalCode, handlerPath, isProduction) => {
     case "serviceWorker":
       return originalCode;
     case "ESModules":
-      return isProduction ? originalCode : await generateWorkerEventHandler(handlerPath);
+      return await generateWorkerEventHandler(handlerPath, isProduction);
     case "legacy":
       feedback2.build.warn(WORKER_MESSAGES.LEGACY_DEPRECATION);
       return generateLegacyWrapper(handlerPath);
@@ -1145,23 +1476,23 @@ var checkAndChangeAddEventListener = (eventTarget, newEvent, code, replaceCode =
   return { matchEvent: matchEvent || firewallFunction, codeChanged };
 };
 function checkPortAvailability(port) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const client = new net.Socket();
     client.setTimeout(1e3);
     client.on("connect", () => {
       client.destroy();
-      resolve3(true);
+      resolve4(true);
     });
     client.on("timeout", () => {
       client.destroy();
-      resolve3(false);
+      resolve4(false);
     });
     client.on("error", (err) => {
       client.destroy();
       if (err.message.includes("ECONNREFUSED")) {
-        resolve3(false);
+        resolve4(false);
       } else {
-        resolve3(true);
+        resolve4(true);
       }
     });
     client.connect(port, "127.0.0.1");

package/dist/{commands-RSK5SDDH.js → commands-3CZDZLRU.js}

@@ -7,7 +7,7 @@ import {
   readAzionConfig,
   writeStore,
   writeUserConfig
-} from "./chunk-ENG7UVEB.js";
+} from "./chunk-4JJITWIU.js";
 
 // lib/commands/dev/command.ts
 async function devCommand({
@@ -16,7 +16,7 @@ async function devCommand({
   skipFrameworkBuild = false
 }) {
   const parsedPort = parseInt(port, 10);
-  const { server } = await import("./env-2BQLIEBK.js");
+  const { server } = await import("./env-OBIRN3VT.js");
   const entryPoint = entry || null;
   server(entryPoint, parsedPort, skipFrameworkBuild);
 }

package/dist/{env-2BQLIEBK.js → env-OBIRN3VT.js}

@@ -6,7 +6,7 @@ import {
   server_default,
   writeStore,
   writeUserConfig
-} from "./chunk-ENG7UVEB.js";
+} from "./chunk-4JJITWIU.js";
 export {
   env_default as default,
   readAzionConfig,

package/dist/main.js

@@ -3,7 +3,7 @@ import {
   BUNDLER,
   debug,
   executeCleanup
-} from "./chunk-ENG7UVEB.js";
+} from "./chunk-4JJITWIU.js";
 
 // lib/main.ts
 import { Command } from "commander";
@@ -71,7 +71,7 @@ function startBundler() {
   AzionBundler.version(globalThis.bundler.version);
   if (process.argv.length === 2) process.argv.push("build");
   AzionBundler.command("store <command>").description("Manage store configuration").option("-c, --config <json>", `Configuration in JSON format (e.g., '{"key": "value"}')`).option("-s, --scope <scope>", "Scope of the store (default: global)").action(async (command, options) => {
-    const { storeCommand } = await import("./commands-RSK5SDDH.js");
+    const { storeCommand } = await import("./commands-3CZDZLRU.js");
     await storeCommand({
       command,
       options
@@ -84,7 +84,7 @@ function startBundler() {
     "-w, --worker [boolean]",
     "Indicates that the constructed code inserts its own worker expression. Use --worker or --worker=true to enable, --worker=false to disable"
   ).option("-d, --dev", "Build in development mode", false).option("-x, --experimental [boolean]", "Enable experimental features", false).option("--skip-framework-build", "Skip framework build step", false).action(async (options) => {
-    const { buildCommand, manifestCommand } = await import("./commands-RSK5SDDH.js");
+    const { buildCommand, manifestCommand } = await import("./commands-3CZDZLRU.js");
     const { dev, experimental, ...buildOptions } = options;
     if (experimental) globalThis.bundler.experimental = true;
     const { config } = await buildCommand({
@@ -94,13 +94,13 @@ function startBundler() {
     await manifestCommand({ action: "generate", config });
   });
   AzionBundler.command("dev").description("Start local development environment").argument("[entry]", "Specify the entry file (default: .edge/worker.dev.js)").option("-p, --port <port>", "Specify the port", "3333").option("-x, --experimental [boolean]", "Enable experimental features", false).option("--skip-framework-build", "Skip framework build step", false).action(async (entry, options) => {
-    const { devCommand } = await import("./commands-RSK5SDDH.js");
+    const { devCommand } = await import("./commands-3CZDZLRU.js");
     const { experimental } = options;
     if (experimental) globalThis.bundler.experimental = true;
     await devCommand({ entry, ...options });
   });
   AzionBundler.command("presets <command>").description("Manage presets for Azion projects").argument("[preset]", "Preset name (required for config command)").action(async (command, preset) => {
-    const { presetsCommand } = await import("./commands-RSK5SDDH.js");
+    const { presetsCommand } = await import("./commands-3CZDZLRU.js");
     await presetsCommand(command, { preset });
   });
   AzionBundler.command("manifest [action]").description("Manage manifest files for Azion").argument(
@@ -116,14 +116,14 @@ Examples:
   $ ef manifest -e azion.config.js -o .edge
     `
   ).action(async (action, options) => {
-    const { manifestCommand } = await import("./commands-RSK5SDDH.js");
+    const { manifestCommand } = await import("./commands-3CZDZLRU.js");
     await manifestCommand({
       ...options,
       action
     });
   });
   AzionBundler.command("config <command>").description("Manage azion.config settings").option("-k, --key <key...>", "Property key (e.g., build.preset or edgeApplications[0].name)").option("-v, --value <value...>", "Value to be set").option("-a, --all", "Read or delete entire configuration (for read/delete commands)").action(async (command, options) => {
-    const { configCommand } = await import("./commands-RSK5SDDH.js");
+    const { configCommand } = await import("./commands-3CZDZLRU.js");
     await configCommand({
       command,
       options

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edge-functions",
-  "version": "5.2.0",
+  "version": "5.3.0-stage.2",
   "description": "Tool to launch and build JavaScript/Frameworks. This tool automates polyfills for Edge Computing and assists in creating Workers, notably for the Azion platform.",
   "main": "dist/main.js",
   "module": "dist/main.ts",
@@ -25,8 +25,8 @@
     "e2e:start": "yarn submodule:update && tests/scripts/start-e2e-env.sh",
     "e2e:stop": "tests/scripts/stop-e2e-env.sh",
     "e2e:destroy": "tests/scripts/destroy-e2e-env.sh",
-    "test:e2e": "yarn e2e:start && NODE_OPTIONS='--experimental-vm-modules' jest --maxWorkers 1 --config=./jest-e2e.config.js tests/e2e/ --json --outputFile e2e_results.json && yarn e2e:stop; yarn task:reports",
-    "test:nodejs-apis": "yarn e2e:start && NODE_OPTIONS='--experimental-vm-modules' jest --maxWorkers 1 --config=./jest-e2e.config.js tests/nodejs-apis/ --json --outputFile nodejs_apis_results.json && yarn e2e:stop && yarn task:reports-nodejs-apis",
+    "test:e2e": "yarn e2e:start && NODE_OPTIONS='--experimental-vm-modules' jest --detectOpenHandles --runInBand --config=./jest-e2e.config.js tests/e2e/ --json --outputFile e2e_results.json && yarn e2e:stop; yarn task:reports",
+    "test:nodejs-apis": "yarn e2e:start && NODE_OPTIONS='--experimental-vm-modules' jest --runInBand --config=./jest-e2e.config.js tests/nodejs-apis/ --json --outputFile nodejs_apis_results.json && yarn e2e:stop && yarn task:reports-nodejs-apis",
     "prepare": "husky install",
     "submodule:update": "git submodule update --init --recursive && git submodule foreach git pull origin main"
   },
@@ -42,8 +42,9 @@
   ],
   "license": "MIT",
   "dependencies": {
+    "@edge-runtime/primitives": "4.0.5",
     "@netlify/framework-info": "^9.9.1",
-    "azion": "~1.20.0",
+    "azion": "~1.20.1",
     "chokidar": "^3.5.3",
     "commander": "^10.0.1",
     "cosmiconfig": "^9.0.0",
@@ -102,5 +103,6 @@
     "dist",
     "package.json",
     "README.md"
-  ]
+  ],
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }