edge-functions 1.0.0 → 1.3.0

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

@@ -0,0 +1,147 @@
+// Based on https://github.com/remorses/esbuild-plugins/blob/master/node-modules-polyfill/src/index.ts
+
+import escapeStringRegexp from 'escape-string-regexp';
+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;
+}
+
+/**
+ * Generates a template for commonjs with module require
+ * @param {string} importPath - the import path
+ * @returns {string} the template
+ */
+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()];
+
+  return {
+    name,
+    setup: function setup({ onLoad, onResolve, initialOptions }) {
+      // polyfills contain global keyword, it must be defined
+      if (initialOptions?.define && !initialOptions.define?.global) {
+        // eslint-disable-next-line
+        initialOptions.define.global = 'globalThis';
+      } else if (!initialOptions?.define) {
+        // eslint-disable-next-line
+        initialOptions.define = { global: 'globalThis' };
+      }
+
+      // TODO these polyfill module cannot import anything, is that ok?
+      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',
+          };
+        }
+      }
+      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;
+
+        if (!polyfilledBuiltins.has(argsPath)) {
+          return;
+        }
+
+        const isCommonjs = !ignoreRequire && args.kind === 'require-call';
+
+        // eslint-disable-next-line
+        return {
+          namespace: isCommonjs ? commonjsNamespace : namespace,
+          path: argsPath,
+        };
+      }
+      onResolve({ filter }, resolver);
+      // onResolve({ filter: /.*/, namespace }, resolver)
+    },
+  };
+}
+
+export default NodeModulesPolyfillPlugin;

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

@@ -0,0 +1,124 @@
+// Taken from https://github.com/ionic-team/rollup-plugin-node-polyfills/blob/master/src/modules.ts
+
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+
+/**
+ * Generates a Map composed by the module name and location
+ * @returns {Map} - the map with module locations
+ */
+function builtinsPolyfills() {
+  const libs = new Map();
+
+  libs.set(
+    'process',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/process-es6'),
+  );
+  libs.set(
+    'buffer',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/buffer-es6'),
+  );
+  libs.set(
+    'util',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/util'),
+  );
+  libs.set('sys', libs.get('util'));
+  libs.set(
+    'events',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/events'),
+  );
+  libs.set(
+    'stream',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/stream'),
+  );
+  libs.set(
+    'path',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/path'),
+  );
+  libs.set(
+    'querystring',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/qs'),
+  );
+  libs.set(
+    'punycode',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/punycode'),
+  );
+  libs.set(
+    'url',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/url'),
+  );
+  libs.set(
+    'string_decoder',
+    require.resolve(
+      'rollup-plugin-node-polyfills/polyfills/string-decoder',
+    ),
+  );
+  libs.set(
+    'http',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/http'),
+  );
+  libs.set(
+    'https',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/http'),
+  );
+  libs.set('os', require.resolve('rollup-plugin-node-polyfills/polyfills/os'));
+  libs.set(
+    'assert',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/assert'),
+  );
+  libs.set(
+    'constants',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/constants'),
+  );
+  libs.set(
+    '_stream_duplex',
+    require.resolve(
+      'rollup-plugin-node-polyfills/polyfills/readable-stream/duplex',
+    ),
+  );
+  libs.set(
+    '_stream_passthrough',
+    require.resolve(
+      'rollup-plugin-node-polyfills/polyfills/readable-stream/passthrough',
+    ),
+  );
+  libs.set(
+    '_stream_readable',
+    require.resolve(
+      'rollup-plugin-node-polyfills/polyfills/readable-stream/readable',
+    ),
+  );
+  libs.set(
+    '_stream_writable',
+    require.resolve(
+      'rollup-plugin-node-polyfills/polyfills/readable-stream/writable',
+    ),
+  );
+  libs.set(
+    '_stream_transform',
+    require.resolve(
+      'rollup-plugin-node-polyfills/polyfills/readable-stream/transform',
+    ),
+  );
+  libs.set(
+    'console',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/console'),
+  );
+  libs.set(
+    'zlib',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/zlib'),
+  );
+  libs.set(
+    'tty',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/tty'),
+  );
+  libs.set(
+    'domain',
+    require.resolve('rollup-plugin-node-polyfills/polyfills/domain'),
+  );
+
+  return libs;
+}
+
+export default builtinsPolyfills;

