edge-functions 1.3.0 → 1.5.0

package/lib/commands/index.js

@@ -0,0 +1,13 @@
+import authCommand from './auth.commands.js';
+import buildCommand from './build.commands.js';
+import deployCommand from './deploy.commands.js';
+import devCommand from './dev.commands.js';
+import initCommand from './init.commands.js';
+import logsCommand from './logs.commands.js';
+import presetsCommand from './presets.commands.js';
+import storageCommand from './storage.commands.js';
+
+export {
+  authCommand, buildCommand, deployCommand, devCommand,
+  initCommand, logsCommand, presetsCommand, storageCommand,
+};

package/lib/commands/init.commands.js

@@ -0,0 +1,61 @@
+import { createPromptModule } from 'inquirer';
+import { FrameworkInitializer, Messages } from '#constants';
+import { feedback } from '#utils';
+import { vulcan } from '#env';
+
+const prompt = createPromptModule();
+/**
+ * A command to Initializes a new project with the selected framework template.
+ * @memberof commands
+ * This function prompts the user to select a framework template and enter a project name.
+ * Then it initializes a new project based on the selected template.
+ * @param {object} options - An object containing the name for the new project.
+ * @param {string} options.name - The name of the new project.
+ * If not provided, the function will prompt for it.
+ * @returns {Promise<void>} - A promise that resolves when the new project is initialized.
+ * @example
+ *
+ * initCommand({ name: 'my_new_project' });
+ */
+async function initComamnd({ name }) {
+  const AVALIABLE_TEMPLATES = Object.keys(FrameworkInitializer);
+  let projectName = 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) {
+    process.env.VULCAN_CURRENT_PRESET = projectName; // for Azion CLI in Golang(temp)
+    await createFrameworkTemplate(projectName);
+  } else {
+    feedback.error(Messages.errors.invalid_choice);
+  }
+}
+
+export default initComamnd;

package/lib/commands/logs.commands.js

@@ -0,0 +1,34 @@
+import { feedback } from '#utils';
+import { Messages } from '#constants';
+/**
+ * A comamnd to display logs for a specified function or application.
+ * @memberof commands
+ * This function allows the user to view logs for a specific function or application.
+ * Note that viewing logs for applications is currently unsupported.
+ * @param {string} type - The type of entity to show logs for.
+ * Accepted values are 'function' and 'application'.
+ * @param {string} id - The identifier for the function or application.
+ * @param {object} options - Additional options for fetching logs.
+ * @param {boolean} options.watch - If true, keep watching the logs and updating in real-time.
+ * @returns {Promise<void>} - A promise that resolves when logs are fetched and displayed.
+ * @example
+ *
+ * logsCommand('function', 'functionId123', { watch: true });
+ */
+async function logsCommand(type, id, { watch }) {
+  const { functions } = await import('#platform');
+
+  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);
+  }
+}
+
+export default logsCommand;

package/lib/commands/presets.commands.js

@@ -0,0 +1,97 @@
+import { createPromptModule } from 'inquirer';
+import { Messages } from '#constants';
+import { feedback, debug } from '#utils';
+
+const prompt = createPromptModule();
+
+/**
+ * Manages presets for the application.
+ * @memberof commands
+ * This command allows the user to create or list presets.
+ * The user is guided by a series of prompts to enter a preset name and mode.
+ * @param {string} command - The operation to be performed:
+ * 'create' to create a preset, 'ls' to list presets.
+ * @returns {Promise<void>} - A promise that resolves when the action is complete.
+ * @example
+ *
+ * // To create a new preset
+ * presetsCommand('create');
+ *
+ * // To list existing presets
+ * presetsCommand('ls');
+ */
+async function presetsCommand(command) {
+  const { presets } = await import('#utils');
+
+  let name;
+  let mode;
+
+  switch (command) {
+    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;
+  }
+}
+
+export default presetsCommand;

package/lib/commands/storage.commands.js

@@ -0,0 +1,22 @@
+import { join } from 'path';
+
+/**
+ * A command to uploads static files for a given version of the application.
+ * @memberof commands
+ * The function identifies the build version, prepares a base path for static files,
+ * and uploads these files to the storage of the core platform.
+ * @returns {Promise<void>} - A promise that resolves when static files are successfully uploaded.
+ * @example
+ *
+ * storageCommand();
+ */
+async function storageCommand() {
+  const { core } = await import('#platform');
+  const { getVulcanBuildId } = await import('#utils');
+
+  const versionId = getVulcanBuildId();
+  const basePath = join(process.cwd(), '.edge/storage/');
+  await core.actions.uploadStatics(versionId, basePath);
+}
+
+export default storageCommand;

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

