edge-functions 2.2.0-stage.1 → 2.2.0-stage.2

package/lib/build/bundlers/polyfills/node/crypto.js

@@ -0,0 +1,70 @@
+/* eslint-disable */
+import crypto from 'crypto-browserify';
+
+crypto.webcrypto = globalThis.crypto;
+export default crypto;
+export var { Cipher } = crypto;
+export var { Cipheriv } = crypto;
+export var { Decipher } = crypto;
+export var { Decipheriv } = crypto;
+export var { DiffieHellman } = crypto;
+export var { DiffieHellmanGroup } = crypto;
+export var { Hash } = crypto;
+export var { Hmac } = crypto;
+export var { Sign } = crypto;
+export var { Verify } = crypto;
+export var { constants } = crypto;
+export var { createCipher } = crypto;
+export var { createCipheriv } = crypto;
+export var { createCredentials } = crypto;
+export var { createDecipher } = crypto;
+export var { createDecipheriv } = crypto;
+export var { createDiffieHellman } = crypto;
+export var { createDiffieHellmanGroup } = crypto;
+export var { createECDH } = crypto;
+export var { createHash } = crypto;
+export var { createHmac } = crypto;
+export var { createSign } = crypto;
+export var { createVerify } = crypto;
+export var { getCiphers } = crypto;
+export var { getDiffieHellman } = crypto;
+export var { getHashes } = crypto;
+export var { listCiphers } = crypto;
+export var { pbkdf2 } = crypto;
+export var { pbkdf2Sync } = crypto;
+export var { privateDecrypt } = crypto;
+export var { privateEncrypt } = crypto;
+export var { prng } = crypto;
+export var { pseudoRandomBytes } = crypto;
+export var { publicDecrypt } = crypto;
+export var { publicEncrypt } = crypto;
+export var { randomBytes } = crypto;
+export var { randomFill } = crypto;
+export var { randomFillSync } = crypto;
+export var { rng } = crypto;
+export var { webcrypto } = crypto;
+
+export var getRandomValues = function (abv) {
+  let l = abv.length;
+  while (l--) {
+    const bytes = randomBytes(7);
+    let randomFloat = (bytes[0] % 32) / 32;
+
+    for (let i = 0; i < bytes.length; i++) {
+      const byte = bytes[i];
+      randomFloat = (randomFloat + byte) / 256;
+    }
+
+    abv[l] = Math.floor(randomFloat * 256);
+  }
+  return abv;
+};
+
+export var randomUUID = function () {
+  return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, function (c) {
+    return (
+      c ^
+      (getRandomValues(new Uint8Array(1))[0] & (15 >> (c / 4)))
+    ).toString(16);
+  });
+};

package/lib/build/bundlers/polyfills/node/globals/buffer.js

@@ -0,0 +1,4 @@
+/* eslint-disable */
+import { Buffer } from 'buffer';
+
+globalThis.Buffer = Buffer;

package/lib/build/bundlers/polyfills/node/globals/path-dirname.js

@@ -0,0 +1,6 @@
+/* eslint-disable */
+import path from 'path';
+
+globalThis.__filename = process.cwd();
+
+globalThis.__dirname = path.dirname(__filename);

package/lib/build/{polyfills → bundlers/polyfills}/node/globals/process.js

@@ -13,7 +13,7 @@
  */
 
 // shim for using process in browser
-const process = {};
+// globalThis.process = process;
 
 // cached from whatever global is present so that test runners that stub it
 // don't break things.  But we need to wrap it in a try catch in case it is
