edge-functions 1.0.0

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

@@ -0,0 +1,84 @@
+import fs from 'fs';
+import path from 'path';
+import mime from 'mime-types';
+import { promisify } from 'util';
+import { feedback, debug } from '#utils';
+import { Messages } from '#constants';
+import StorageService from '../../services/storage.service.js';
+
+/**
+ * @function
+ * @memberof platform
+ * @name uploadStatics
+ * @description Uploads files to the storage. This function recursively navigates
+ * through the directory structure from the specified base path and uploads all the files
+ * it encounters. It counts the successful uploads and provides feedback on each file upload status.
+ * @param {string} versionId - The ID of the version to which the files are to be uploaded.
+ * @param {string} basePath - The base path from where files to upload are located.
+ * @param {string} [currentPath] - The current path being processed, used for recursive calls.
+ * Defaults to an empty string.
+ * @returns {Promise<number>} A promise that resolves with the total number of files
+ *  uploaded successfully.
+ * @throws Will throw an error if there's a problem reading files or directories,
+ * or uploading a file.
+ * @example
+ * try {
+ *    const totalUploaded = await uploadStatics('version123', './path/to/files');
+ *    console.log(`Total files uploaded: ${totalUploaded}`);
+ * } catch (error) {
+ *    console.error(error);
+ * }
+ */
+async function uploadStatics(versionId, basePath, currentPath = '') {
+  let successUploadCount = 0;
+  /**
+   * Uploads files recursively to the storage.
+   * @param {string} filePath - The file path.
+   * @returns {Promise<void>} A Promise that resolves when the file is uploaded.
+   */
+  async function uploadFiles(filePath) {
+    const fullFilePath = path.join(basePath, filePath);
+    const fileStat = await promisify(fs.stat)(fullFilePath);
+
+    if (fileStat.isFile()) {
+      const fileContent = await promisify(fs.readFile)(fullFilePath, 'utf8');
+      const mimeType = mime.lookup(fullFilePath);
+      const staticPath = path.join(currentPath, filePath);
+
+      try {
+        const response = await StorageService.upload(versionId, fileContent, staticPath, mimeType);
+        if (response.statusText === 'OK') {
+          successUploadCount += 1;
+          feedback.statics.success(
+            Messages.platform.storage.success.file_uploaded_success(filePath),
+          );
+        }
+        if (!response.status === 'OK') { throw new Error(response); }
+      } catch (error) {
+        feedback.statics.error(Messages.platform.storage.errors.file_upload_failed(filePath));
+        debug.error(error);
+      }
+    } else if (fileStat.isDirectory()) {
+      const subDirPath = path.join(currentPath, filePath);
+      const subDirFiles = await promisify(fs.readdir)(path.join(basePath, subDirPath));
+
+      await Promise.all(subDirFiles.map((file) => uploadFiles(path.join(subDirPath, file))));
+    }
+  }
+
+  try {
+    const files = await promisify(fs.readdir)(path.join(basePath, currentPath));
+    await Promise.all(files.map((file) => uploadFiles(file)));
+  } catch (error) {
+    debug.error(error);
+    throw error;
+  }
+
+  feedback.statics.success(
+    Messages.platform.storage.success.statics_uploaded_finish(successUploadCount),
+  );
+  return successUploadCount;
+}
+
+// eslint-disable-next-line import/prefer-default-export
+export { uploadStatics };

package/lib/platform/actions/domain/createDomain.actions.js

@@ -0,0 +1,42 @@
+import { debug } from '#utils';
+import DomainService from '../../services/domain.service.js';
+
+/**
+ * @function
+ * @memberof platform
+ * @name createDomain
+ * @description Creates a new domain for a specific application. This operation requires
+ * both the name for the new domain and the ID of the application to which it will be linked.
+ * @param {string} domainName - The name of the domain to be created.
+ * @param {number} applicationId - The ID of the application to which the new domain will be linked.
+ * @returns {Promise<object>} A promise that resolves with the created domain's details.
+ * The object returned contains details such as the ID, name, associated
+ * edge application ID, and other properties.
+ * @throws Will throw an error if the domain creation fails.
+ * @example
+ * try {
+ *    const domainDetails = await createDomain('example.com', 1234);
+ *    console.log(`Domain created with ID: ${domainDetails.id}`);
+ * } catch (error) {
+ *    console.error('Failed to create domain:', error);
+ * }
+ */
+async function createDomain(domainName, applicationId) {
+  try {
+    const payload = {
+      name: domainName,
+      cname_access_only: false,
+      digital_certificate_id: null,
+      edge_application_id: applicationId,
+      is_active: true,
+    };
+
+    const response = await (await DomainService.create(payload)).json();
+    return response.results;
+  } catch (error) {
+    debug.error(error);
+    throw error;
+  }
+}
+
+export default createDomain;

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