@@ -26,7 +26,7 @@ import { exec } from '#utils';
 
 const FrameworkInitializer = {
   Angular: async (projectName) => {
-    await exec(`npx ng new ${projectName}`, 'Angular', false, true);
+    await exec(`npx @angular/cli new ${projectName}`, 'Angular', false, true);
   },
   Astro: async (projectName) => {
     await exec(`npx create-astro ${projectName}`, 'Astro', false, true);
@@ -41,7 +41,7 @@ const FrameworkInitializer = {
     await exec(`npx create-react-app ${projectName}`, 'React', false, true);
   },
   Vue: async (projectName) => {
-    await exec(`npx vue create ${projectName}`, 'Vue', false, true);
+    await exec(`npx @vue/cli create ${projectName}`, 'Vue', false, true);
   },
   Vite: async (projectName) => {
     await exec(`npx create-vue ${projectName}`, 'Vue/Vite', false, true);

package/lib/constants/messages/build.messages.js

@@ -10,6 +10,7 @@ const build = {
     vulcan_build_succeeded: 'Vulcan Build succeeded!',
   },
   info: {
+    rebuilding: 'We are rebuilding with the new changes...',
     prebuild_starting: 'Starting prebuild...',
     vulcan_build_starting: 'Starting Vulcan build...',
 

package/lib/env/polyfills/fetch.polyfills.js

@@ -2,6 +2,7 @@ import { join } from 'path';
 import { readFileSync } from 'fs';
 import mime from 'mime-types';
 import { EdgeRuntime } from 'edge-runtime';
+import { getUrlFromResource, getVulcanBuildId } from '#utils';
 
 /**
  * A custom fetch implementation that adds an additional path to the URL if it starts with 'file://'.
@@ -9,19 +10,18 @@ import { EdgeRuntime } from 'edge-runtime';
  * it behaves as if the request is made from within the edge itself. In this case, an additional
  * '.edge/storage' folder is appended to the URL to represent the edge environment.
  * @param {EdgeRuntime} context - VMContext
- * @param {URL} url - The URL to fetch.
+ * @param {URL|Request|string} resource - The resource to fetch.
  * @param {object} [options] - The fetch options.
  * @returns {Promise<Response>} A Promise that resolves to the Response object.
  */
-async function fetchPolyfill(context, url, options) {
-  const {
-    URL, Headers, Response,
-  } = context;
+async function fetchPolyfill(context, resource, options) {
+  const { Headers, Response } = context;
 
-  const urlOBJ = new URL(url);
-  if (urlOBJ.href.startsWith('file://')) {
-    // url pathname = /VERSION_ID/filePath
-    const file = url.pathname.slice(15);
+  const urlObj = getUrlFromResource(resource);
+
+  if (urlObj.href.startsWith('file://')) {
+    const versionId = getVulcanBuildId();
+    const file = urlObj.pathname.replace(`/${versionId}`, '');
     const filePath = join(process.cwd(), '.edge', 'storage', file);
     const fileContent = readFileSync(filePath);
     const contentType = mime.lookup(filePath) || 'application/octet-stream';
@@ -33,7 +33,7 @@ async function fetchPolyfill(context, url, options) {
     return response;
   }
 
-  return fetch(url, options);
+  return fetch(resource, options);
 }
 
 export default fetchPolyfill;

package/lib/env/runtime.env.js

@@ -36,7 +36,7 @@ import { fetchPolyfill, FetchEventPolyfill } from './polyfills/index.js';
  */
 function runtime(code) {
   const extend = (context) => {
-    context.fetch = (url, options) => fetchPolyfill(context, url, options);
+    context.fetch = (resource, options) => fetchPolyfill(context, resource, options);
     context.FetchEvent = FetchEventPolyfill;
     context.FirewallEvent = {}; // TODO: Firewall Event
     /*

package/lib/env/server.env.js

@@ -1,46 +1,124 @@
-import { debug, readWorkerFile, feedback } from '#utils';
+import {
+  debug, readWorkerFile, feedback, exec,
+} from '#utils';
 import { Messages } from '#constants';
-import { runServer } from 'edge-runtime';
+import edgeRuntimePackage from 'edge-runtime';
+import chokidar from 'chokidar';
 import runtime from './runtime.env.js';
+import vulcan from './vulcan.env.js';
+
+const { runServer, EdgeRuntimeServer } = edgeRuntimePackage;
+
+let currentServer;
+let isChangeHandlerRunning = false;
 
 /**
- * Read the worker code from the file.
- * @param {string} workerPath - The path to the file containing the code.
- * @returns {Promise<string>} A promise that resolves to the worker code.
+ * Read the worker code from a specified path.
+ * @param {string} workerPath - Path to the worker file.
+ * @returns {Promise<string>} - The worker code.
+ * @throws {Error} - If unable to read the worker file.
  */
 async function readWorkerCode(workerPath) {
   try {
-    const worker = await readWorkerFile(workerPath);
-    return worker;
+    return await readWorkerFile(workerPath);
   } catch (error) {
     debug.error(error);
-    feedback.server.error(
-      Messages.env.server.errors.load_worker_failed(workerPath),
-    );
+    feedback.server.error(Messages.env.server.errors.load_worker_failed(workerPath));
     throw error;
   }
 }
 
 /**
- * Start the HTTP server with the specified port and file path to load the code from.
- * @param {string} workerPath - The path to the file containing the worker code.
- * @param {number} port - The port to listen on.
+ * Initialize and run the server with the given port and worker code.
+ * @param {number} port - The port number.
+ * @param {string} workerCode - The worker code.
+ * @returns {Promise<EdgeRuntimeServer>} - The initialized server.
  */
-async function startServer(workerPath, port) {
+async function initializeServer(port, workerCode) {
+  const execution = runtime(workerCode);
+  return runServer({ port, host: 'localhost', runtime: execution });
+}
+
+/**
+ * Handle server operations: start, restart.
+ * @param {string} workerPath - Path to the worker file.
+ * @param {number} port - The port number.
+ */
+async function manageServer(workerPath, port) {
   try {
     const workerCode = await readWorkerCode(workerPath);
-    const execution = runtime(workerCode);
-    const server = await runServer({
-      port,
-      host: 'localhost',
-      runtime: execution,
-    });
-    feedback.server.success(
-      Messages.env.server.success.server_running(server.url),
-    );
+
+    if (currentServer) {
+      await currentServer.close();
+    }
+
+    try {
+      currentServer = await initializeServer(port, workerCode);
+      feedback.server.success(Messages.env.server.success.server_running(`http://localhost:${port}`));
+    } catch (error) {
+      if (error.code === 'EADDRINUSE') {
+        await manageServer(workerPath, port + 1);
+      } else {
+        throw error;
+      }
+    }
   } catch (error) {
     debug.error(error);
+    process.exit(1);
+  }
+}
+
+/**
+ * Handle file changes and prevent concurrent execution.
+ * @param {string} path - Path of the changed file.
+ * @param {string} workerPath - Path to the worker file.
+ * @param {number} port - The port number.
+ */
+async function handleFileChange(path, workerPath, port) {
+  if (isChangeHandlerRunning) return;
+
+  isChangeHandlerRunning = true;
+
+  if (path.startsWith('vulcan') || path.startsWith('.edge') || path.startsWith('node_modules/.cache')) {
+    isChangeHandlerRunning = false;
+    return;
   }
+
+  const {
+    entry, preset, mode, useNodePolyfills,
+  } = await vulcan.readVulcanEnv('local');
+
+  feedback.build.info(Messages.build.info.rebuilding);
+
+  try {
+    await exec(`vulcan build --entry ${entry} --preset ${preset} --mode ${mode} --useNodePolyfills ${useNodePolyfills}`);
+    await manageServer(workerPath, port);
+  } catch (error) {
+    debug.error(`Build or server restart failed: ${error}`);
+  }
+
+  isChangeHandlerRunning = false;
+}
+
+/**
+ * Entry point function to start the server and watch for file changes.
+ * @param {string} workerPath - Path to the worker file.
+ * @param {number} port - The port number.
+ */
+async function startServer(workerPath, port) {
+  await manageServer(workerPath, port); // Initialize the server for the first time
+
+  const watcher = chokidar.watch('./', {
+    persistent: true,
+    ignoreInitial: false,
+    depth: 99,
+  });
+
+  watcher.on('change', async (path) => {
+    await handleFileChange(path, workerPath, port);
+  });
+
+  watcher.on('error', (error) => debug.error(`Watcher error: ${error}`));
 }
 
 export default startServer;

package/lib/env/vulcan.env.js

@@ -4,17 +4,23 @@ import fs from 'fs/promises';
 import path from 'path';
 
 /**
- * Create or update the Vulcan environment file with the specified name and value.
- * @param {string} name - The name of the variable.
- * @param {string} value - The value of the variable.
+ * Creates or updates Vulcan environment variables, either at the global or project level.
+ * @async
+ * @param {object} variables - An object containing the environment variables to set.
+ * @param {string} [scope='local'] - Determines the scope of the variable ('global' or 'local').
+ * @throws {Error} Throws an error if the environment file cannot be read or written.
+ * @example
+ * // Set multiple global environment variables
+ * createVulcanEnv({ API_KEY: 'abc123', ANOTHER_KEY: 'xyz' }, 'global')
+ *   .catch(error => console.error(error));
  */
-async function createVulcanEnv(name, value) {
-  const azionDirPath = path.join(process.env.HOME, '.azion');
-  const vulcanEnvPath = path.join(azionDirPath, 'vulcan.env');
+async function createVulcanEnv(variables, scope = 'global') {
+  const basePath = scope === 'global' ? path.join(process.env.HOME, '.azion') : path.join(process.cwd());
+  const vulcanEnvPath = path.join(basePath, 'vulcan.env');
 
   // Create the .azion folder if it doesn't exist
   try {
-    await fs.mkdir(azionDirPath, { recursive: true });
+    await fs.mkdir(basePath, { recursive: true });
   } catch (error) {
     debug.error(error);
     feedback.error(Messages.errors.folder_creation_failed(vulcanEnvPath));
@@ -26,7 +32,6 @@ async function createVulcanEnv(name, value) {
   try {
     envData = await fs.readFile(vulcanEnvPath, 'utf8');
   } catch (error) {
-    // Ignore error if the file doesn't exist
     if (error.code !== 'ENOENT') {
       debug.error(error);
       feedback.error(Messages.errors.file_doesnt_exist(vulcanEnvPath));
@@ -34,15 +39,17 @@ async function createVulcanEnv(name, value) {
     }
   }
 
-  // Update or add the variable to the environment data
-  const variableLine = `${name}=${value}`;
-  const variableRegex = new RegExp(`${name}=.+`);
+  // Update or add each variable to the environment data
+  Object.entries(variables).forEach(([key, value]) => {
+    const variableLine = `${key}=${value}`;
+    const variableRegex = new RegExp(`${key}=.+`);
 
-  if (envData.match(variableRegex)) {
-    envData = envData.replace(variableRegex, variableLine);
-  } else {
-    envData += `${variableLine}\n`;
-  }
+    if (envData.match(variableRegex)) {
+      envData = envData.replace(variableRegex, variableLine);
+    } else {
+      envData += `${variableLine}\n`;
+    }
+  });
 
   // Write the updated environment data to the file
   try {
@@ -55,12 +62,27 @@ async function createVulcanEnv(name, value) {
 }
 
 /**
- * Reads the vulcan.env file and returns an object with the variables and their values.
- * @returns {object|null} An object with the variables and their values,
- * or null if the file doesn't exist.
+ * Reads the vulcan.env file, either at the global or project level,
+ * and returns an object with the variables and their values.
+ * @param {string} [scope='local'] - Determines the scope of the environment
+ * file ('global' or 'local').
+ * @returns {Promise<object|null>} A promise that resolves to an object with
+ * the variables and their values, or null if the file doesn't exist.
+ * @throws {Error} Throws an error if the environment file cannot be read.
+ * @example
+ * // Read global environment variables
+ * readVulcanEnv('global')
+ *   .then(env => console.log(env))
+ *   .catch(error => console.error(error));
+ *
+ * // Read project-level environment variables
+ * readVulcanEnv('local')
+ *   .then(env => console.log(env))
+ *   .catch(error => console.error(error));
  */
-async function readVulcanEnv() {
-  const vulcanEnvPath = path.join(process.env.HOME, '.azion', 'vulcan.env');
+async function readVulcanEnv(scope = 'global') {
+  const basePath = scope === 'global' ? path.join(process.env.HOME, '.azion') : path.join(process.cwd());
+  const vulcanEnvPath = path.join(basePath, 'vulcan.env');
 
   try {
     // Check if the vulcan.env file exists