edge-functions 4.5.0 → 4.6.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [4.6.0](https://github.com/aziontech/bundler/compare/v4.5.0...v4.6.0) (2025-02-06)
+
+
+### Features
+
+* adding the unenv package and removing the polyfill manager ([#425](https://github.com/aziontech/bundler/issues/425)) ([529c267](https://github.com/aziontech/bundler/commit/529c267affba776467dd5127980078e8d98dbde6))
+
+## [4.6.0-stage.1](https://github.com/aziontech/bundler/compare/v4.5.0...v4.6.0-stage.1) (2025-02-04)
+
+
+### Features
+
+* adding the unenv package and removing the polyfill manager ([#425](https://github.com/aziontech/bundler/issues/425)) ([529c267](https://github.com/aziontech/bundler/commit/529c267affba776467dd5127980078e8d98dbde6))
+
 ## [4.5.0](https://github.com/aziontech/bundler/compare/v4.4.2...v4.5.0) (2025-01-30)
 
 

package/docs/nodejs-apis.md

@@ -51,7 +51,7 @@ Table:
 | Fs             | ✅      |
 | Async Hooks    | ✅      |
 
-Last test run date: 01/30/25 03:54:42 AM
+Last test run date: 02/06/25 03:55:49 AM
 #### Docs support
 
 See support for the Node.js APIs in the [https://www.azion.com/en/documentation/products/azion-edge-runtime/compatibility/node/](https://www.azion.com/en/documentation/products/azion-edge-runtime/compatibility/node/)

package/lib/build/bundlers/esbuild/esbuild.bundlers.test.js

@@ -53,7 +53,9 @@ describe('Esbuild Bundler', () => {
 
       const result = fs.readFileSync(tmpOutput.name, 'utf-8');
 
-      expect(result).toContain('vulcan-node-modules-polyfills:crypto');
+      expect(result).toContain(
+        'node-built-in-modules:unenv/runtime/node/crypto/index',
+      );
     },
     TIMEOUT,
   );

package/lib/build/bundlers/esbuild/esbuild.config.js

@@ -45,7 +45,7 @@ export default {
   target: 'es2022',
   format: 'esm',
   platform: 'browser',
-  mainFields: ['browser', 'main', 'module'],
+  mainFields: ['browser', 'module', 'main'],
   loader: {
     '.js': 'jsx',
   },

package/lib/build/bundlers/esbuild/plugins/azion-polyfills/azion-polyfills.plugins.js

@@ -1,7 +1,7 @@
 /* eslint-disable consistent-return */
 import fs from 'fs';
 import path from 'path';
-import PolyfillsManager from '../../../polyfills/index.js';
+import azionLibs from '../../../helpers/azion-libs.js';
 
 /**
  * ESBuild Azion Module Plugin for polyfilling node modules.
@@ -9,7 +9,7 @@ import PolyfillsManager from '../../../polyfills/index.js';
  * @returns {object} - ESBuild plugin object.
  */
 const ESBuildAzionModulePlugin = (buildProd) => {
-  const NAME = 'vulcan-azion-modules-polyfills';
+  const NAME = 'bundler-azion-modules-polyfills';
   const NAMESPACE = NAME;
   const filter = /^azion:/;
   const prefix = 'azion:';
@@ -21,14 +21,12 @@ const ESBuildAzionModulePlugin = (buildProd) => {
      */
     name: NAME,
     setup: (build) => {
-      const polyfillManager = PolyfillsManager.buildPolyfills();
-
       const options = build.initialOptions;
 
       // external
       if (buildProd) {
         options.external = options.external || [];
-        [...polyfillManager.external].forEach(([key]) => {
+        [...azionLibs.external].forEach(([key]) => {
           if (/^[^:]+:/.test(key) && !options.external.includes(key)) {
             options.external.push(key);
           }
@@ -38,8 +36,8 @@ const ESBuildAzionModulePlugin = (buildProd) => {
       if (!buildProd) {
         // build inject prefix (azion:) is not present and the polyfill is Azion
         options.inject = options.inject || [];
-        if (polyfillManager.external) {
-          [...polyfillManager.external].forEach(([key, value]) => {
+        if (azionLibs.external) {
+          [...azionLibs.external].forEach(([key, value]) => {
             const hasPrefix = /^[^:]+:/.test(key);
             if (
               !hasPrefix &&
@@ -57,13 +55,13 @@ const ESBuildAzionModulePlugin = (buildProd) => {
        * @returns {object|undefined} - Object with path and namespace or undefined.
        */
       build.onResolve({ filter }, async (args) => {
-        if (!buildProd && polyfillManager.external.has(args.path)) {
+        if (!buildProd && azionLibs.external.has(args.path)) {
           return {
             path: args.path,
             namespace: NAMESPACE,
           };
         }
-        if (!polyfillManager.external.has(args.path)) {
+        if (!azionLibs.external.has(args.path)) {
           return;
         }
 
@@ -87,10 +85,10 @@ const ESBuildAzionModulePlugin = (buildProd) => {
        * @returns {object} - Object with loader, contents, and resolve directory.
        */
       build.onLoad({ filter, namespace: NAMESPACE }, async (args) => {
-        if (!polyfillManager.external.has(args.path)) {
+        if (!azionLibs.external.has(args.path)) {
           return;
         }
-        const resolved = polyfillManager.external.get(args.path);
+        const resolved = azionLibs.external.get(args.path);
         const contents = await fs.promises.readFile(resolved, 'utf8');
         const resolveDir = path.dirname(resolved);
 

package/lib/build/bundlers/esbuild/plugins/azion-polyfills/azion-polyfills.plugins.test.js

@@ -40,7 +40,7 @@ describe('Esbuild Azion Plugin', () => {
     });
 
     expect(results.outputFiles.at(0)?.text.trim()).toContain(
-      'vulcan-azion-modules-polyfills',
+      'bundler-azion-modules-polyfills',
     );
   });
 });

package/lib/build/bundlers/esbuild/plugins/node-polyfills/node-polyfills.plugins.js

@@ -1,16 +1,297 @@
 /* eslint-disable consistent-return */
+import { createRequire } from 'module';
 import fs from 'fs';
 import path from 'path';
-import PolyfillsManager from '../../../polyfills/index.js';
+import { env, nodeless } from 'unenv';
+import { builtinModules } from 'node:module';
+import { getAbsoluteLibDirPath } from '#utils';
+import unenvPresetAzion from 'azion/unenv-preset';
+
+const require = createRequire(import.meta.url);
+
+const { alias, inject, polyfill, external } = env(nodeless, unenvPresetAzion);
+
+const INTERNAL_POLYFILL_DEV = 'internal-env-dev';
+const INTERNAL_POLYFILL_PROD = 'internal-env-prod';
+const INTERNAL_POLYFILL_PATH = `${getAbsoluteLibDirPath()}/env/polyfills`;
+const INTERNAL_POLYFILL_PATH_PROD = `azion/unenv-preset/src/polyfills/node`;
+const POLYFILL_PREFIX_DEV = 'aziondev:';
+const POLYFILL_PREFIX_PROD = 'azionprd:';
+
+/**
+ * Get global inject
+ * @param {*} globalInject Global inject
+ * @returns {*} Return import statement and export name
+ */
+function getGlobalInject(globalInject) {
+  if (typeof globalInject === 'string') {
+    return {
+      importStatement: `import globalVar from "${globalInject}";`,
+      exportName: 'globalVar',
+    };
+  }
+  const [moduleSpecifier, exportName] = globalInject;
+  return {
+    importStatement: `import { ${exportName} } from "${moduleSpecifier}";`,
+    exportName,
+  };
+}
+
+/**
+ * Handle alias unenv
+ * @param {*} build Build object
+ */
+function handleAliasUnenv(build) {
+  const UNENV_ALIAS_NAMESPACE = 'imported-unenv-alias';
+
+  const aliasAbsolute = {};
+  Object.entries(alias).forEach(([module, unresolvedAlias]) => {
+    try {
+      aliasAbsolute[module] = require
+        .resolve(unresolvedAlias)
+        .replace(/\.cjs$/, '.mjs');
+    } catch (e) {
+      console.log(e?.message);
+      // this is an alias for package that is not installed in the current app => ignore
+    }
+  });
+
+  const UNENV_ALIAS_RE = new RegExp(
+    `^(${Object.keys(aliasAbsolute).join('|')})$`,
+  );
+
+  build.onResolve({ filter: UNENV_ALIAS_RE }, (args) => {
+    return {
+      path: args.path,
+      namespace: UNENV_ALIAS_NAMESPACE,
+    };
+  });
+
+  build.onLoad(
+    { filter: /.*/, namespace: UNENV_ALIAS_NAMESPACE },
+    async (args) => {
+      const filePath = aliasAbsolute[args.path];
+      const contents = await fs.promises.readFile(filePath, 'utf8');
+      const resolveDir = path.dirname(filePath);
+
+      return {
+        loader: 'js',
+        contents,
+        resolveDir,
+      };
+    },
+  );
+}
+
+/**
+ * Node built in modules
+ * @param {*} build Build object
+ * @param {*} isProd Is production build
+ */
+function nodeBuiltInModules(build, isProd) {
+  const IMPORTED_NODE_BUILT_IN_NAMESPACE = 'node-built-in-modules';
+
+  const NODEJS_MODULES_RE = new RegExp(
+    `^(node:)?(${builtinModules.join('|')})$`,
+  );
+
+  build.onResolve({ filter: NODEJS_MODULES_RE }, (args) => {
+    const nameModuleWithoutNode = args.path.replace('node:', '');
+    const pathAlias =
+      alias[nameModuleWithoutNode] ?? alias[args.path] ?? args.path;
+
+    const findModulePolyfill = (prefix, nameModule) => {
+      return polyfill.find((p) => p.startsWith(`${prefix}${nameModule}`));
+    };
+
+    const resolvePolyfill = (prefix, namespace, nameModule) => {
+      const externalModule = external.find((ext) => {
+        return (
+          ext === nameModule ||
+          ext === args.path ||
+          `node:${nameModule}` === ext
+        );
+      });
+      const polyfillResult = findModulePolyfill(prefix, nameModule);
+      // if polyfill is not found, check if the module is external
+      if (!polyfillResult && externalModule) {
+        return {
+          path: args.path,
+          external: externalModule.includes(args.path),
+        };
+      }
+      if (polyfillResult) {
+        return { path: nameModule, namespace };
+      }
+    };
+
+    const result = isProd
+      ? resolvePolyfill(
+          POLYFILL_PREFIX_PROD,
+          INTERNAL_POLYFILL_PROD,
+          nameModuleWithoutNode,
+        )
+      : resolvePolyfill(
+          POLYFILL_PREFIX_DEV,
+          INTERNAL_POLYFILL_DEV,
+          nameModuleWithoutNode,
+        );
+
+    return (
+      result ?? {
+        path: pathAlias,
+        namespace: IMPORTED_NODE_BUILT_IN_NAMESPACE,
+        external: external.includes(args.path),
+      }
+    );
+  });
+
+  build.onLoad(
+    { filter: /.*/, namespace: IMPORTED_NODE_BUILT_IN_NAMESPACE },
+    async (args) => {
+      const resolved = require.resolve(args.path);
+      const contents = await fs.promises.readFile(resolved, 'utf8');
+      const resolveDir = path.dirname(resolved);
+
+      return {
+        loader: 'js',
+        contents,
+        resolveDir,
+      };
+    },
+  );
+}
+
+/**
+ * Handle node js globals
+ * @param {*} build Build object
+ */
+function handleNodeJSGlobals(build) {
+  const UNENV_GLOBALS_RE = /_global_polyfill-([^.]+)\.js$/;
+  const prefix = path.resolve(
+    getAbsoluteLibDirPath(),
+    '../',
+    '_global_polyfill-',
+  );
+
+  // eslint-disable-next-line no-param-reassign
+  build.initialOptions.inject = [
+    ...(build.initialOptions.inject ?? []),
+    ...Object.keys(inject).map((globalName) => `${prefix}${globalName}.js`),
+  ];
+
+  build.onResolve({ filter: UNENV_GLOBALS_RE }, (args) => ({
+    path: args.path,
+  }));
+
+  build.onLoad({ filter: UNENV_GLOBALS_RE }, (args) => {
+    const globalName = args.path.match(UNENV_GLOBALS_RE)[1];
+    const { importStatement, exportName } = getGlobalInject(inject[globalName]);
+
+    return {
+      contents: `
+				${importStatement}
+				globalThis.${globalName} = ${exportName};
+			`,
+    };
+  });
+}
+
+/**
+ * Handle internal polyfill env dev
+ * @param {*} build Build object
+ */
+function handleInternalPolyfillEnvDev(build) {
+  build.onLoad(
+    { filter: /.*/, namespace: INTERNAL_POLYFILL_DEV },
+    async (args) => {
+      try {
+        const argsPathWhitoutNode = args.path.replace('node:', '');
+        const polyfillPath = polyfill.find((p) =>
+          p.startsWith(`${POLYFILL_PREFIX_DEV}${argsPathWhitoutNode}`),
+        );
+        const internalPolyfillsPath = path.join(
+          INTERNAL_POLYFILL_PATH,
+          polyfillPath.replace(
+            `${POLYFILL_PREFIX_DEV}${argsPathWhitoutNode}:/`,
+            '',
+          ),
+        );
+        const contents = await fs.promises.readFile(
+          internalPolyfillsPath,
+          'utf8',
+        );
+        const resolveDir = path.dirname(internalPolyfillsPath);
+        return {
+          loader: 'js',
+          contents,
+          resolveDir,
+        };
+      } catch (error) {
+        console.error(`Error loading polyfill for ${args.path}`, error);
+      }
+    },
+  );
+}
+
+/**
+ * Handle internal polyfill env prod
+ * @param {*} build Build object
+ */
+function handleInternalPolyfillEnvProd(build) {
+  build.onLoad(
+    { filter: /.*/, namespace: INTERNAL_POLYFILL_PROD },
+    async (args) => {
+      try {
+        const polyfillPath = polyfill.find((p) =>
+          p.startsWith(`${POLYFILL_PREFIX_PROD}${args.path}`),
+        );
+        const internalPolyfillsPath = path.join(
+          INTERNAL_POLYFILL_PATH_PROD,
+          polyfillPath.replace(`${POLYFILL_PREFIX_PROD}${args.path}:/`, ''),
+        );
+        const resolved = require.resolve(internalPolyfillsPath);
+        const contents = await fs.promises.readFile(resolved, 'utf8');
+        const resolveDir = path.dirname(resolved);
+        return {
+          loader: 'js',
+          contents,
+          resolveDir,
+        };
+      } catch (error) {
+        console.error(`Error loading polyfill prod for ${args.path}`, error);
+      }
+    },
+  );
+}
+
+/**
+ * Define next js runtime
+ * @param {*} options Options object
+ */
+function defineNextJsRuntime(options) {
+  if (fs.existsSync(path.join(process.cwd(), '.next'))) {
+    const buildId = fs.readFileSync(
+      path.join(process.cwd(), '.next/BUILD_ID'),
+      'utf-8',
+    );
+    // eslint-disable-next-line no-param-reassign
+    options.define = {
+      ...options.define,
+      'process.env.NEXT_RUNTIME': '"edge"',
+      'process.env.NEXT_COMPUTE_JS': 'true',
+      'process.env.__NEXT_BUILD_ID': `"${buildId}"`,
+    };
+  }
+}
 
 /**
- * @param {boolean} buildProd Parameter to identify whether the build is dev or prod
  * ESBuild Node Module Plugin for polyfilling node modules.
+ * @param {boolean} buildProd Parameter to identify whether the build is dev or prod
  * @returns {object} - ESBuild plugin object.
  */
 const ESBuildNodeModulePlugin = (buildProd) => {
-  const NAME = 'vulcan-node-modules-polyfills';
-  const NAMESPACE = NAME;
+  const NAME = 'bundler-node-modules-polyfills';
 
   return {
     /**
@@ -19,11 +300,10 @@ const ESBuildNodeModulePlugin = (buildProd) => {
      */
     name: NAME,
     setup: (build) => {
-      const polyfillManager = PolyfillsManager.buildPolyfills();
-
       // build options
       const options = build.initialOptions;
       options.define = options.define || {};
+
       if (!options.define?.global) {
         options.define.global = 'globalThis';
       }
@@ -34,124 +314,22 @@ const ESBuildNodeModulePlugin = (buildProd) => {
         'process.env.NODE_ENV': '"production"',
       };
 
-      if (fs.existsSync(path.join(process.cwd(), '.next'))) {
-        const buildId = fs.readFileSync(
-          path.join(process.cwd(), '.next/BUILD_ID'),
-          'utf-8',
-        );
-        options.define = {
-          ...options.define,
-          'process.env.NEXT_RUNTIME': '"edge"',
-          'process.env.NEXT_COMPUTE_JS': 'true',
-          'process.env.__NEXT_BUILD_ID': `"${buildId}"`,
-        };
-      }
+      // define nextjs runtime
+      defineNextJsRuntime(options);
 
       // build inject
       options.inject = options.inject || [];
-      if (polyfillManager.globals) {
-        [...polyfillManager.globals].forEach(([, value]) => {
-          options.inject.push(value);
-        });
-      }
-
-      // external
-      if (buildProd) {
-        options.external = options.external || [];
-        [...polyfillManager.external].forEach(([key]) => {
-          if (!/^[^:]+:/.test(key)) {
-            options.external.push(key);
-            options.external.push(`node:${key}`);
-          }
-        });
-      }
-
-      /**
-       * Resolve callback for ESBuild.
-       * @param {object} args - Arguments object.
-       * @returns {object|undefined} - Object with path and namespace or undefined.
-       */
-      build.onResolve({ filter: /.*/ }, async (args) => {
-        const argsPath = args.path.replace(/^node:/, '');
-
-        if (
-          !buildProd &&
-          polyfillManager.external.has(argsPath) &&
-          !/^[^:]+:/.test(argsPath)
-        ) {
-          return {
-            path: args.path,
-            namespace: NAMESPACE,
-          };
-        }
-
-        if (!polyfillManager.libs.has(argsPath)) {
-          return;
-        }
-
-        // alias bypass
-        options.alias = options.alias || {};
-        if (
-          Object.keys(options.alias)?.length > 0 &&
-          options?.alias[argsPath]
-        ) {
-          return;
-        }
-
-        // external bypass
-        if (
-          options?.external?.length > 0 &&
-          options?.external?.includes(argsPath)
-        ) {
-          return;
-        }
-
-        return {
-          path: args.path,
-          namespace: NAMESPACE,
-        };
-      });
 
-      /**
-       * Load callback for assets.
-       * @param {object} args - Arguments object.
-       * @returns {object} - Object with contents and loader type.
-       */
-      build.onLoad({ filter: /\.(txt|html)/ }, async (args) => {
-        const contents = await fs.promises.readFile(args.path, 'utf8');
-        return {
-          contents,
-          loader: 'text',
-        };
-      });
-
-      /**
-       * Load callback for node module files.
-       * @param {object} args - Arguments object.
-       * @returns {object} - Object with loader, contents, and resolve directory.
-       */
-      build.onLoad({ filter: /.*/, namespace: NAMESPACE }, async (args) => {
-        const argsPath = args.path.replace(/^node:/, '');
-
-        let resolved = polyfillManager.libs.get(argsPath);
-
-        if (
-          !buildProd &&
-          polyfillManager.external.has(argsPath) &&
-          !/^[^:]+:/.test(argsPath)
-        ) {
-          resolved = polyfillManager.external.get(argsPath);
-        }
-
-        const contents = await fs.promises.readFile(resolved, 'utf8');
-        const resolveDir = path.dirname(resolved);
+      options.alias = {
+        ...options.alias,
+      };
 
-        return {
-          loader: 'js',
-          contents,
-          resolveDir,
-        };
-      });
+      // resolve modules
+      nodeBuiltInModules(build, buildProd);
+      handleAliasUnenv(build, alias, external);
+      handleNodeJSGlobals(build, inject);
+      handleInternalPolyfillEnvDev(build);
+      handleInternalPolyfillEnvProd(build);
     },
   };
 };

package/lib/build/bundlers/esbuild/plugins/node-polyfills/node-polyfills.plugins.test.js

@@ -34,7 +34,7 @@ describe('Esbuild Node Plugin', () => {
     });
 
     expect(results.outputFiles.at(0)?.text.trim()).toContain(
-      'vulcan-node-modules-polyfills:crypto',
+      'node-built-in-modules:unenv/runtime/node/crypto/index',
     );
   });
 });

package/lib/build/bundlers/helpers/azion-libs.js

@@ -0,0 +1,25 @@
+import { getAbsoluteLibDirPath } from '#utils';
+
+const libDirPath = getAbsoluteLibDirPath();
+
+const externalPolyfillsPath = `${libDirPath}/env/polyfills`;
+
+export default {
+  libs: new Map(),
+  globals: new Map(),
+  alias: new Map(),
+  external: new Map([
+    [
+      'azion:storage',
+      `${externalPolyfillsPath}/azion/storage/storage.polyfills.js`,
+    ],
+    [
+      'Azion.env',
+      `${externalPolyfillsPath}/azion/env-vars/env-vars.polyfills.js`,
+    ],
+    [
+      'Azion.networkList',
+      `${externalPolyfillsPath}/azion/network-list/network-list.polyfills.js`,
+    ],
+  ]),
+};

package/lib/build/bundlers/webpack/plugins/azion-polyfills/azion-polyfills.plugins.js

@@ -1,6 +1,6 @@
 /* eslint-disable no-param-reassign,class-methods-use-this */
 import { generateWebpackBanner } from '#utils';
-import PolyfillsManager from '../../../polyfills/index.js';
+import azionLibs from '../../../helpers/azion-libs.js';
 
 class AzionPolyfillPlugin {
   constructor(buildProd) {
@@ -9,8 +9,6 @@ class AzionPolyfillPlugin {
   }
 
   apply(compiler) {
-    const polyfillsManager = PolyfillsManager.buildPolyfills();
-
     if (!compiler.options.plugins?.length) {
       compiler.options.plugins = [];
     }
@@ -30,7 +28,7 @@ class AzionPolyfillPlugin {
     );
 
     const filteredExternal = new Map(
-      [...polyfillsManager.external].filter(([key]) => {
+      [...azionLibs.external].filter(([key]) => {
         const hasPrefix = new RegExp(`^${this.prefix}`).test(key);
         return hasPrefix;
       }),
@@ -38,7 +36,7 @@ class AzionPolyfillPlugin {
 
     // build inject prefix (azion:) is not present and the polyfill is Azion
     if (!this.buildProd) {
-      [...polyfillsManager.external].forEach(([key]) => {
+      [...azionLibs.external].forEach(([key]) => {
         const hasPrefix = /^[^:]+:/.test(key);
         if (
           !hasPrefix &&
@@ -46,9 +44,7 @@ class AzionPolyfillPlugin {
         ) {
           compiler.options.plugins.push(
             new compiler.webpack.BannerPlugin({
-              banner: generateWebpackBanner([
-                polyfillsManager.external.get(key),
-              ]),
+              banner: generateWebpackBanner([azionLibs.external.get(key)]),
               raw: true,
             }),
           );