edge-functions 1.0.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
@@ -120,51 +338,17 @@ 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/woker.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('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);
       });
 
@@ -176,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([
           {
@@ -201,49 +385,6 @@ function startVulcanProgram() {
       });
   }
 
-  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',
-    )
-    .action(async ({
-      preset, mode, entry, versionId,
-    }) => {
-      // TODO: generate versionID in dispatcher (currently generated for webpackconfig)
-      const BuildDispatcher = (await import('#build')).default;
-      const buildDispatcher = new BuildDispatcher(
-        preset,
-        mode,
-        entry,
-        versionId,
-      );
-      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);
 }
 
@@ -251,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/notations/namespaces.js

@@ -28,3 +28,8 @@
  * @namespace edge
  * @description Contains imported and computer-ready functions for use on the edge.
  */
+
+/**
+ * @namespace polyfills
+ * @description Contains polyfills that are used in the local environment and in build.
+ */

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

@@ -45,7 +45,7 @@ async function auth(loginOption, credentials) {
       }
       if (responseJSON.token) {
         await vulcan.createVulcanEnv('API_TOKEN', responseJSON.token);
-        feedback.success(Messages.platform.auth.success.api_auth_success);
+        feedback.success(Messages.platform.auth.success.auth_success);
       }
     }
     if (loginOption === 'token') {

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

@@ -1,6 +1,8 @@
 import { AzionEdges, Messages } from '#constants';
-import { feedback, debug } from '#utils';
-import open from 'open';
+import { feedback, debug, exec } from '#utils';
+
+const isWindows = process.platform === 'win32';
+
 /**
  * @function
  * @memberof platform
@@ -38,13 +40,14 @@ function watchPropagation(domain) {
         clearInterval(intervalId);
 
         let remainingEdgeIndex = currentEdgeIndex + 1;
-        const remainingEdgesIntervalId = setInterval(() => {
+        const remainingEdgesIntervalId = setInterval(async () => {
           if (remainingEdgeIndex >= AzionEdges.length) {
             clearInterval(remainingEdgesIntervalId);
             f.interactive.complete(
               Messages.platform.propagation.success.propagation_complete,
             );
-            open(`https://${domain}`);
+            await exec(`${isWindows ? 'start ' : 'open '} https://${domain} `);
+
             process.exit(0);
           } else {
             const remainingEdge = AzionEdges[remainingEdgeIndex];
@@ -72,4 +75,4 @@ function watchPropagation(domain) {
 }
 
 // eslint-disable-next-line import/prefer-default-export
-export { watchPropagation };
+export { watchPropagation };

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

@@ -43,7 +43,7 @@ async function uploadStatics(versionId, basePath, currentPath = '') {
     if (fileStat.isFile()) {
       const fileContent = await promisify(fs.readFile)(fullFilePath, 'utf8');
       const mimeType = mime.lookup(fullFilePath);
-      const staticPath = path.join(currentPath, filePath);
+      const staticPath = path.join(currentPath, filePath).replace(/\\/g, '/');
 
       try {
         const response = await StorageService.upload(versionId, fileContent, staticPath, mimeType);

package/lib/platform/actions/function/showFunctionLogs.actions.js

@@ -5,36 +5,19 @@ import eventsService from '../../services/events.service.js';
 /**
  *
  * @param {object} log - View logs organized in a box.
- * @param {boolean} [watch=false] - Whether to observe logs in real time.
  */
-function displayLogInBox(log, watch = false) {
-  const functionIdLabel = 'Function ID:';
-  const dateLabel = 'Date:';
-  const eventIdLabel = 'Event ID:';
-  const functionIdLine = `${functionIdLabel} ${log.functionId}`;
-  const dateLine = `${dateLabel} ${log.date}`;
-  const eventIdLine = `${eventIdLabel} ${log.eventId}`;
-  const maxLength = Math.max(
-    functionIdLine.length,
-    dateLine.length,
-    eventIdLine.length,
-    ...log.logs.map((line) => line.length),
-  );
-  const horizontalLine = '═'.repeat(maxLength + 2);
-
-  console.log(`╔${horizontalLine}╗`);
-  console.log(`║ ${functionIdLine.padEnd(maxLength)} ║`);
-  console.log(`║ ${eventIdLine.padEnd(maxLength)} ║`);
-  console.log(`║ ${dateLine.padEnd(maxLength)} ║`);
-  console.log(`╠${horizontalLine}╣`);
-  log.logs.forEach((line) => {
-    console.log(`║ ${line.padEnd(maxLength)} ║`);
+function displayLogInBox(log) {
+  log.logLines.forEach((line) => {
+    try {
+      const trimmedLine = line.trim();
+      const parsedJSON = JSON.parse(trimmedLine);
+      const formattedJSON = JSON.stringify(parsedJSON, null, 2);
+      feedback.logs(log.functionId, log.eventId, log.date.toLocaleString()).debug(`\n${formattedJSON}`);
+    } catch (error) {
+      console.log(error);
+      feedback.logs(`Function ID: ${log.functionId}`, log.eventId, log.date.toLocaleString()).debug(`\n${line}`);
+    }
   });
-  console.log(`╚${horizontalLine}╝`);
-
-  if (watch) {
-    console.log(Messages.platform.logs.info.watch_true);
-  }
 }
 
 /**
@@ -60,90 +43,86 @@ function displayLogInBox(log, watch = false) {
  * showFunctionLogs();
  */
 async function showFunctionLogs(functionId, watch = false) {
-  let previousConsoleLogId = null;
+  let watchStartTime = new Date();
+  let logsToDisplay = {};
 
   /**
    * Mounts the structure for a console log.
    * @param {object} azionLog - The Azion log event.
-   * @param {string} azionLog.id - The ID of the  event.
+   * @param {string} azionLog.id - The ID of the event.
    * @param {string} azionLog.ts - The timestamp of the event.
    * @returns {object} - The log event structure.
    * @property {string} eventId - The ID of the event.
-   * @property {string} date - The formatted date of the event.
-   * @property {string[]} logs - The array of log messages.
+   * @property {string} functionId - The ID of the function.
+   * @property {Date} date - The date object of the event.
+   * @property {string[]} logLines - The array of log lines.
    */
-  const mountEventLogStructure = (azionLog) => ({
-    eventId: azionLog.id,
-    functionId: azionLog.functionId,
-    date: new Date(azionLog.ts).toLocaleString(),
-    logs: [],
-  });
+  function mountEventLogStructure(azionLog) {
+    return {
+      eventId: azionLog.id,
+      functionId: azionLog.functionId,
+      date: new Date(azionLog.ts),
+      logLines: [],
+    };
+  }
 
-  /**
-   * Internal function for performing polling and retrieving function logs.
-   * @returns {void}
-   */
-  const startPoll = async () => {
-    try {
+  try {
+    const getLogs = async () => {
       const response = await eventsService.getFunctionsLogs(functionId);
-      const responseJSON = await response.json();
-      const { cellsConsoleEvents } = responseJSON.data;
-      const requestSuccess = !!cellsConsoleEvents;
 
-      if (!requestSuccess) {
-        throw new Error(JSON.stringify(responseJSON));
-      }
-      if (requestSuccess) {
-        const nextConsoleLog = cellsConsoleEvents.length > 0 ? cellsConsoleEvents[0] : null;
+      if (response.status === 200) {
+        const responseJSON = await response.json();
+
+        const { cellsConsoleEvents } = responseJSON.data;
+        const requestSuccess = !!cellsConsoleEvents;
 
-        if (!nextConsoleLog) {
-          feedback.info(Messages.platform.logs.info.no_logs);
+        if (!requestSuccess) {
+          throw new Error(JSON.stringify(responseJSON));
         }
-        if (nextConsoleLog) {
-          if (nextConsoleLog?.id !== previousConsoleLogId) {
-            if (watch) {
-              const event = mountEventLogStructure(nextConsoleLog);
-              // eslint-disable-next-line max-len
-              const logsGroupedByRequest = cellsConsoleEvents.filter((item) => item.id === nextConsoleLog.id);
-              logsGroupedByRequest.forEach((log) => {
-                event.logs.push(log.line);
-              });
-              displayLogInBox(event, watch);
-              previousConsoleLogId = nextConsoleLog.id;
-            }
-
-            if (!watch) {
-              const logsGroupedByRequest = Object.values(cellsConsoleEvents
-                .reduce((result, event) => {
-                  const { id, line } = event;
-
-                  if (!result[id]) {
-                  // eslint-disable-next-line no-param-reassign
-                    result[id] = mountEventLogStructure(event);
-                  }
-
-                  result[id].logs.push(line);
-
-                  return result;
-                }, {}));
-
-              logsGroupedByRequest.forEach((log) => {
-                displayLogInBox(log, watch);
-              });
-            }
+
+        if (watch) {
+          if (watch) {
+            feedback.watch(Messages.platform.logs.info.watch_true);
           }
+          logsToDisplay = {}; // Clear logsToDisplay on each poll when in watch mode
         }
+
+        cellsConsoleEvents.forEach((event) => {
+          const { id, line, ts } = event;
+          const eventDate = new Date(ts);
+
+          if (watch && eventDate < watchStartTime) {
+            return; // Skip logs that are older than watchStartTime
+          }
+
+          if (!logsToDisplay[id]) {
+            logsToDisplay[id] = mountEventLogStructure(event);
+          }
+
+          logsToDisplay[id].logLines.push(line);
+          logsToDisplay[id].date = eventDate;
+        });
+
+        Object.values(logsToDisplay).forEach((log) => {
+          displayLogInBox(log, watch);
+        });
+
+        watchStartTime = new Date();
       }
 
       if (watch) {
-        setTimeout(startPoll, 500);
+        setTimeout(getLogs, 3000);
       }
-    } catch (error) {
-      debug.error(error);
-    }
-  };
+    };
 
-  startPoll();
+    getLogs();
+  } catch (error) {
+    debug.error(error);
+  }
 }
 
+process.on('exit', () => {
+  feedback.interactive.breakInteractiveChain();
+});
+
 export default showFunctionLogs;

package/lib/platform/edgehooks/debugRequest/debugRequest.hooks.js

@@ -0,0 +1,28 @@
+/**
+ * @function
+ * @name DebugRequest
+ * @memberof edge
+ * @description
+ * The `DebugRequest` function is used to debug and display the details of an incoming request.
+ * It takes the request as a parameter and logs the request URL, method, and headers to the console.
+ * @param {FetchEvent} event - The incoming FetchEvent object.
+ * @returns {Promise<void>} A promise that resolves once the request details are logged.
+ */
+async function DebugRequest(event) {
+  const { request } = event;
+  const headers = new Headers(request.headers);
+
+  const requestData = {
+    url: request.url,
+    method: request.method,
+    headers: {},
+  };
+
+  headers.forEach((value, name) => {
+    requestData.headers[name] = value;
+  });
+
+  return event.console.log(requestData);
+}
+
+export default DebugRequest;

package/lib/platform/edgehooks/debugRequest/index.js

@@ -0,0 +1,3 @@
+import debugRequest from './debugRequest.hooks.js';
+
+export default debugRequest;