@@ -172,7 +172,7 @@ function cleanUpNextTick() {
  *
  */
 
-process.nextTick = function (fun) {
+const nextTick = function (fun) {
   const args = new Array(arguments.length - 1);
   if (arguments.length > 1) {
     for (let i = 1; i < arguments.length; i++) {
@@ -197,42 +197,94 @@ function Item(fun, array) {
 Item.prototype.run = function () {
   this.fun.apply(null, this.array);
 };
-process.title = 'browser';
-process.browser = true;
-process.env = {};
-process.argv = [];
-process.version = ''; // empty string to avoid regexp issues
-process.versions = { node: '18.3.1' }; // fake version
+const title = 'browser';
+const browser = true;
+const env = {};
+const argv = [];
+const version = ''; // empty string to avoid regexp issues
+const versions = { node: '18.3.1' }; // fake version
 
 /**
  *
  */
 function noop() {}
 
-process.on = noop;
-process.addListener = noop;
-process.once = noop;
-process.off = noop;
-process.removeListener = noop;
-process.removeAllListeners = noop;
-process.emit = noop;
-process.prependListener = noop;
-process.prependOnceListener = noop;
-
-process.listeners = function () {
+const on = noop;
+const addListener = noop;
+const once = noop;
+const off = noop;
+const removeListener = noop;
+const removeAllListeners = noop;
+const emit = noop;
+const prependListener = noop;
+const prependOnceListener = noop;
+
+const listeners = function () {
   return [];
 };
 
-process.binding = function () {
-  throw new Error('process.binding is not supported');
+const binding = function () {
+  throw new Error('const binding is not supported');
 };
 
-process.cwd = function () {
+const cwd = function () {
   return '/';
 };
-process.chdir = function () {
+const chdir = function () {
   throw new Error('process.chdir is not supported');
 };
-process.umask = function () {
+const umask = function () {
   return 0;
 };
+
+const process = {
+  nextTick,
+  title,
+  browser,
+  env,
+  argv,
+  version,
+  versions,
+  on,
+  addListener,
+  once,
+  off,
+  removeListener,
+  removeAllListeners,
+  emit,
+  prependListener,
+  prependOnceListener,
+  listeners,
+  binding,
+  cwd,
+  chdir,
+  umask,
+};
+
+export default process;
+
+export {
+  nextTick,
+  title,
+  browser,
+  env,
+  argv,
+  version,
+  versions,
+  on,
+  addListener,
+  once,
+  off,
+  removeListener,
+  removeAllListeners,
+  emit,
+  prependListener,
+  prependOnceListener,
+  listeners,
+  binding,
+  cwd,
+  chdir,
+  umask,
+};
+
+globalThis.process = process;

package/lib/build/bundlers/polyfills/polyfills-manager.js

@@ -0,0 +1,138 @@
+import { createRequire } from 'module';
+import { getAbsoluteLibDirPath } from '#utils';
+
+const require = createRequire(import.meta.url);
+const libDirPath = getAbsoluteLibDirPath();
+const polyfillsPath = `${libDirPath}/build/bundlers/polyfills`;
+const nextNodePresetPath = `${libDirPath}/presets/custom/next/compute/node`;
+const nodePolyfillsPath = `${polyfillsPath}/node`;
+
+/**
+ * Manages and builds polyfills for Node and global browser environments.
+ */
+class PolyfillsManager {
+  /**
+   * Constructs a PolyfillsManager instance.
+   */
+  constructor() {
+    /** @type {Map<string, string>} */
+    this.globals = new Map();
+    /** @type {Map<string, string|boolean>} */
+    this.libs = new Map();
+    /** @type {Map<string, string|boolean>} */
+    this.alias = new Map();
+  }
+
+  /**
+   * Sets a global polyfill.
+   * @param {string} name - Name of the global.
+   * @param {string} path - Path to the polyfill.
+   */
+  setGlobal(name, path) {
+    this.globals.set(name, path);
+  }
+
+  /**
+   * Sets a module/library polyfill.
+   * @param {string} name - Name of the module/library.
+   * @param {string|boolean} path - Path to the polyfill or a boolean value.
+   */
+  setLib(name, path) {
+    this.libs.set(name, path);
+  }
+
+  /**
+   * Sets a module/alias polyfill.
+   * @param {string} name - Name of the module/alias.
+   * @param {string|boolean} path - Path to the polyfill or a boolean value.
+   */
+  setAlias(name, path) {
+    this.alias.set(name, path);
+  }
+
+  /**
+   * Builds and retrieves the polyfills for Node and globals.
+   * @returns {{ libs: Map<string, string|boolean>, globals: Map<string, string>, alias: Map<string, string> }} - Object containing libs and globals.
+   */
+  buildPolyfills() {
+    this.setGlobal('buffer', `${nodePolyfillsPath}/globals/buffer.js`);
+    this.setGlobal('console', require.resolve('console-browserify'));
+    this.setGlobal('navigator', `${nodePolyfillsPath}/globals/navigator.js`);
+    this.setGlobal(
+      'performance',
+      `${nodePolyfillsPath}/globals/performance.js`,
+    );
+    this.setGlobal('process', `${nodePolyfillsPath}/globals/process.js`);
+    this.setGlobal('__dirname', `${nodePolyfillsPath}/globals/path-dirname.js`);
+    this.setGlobal(
+      '__filename',
+      `${nodePolyfillsPath}/globals/path-dirname.js`,
+    );
+
+    this.setLib('accepts', require.resolve('accepts'));
+    this.setLib('async_hooks', `${nodePolyfillsPath}/_empty.js`);
+    this.setLib('buffer', require.resolve('buffer/'));
+    this.setLib('child_process', `${nodePolyfillsPath}/_empty.js`);
+    this.setLib('cluster', `${nodePolyfillsPath}/_empty.js`);
+    this.setLib('console', require.resolve('console-browserify'));
+    this.setLib('crypto', `${nodePolyfillsPath}/crypto.js`);
+    this.setLib('dgram', `${nodePolyfillsPath}/_empty.js`);
+    this.setLib('dns', `${nodePolyfillsPath}/dns.js`);
+    this.setLib('events', require.resolve('events/'));
+    this.setLib('fs', `${nodePolyfillsPath}/fs.js`);
+    this.setLib('http', require.resolve('stream-http'));
+    this.setLib('http2', `${nodePolyfillsPath}/http2.js`);
+    this.setLib('https', require.resolve('stream-http'));
+    this.setLib('inspector', `${nodePolyfillsPath}/_empty.js`);
+    this.setLib('module', `${nodePolyfillsPath}/module.js`);
+    this.setLib('net', `${nodePolyfillsPath}/_empty.js`);
+    this.setLib('os', require.resolve('os-browserify/browser'));
+    this.setLib('path', require.resolve('path-browserify'));
+    this.setLib('perf_hooks', `${nodePolyfillsPath}/_empty.js`);
+    this.setLib('process', `${nodePolyfillsPath}/globals/process.js`);
+    this.setLib('querystring', require.resolve('querystring-es3/'));
+    this.setLib('readline', `${nodePolyfillsPath}/_empty.js`);
+    this.setLib('repl', `${nodePolyfillsPath}/_empty.js`);
+    this.setLib('stream', require.resolve('stream-browserify'));
+    this.setLib(
+      '_stream_passthrough',
+      require.resolve('readable-stream/lib/_stream_passthrough.js'),
+    );
+    this.setLib(
+      '_stream_readable',
+      require.resolve('readable-stream/lib/stream.js'),
+    );
+    this.setLib(
+      '_stream_transform',
+      require.resolve('readable-stream/lib/_stream_transform.js'),
+    );
+    this.setLib(
+      '_stream_writable',
+      require.resolve('readable-stream/lib/_stream_writable.js'),
+    );
+    this.setLib('string_decoder', require.resolve('string_decoder/'));
+    this.setLib('sys', require.resolve('util/util.js'));
+    this.setLib('timers', require.resolve('timers-browserify'));
+    this.setLib('tls', `${nodePolyfillsPath}/_empty.js`);
+    this.setLib('tty', require.resolve('tty-browserify'));
+    this.setLib('url', require.resolve('url/'));
+    this.setLib('util', require.resolve('util/'));
+    this.setLib('vm', require.resolve('vm-browserify'));
+    this.setLib('zlib', require.resolve('browserify-zlib'));
+    this.setLib(
+      'next/dist/compiled/etag',
+      `${nextNodePresetPath}/custom-server/12.3.1/util/etag.js`,
+    );
+    this.setLib(
+      '@fastly/http-compute-js',
+      require.resolve('@fastly/http-compute-js'),
+    );
+
+    this.setAlias('util', require.resolve('util/'));
+    this.setAlias('process', `${nodePolyfillsPath}/globals/process.js`);
+
+    return { libs: this.libs, globals: this.globals, alias: this.alias };
+  }
+}
+
+export default new PolyfillsManager();

package/lib/build/bundlers/{esbuild/plugins/node-polyfills/node-pollyfills-paths.test.js → polyfills/polyfills-manager.test.js}

@@ -1,40 +1,53 @@
 import { expect, it } from '@jest/globals';
-import builtinsPolyfills from './node-polyfills-paths.js';
+import PolyfillsManager from './polyfills-manager.js';
 
-describe('Node polyfill paths', () => {
+describe('Polyfills Manager', () => {
   it('Should return map of polyfills', () => {
     const expectedPolyfills = [
-      'process',
+      'accepts',
+      'async_hooks',
       'buffer',
-      'util',
-      'sys',
+      'child_process',
+      'cluster',
+      'console',
+      'crypto',
+      'dgram',
+      'dns',
       'events',
-      'stream',
-      'path',
-      'querystring',
-      'punycode',
-      'url',
-      'string_decoder',
+      'fs',
       'http',
+      'http2',
       'https',
+      'inspector',
+      'module',
+      'net',
       'os',
-      'assert',
-      'constants',
-      '_stream_duplex',
+      'path',
+      'perf_hooks',
+      'process',
+      'querystring',
+      'readline',
+      'repl',
+      'stream',
       '_stream_passthrough',
       '_stream_readable',
-      '_stream_writable',
       '_stream_transform',
-      'console',
-      'zlib',
+      '_stream_writable',
+      'string_decoder',
+      'sys',
+      'timers',
+      'tls',
       'tty',
-      'domain',
+      'url',
+      'util',
+      'vm',
+      'zlib',
+      'next/dist/compiled/etag',
+      '@fastly/http-compute-js',
     ];
-    const listOfAvailablePolyfills = builtinsPolyfills();
     const arraylistOfAvailablePolyfills = Array.from(
-      listOfAvailablePolyfills.keys(),
+      PolyfillsManager.buildPolyfills().libs.keys(),
     );
-
     expect(arraylistOfAvailablePolyfills).toEqual(expectedPolyfills);
   });
 });

package/lib/build/bundlers/webpack/index.js

@@ -1,23 +1,25 @@
+/* eslint-disable no-param-reassign */
 import { promisify } from 'util';
 import webpack from 'webpack';
-import { merge } from 'webpack-merge';
+import lodash from 'lodash';
 
 import { feedback, debug } from '#utils';
 import { Messages } from '#constants';
 
 import AzionWebpackConfig from './webpack.config.js';
+import NodePolyfillPlugin from './plugins/node-polyfills/index.js';
+import BundlerBase from '../bundler-base.js';
 
-class Webpack {
+class Webpack extends BundlerBase {
+  // eslint-disable-next-line no-useless-constructor
   constructor(builderConfig) {
-    this.builderConfig = builderConfig;
-    this.customConfigPreset = builderConfig.custom;
-    this.customConfigLocal = builderConfig.localCustom;
+    super(builderConfig);
   }
 
-  run = async () => {
+  async run() {
     const runWebpack = promisify(webpack);
 
-    let config = AzionWebpackConfig;
+    let config = lodash.cloneDeep(AzionWebpackConfig);
     config.entry = this.builderConfig.entry;
     config.plugins = [
       new webpack.DefinePlugin({
@@ -26,33 +28,49 @@ class Webpack {
       ...config.plugins,
     ];
 
-    const hasCustomConfig = Object.keys(this.customConfigPreset).length > 0;
-    if (hasCustomConfig) {
-      config = merge(this.customConfigPreset, this.customConfigLocal, config);
+    config = super.mergeConfig(config);
+    config = this.applyConfig(config);
+
+    try {
+      const stats = await runWebpack(config);
+
+      const info = stats.toJson();
+      if (stats.hasErrors()) {
+        info.errors.forEach((msg) => {
+          feedback.build.error(msg);
+        });
+      }
+    } catch (error) {
+      debug.error(error);
+      throw Error(Messages.build.error.vulcan_build_failed);
     }
+  }
 
+  applyConfig(config) {
+    const updatedConfig = { ...config };
     // inject content in worker initial code.
     if (this.builderConfig.contentToInject) {
       const workerInitContent = this.builderConfig.contentToInject;
 
-      const bannerPluginIndex = config.plugins.findIndex(
+      const bannerPluginIndex = updatedConfig.plugins.findIndex(
         (plugin) => plugin instanceof webpack.BannerPlugin,
       );
 
       if (bannerPluginIndex !== -1) {
-        const oldContent = config.plugins[bannerPluginIndex].options.banner;
-        const pluginToRemove = config.plugins[bannerPluginIndex];
-        config.plugins = config.plugins.filter(
+        const oldContent =
+          updatedConfig.plugins[bannerPluginIndex].options.banner;
+        const pluginToRemove = updatedConfig.plugins[bannerPluginIndex];
+        updatedConfig.plugins = updatedConfig.plugins.filter(
           (plugin) => plugin !== pluginToRemove,
         );
-        config.plugins.push(
+        updatedConfig.plugins.push(
           new webpack.BannerPlugin({
             banner: `${oldContent} ${workerInitContent}`,
             raw: true,
           }),
         );
       } else {
-        config.plugins.push(
+        updatedConfig.plugins.push(
           new webpack.BannerPlugin({
             banner: workerInitContent,
             raw: true,
@@ -61,20 +79,18 @@ class Webpack {
       }
     }
 
-    try {
-      const stats = await runWebpack(config);
+    // use polyfill with useNodePolyfills and preset mode compute
+    const useNodePolyfills =
+      (this.builderConfig?.useNodePolyfills ||
+        this.customConfigPreset?.useNodePolyfills ||
+        this.customConfigLocal?.useNodePolyfills) &&
+      this.presetMode === 'compute';
 
-      const info = stats.toJson();
-      if (stats.hasErrors()) {
-        info.errors.forEach((msg) => {
-          feedback.build.error(msg);
-        });
-      }
-    } catch (error) {
-      debug.error(error);
-      throw Error(Messages.build.error.vulcan_build_failed);
+    if (useNodePolyfills) {
+      updatedConfig.plugins.push(new NodePolyfillPlugin());
     }
-  };
+    return updatedConfig;
+  }
 }
 
 export default Webpack;

package/lib/build/bundlers/webpack/index.test.js

@@ -0,0 +1,101 @@
+import fs from 'fs';
+import tmp from 'tmp';
+import Webpack from './index.js';
+import AzionWebpackConfig from './webpack.config.js';
+
+// IN MILESECONDS
+const TIMEOUT = 20000;
+
+describe('Webpack Bundler', () => {
+  let tmpDir;
+  let tmpEntry;
+  let tmpOutput;
+
+  beforeEach(async () => {
+    tmpDir = tmp.dirSync();
+    tmpEntry = tmp.fileSync({
+      postfix: '.js',
+      dir: tmpDir.name,
+      name: 'entry.js',
+    });
+    tmpOutput = tmp.fileSync({
+      postfix: '.js',
+      dir: tmpDir.name,
+      name: 'output.js',
+    });
+  });
+
+  afterEach(async () => {
+    tmpEntry.removeCallback();
+    tmpOutput.removeCallback();
+    tmpDir.removeCallback();
+  });
+
+  it(
+    'should execute the bundle successfully',
+    async () => {
+      const code = `import crypto from 'crypto';console.log(process.env.NODE_ENV);`;
+      await fs.promises.writeFile(tmpEntry.name, code);
+
+      const bundler = new Webpack({
+        buildId: '12345',
+        custom: {},
+        entry: tmpEntry.name,
+        localCustom: {
+          optimization: {
+            minimize: false,
+          },
+          output: {
+            path: tmpDir.name,
+            filename: 'output.js',
+          },
+          infrastructureLogging: {
+            level: 'error',
+          },
+        },
+        useNodePolyfills: true,
+        useOwnWorker: false,
+        preset: {
+          name: 'javascript',
+          mode: 'compute',
+        },
+      });
+      await bundler.run();
+
+      const result = fs.readFileSync(tmpOutput.name, 'utf-8');
+
+      expect(result).toContain('./lib/build/bundlers/polyfills/node/crypto.js');
+    },
+    TIMEOUT,
+  );
+
+  it(
+    'should merge the config, in this case optimization.minimize false',
+    async () => {
+      const bundler = new Webpack({
+        buildId: '123456',
+        custom: {
+          optimization: {
+            minimize: true,
+          },
+        },
+        entry: tmpEntry.name,
+        localCustom: {
+          optimization: {
+            minimize: false,
+          },
+        },
+        useNodePolyfills: false,
+        useOwnWorker: false,
+        preset: {
+          name: 'javascript',
+          mode: 'compute',
+        },
+      });
+      let config = AzionWebpackConfig;
+      config = bundler.mergeConfig(config);
+      expect(config?.optimization?.minimize).toBeFalsy();
+    },
+    TIMEOUT,
+  );
+});