edge-functions 1.1.0 → 1.3.0

package/lib/main.js

@@ -1,15 +1,23 @@
 #! /usr/bin/env node
-import path from 'path';
+import { join, resolve } from 'path';
+import { readFileSync } from 'fs';
 import { Command } from 'commander';
 import { createPromptModule } from 'inquirer';
 import { satisfies } from 'semver';
-import { feedback, debug } from '#utils';
-import { Messages } from '#constants';
+import {
+  feedback, debug, getAbsoluteLibDirPath,
+} from '#utils';
+import { Messages, FrameworkInitializer } from '#constants';
 
 const MIN_NODE_VERSION = '18.0.0';
 
+const vulcanLibPath = getAbsoluteLibDirPath();
+const vulcanRootPath = resolve(vulcanLibPath, '..');
+const vulcanPackageJSON = JSON.parse(readFileSync(`${vulcanRootPath}/package.json`, 'utf8'));
+const vulcanVersion = vulcanPackageJSON.version;
+
 const debugEnabled = process.env.DEBUG === 'true';
-const version = process.env.npm_package_version;
+
 const program = new Command();
 const prompt = createPromptModule();
 
@@ -33,21 +41,231 @@ function validateNodeMinVersion() {
  *    setVulcanEnvironment();
  */
 function setVulcanEnvironment() {
-  const ENV = process.env.AZION_ENV || 'production';
-  if (!['production', 'stage', 'local'].includes(ENV)) {
+  const vulcanContext = {
+    env: 'production',
+    root: vulcanRootPath,
+    package: vulcanPackageJSON,
+    debug: debugEnabled,
+    version: vulcanVersion,
+  };
+
+  const AZION_ENV = process.env.AZION_ENV || vulcanContext.env;
+  if (!['production', 'stage', 'local'].includes(AZION_ENV)) {
     feedback.error(Messages.env.errors.invalid_environment);
     process.exit(1);
   } else {
-    globalThis.vulcan = { env: ENV };
+    vulcanContext.env = AZION_ENV;
   }
+  globalThis.vulcan = vulcanContext;
 }
 /**
  * Starts the command-line interface program.
  * @example
- *    startProgram();
+ *    startVulcanProgram();
  */
 function startVulcanProgram() {
-  program.version(version);
+  program.version(vulcanVersion);
+
+  program
+    .command('init')
+    .option('--name <project_name>', 'Project name')
+    .description('Initialize a new project')
+    .action(async (options) => {
+      const AVALIABLE_TEMPLATES = Object.keys(FrameworkInitializer);
+      let projectName = options.name;
+
+      const { frameworkChoice } = await prompt([
+        {
+          type: 'list',
+          name: 'frameworkChoice',
+          message: 'Choose a template for your project:',
+          choices: AVALIABLE_TEMPLATES,
+        },
+      ]);
+
+      while (!projectName) {
+      // eslint-disable-next-line no-await-in-loop
+        const { projectName: inputName } = await prompt([
+          {
+            type: 'input',
+            name: 'projectName',
+            message: 'Enter your project name:',
+          },
+        ]);
+
+        if (inputName) {
+          projectName = inputName;
+        }
+        if (!inputName) {
+          feedback.pending(Messages.info.name_required);
+        }
+      }
+
+      const createFrameworkTemplate = FrameworkInitializer[frameworkChoice];
+
+      if (createFrameworkTemplate) {
+        await createFrameworkTemplate(projectName);
+      } else {
+        feedback.error(Messages.errors.invalid_choice);
+      }
+    });
+
+  program
+    .command('build')
+    .description('Build a project for edge deployment')
+    .option(
+      '--preset <type>',
+      'Preset of build target (e.g., vue, next, javascript)',
+      'javascript',
+    )
+    .option(
+      '--mode <type>',
+      'Mode of build target (e.g., deliver, compute)',
+      'compute',
+    )
+    .option(
+      '--entry <string>',
+      'Code entrypoint (default: ./main.js)',
+      './main.js',
+    )
+    .option(
+      '--useNodePolyfills',
+      'Use node polyfills in build.',
+    )
+    .action(async ({
+      preset, mode, entry, versionId, useNodePolyfills,
+    }) => {
+      let entryPoint = entry;
+
+      if (preset === 'javascript') {
+        feedback.info('Using main.js as entrypoint by default');
+      }
+      if (preset === 'typescript') {
+        feedback.info('Using main.ts as entrypoint by default');
+        entryPoint = './main.ts';
+      }
+
+      const BuildDispatcher = (await import('#build')).default;
+      const buildDispatcher = new BuildDispatcher(
+        preset,
+        mode,
+        entryPoint,
+        versionId,
+        useNodePolyfills,
+      );
+      await buildDispatcher.run();
+    });
+
+  program
+    .command('dev')
+    .description('Start local environment')
+    .arguments('[file]')
+    .option('-p, --port <port>', 'Specify the port', '3000')
+    .action(async (file, options) => {
+      const { port } = options;
+      const parsedPort = parseInt(port, 10);
+      const { server } = await import('#env');
+      const entryPoint = file || join(process.cwd(), '.edge/worker.js');
+      server(entryPoint, parsedPort);
+    });
+
+  program
+    .command('presets <type>')
+    .description('Create or use defined project presets for Edge')
+    .action(async (type) => {
+      const { presets } = await import('#utils');
+
+      let name;
+      let mode;
+
+      switch (type) {
+        case 'create':
+          // eslint-disable-next-line no-constant-condition
+          while (true) {
+            // eslint-disable-next-line no-await-in-loop
+            const { inputPresetName } = await prompt([
+              {
+                type: 'input',
+                name: 'inputPresetName',
+                message: 'Enter the preset name:',
+              },
+            ]);
+
+            const presetExists = presets
+              .getKeys()
+              .map((existingPresetName) => existingPresetName.toLowerCase())
+              .includes(inputPresetName.toLowerCase());
+
+            if (presetExists) {
+              feedback.error('A preset with this name already exists.');
+            } else if (!inputPresetName) {
+              feedback.error('Preset name cannot be empty.');
+            } else {
+              name = inputPresetName;
+              break;
+            }
+          }
+
+          // eslint-disable-next-line no-constant-condition
+          while (true) {
+            // eslint-disable-next-line no-await-in-loop
+            const { inputMode } = await prompt([
+              {
+                type: 'list',
+                name: 'inputMode',
+                message: 'Choose the mode:',
+                choices: ['compute', 'deliver'],
+              },
+            ]);
+
+            if (['compute', 'deliver'].includes(inputMode)) {
+              mode = inputMode;
+              break;
+            } else {
+              feedback.error('Invalid mode. Choose either "compute" or "deliver".');
+            }
+          }
+
+          try {
+            presets.set(name, mode);
+            feedback.success(`${name}(${mode}) created with success!`);
+            feedback.info(`Now open './lib/presets/${name}/${mode}' and work on your preset.`);
+          } catch (error) {
+            debug.error(error);
+            feedback.error(Messages.errors.folder_creation_failed(name));
+          }
+          break;
+
+        case 'ls':
+          presets.getBeautify().forEach((preset) => feedback.option(preset));
+          break;
+
+        default:
+          feedback.error('Invalid argument provided.');
+          break;
+      }
+    });
+
+  program
+    .command('logs <type> [id]')
+    .description('Perform operations on function or application logs')
+    .option('-w, --watch', 'Show real-time logs')
+    .action(async (type, id, options) => {
+      const { functions } = await import('#platform');
+      const { watch } = options;
+
+      if (!['function', 'application'].includes(type)) {
+        feedback.error(Messages.platform.logs.errors.invalid_log_type);
+        return;
+      }
+
+      if (type === 'function') {
+        functions.actions.showFunctionLogs(id, watch);
+      }
+      if (type === 'application') {
+        feedback.info(Messages.platform.logs.info.unsupported_log_type);
+      }
+    });
 
   if (debugEnabled) {
     program
@@ -123,14 +341,14 @@ function startVulcanProgram() {
     program
       .command('storage sync')
       .description(
-        'Synchronize local .edge/statics with the Edge Function storage',
+        'Synchronize local .edge/storage with the Edge Function storage',
       )
       .action(async () => {
         const { core } = await import('#platform');
         const { getVulcanBuildId } = await import('#utils');
 
         const versionId = getVulcanBuildId();
-        const basePath = path.join(process.cwd(), '.edge/statics/');
+        const basePath = join(process.cwd(), '.edge/storage/');
         await core.actions.uploadStatics(versionId, basePath);
       });
 
@@ -142,7 +360,7 @@ function startVulcanProgram() {
         const { getVulcanBuildId } = await import('#utils');
 
         const versionId = getVulcanBuildId();
-        const staticsPath = path.join(process.cwd(), '/.edge/statics');
+        const staticsPath = join(process.cwd(), '/.edge/storage');
 
         const answers = await prompt([
           {
@@ -167,87 +385,6 @@ function startVulcanProgram() {
       });
   }
 
-  program
-    .command('run')
-    .description('Run Edge Function')
-    .arguments('[file]')
-    .option('-p, --port <port>', 'Specify the port', '3000')
-    .action(async (file, options) => {
-      const { port } = options;
-      const parsedPort = parseInt(port, 10);
-      const { server } = await import('#env');
-      const entryPoint = file || path.join(process.cwd(), '.edge/worker.js');
-      server(entryPoint, parsedPort);
-    });
-
-  program
-    .command('logs <type> [id]')
-    .description('Perform operations on function or application logs')
-    .option('-w, --watch', 'Show real-time logs')
-    .action(async (type, id, options) => {
-      const { functions } = await import('#platform');
-      const { watch } = options;
-
-      if (!['function', 'application'].includes(type)) {
-        feedback.error(Messages.platform.logs.errors.invalid_log_type);
-        return;
-      }
-
-      if (type === 'function') {
-        functions.actions.showFunctionLogs(id, watch);
-      }
-      if (type === 'application') {
-        feedback.info(Messages.platform.logs.info.unsupported_log_type);
-      }
-    });
-  program
-    .command('build')
-    .description('Build a project for edge deployment')
-    .option(
-      '--preset <type>',
-      'Preset of build target (e.g., vue, next, javascript)',
-      'javascript',
-    )
-    .option(
-      '--mode <type>',
-      'Mode of build target (e.g., deliver, compute)',
-      'compute',
-    )
-    .option(
-      '--entry <string>',
-      'Code entrypoint (default: ./main.js)',
-      './main.js',
-    )
-    .option(
-      '--useNodePolyfills',
-      'Use node polyfills in build.',
-    )
-    .action(async ({
-      preset, mode, entry, versionId, useNodePolyfills,
-    }) => {
-      // TODO: generate versionID in dispatcher (currently generated for webpackconfig)
-      const BuildDispatcher = (await import('#build')).default;
-      const buildDispatcher = new BuildDispatcher(
-        preset,
-        mode,
-        entry,
-        versionId,
-        useNodePolyfills,
-      );
-      await buildDispatcher.run();
-    });
-
-  program
-    .command('presets <type>')
-    .description('Create or use defined project presets for Edge.')
-    .action(async (type) => {
-      const { getPresetsList } = await import('#utils');
-      const presets = getPresetsList();
-
-      if (type === 'ls') {
-        presets.forEach((preset) => feedback.option(preset));
-      }
-    });
   program.parse(process.argv);
 }
 
@@ -255,10 +392,13 @@ try {
   if (validateNodeMinVersion()) {
     setVulcanEnvironment();
     startVulcanProgram();
-  } else {
+  }
+  if (!validateNodeMinVersion()) {
     feedback.error(Messages.errors.invalid_node_version(MIN_NODE_VERSION));
+    process.exit(1);
   }
 } catch (error) {
   feedback.error(Messages.errors.unknown_error);
   debug.error(error);
+  process.exit(1);
 }

package/lib/platform/actions/core/propagation.actions.js

@@ -1,5 +1,8 @@
 import { AzionEdges, Messages } from '#constants';
 import { feedback, debug, exec } from '#utils';
+
+const isWindows = process.platform === 'win32';
+
 /**
  * @function
  * @memberof platform
@@ -18,8 +21,6 @@ import { feedback, debug, exec } from '#utils';
  *    console.error(error);
  * }
  */
-const isWindows = process.platform === 'win32';
-
 function watchPropagation(domain) {
   let currentEdgeIndex = 0;
   let intervalId = null;
@@ -39,13 +40,13 @@ function watchPropagation(domain) {
         clearInterval(intervalId);
 
         let remainingEdgeIndex = currentEdgeIndex + 1;
-        const remainingEdgesIntervalId =  setInterval(async () => {
+        const remainingEdgesIntervalId = setInterval(async () => {
           if (remainingEdgeIndex >= AzionEdges.length) {
             clearInterval(remainingEdgesIntervalId);
             f.interactive.complete(
               Messages.platform.propagation.success.propagation_complete,
             );
-            await exec(`${isWindows ? 'start ' : 'open ' } https://${domain} `)
+            await exec(`${isWindows ? 'start ' : 'open '} https://${domain} `);
 
             process.exit(0);
           } else {

package/lib/presets/custom/angular/deliver/prebuild.js

@@ -1,4 +1,4 @@
-import { exec, feedback, getPackageManager } from '#utils';
+import { exec, getPackageManager } from '#utils';
 
 const packageManager = await getPackageManager();
 
@@ -7,15 +7,11 @@ const packageManager = await getPackageManager();
  * @param {object} buildContext - info about the build
  */
 async function prebuild(buildContext) {
-  try {
-    // This is because npm interprets arguments passed directly
-    // after the script as options for npm itself, not the script itself.
-    const npmArgsForward = packageManager === 'npm' ? '--' : '';
-    // support npm, yarn, pnpm
-    await exec(`${packageManager} run build ${npmArgsForward} --output-path=.edge/storage`, 'Angular', true);
-  } catch (error) {
-    feedback.prebuild.error(error);
-  }
+  // This is because npm interprets arguments passed directly
+  // after the script as options for npm itself, not the script itself.
+  const npmArgsForward = packageManager === 'npm' ? '--' : '';
+  // support npm, yarn, pnpm
+  await exec(`${packageManager} run build ${npmArgsForward} --output-path=.edge/storage`, 'Angular', true);
 }
 
 export default prebuild;

package/lib/presets/custom/astro/deliver/prebuild.js

@@ -10,29 +10,25 @@ const packageManager = await getPackageManager();
  * @param {object} buildContext - info about the build
  */
 async function prebuild(buildContext) {
-  try {
-    const newOutDir = '.edge/storage';
-    let outDir = 'dist';
+  const newOutDir = '.edge/storage';
+  let outDir = 'dist';
 
-    // check if an output path is specified in config file
-    const configFileContent = await readFile('./astro.config.mjs', 'utf-8');
-    const attributeMatch = Array.from(
-      configFileContent.matchAll(/outDir:(.*)\n/g),
-      (match) => match,
-    )[0];
-    if (attributeMatch) {
-      // get the specified value in config
-      outDir = attributeMatch[1].trim();
-    }
+  // check if an output path is specified in config file
+  const configFileContent = await readFile('./astro.config.mjs', 'utf-8');
+  const attributeMatch = Array.from(
+    configFileContent.matchAll(/outDir:(.*)\n/g),
+    (match) => match,
+  )[0];
+  if (attributeMatch) {
+    // get the specified value in config
+    outDir = attributeMatch[1].trim();
+  }
 
-    await exec(`${packageManager} run build`, 'Astro', true);
+  await exec(`${packageManager} run build`, 'Astro', true);
 
-    // move files to vulcan default path
-    copyDirectory(outDir, newOutDir);
-    rm(outDir, { recursive: true, force: true });
-  } catch (error) {
-    feedback.prebuild.error(error);
-  }
+  // move files to vulcan default path
+  copyDirectory(outDir, newOutDir);
+  rm(outDir, { recursive: true, force: true });
 }
 
 export default prebuild;

package/lib/presets/custom/hexo/deliver/prebuild.js

@@ -10,29 +10,25 @@ const packageManager = await getPackageManager();
  * @param {object} buildContext - info about the build
  */
 async function prebuild(buildContext) {
-  try {
-    const newOutDir = '.edge/storage';
-    let outDir = 'public';
+  const newOutDir = '.edge/storage';
+  let outDir = 'public';
 
-    // check if an output path is specified in config file
-    const configFileContent = await readFile('./_config.yml', 'utf-8');
-    const attributeMatch = Array.from(
-      configFileContent.matchAll(/public_dir:(.*)\n/g),
-      (match) => match,
-    )[0];
-    if (attributeMatch) {
-      // get the specified value in config
-      outDir = attributeMatch[1].trim().replace(/["']/g, '');
-    }
+  // check if an output path is specified in config file
+  const configFileContent = await readFile('./_config.yml', 'utf-8');
+  const attributeMatch = Array.from(
+    configFileContent.matchAll(/public_dir:(.*)\n/g),
+    (match) => match,
+  )[0];
+  if (attributeMatch) {
+    // get the specified value in config
+    outDir = attributeMatch[1].trim().replace(/["']/g, '');
+  }
 
-    await exec('npx hexo generate', 'Hexo', true);
+  await exec(`${packageManager} hexo generate`, 'Hexo', true);
 
-    // move files to vulcan default path
-    copyDirectory(outDir, newOutDir);
-    rm(outDir, { recursive: true, force: true });
-  } catch (error) {
-    feedback.prebuild.error(error);
-  }
+  // move files to vulcan default path
+  copyDirectory(outDir, newOutDir);
+  rm(outDir, { recursive: true, force: true });
 }
 
 export default prebuild;

package/lib/presets/custom/next/deliver/prebuild.js

@@ -143,52 +143,48 @@ function validateStaticSiteMode(nextConfig) {
  * @param {object} buildContext - info about the build
  */
 async function prebuild(buildContext) {
-  try {
-    feedback.prebuild.info('Starting Next.js static build process...');
+  feedback.prebuild.info('Starting Next.js static build process...');
 
-    const nextVersion = getPackageVersion('next');
-    feedback.prebuild.info('Detected Next.js version:', nextVersion);
+  const nextVersion = getPackageVersion('next');
+  feedback.prebuild.info('Detected Next.js version:', nextVersion);
 
-    const staticsOutputDir = '.edge/storage';
+  const staticsOutputDir = '.edge/storage';
 
-    if (isANewerVersion(nextVersion)) {
-      const nextConfig = await getNextConfig();
+  if (isANewerVersion(nextVersion)) {
+    const nextConfig = await getNextConfig();
 
-      validateStaticSiteMode(nextConfig);
+    validateStaticSiteMode(nextConfig);
 
-      // check if an output path is specified in config file
-      let outDir = 'out';
-      const configFileContent = await readFile('./next.config.js', 'utf-8');
-      const attributeMatch = Array.from(
-        configFileContent.matchAll(/distDir:(.*),/g),
-        (match) => match,
-      )[0];
-      if (attributeMatch) {
-        // get the specified value in config
-        outDir = attributeMatch[1].trim().replace(/["']/g, '');
-      }
+    // check if an output path is specified in config file
+    let outDir = 'out';
+    const configFileContent = await readFile('./next.config.js', 'utf-8');
+    const attributeMatch = Array.from(
+      configFileContent.matchAll(/distDir:(.*),/g),
+      (match) => match,
+    )[0];
+    if (attributeMatch) {
+      // get the specified value in config
+      outDir = attributeMatch[1].trim().replace(/["']/g, '');
+    }
 
-      await exec(`${packageManager} run build`, `Next ${nextVersion}`, true);
+    await exec(`${packageManager} run build`, `Next ${nextVersion}`, true);
 
-      // move files to vulcan default path
-      copyDirectory(outDir, staticsOutputDir);
-      rm(outDir, { recursive: true, force: true });
+    // move files to vulcan default path
+    copyDirectory(outDir, staticsOutputDir);
+    rm(outDir, { recursive: true, force: true });
 
-      feedback.prebuild.info('Adapting Next.js build output...');
-      await moveFiles(`${process.cwd()}/${staticsOutputDir}`);
-    } else {
-      await exec(`${packageManager} run build`, `Next ${nextVersion}`, true);
+    feedback.prebuild.info('Adapting Next.js build output...');
+    await moveFiles(`${process.cwd()}/${staticsOutputDir}`);
+  } else {
+    await exec(`${packageManager} run build`, `Next ${nextVersion}`, true);
 
-      await exec(`npx next export -o ${staticsOutputDir}`, `Next ${nextVersion}`, true);
+    await exec(`npx next export -o ${staticsOutputDir}`, `Next ${nextVersion}`, true);
 
-      feedback.prebuild.info('Adapting Next.js build output...');
-      await moveFiles(`${process.cwd()}/${staticsOutputDir}`);
-    }
-
-    feedback.prebuild.success('Next.js build adaptation completed successfully.');
-  } catch (error) {
-    feedback.prebuild.error('Error occurred during Next.js build adaptation:', error);
+    feedback.prebuild.info('Adapting Next.js build output...');
+    await moveFiles(`${process.cwd()}/${staticsOutputDir}`);
   }
+
+  feedback.prebuild.success('Next.js build adaptation completed successfully.');
 }
 
 export default prebuild;

package/lib/presets/custom/react/deliver/prebuild.js

@@ -1,4 +1,4 @@
-import { exec, feedback, getPackageManager } from '#utils';
+import { exec, getPackageManager } from '#utils';
 
 const packageManager = await getPackageManager();
 
@@ -7,11 +7,7 @@ const packageManager = await getPackageManager();
  * @param {object} buildContext - info about the build
  */
 async function prebuild(buildContext) {
-  try {
-    await exec(`BUILD_PATH="./.edge/storage" ${packageManager} run build`, 'React', true);
-  } catch (error) {
-    feedback.prebuild.error(error);
-  }
+  await exec(`BUILD_PATH="./.edge/storage" ${packageManager} run build`, 'React', true);
 }
 
 export default prebuild;