@@ -0,0 +1,79 @@
+import fs from 'fs';
+import path from 'path';
+import { debug } from '#utils';
+import FunctionService from '../../services/function.service.js';
+
+/**
+ * Get the initiator type based on the code signature.
+ * @param {string} code - The code for the function.
+ * @returns {string} The initiator type.
+ */
+function getInitiatorType(code) {
+  const fetchSignature = 'addEventListener(\'fetch\'';
+  const firewallSignature = 'addEventListener(\'firewall\'';
+
+  if (code.includes(fetchSignature)) {
+    return 'edge_application';
+  } if (code.includes(firewallSignature)) {
+    return 'edge_firewall';
+  }
+  return 'edge_application';
+}
+
+/**
+ * @function
+ * @memberof platform
+ * @name createFunction
+ * @description Creates a new function (worker) for the edge application.
+ * It reads the function code and arguments from the respective '.edge/worker.js'
+ * and '.edge/args.json' files, and infers the initiator type based on the function's code.
+ * @param {string} [functionName] - Optional. The name of the function to be created.
+ * If not provided, the name is determined from the function's code.
+ * @returns {Promise<object>} A promise that resolves with the details of the created
+ * function. The object returned contains details such as the function ID, name, code,
+ * language, initiator type, arguments, and activation status.
+ * @throws {Error} If the function creation fails, possibly due to invalid code or
+ * function arguments, or due to a problem with the FunctionService.
+ * @example
+ * try {
+ *    const functionDetails = await createFunction('myFunction');
+ *    console.log(`Function created with ID: ${functionDetails.id}`);
+ * } catch (error) {
+ *    console.error('Failed to create function:', error);
+ * }
+ */
+async function createFunction(functionName) {
+  try {
+    // get code
+    const workerFilePath = path.join(process.cwd(), '.edge/worker.js');
+    const code = fs.readFileSync(workerFilePath, 'utf8');
+
+    // get json_args
+    const argsFilePath = path.join(process.cwd(), '.edge/args.json');
+    let jsonArgs = {};
+    if (fs.existsSync(argsFilePath)) {
+      const argsData = fs.readFileSync(argsFilePath, 'utf8');
+      jsonArgs = JSON.parse(argsData);
+    }
+
+    // get initiator_type
+    const initiatorType = getInitiatorType(code);
+
+    const payload = {
+      name: functionName,
+      code,
+      language: 'javascript',
+      initiator_type: initiatorType,
+      json_args: jsonArgs,
+      active: true,
+    };
+
+    const response = await (await FunctionService.create(payload)).json();
+    return response.results;
+  } catch (error) {
+    debug.error(error);
+    throw error;
+  }
+}
+
+export default createFunction;

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

