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

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [2.2.0-stage.2](https://github.com/aziontech/vulcan/compare/v2.2.0-stage.1...v2.2.0-stage.2) (2023-12-06)
+
+
+### Features
+
+* esbuild bundler improvements and changes ([5e668c4](https://github.com/aziontech/vulcan/commit/5e668c4c8c725de37102b776708a5641980842f4))
+* improvements bundlers ([d546697](https://github.com/aziontech/vulcan/commit/d546697154b61124b947fff347b494dc474b7c36))
+* initial code for organizing polyfill plugins ([2212272](https://github.com/aziontech/vulcan/commit/22122729bbdf0155357142c7fcbebd612d0509e3))
+
+
+### Bug Fixes
+
+* esbuild plugin initial options ([8c84baa](https://github.com/aziontech/vulcan/commit/8c84baa117ed84a67202284d34abb05857083ec2))
+* prevent reference sharing in config ([98b8caa](https://github.com/aziontech/vulcan/commit/98b8caa526e554401aeec2afed2dd126b29994f0))
+
 ## [2.2.0-stage.1](https://github.com/aziontech/vulcan/compare/v2.1.0...v2.2.0-stage.1) (2023-12-05)
 
 

package/README.md

@@ -108,7 +108,7 @@ Defines which build tool to use. The available options are `esbuild` and `webpac
 **Type:** Boolean
 
 **Description:**  
-Determines if Node.js polyfills should be applied. This is useful for projects that leverage Node.js specific functionalities but are targeting environments without such built-in capabilities.
+Determines whether Node.js polyfills should be applied. This is useful for projects that leverage specific Node.js functionality but target environments without these built-in features. The use of useNodePolyfills is ignored when used in mode `deliver` presets, as Node.js features must be resolved at build time by the framework process itself.
 
 ### UseOwnWorker
 

package/jest.config.e2e.js

@@ -0,0 +1,8 @@
+export default {
+  transform: {
+    '^.+\\.(js|jsx)?$': 'babel-jest',
+  },
+  testPathIgnorePatterns: ['/node_modules/', '/examples/'],
+  testEnvironment: 'node',
+  globalSetup: '<rootDir>/jest.global.setup.js',
+};

package/jest.config.unit.js

@@ -0,0 +1,7 @@
+export default {
+  transform: {
+    '^.+\\.(t|j)s?$': '@swc/jest',
+  },
+  testPathIgnorePatterns: ['/node_modules/', '/examples/'],
+  testEnvironment: 'node',
+};

package/lib/build/bundlers/bundler-base.js

@@ -0,0 +1,102 @@
+import { Messages } from '#constants';
+import { feedback } from '#utils';
+import merge from 'lodash.merge';
+
+/**
+ * Base class for a bundler.
+ * @class
+ */
+class BundlerBase {
+  /**
+   * Represents a configuration object.
+   * @typedef {object} BuilderConfig
+   * @property {string} entry - The entry point for the configuration
+   * @property {string} buildId - The build ID
+   * @property {boolean} useNodePolyfills - Indicates if Node polyfills are being used
+   * @property {boolean} useOwnWorker - Indicates if a custom worker is being used
+   * @property {object} custom - Custom configuration.
+   * @property {*} localCustom - Local custom data
+   * @property {*} preset - The preset configuration
+   * @property {string} contentToInject - Content to inject
+   */
+
+  /**
+   * @param {BuilderConfig} builderConfig - Constructor configuration.
+   */
+  constructor(builderConfig) {
+    /**
+     * Constructor configuration.
+     * @type {BuilderConfig}
+     */
+    this.builderConfig = builderConfig;
+
+    /**
+     * Custom configuration from the preset.
+     * @type {object}
+     */
+    this.customConfigPreset = builderConfig.custom;
+
+    /**
+     * Local custom configuration.
+     * @type {object}
+     */
+    this.customConfigLocal = builderConfig.localCustom;
+
+    /**
+     * Preset mode. e.g deliver | mode
+     * @type {object}
+     */
+    this.presetMode = builderConfig?.preset?.mode;
+  }
+
+  /**
+   * Executes the plugin modification logic.
+   * This method can be overridden by subclasses.
+   * @returns {Promise<void>}
+   * @abstract
+   */
+  // eslint-disable-next-line class-methods-use-this
+  async run() {
+    // Implement plugin modification logic here
+    // This method can be overridden by subclasses
+    // as it does not require the use of `this`
+    // eslint-disable-next-line class-methods-use-this
+    throw new Error('Running BundlerBase run method');
+  }
+
+  /**
+   * Applies the configuration.
+   * @param {object} config - Configuration to be applies.
+   * @returns {object} - The apply configuration.
+   * @abstract
+   */
+  // eslint-disable-next-line class-methods-use-this
+  applyConfig(config) {
+    // The ESLint error is being ignored for this method
+    // as it does not require the use of `this`
+    return config;
+  }
+
+  /**
+   * Merges the configuration with the current configuration.
+   * @param {object} config - Configuration to be merged.
+   * @returns {object} - The merged configuration.
+   */
+  mergeConfig(config = {}) {
+    const isDeliverMode = this.presetMode === 'deliver';
+    // waring mode deliver when useNodePolyfills
+    if (this.builderConfig.useNodePolyfills && isDeliverMode) {
+      feedback.build.warn(
+        Messages.build.warning.use_node_polyfill_mode_deliver,
+      );
+    }
+    const hasCustomConfig = Object.keys(this.customConfigPreset).length > 0;
+    const hasCustomConfigLocal = Object.keys(this.customConfigLocal).length > 0;
+    if (hasCustomConfig || hasCustomConfigLocal) {
+      return merge(config, this.customConfigPreset, this.customConfigLocal);
+    }
+    return config;
+  }
+}
+
+export default BundlerBase;

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

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

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

@@ -1,59 +1,72 @@
 import * as esbuild from 'esbuild';
-import merge from 'deepmerge';
+import lodash from 'lodash';
 
-import { debug } from '#utils';
 import { Messages } from '#constants';
+import { debug } from '#utils';
 
+import BundlerBase from '../bundler-base.js';
 import AzionEsbuildConfig from './esbuild.config.js';
-import { NodeModulesPolyfillPlugin } from './plugins/node-polyfills/index.js';
+import ESBuildNodeModulePlugin from './plugins/node-polyfills/index.js';
 
-class Esbuild {
-  constructor(builderConfig) {
-    this.builderConfig = builderConfig;
-    this.customConfigPreset = builderConfig.custom;
-    this.customConfigLocal = builderConfig.localCustom;
-  }
-
-  run = async () => {
-    let config = AzionEsbuildConfig;
+/**
+ * Class representing an ESBuild bundler, extending BundlerBase.
+ */
+class Esbuild extends BundlerBase {
+  /**
+   * Asynchronous method to run the ESBuild bundler.
+   */
+  async run() {
+    let config = lodash.cloneDeep(AzionEsbuildConfig);
     config.entryPoints = [this.builderConfig.entry];
     config.define = {
       AZION_VERSION_ID: JSON.stringify(this.builderConfig.buildId),
     };
 
-    const hasCustomConfig = Object.keys(this.customConfigPreset).length > 0;
-    if (hasCustomConfig) {
-      config = merge(this.customConfigPreset, this.customConfigLocal, config);
+    if (!config.plugins) config.plugins = [];
+
+    // merge config common
+    config = super.mergeConfig(config);
+    config = this.applyConfig(config);
+
+    try {
+      await esbuild.build(config);
+    } catch (error) {
+      debug.error(error);
+      throw Error(Messages.build.error.vulcan_build_failed);
     }
+  }
 
-    if (
-      this.builderConfig.useNodePolyfills ||
-      this.customConfigPreset.useNodePolyfills ||
-      this.customConfigLocal
-    ) {
-      if (!config.plugins) config.plugins = [];
+  /**
+   * Applies specific configurations to the ESBuild config.
+   * @param {object} config - ESBuild configuration object.
+   * @returns {object} - Updated ESBuild configuration object.
+   */
+  applyConfig(config) {
+    const updatedConfig = { ...config };
+    // use polyfill with useNodePolyfills and preset mode compute
+    const useNodePolyfills =
+      (this.builderConfig?.useNodePolyfills ||
+        this.customConfigPreset?.useNodePolyfills ||
+        this.customConfigLocal?.useNodePolyfills) &&
+      this.presetMode === 'compute';
 
-      config.plugins = [NodeModulesPolyfillPlugin(), ...config.plugins];
+    if (useNodePolyfills) {
+      if (!updatedConfig.plugins) updatedConfig.plugins = [];
+      updatedConfig.plugins.push(ESBuildNodeModulePlugin());
     }
 
     // inject content in worker initial code.
     if (this.builderConfig.contentToInject) {
       const workerInitContent = this.builderConfig.contentToInject;
 
-      if (config.banner?.js) {
-        config.banner.js = `${config.banner.js} ${workerInitContent}`;
+      if (updatedConfig.banner?.js) {
+        updatedConfig.banner.js = `${updatedConfig.banner.js} ${workerInitContent}`;
       } else {
-        config.banner = { js: workerInitContent };
+        updatedConfig.banner = { js: workerInitContent };
       }
     }
-
-    try {
-      await esbuild.build(config);
-    } catch (error) {
-      debug.error(error);
-      throw Error(Messages.build.error.vulcan_build_failed);
-    }
-  };
+    return updatedConfig;
+  }
 }
 
 export default Esbuild;

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

@@ -0,0 +1,90 @@
+import fs from 'fs';
+import tmp from 'tmp';
+import Esbuild from './index.js';
+import AzionEsbuildConfig from './esbuild.config.js';
+
+// IN MILESECONDS
+const TIMEOUT = 20000;
+
+describe('Esbuild 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 Esbuild({
+        buildId: '12345',
+        custom: {},
+        entry: tmpEntry.name,
+        localCustom: {
+          outfile: tmpOutput.name,
+          minify: false,
+        },
+        useNodePolyfills: true,
+        useOwnWorker: false,
+        preset: {
+          name: 'javascript',
+          mode: 'compute',
+        },
+      });
+      await bundler.run();
+
+      const result = fs.readFileSync(tmpOutput.name, 'utf-8');
+
+      expect(result).toContain('vulcan-node-modules-polyfills:crypto');
+    },
+    TIMEOUT,
+  );
+
+  it(
+    'should merge the config, in this case optimization.minimize false',
+    async () => {
+      const bundler = new Esbuild({
+        buildId: '12345',
+        custom: {
+          minify: true,
+        },
+        entry: tmpEntry.name,
+        localCustom: {
+          outfile: tmpOutput.name,
+          minify: false,
+        },
+        useNodePolyfills: false,
+        useOwnWorker: false,
+        preset: {
+          name: 'javascript',
+          mode: 'compute',
+        },
+      });
+      let config = AzionEsbuildConfig;
+      config = bundler.mergeConfig(config);
+      expect(config?.minify).toBeFalsy();
+    },
+    TIMEOUT,
+  );
+});

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

@@ -1,154 +1,115 @@
-/* eslint-disable */
-// Based on https://github.com/remorses/esbuild-plugins/blob/master/node-modules-polyfill/src/index.ts
-
+/* eslint-disable consistent-return */
 import fs from 'fs';
 import path from 'path';
-
-import builtinsPolyfills from './node-polyfills-paths.js';
-
-const NAME = 'node-modules-polyfills';
-const NAMESPACE = NAME;
-
-/**
- * Remove ending slash
- * @param {string} importee - the imported path
- * @returns {string} the new path without ending slash
- */
-function removeEndingSlash(importee) {
-  if (importee && importee.slice(-1) === '/') {
-    return importee.slice(0, -1);
-  }
-
-  return importee;
-}
-
-function escapeStringRegexp(string) {
-  if (typeof string !== 'string') {
-    throw new TypeError('Expected a string');
-  }
-
-  // Escape characters with special meaning either inside or outside character sets.
-  // Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
-  return string.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
-}
+import PolyfillsManager from '../../../polyfills/polyfills-manager.js';
 
 /**
- * Generates a template for commonjs with module require
- * @param {string} importPath - the import path
- * @returns {string} the template
+ * ESBuild Node Module Plugin for polyfilling node modules.
+ * @returns {object} - ESBuild plugin object.
  */
-function commonJsTemplate({ importPath }) {
-  return `
-const polyfill = require('${importPath}')
-
-if (polyfill && polyfill.default) {
-    module.exports = polyfill.default
-    for (let k in polyfill) {
-        module.exports[k] = polyfill[k]
-    }
-} else if (polyfill)  {
-    module.exports = polyfill
-}
-
-
-`;
-}
-
-/**
- * Plugin to use nodejs polyfills
- * @param {object} options - Options to use with the plugin
- * @returns {object} - the plugin
- */
-export function NodeModulesPolyfillPlugin(options = {}) {
-  const { namespace = NAMESPACE, name = NAME } = options;
-  if (namespace.endsWith('commonjs')) {
-    throw new Error(`namespace ${namespace} must not end with commonjs`);
-  }
-  // this namespace is needed to make ES modules expose their default export to require:
-  // require('assert') will give you import('assert').default
-  const commonjsNamespace = `${namespace}-commonjs`;
-  const polyfilledBuiltins = builtinsPolyfills();
-  const polyfilledBuiltinsNames = [...polyfilledBuiltins.keys()];
+const ESBuildNodeModulePlugin = () => {
+  const NAME = 'vulcan-node-modules-polyfills';
+  const NAMESPACE = NAME;
 
   return {
-    name,
-    setup: function setup({ onLoad, onResolve, initialOptions }) {
-      // polyfills contain global keyword, it must be defined
-      if (initialOptions?.define && !initialOptions.define?.global) {
-        initialOptions.define.global = 'globalThis';
-      } else if (!initialOptions?.define) {
-        initialOptions.define = { global: 'globalThis' };
+    /**
+     * Name and setup of the ESBuild plugin.
+     * @param {object} build - ESBuild build object.
+     */
+    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';
+      }
+
+      // define env
+      options.define = {
+        ...options.define,
+        'process.env.NODE_ENV': '"production"',
+        'process.env.NEXT_RUNTIME': JSON.stringify('edge'),
+        'process.env.NEXT_COMPUTE_JS': JSON.stringify(true),
+      };
+
+      // build inject
+      options.inject = options.inject || [];
+      if (polyfillManager.globals) {
+        [...polyfillManager.globals].forEach(([, value]) => {
+          options.inject.push(value);
+        });
       }
 
-      // TODO these polyfill module cannot import anything, is that ok?
       /**
-       *
-       * @param args
+       * Resolve callback for ESBuild.
+       * @param {object} args - Arguments object.
+       * @returns {object|undefined} - Object with path and namespace or undefined.
        */
-      async function loader(args) {
-        try {
-          const argsPath = args.path.replace(/^node:/, '');
-          const isCommonjs = args.namespace.endsWith('commonjs');
-
-          const resolved = polyfilledBuiltins.get(removeEndingSlash(argsPath));
-          const contents = await (
-            await fs.promises.readFile(resolved)
-          ).toString();
-          const resolveDir = path.dirname(resolved);
-
-          if (isCommonjs) {
-            return {
-              loader: 'js',
-              contents: commonJsTemplate({
-                importPath: argsPath,
-              }),
-              resolveDir,
-            };
-          }
-          return {
-            loader: 'js',
-            contents,
-            resolveDir,
-          };
-        } catch (e) {
-          console.error('node-modules-polyfill', e);
-          return {
-            contents: 'export {}',
-            loader: 'js',
-          };
+      build.onResolve({ filter: /.*/ }, async (args) => {
+        const argsPath = args.path.replace(/^node:/, '');
+        if (!polyfillManager.libs.has(argsPath)) {
+          return;
         }
-      }
-      onLoad({ filter: /.*/, namespace }, loader);
-      onLoad({ filter: /.*/, namespace: commonjsNamespace }, loader);
-      const filter = new RegExp(
-        [
-          ...polyfilledBuiltinsNames,
-          ...polyfilledBuiltinsNames.map((n) => `node:${n}`),
-        ]
-          .map(escapeStringRegexp)
-          .join('|'), // TODO builtins could end with slash, keep in mind in regex
-      );
 
-      async function resolver(args) {
-        const argsPath = args.path.replace(/^node:/, '');
-        const ignoreRequire = args.namespace === commonjsNamespace;
+        // alias bypass
+        options.alias = options.alias || {};
+        if (
+          Object.keys(options.alias)?.length > 0 &&
+          options?.alias[argsPath]
+        ) {
+          return;
+        }
 
-        if (!polyfilledBuiltins.has(argsPath)) {
+        // external bypass
+        if (
+          options?.external?.length > 0 &&
+          options?.external?.includes(argsPath)
+        ) {
           return;
         }
 
-        const isCommonjs = !ignoreRequire && args.kind === 'require-call';
+        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 {
-          namespace: isCommonjs ? commonjsNamespace : namespace,
-          path: argsPath,
+          contents,
+          loader: 'text',
         };
-      }
-      onResolve({ filter }, resolver);
-      // onResolve({ filter: /.*/, namespace }, resolver)
+      });
+
+      /**
+       * 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:/, '');
+
+        const resolved = polyfillManager.libs.get(argsPath);
+        const contents = await fs.promises.readFile(resolved, 'utf8');
+        const resolveDir = path.dirname(resolved);
+
+        return {
+          loader: 'js',
+          contents,
+          resolveDir,
+        };
+      });
     },
   };
-}
+};
 
-export default NodeModulesPolyfillPlugin;
-/* eslint-enable */
+export default ESBuildNodeModulePlugin;

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

@@ -0,0 +1,38 @@
+import * as esbuild from 'esbuild';
+import ESBuildNodeModulePlugin from './index.js';
+
+describe('Esbuild Node Plugin', () => {
+  it('should check the env (NODE_ENV) in define options', async () => {
+    const results = await esbuild.build({
+      write: false,
+      stdin: {
+        contents: 'console.log(process.env.NODE_ENV)',
+      },
+      plugins: [ESBuildNodeModulePlugin()],
+    });
+
+    expect(results.outputFiles.at(0)?.text.trim()).toContain(
+      'console.log("production");',
+    );
+  });
+
+  it('should resolve global crypto polyfill', async () => {
+    const results = await esbuild.build({
+      write: false,
+      target: 'es2022',
+      format: 'esm',
+      platform: 'browser',
+      mainFields: ['browser', 'main', 'module'],
+      bundle: true,
+      minify: false,
+      stdin: {
+        contents: 'import crypto from "crypto";',
+      },
+      plugins: [ESBuildNodeModulePlugin()],
+    });
+
+    expect(results.outputFiles.at(0)?.text.trim()).toContain(
+      'vulcan-node-modules-polyfills:crypto',
+    );
+  });
+});