package/lib/build/bundlers/index.js

@@ -1,4 +1,4 @@
 import Webpack from './webpack/index.js';
+import Esbuild from './esbuild/index.js';
 
-// eslint-disable-next-line import/prefer-default-export
-export { Webpack };
+export { Esbuild, Webpack };

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

@@ -1,26 +1,35 @@
-import webpack from 'webpack';
 import { promisify } from 'util';
+import webpack from 'webpack';
+import { merge } from 'webpack-merge';
+
 import { feedback, debug } from '#utils';
 import { Messages } from '#constants';
 
 import AzionWebpackConfig from './webpack.config.js';
 
 class Webpack {
-  constructor(customConfig, useNodePolyfills) {
-    this.customConfig = customConfig;
-    this.useNodePolyfills = useNodePolyfills;
+  constructor(builderConfig) {
+    this.builderConfig = builderConfig;
+    this.customConfig = builderConfig.custom;
   }
 
   run = async () => {
     const runWebpack = promisify(webpack);
 
-    const config = AzionWebpackConfig;
-    config.entry = this.customConfig.entry;
+    let config = AzionWebpackConfig;
+    config.entry = this.builderConfig.entry;
     config.plugins = [
-      new webpack.ProgressPlugin(),
+      new webpack.DefinePlugin({
+        AZION_VERSION_ID: JSON.stringify(this.builderConfig.buildId),
+      }),
       ...config.plugins,
     ];
 
+    const hasCustomConfig = Object.keys(this.customConfig).length > 0;
+    if (hasCustomConfig) {
+      config = merge(this.customConfig, config);
+    }
+
     try {
       const stats = await runWebpack(config);
 

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

@@ -1,24 +1,10 @@
 import webpack from 'webpack';
 import { join } from 'path';
-import { writeFile, mkdir } from 'fs/promises';
-import { generateTimestamp } from '#utils';
+import { fileURLToPath } from 'url';
 
 const projectRoot = process.cwd();
-const outputPath = join(projectRoot, '.edge');
-
-/**
- * Generates a build ID and saves it in the .env file (for deploy).
- * @returns {Promise<string>} The generated build ID.
- */
-async function generateBuildId() {
-  const envFilePath = join(outputPath, '.env');
-  const BUILD_VERSION___AKA__VERSION_ID = generateTimestamp();
-  const envContent = `VERSION_ID=${BUILD_VERSION___AKA__VERSION_ID}`;
-
-  await mkdir(outputPath, { recursive: true });
-  await writeFile(envFilePath, envContent);
-  return BUILD_VERSION___AKA__VERSION_ID;
-}
+const isWindows = process.platform === 'win32';
+const outputPath = isWindows ? fileURLToPath(new URL(`file:///${join(projectRoot, '.edge')}`)) : join(projectRoot, '.edge');
 
 export default {
   output: {
@@ -27,12 +13,6 @@ export default {
     globalObject: 'this',
   },
   mode: 'production',
-  target: 'webworker',
-  plugins: [
-    new webpack.DefinePlugin({
-      AZION: {
-        VERSION_ID: JSON.stringify(await generateBuildId()),
-      },
-    }),
-  ],
+  target: ['webworker', 'es2022'],
+  plugins: [new webpack.ProgressPlugin()],
 };

package/lib/build/dispatcher/dispatcher.js

@@ -1,34 +1,28 @@
 import { join, resolve } from 'path';
-import { readFileSync, readdirSync, existsSync } from 'fs';
-import { writeFile, rm } from 'fs/promises';
-import { Webpack } from '#bundlers';
-import { feedback, generateTimestamp, getAbsoluteLibDirPath } from '#utils';
+import {
+  readFileSync, existsSync, mkdirSync, writeFileSync, rmSync,
+} from 'fs';
+import { fileURLToPath } from 'url';
+import { Esbuild, Webpack } from '#bundlers';
+import {
+  feedback, debug, generateTimestamp, getAbsoluteLibDirPath, presets,
+} from '#utils';
 import { Messages } from '#constants';
 
 const vulcanLibPath = getAbsoluteLibDirPath();
 const vulcanRootPath = resolve(vulcanLibPath, '..');
+const isWindows = process.platform === 'win32';
 
 /**
- * Get the valid build presets based on the folders inside the presets/default
- * and presets/custom directories.
- * @returns {string[]} An array of valid build presets.
+ * Get the path corresponding to a specific alias defined in the package.json.
+ * @param {string} alias - The desired alias.
+ * @returns {string} The path corresponding to the alias.
+ */
+/**
+ * Get the path corresponding to a specific alias defined in the package.json.
+ * @param {string} alias - The desired alias.
+ * @returns {string} The path corresponding to the alias.
  */
-function getValidPresets() {
-  const types = ['default', 'custom'];
-  const validPresets = [];
-
-  types.forEach((type) => {
-    const presetsPath = join(vulcanLibPath, 'presets', type);
-    const directories = readdirSync(presetsPath, { withFileTypes: true })
-      .filter((dirent) => dirent.isDirectory())
-      .map((dirent) => dirent.name);
-
-    validPresets.push(...directories);
-  });
-
-  return validPresets;
-}
-
 /**
  * Get the path corresponding to a specific alias defined in the package.json.
  * @param {string} alias - The desired alias.
@@ -40,9 +34,12 @@ async function getAliasPath(alias) {
   const packageJson = JSON.parse(packageJsonContent);
   let aliasPath = packageJson.imports[`#${alias}`];
   aliasPath = aliasPath.replace('./', `${vulcanRootPath}/`);
+  if (isWindows) {
+    aliasPath = aliasPath.replace(/[\\/]/g, '\\\\');
+  }
+
   return aliasPath;
 }
-
 /**
  * Move requires and imports to file init
  * @param {string} entryContent - The file content to be fixed.
@@ -64,7 +61,6 @@ function fixImportsAndRequestsPlace(entryContent) {
 
   return newCode;
 }
-
 /**
  * Get a build context based on arguments
  * @param {string} preset - The build preset.
@@ -73,14 +69,13 @@ function fixImportsAndRequestsPlace(entryContent) {
  * @returns {any} The context that will be used in build.
  */
 async function loadBuildContext(preset, entry, mode) {
-  const VALID_BUILD_PRESETS = getValidPresets();
+  const VALID_BUILD_PRESETS = presets.getKeys();
+
   const validPreset = VALID_BUILD_PRESETS.includes(preset);
 
   if (!validPreset) {
-    throw Error(
-      'Invalid build preset. Available presets: ',
-      VALID_BUILD_PRESETS.concat(','),
-    );
+    feedback.build.error(Messages.build.error.invalid_preset);
+    process.exit(1);
   }
 
   let configFilePath;
@@ -102,8 +97,14 @@ async function loadBuildContext(preset, entry, mode) {
     configFilePath = join(modePath, 'config.js');
     prebuildFilePath = join(modePath, 'prebuild.js');
     handlerFilePath = join(modePath, 'handler.js');
+  } else {
+    feedback.build.error(Messages.build.error.invalid_preset_mode(mode, preset));
+    process.exit(1);
   }
 
+  configFilePath = new URL(`file://${configFilePath}`).href;
+  prebuildFilePath = new URL(`file://${prebuildFilePath}`).href;
+
   const config = (await import(configFilePath)).default;
   const prebuild = (await import(prebuildFilePath)).default;
   const handlerTemplate = readFileSync(handlerFilePath, 'utf-8');
@@ -123,10 +124,16 @@ async function loadBuildContext(preset, entry, mode) {
   const edgehooksPath = await getAliasPath('edge');
   newEntryContent = newEntryContent.replace('#edge', edgehooksPath);
 
-  if (mode === 'server') {
-    const filePath = join(process.cwd(), entry);
-    const entryContent = readFileSync(filePath, 'utf-8');
-    newEntryContent = newEntryContent.replace('__JS_CODE__', entryContent);
+  if ((preset === 'javascript' || preset === 'typescript') && (mode === 'compute')) {
+    try {
+      const filePath = join(process.cwd(), entry);
+      const entryContent = readFileSync(filePath, 'utf-8');
+      newEntryContent = newEntryContent.replace('__JS_CODE__', entryContent);
+    } catch (error) {
+      feedback.build.error(Messages.errors.file_doesnt_exist(entry));
+      debug.error(error);
+      process.exit(1);
+    }
   }
 
   newEntryContent = fixImportsAndRequestsPlace(newEntryContent);
@@ -140,6 +147,24 @@ async function loadBuildContext(preset, entry, mode) {
   return buildContext;
 }
 
+/**
+ * Generates a build ID and saves it in the .env file (for deploy).
+ * @returns {Promise<string>} The generated build ID.
+ */
+function generateBuildId() {
+  const projectRoot = process.cwd();
+  const outputPath = isWindows ? fileURLToPath(new URL(`file:///${join(projectRoot, '.edge')}`)) : join(projectRoot, '.edge');
+
+  const envFilePath = join(outputPath, '.env');
+  const BUILD_VERSION___AKA__VERSION_ID = generateTimestamp();
+  const envContent = `VERSION_ID=${BUILD_VERSION___AKA__VERSION_ID}`;
+
+  mkdirSync(outputPath, { recursive: true });
+  writeFileSync(envFilePath, envContent);
+
+  return BUILD_VERSION___AKA__VERSION_ID;
+}
+
 /**
  * Class representing a Dispatcher for build operations.
  * @example
@@ -153,12 +178,14 @@ class Dispatcher {
    * @param {string} mode - The mode of build target.
    * @param {string} entry - The entry point for the build.
    * @param {string} versionId - The version ID for the build.
+   * @param {boolean} useNodePolyfills - The flag to indicates polyfills use.
    */
-  constructor(preset, mode, entry, versionId) {
+  constructor(preset, mode, entry, versionId, useNodePolyfills) {
     this.preset = preset;
     this.mode = mode;
     this.entry = entry;
     this.versionId = versionId;
+    this.useNodePolyfills = useNodePolyfills;
   }
 
   /**
@@ -166,45 +193,68 @@ class Dispatcher {
    */
   run = async () => {
     // Load Context based on preset
-    feedback.prebuild.info(Messages.build.info.prebuild_starting);
-
     const { entryContent, prebuild, config } = await loadBuildContext(
       this.preset,
       this.entry,
       this.mode,
     );
 
-    // Run prebuild actions
-    await prebuild(); // TODO: send context to prebuild
-    feedback.prebuild.success(Messages.build.success.prebuild_succeeded);
-    feedback.prebuild.info(Messages.build.info.vulcan_build_starting);
-
-    // create tmp entrypoint
-    const buildId = generateTimestamp(); // TODO: use versionID
-    const currentDir = process.cwd();
-    const tempBuilderEntryPath = join(currentDir, `vulcan-${buildId}.temp.js`);
-
-    await writeFile(tempBuilderEntryPath, entryContent);
-
-    // builder entry
-    config.entry = tempBuilderEntryPath;
-
-    let builder;
-    switch (config.builder) {
-      case 'webpack':
-        builder = new Webpack(config, config.useNodePolyfills);
-        break;
-      default:
-        builder = new Webpack(config, config.useNodePolyfills);
-        break;
-    }
+    const buildId = generateBuildId();
 
-    // Run common build
-    await builder.run();
+    const buildContext = {
+      preset: this.preset,
+      entry: this.entry,
+      mode: this.mode,
+      cliVersionId: this.versionId,
+      useNodePolyfills: this.useNodePolyfills,
+      buildId,
+      config,
+      entryContent,
+    };
 
-    // delete .temp files
-    rm(tempBuilderEntryPath);
-    feedback.build.success(Messages.build.success.vulcan_build_succeeded);
+    // Run prebuild actions
+    try {
+      feedback.prebuild.info(Messages.build.info.prebuild_starting);
+      await prebuild(buildContext);
+      feedback.prebuild.success(Messages.build.success.prebuild_succeeded);
+
+      feedback.build.info(Messages.build.info.vulcan_build_starting);
+      // create tmp entrypoint
+      const currentDir = process.cwd();
+      let tempEntryFile = `vulcan-${buildId}.temp.`;
+      tempEntryFile += (this.preset === 'typescript') ? 'ts' : 'js';
+      const tempBuilderEntryPath = join(currentDir, tempEntryFile);
+
+      writeFileSync(tempBuilderEntryPath, entryContent);
+
+      // builder entry
+      config.entry = tempBuilderEntryPath;
+      config.buildId = buildId;
+      config.useNodePolyfills = this.useNodePolyfills;
+
+      let builder;
+      switch (config.builder) {
+        case 'webpack':
+          builder = new Webpack(config);
+          break;
+        case 'esbuild':
+          builder = new Esbuild(config);
+          break;
+        default:
+          builder = new Webpack(config);
+          break;
+      }
+
+      // Run common build
+      await builder.run();
+
+      // delete .temp files
+      rmSync(tempBuilderEntryPath);
+      feedback.build.success(Messages.build.success.vulcan_build_succeeded);
+    } catch (error) {
+      debug.error(error);
+      process.exit(1);
+    }
   };
 }
 

package/lib/constants/framework-initializer.constants.js

@@ -0,0 +1,51 @@
+/**
+ * FrameworkInitializer contains various methods to initialize new projects
+ * in different JavaScript frameworks.
+ *
+ * Each method is an asynchronous function that takes a `projectName` as an argument.
+ * This `projectName` is then used to initialize a new project in the respective framework.
+ * @namespace FrameworkInitializer
+ * @typedef {object} FrameworkInitializer
+ * @property {Function} Angular - Initializes a new Angular project.
+ * @property {Function} Astro - Initializes a new Astro project.
+ * @property {Function} Hexo - Initializes a new Hexo project.
+ * @property {Function} Next - Initializes a new Next.js project.
+ * @property {Function} React - Initializes a new React project.
+ * @property {Function} Vue - Initializes a new Vue project.
+ * @property {Function} Vite - Initializes a new Vue project with Vite.
+ * @example
+ * const { Angular, React } = FrameworkInitializer;
+ *
+ * // Initialize a new Angular project called 'myAngularProject'
+ * await Angular('myAngularProject');
+ *
+ * // Initialize a new React project called 'myReactProject'
+ * await React('myReactProject');
+ */
+import { exec } from '#utils';
+
+const FrameworkInitializer = {
+  Angular: async (projectName) => {
+    await exec(`npx ng new ${projectName}`, 'Angular', false, true);
+  },
+  Astro: async (projectName) => {
+    await exec(`npx create-astro ${projectName}`, 'Astro', false, true);
+  },
+  Hexo: async (projectName) => {
+    await exec(`npx hexo init ${projectName}`, 'Hexo', false, true);
+  },
+  Next: async (projectName) => {
+    await exec(`npx create-next-app ${projectName}`, 'Next', false, true);
+  },
+  React: async (projectName) => {
+    await exec(`npx create-react-app ${projectName}`, 'React', false, true);
+  },
+  Vue: async (projectName) => {
+    await exec(`npx vue create ${projectName}`, 'Vue', false, true);
+  },
+  Vite: async (projectName) => {
+    await exec(`npx create-vue ${projectName}`, 'Vue/Vite', false, true);
+  },
+};
+
+export default FrameworkInitializer;

package/lib/constants/index.js

@@ -1,5 +1,8 @@
 import RuntimeApis from './runtime-apis.constants.js';
 import AzionEdges from './azion-edges.constants.js';
 import Messages from './messages/index.js';
+import FrameworkInitializer from './framework-initializer.constants.js';
 
-export { AzionEdges, RuntimeApis, Messages };
+export {
+  AzionEdges, RuntimeApis, Messages, FrameworkInitializer,
+};