@@ -0,0 +1,149 @@
+import { feedback, debug } from '#utils';
+import { Messages } from '#constants';
+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)} ║`);
+  });
+  console.log(`╚${horizontalLine}╝`);
+
+  if (watch) {
+    console.log(Messages.platform.logs.info.watch_true);
+  }
+}
+
+/**
+ * @function
+ * @memberof platform
+ * @name showFunctionLogs
+ * @description This function retrieves and displays the logs of a specific function
+ * or all functions from the edge application. If the watch parameter is set to true,
+ * it continuously polls and updates the function logs in real time.
+ * @param {string} [functionId] - Optional. The ID of the function for which to retrieve the logs.
+ *  If not provided, the logs from all functions are retrieved.
+ * @param {boolean} [watch=false] - Optional. If set to true, the function logs are observed
+ *  and updated in real time. Default is false.
+ * @returns {void} This function does not return anything. It retrieves and logs the function
+ * logs to the console.
+ * @throws {Error} If an error occurs while retrieving the logs, it is caught
+ * and logged to the console.
+ * @example
+ * // To observe logs for a specific function in real time:
+ * showFunctionLogs('myFunctionId', true);
+ *
+ * // To get logs from all functions:
+ * showFunctionLogs();
+ */
+async function showFunctionLogs(functionId, watch = false) {
+  let previousConsoleLogId = null;
+
+  /**
+   * 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.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.
+   */
+  const mountEventLogStructure = (azionLog) => ({
+    eventId: azionLog.id,
+    functionId: azionLog.functionId,
+    date: new Date(azionLog.ts).toLocaleString(),
+    logs: [],
+  });
+
+  /**
+   * Internal function for performing polling and retrieving function logs.
+   * @returns {void}
+   */
+  const startPoll = async () => {
+    try {
+      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 (!nextConsoleLog) {
+          feedback.info(Messages.platform.logs.info.no_logs);
+        }
+        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) {
+        setTimeout(startPoll, 500);
+      }
+    } catch (error) {
+      debug.error(error);
+    }
+  };
+
+  startPoll();
+}
+
+export default showFunctionLogs;

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

@@ -0,0 +1,101 @@
+/**
+ * @function formatLog
+ * @description Formats the request and error information for logging.
+ * @param {Error} error - The error object.
+ * @returns {string} The formatted log string.
+ */
+function formatLog(error) {
+  let formattedLog = '';
+
+  if (error) {
+    const formattedError = error instanceof Error ? error.stack : error;
+    formattedLog += `<b>Error:</b>\n${formattedError}`;
+  }
+
+  return formattedLog;
+}
+
+/**
+ * @function createErrorHTML
+ * @description Creates the HTML content for the custom error page.
+ * @param {number} errorCode - The error code.
+ * @param {string} errorDescription - The error description.
+ * @param {Error} [error] - Optional. The debug object containing error object.
+ * @returns {string} The HTML content.
+ */
+function createErrorHTML(errorCode, errorDescription, error) {
+  const formattedLog = formatLog(error);
+
+  return `<!DOCTYPE html>
+      <html lang="en">
+      <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Error ${errorCode} - ${errorDescription}</title>
+        <style>
+          body {
+            background-color: black;
+            color: rgb(255, 108, 55);
+            font-family: Arial, sans-serif;
+            text-align: center;
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+            height: 100vh;
+            margin: 0;
+          }
+          h1 {
+            font-size: 36px;
+            margin-bottom: 10px;
+            animation: levitate 2s ease-in-out infinite alternate;
+          }
+          p {
+            font-size: 18px;
+            margin-bottom: 5px;
+          }
+          a {
+            color: rgb(255, 108, 55);
+            text-decoration: none;
+          }
+      
+          @keyframes levitate {
+            0% {
+              transform: translateY(0);
+            }
+            50% {
+              transform: translateY(-10px);
+            }
+            100% {
+              transform: translateY(0);
+            }
+          }
+        </style>
+      </head>
+      <body>
+        <h1>Error ${errorCode}</h1>
+        <p>${errorDescription || ''}</p>
+        <pre>${formattedLog}</pre>
+      </body>
+      </html>`;
+}
+
+/**
+ * @function
+ * @memberof edge
+ * @name ErrorHTML
+ * @description Handles an error by logging the request and error
+ * information and returning a custom HTML response.
+ * @param {number} code - The error code.
+ * @param {string} description - The error description.
+ * @param {Error} [error] - Optional. The error object for debugging.
+ *  If provided, the error will be displayed on the error page.
+ * @returns {Response} The custom HTML response.
+ */
+function ErrorHTML(code, description, error) {
+  const errorHTML = createErrorHTML(code, description, error);
+  const headers = { 'Content-Type': 'text/html' };
+  return new Response(errorHTML, { status: code, headers });
+}
+
+export default ErrorHTML;

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

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

package/lib/platform/edgehooks/index.js

@@ -0,0 +1,5 @@
+import mountSPA from './mountSPA/mountSPA.hooks.js';
+import mountSSG from './mountSSG/mountSSG.hooks.js';
+import ErrorHTML from './ErrorHTML/ErrorHTML.hooks.js';
+
+export { mountSPA, mountSSG, ErrorHTML };

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

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

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

@@ -0,0 +1,55 @@
+/**
+ * @memberof edge
+ * @function
+ * @name mountSPA
+ * @description
+ * The `mountSPA` function is designed to process requests to a Single Page Application (SPA)
+ * that's being computed at the edge of a Content Delivery Network (CDN).
+ *
+ * This function determines if the incoming request is for a static
+ * asset or a route within the application,
+ * and mounts the appropriate request URL for fetching the required resource from the origin server.
+ * @param {string} requestURL - The original URL from the incoming request.
+ * @param {string} versionId - The version ID representing the build/assets stored.
+ * @returns {Promise<Response>} A promise that resolves to the response from the fetched resource.
+ * @example
+ * // Handle a request for a homepage
+ * // Input: mountSSG('https://example.com/', 'v1');
+ * // Output: fetch('file:///v1/index.html');
+ * @example
+ * // Handle a request for an asset (CSS file)
+ * // Input: mountSSG('https://example.com/styles/main.css', 'v1');
+ * // Output: fetch('file:///v1/styles/main.css');
+ * @example
+ * // Handle a request for a specific route
+ * // Input: mountSSG('https://example.com/about', 'v1');
+ * // Output: fetch('file:///v1/index.html');
+ */
+export default function mountSPA(requestURL, versionId) {
+  /**
+   * The path extracted from the request URL.
+   * @type {string}
+   */
+  const requestPath = new URL(requestURL).pathname;
+
+  let assetPath;
+
+  /**
+   * Regular expression to match the file extension at the end of a string.
+   * Used to determine if the requestPath is an asset or a route.
+   * @type {RegExp}
+   */
+  const fileExtensionRegex = /\.[^.]+$/;
+
+  if (fileExtensionRegex.test(requestPath)) {
+    // If the requestPath has a file extension, it is considered an asset.
+    // Concatenate the versionId and requestPath to form the complete asset URL.
+    assetPath = new URL(`/${versionId}${requestPath}`, 'file://');
+  } else {
+    // If the requestPath does not have a file extension, it is treated as a route.
+    // Append the versionId and the route "index.html" to form the complete asset URL.
+    assetPath = new URL(`/${versionId}/index.html`, 'file://');
+  }
+
+  return fetch(assetPath);
+}

package/lib/platform/edgehooks/mountSPA/mountSPA.hooks.test.js

@@ -0,0 +1,19 @@
+import assert from 'assert';
+import { feedback } from '#utils';
+import mountSPA from './index.js';
+
+/**
+ * Test the mountSPA function.
+ */
+function testmountSPA() {
+  const requestURL = 'https://example.com/path/to/resource';
+  const versionId = 'v1';
+  const expectedAssetUrl = 'file:///v1/path/to/resource';
+
+  const assetUrl = mountSPA(requestURL, versionId);
+
+  assert.strictEqual(assetUrl.href, expectedAssetUrl);
+  feedback.success('mountSPA test passed!');
+}
+
+testmountSPA();

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

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

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

@@ -0,0 +1,61 @@
+/**
+ * @memberof edge
+ * @function mountSSG
+ * @name mountSSG
+ *@description
+ * The `mountSSG` function is designed to handle requests for Static Site Generation (SSG)
+ * at the edge, that is, directly within a serverless worker.
+ * It processes the incoming request URL and an associated version ID. The function constructs
+ * the appropriate asset path based on these parameters, and fetches the corresponding
+ * response from the SSG.
+ * @param {string} requestURL - The original URL from the event request.
+ * @param {string} versionId - The version ID representing the build/assets stored.
+ * @returns {Promise<Response>} A promise that resolves to the response from the SSG.
+ * @example
+ * // Handle a request for a homepage
+ * // Input: mountSSG('https://example.com/', 'v1');
+ * // Output: fetch('file:///v1/index.html');
+ * @example
+ * // Handle a request for an asset (CSS file)
+ * // Input: mountSSG('https://example.com/styles/main.css', 'v1');
+ * // Output: fetch('file:///v1/styles/main.css');
+ * @example
+ * // Handle a request for a specific route
+ * // Input: mountSSG('https://example.com/about', 'v1');
+ * // Output: fetch('file:///v1/about/index.html');
+ */
+export default function mountSSG(requestURL, versionId) {
+  /**
+   * The path extracted from the request URL.
+   * @type {string}
+   */
+  const requestPath = new URL(requestURL).pathname;
+
+  // Check if the requestPath has a trailing slash and remove the trailing slash if it exists
+  const hasTrailingSlash = requestPath.endsWith('/');
+  const cleanRequestPath = hasTrailingSlash ? requestPath.slice(0, -1) : requestPath;
+
+  /**
+   * Regular expression to match the file extension at the end of a string.
+   * Used to determine if the requestPath is an asset or a route.
+   * @type {RegExp}
+   */
+  const fileExtensionRegex = /\.[^.]+$/;
+
+  let assetPath;
+
+  if (cleanRequestPath === '/') {
+    // If the requestPath is the root path, append the versionId and 'index.html' to the assetPath.
+    assetPath = new URL(`/${versionId}/index.html`, 'file://');
+  } else if (fileExtensionRegex.test(cleanRequestPath)) {
+    // If the requestPath has a file extension, it is considered an asset.
+    // Concatenate the versionId and requestPath to form the complete asset URL.
+    assetPath = new URL(`/${versionId}${cleanRequestPath}`, 'file://');
+  } else {
+    // If the requestPath is a route without a file extension,
+    // Append the versionId and requestPath to the assetPath.
+    assetPath = new URL(`/${versionId}${cleanRequestPath}/index.html`, 'file://');
+  }
+
+  return fetch(assetPath);
+}

package/lib/platform/index.js

@@ -0,0 +1,65 @@
+// core
+import auth from './actions/core/auth.actions.js';
+import deploy from './actions/core/deploy.actions.js';
+import { uploadStatics } from './actions/core/storage.actions.js';
+import { watchPropagation } from './actions/core/propagation.actions.js';
+// domain
+import createDomain from './actions/domain/createDomain.actions.js';
+
+// application
+import createApplication from './actions/application/createApplication.actions.js';
+import enableEdgeFunctions from './actions/application/enableEdgeFunctions.actions.js';
+import instantiateFunction from './actions/application/instantiateFunction.actions.js';
+import setFunctionAsDefaultRule from './actions/application/setFunctionAsDefaultRule.actions.js';
+
+// function
+import showFunctionLogs from './actions/function/showFunctionLogs.actions.js';
+
+/**
+ * Object containing core-related actions.
+ * @typedef {object} CoreObject
+ * @property {object} actions - Object containing Azion core actions.
+ * @property {auth} actions.auth - Action for Azion authentication.
+ * @property {uploadStatics} actions.uploadStatics - Action for uploading static files.
+ * @property {deploy} actions.deploy - Action for deploying application.
+ * @property {watchPropagation} actions.watchPropagation - Action for watch Edge Propagation.
+ */
+const core = {
+  actions: {
+    auth, deploy, uploadStatics, watchPropagation,
+  },
+};
+
+const applications = {
+  actions: {
+    createApplication,
+    enableEdgeFunctions,
+    instantiateFunction,
+    showFunctionLogs,
+    setFunctionAsDefaultRule,
+  },
+};
+
+/**
+ * Object containing domain-related actions.
+ * @typedef {object} DomainsObject
+ * @property {object} actions - Object containing Azion domain actions.
+ * @property {createDomain} actions.createDomain - Action to create a domain.
+ */
+const domains = {
+  actions: { createDomain },
+};
+
+/**
+ * Object containing function-related actions.
+ * @typedef {object} FunctionsObject
+ * @property {object} actions - Object containing Azion function actions.
+ * @property {showFunctionLogs} actions.showFunctionLogs - Action to perform Azion function logs.
+ */
+const functions = {
+  actions: { showFunctionLogs },
+};
+
+export {
+  core, applications, domains, functions,
+};