edge-functions 2.7.0-stage.1 → 2.7.0

package/CHANGELOG.md

@@ -1,4 +1,4 @@
-## [2.7.0-stage.1](https://github.com/aziontech/vulcan/compare/v2.6.2...v2.7.0-stage.1) (2024-05-02)
+## [2.7.0](https://github.com/aziontech/vulcan/compare/v2.6.2...v2.7.0) (2024-05-07)
 
 
 ### Features
@@ -7,6 +7,20 @@
 * eject azion.config.js file ([#314](https://github.com/aziontech/vulcan/issues/314)) ([5b6494b](https://github.com/aziontech/vulcan/commit/5b6494b19b506b9d7e0ce9a47b41213b681c6167))
 * eject manifest ([ae556fa](https://github.com/aziontech/vulcan/commit/ae556fa3ffdf7b2b97e01e2bf9ae4a766beca8df))
 
+
+### Bug Fixes
+
+* local env loop ([99c3742](https://github.com/aziontech/vulcan/commit/99c37420102d5b49bb029133b6580f165b19f32b))
+* local env loop ([#319](https://github.com/aziontech/vulcan/issues/319)) ([05c4679](https://github.com/aziontech/vulcan/commit/05c4679d8ba6fd1d6d52f9bd44382fd6d1d9df93))
+
+## [2.7.0-stage.2](https://github.com/aziontech/vulcan/compare/v2.7.0-stage.1...v2.7.0-stage.2) (2024-05-07)
+
+
+### Bug Fixes
+
+* local env loop ([99c3742](https://github.com/aziontech/vulcan/commit/99c37420102d5b49bb029133b6580f165b19f32b))
+* local env loop ([#319](https://github.com/aziontech/vulcan/issues/319)) ([05c4679](https://github.com/aziontech/vulcan/commit/05c4679d8ba6fd1d6d52f9bd44382fd6d1d9df93))
+
 ### [2.6.2](https://github.com/aziontech/vulcan/compare/v2.6.1...v2.6.2) (2024-04-22)
 
 

package/README.md

@@ -40,7 +40,7 @@ Table:
 | Simple Js Esm                        | ✅      |
 | Simple Ts Esm                        | ✅      |
 
-Last test run date: 05/02/24 02:51:54 AM
+Last test run date: 05/07/24 02:56:50 AM
 ## Quick Installation
 
 For those who just want to use Vulcan in their project without contributing to the development, you can install it directly from npm.

package/lib/build/dispatcher/dispatcher.js

@@ -123,7 +123,7 @@ class Dispatcher {
    * @returns {object} - Preset files
    */
   async loadPreset() {
-    feedback.build.info('Loading build context...');
+    feedback.build.info('Loading build context ...');
 
     const VALID_BUILD_PRESETS = presets.getKeys();
     const vulcanRootPath = resolve(this.vulcanLibPath, '..');
@@ -343,10 +343,15 @@ class Dispatcher {
   }
 
   static async generateFinalManifest() {
-    feedback.build.info('Checking Azion configuration file...');
+    feedback.build.info(
+      'Checking Azion Edge Application configuration file...',
+    );
     const buildConfigPath = join(process.cwd(), 'azion.config.js');
-    const vulcanCustomConfigModule = (await import(buildConfigPath)).default;
-    await generateManifest(vulcanCustomConfigModule);
+    let vulcanCustomConfigModule = {};
+    if (existsSync(buildConfigPath)) {
+      vulcanCustomConfigModule = (await import(buildConfigPath)).default;
+    }
+    await generateManifest(vulcanCustomConfigModule, true);
     feedback.build.success('Manifest generated successfully.');
   }
 

package/lib/commands/dev.commands.js

@@ -19,11 +19,11 @@ import { Commands } from '#namespaces';
  *
  * devCommand('./path/to/entry.js', { port: 3000 });
  */
-async function devCommand(entry, { port, firewall }) {
+async function devCommand(entry, { firewall, port }) {
   const parsedPort = parseInt(port, 10);
   const { server } = await import('#env');
   const entryPoint = entry || join(process.cwd(), '.edge/worker.js');
-  server(entryPoint, parsedPort, firewall);
+  server(entryPoint, firewall, parsedPort);
 }
 
 export default devCommand;

package/lib/env/server.env.js

@@ -1,3 +1,4 @@
+import net from 'net';
 import { debug, readWorkerFile, feedback, helperHandlerCode } from '#utils';
 import { Messages } from '#constants';
 import { runServer, EdgeRuntime } from 'edge-runtime';
@@ -9,6 +10,39 @@ import buildCommand from '../commands/build.commands.js';
 let currentServer;
 let isChangeHandlerRunning = false;
 
+/**
+ * Checks if a port is in use by trying to connect to it.
+ * @param {number} port - The port number to check.
+ * @returns {Promise<boolean>} - True if the port is in use, false otherwise.
+ */
+function checkPortAvailability(port) {
+  return new Promise((resolve) => {
+    const client = new net.Socket();
+    client.setTimeout(1000); // Timeout for the connection attempt
+
+    client.on('connect', () => {
+      client.destroy(); // Destroy the socket after successful connection
+      resolve(true); // Port is in use
+    });
+
+    client.on('timeout', () => {
+      client.destroy();
+      resolve(false); // Timeout likely means the port is not in use
+    });
+
+    client.on('error', (err) => {
+      client.destroy();
+      if (err.code === 'ECONNREFUSED') {
+        resolve(false); // Connection refused means the port is not in use
+      } else {
+        resolve(true); // Assume port is in use if there's an error
+      }
+    });
+
+    client.connect(port, '127.0.0.1');
+  });
+}
+
 /**
  * Read the worker code from a specified path.
  * @param {string} workerPath - Path to the worker file.
@@ -74,14 +108,14 @@ async function buildToLocalServer(isFirewall) {
  */
 async function manageServer(workerPath, port, isFirewall) {
   try {
-    await buildToLocalServer(isFirewall);
-
-    const workerCode = await readWorkerCode(workerPath);
-
     if (currentServer) {
       await currentServer.close();
     }
 
+    await buildToLocalServer(isFirewall);
+
+    const workerCode = await readWorkerCode(workerPath);
+
     try {
       currentServer = await initializeServer(port, workerCode);
       feedback.server.success(
@@ -139,10 +173,17 @@ async function handleFileChange(path, workerPath, port, isFirewall) {
 /**
  * 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.
  * @param {boolean} isFirewall - (Experimental) Enable isFirewall for local environment.
+ * @param {number} port - The port number.
  */
-async function startServer(workerPath, port, isFirewall) {
+async function startServer(workerPath, isFirewall, port) {
+  const IsPortInUse = await checkPortAvailability(port);
+  if (IsPortInUse) {
+    feedback.server.error(
+      `Port ${port} is in use. Please choose another port.`,
+    );
+    process.exit(1);
+  }
   await manageServer(workerPath, port, isFirewall); // Initialize the server for the first time
 
   const watcher = chokidar.watch('./', {

package/lib/main.js

@@ -1,6 +1,6 @@
 #! /usr/bin/env node
-import { resolve } from 'path';
-import { readFileSync } from 'fs';
+import { resolve, join } from 'path';
+import { readFileSync, readdirSync, unlinkSync } from 'fs';
 import { Command } from 'commander';
 import { satisfies } from 'semver';
 import { feedback, debug, getAbsoluteLibDirPath } from '#utils';
@@ -57,6 +57,55 @@ function setVulcanEnvironment() {
   }
   globalThis.vulcan = vulcanContext;
 }
+
+/**
+ * Removes all temporary files starting with 'vulcan-' and ending with '.temp.js'.
+ */
+function cleanUpTempFiles() {
+  const directory = process.cwd();
+  const tempFiles = readdirSync(directory).filter(
+    (file) => file.startsWith('vulcan-') && file.endsWith('.temp.js'),
+  );
+
+  tempFiles.forEach((file) => {
+    const filePath = join(directory, file);
+    unlinkSync(filePath);
+  });
+}
+
+/**
+ * Sets up event handlers for cleanup and error handling.
+ */
+function setupVulcanProcessHandlers() {
+  process.on('exit', cleanUpTempFiles);
+  process.on('SIGINT', () => {
+    cleanUpTempFiles();
+    process.exit(0);
+  });
+  process.on('SIGTERM', () => {
+    cleanUpTempFiles();
+    process.exit(0);
+  });
+  process.on('SIGHUP', () => {
+    cleanUpTempFiles();
+    process.exit(0);
+  });
+  process.on('SIGBREAK', () => {
+    cleanUpTempFiles();
+    process.exit(0);
+  });
+  process.on('uncaughtException', (error) => {
+    console.error('Uncaught Exception:', error);
+    cleanUpTempFiles();
+    process.exit(1);
+  });
+  process.on('unhandledRejection', (reason) => {
+    console.error('Unhandled Promise Rejection:', reason);
+    cleanUpTempFiles();
+    process.exit(1);
+  });
+}
+
 /**
  * Starts the command-line interface program.
  * @example
@@ -105,7 +154,7 @@ function startVulcanProgram() {
     .command('dev')
     .description('Start local environment')
     .arguments('[entry]')
-    .option('-p, --port <port>', 'Specify the port', '3000')
+    .option('-p, --port <port>', 'Specify the port', '3333')
     .option(
       '--firewall',
       'To enable the firewall (Experimental) for local environment (default: false)',
@@ -137,6 +186,7 @@ try {
   if (validateNodeMinVersion()) {
     setVulcanEnvironment();
     startVulcanProgram();
+    setupVulcanProcessHandlers();
   }
   if (!validateNodeMinVersion()) {
     feedback.error(Messages.errors.invalid_node_version(MIN_NODE_VERSION));

package/lib/notations/namespaces.js

@@ -5,6 +5,12 @@
  */
 const Utils = {};
 
+/**
+ * @namespace Platform
+ * @description Contains functions and actions to interact with the edge platform (Azion).
+ */
+const Platform = {};
+
 /**
  * @namespace Build
  * @description Represents the structure responsible for pre-build and build processes for the edge.
@@ -42,4 +48,20 @@ const Commands = {};
  */
 const Polyfills = {};
 
-export { Utils, Build, Env, Presets, Edge, Polyfills, Commands };
+/**
+ * @namespace Services
+ * @description Azion Platform Services.
+ */
+const Services = {};
+
+export {
+  Utils,
+  Platform,
+  Build,
+  Env,
+  Presets,
+  Edge,
+  Polyfills,
+  Commands,
+  Services,
+};

package/lib/utils/feedback/feedback.utils.js

@@ -40,9 +40,9 @@ const methods = {
     logLevel: 'info',
   },
   option: {
-    badge: '🌋',
-    color: 'green',
-    label: '',
+    badge: '🟣',
+    color: 'magenta',
+    label: 'option',
     logLevel: 'info',
   },
 };
@@ -106,6 +106,33 @@ const scopes = {
       types: methods,
     }),
   },
+  platform: {
+    ...global.scope('Vulcan', 'Platform'),
+    interactive: getLogger({
+      interactive: true,
+      scope: ['Vulcan', 'Platform'],
+      types: methods,
+    }),
+  },
+  statics: {
+    ...global.scope('Vulcan', 'Storage'),
+    interactive: getLogger({
+      interactive: true,
+      scope: ['Vulcan', 'storage'],
+      types: methods,
+    }),
+  },
+  logs: (scope1, scope2, scope3) => ({
+    ...global.scope('Azion', `${scope1}`, scope2, scope3),
+  }),
+  propagation: {
+    ...global.scope('Azion', 'Edge Network'),
+    interactive: getLogger({
+      interactive: true,
+      scope: ['Vulcan', 'Azion Network'],
+      types: methods,
+    }),
+  },
 };
 
 /**

package/lib/utils/generateManifest/generateManifest.utils.js

@@ -1,10 +1,14 @@
-import { writeFileSync, existsSync, mkdirSync, readFileSync } from 'fs';
+import { existsSync, writeFileSync, readFileSync, mkdirSync, rm } from 'fs';
 import { join } from 'path';
 import Ajv from 'ajv';
 import ajvErrors from 'ajv-errors';
 import addKeywords from 'ajv-keywords';
+import os from 'node:os';
+import lodash from 'lodash';
 
 import azionConfigSchema from './fixtures/schema.js';
+import debug from '../debug/debug.utils.js';
+
 /**
  * Validates the provided configuration against a JSON Schema.
  * This function uses AJV (Another JSON Schema Validator) to validate the configuration.
@@ -249,44 +253,34 @@ function processManifestConfig(config) {
 }
 
 /**
- * Loads the Azion deploy configuration from a local file or a provided module.
- * If a custom configuration file 'azion.config.js' exists in the root directory, it takes precedence and is loaded.
- * If the file does not exist, the function will attempt to use the provided configuration module.
- * If no module is provided, a minimal default configuration is returned.
- * @param {string} configPath - The path to the custom configuration file.
- * @param {object} configModule - An alternative configuration module provided as a fallback.
- * @returns {Promise<object>} A promise that resolves to the loaded configuration object.
+ * Removes the temporary folder used to store the manifest file.
+ * This function is typically called after the manifest is generated and copied to the edge directory.
  */
-async function loadAzionConfig(configPath, configModule) {
-  const existCustomAzionConfig = existsSync(configPath); // user created azion.config.js in root directory
-
-  // the file created has priorty over preset
-  if (existCustomAzionConfig) {
-    return (await import(configPath)).default;
-  }
-  if (!existCustomAzionConfig && configModule) {
-    return configModule;
+function removeTmpFolder() {
+  const manifestPath = globalThis.vulcan.tmpManifestFile;
+  if (manifestPath) {
+    const dirName = manifestPath.substring(0, manifestPath.lastIndexOf('/'));
+    rm(dirName, { recursive: true }, (err) => {
+      if (err) {
+        debug.error(err);
+      }
+    });
   }
-  return {
-    rules: {
-      request: [{}], // minimal configuration
-    },
-  };
+  globalThis.vulcan.tmpManifestFile = null;
 }
 
 /**
- * Determines if the project uses the CommonJS module system by default.
- * It checks the 'type' key in the 'package.json' file at the project root.
- * If 'type' is 'commonjs' or absent, returns true. Otherwise, returns false.
- * @returns {boolean} True if the project uses CommonJS, false if it uses ES Modules.
+ * Create the final manifest file to the edge directory.
  */
-function useCommonJS() {
-  const packageJsonPath = join(process.cwd(), 'package.json');
-  if (existsSync(packageJsonPath)) {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-    return packageJson.type !== 'module'; // Returns true for 'commonjs' or no 'type' specified
+async function generateFinalManifest() {
+  const manifestPath = globalThis.vulcan.tmpManifestFile;
+  const finalManifestPath = join(process.cwd(), '.edge', 'manifest.json');
+  if (existsSync(manifestPath)) {
+    writeFileSync(finalManifestPath, readFileSync(manifestPath));
+    removeTmpFolder();
+  } else {
+    throw new Error('Manifest file not found');
   }
-  return true; // Default to CommonJS if 'package.json' does not exist or 'type' key is absent
 }
 
 /**
@@ -294,31 +288,64 @@ function useCommonJS() {
  * If an existing manifest is found, it merges the configurations, prioritizing the custom module.
  * This function is typically called during the prebuild stage to prepare the CDN configuration.
  * @param {object} configModule - The custom configuration module provided by the user.
+ * @param {boolean} shouldGenerateFinalManifest - A flag indicating whether the final manifest should be generated after the temporary manifest is created.
  * @async
  */
-async function generateManifest(configModule) {
-  const configPath = join(process.cwd(), 'azion.config.js');
-  const dotEdgeDir = join(process.cwd(), '.edge');
-  const finalManifestPath = join(dotEdgeDir, 'manifest.json');
+async function generateManifest(
+  configModule,
+  shouldGenerateFinalManifest = false,
+) {
+  const edgeDirPath = join(process.cwd(), '.edge');
+  const tmpDirPath = join(os.tmpdir(), 'vulcan');
+
+  if (!existsSync(tmpDirPath)) {
+    mkdirSync(tmpDirPath);
+  }
+
+  let manifestPath = globalThis.vulcan.tmpManifestFile;
+  if (!manifestPath) {
+    manifestPath = join(tmpDirPath, `manifest-${new Date().getTime()}.json`);
+    globalThis.vulcan.tmpManifestFile = manifestPath;
+  }
 
-  if (!existsSync(dotEdgeDir)) {
-    mkdirSync(dotEdgeDir);
+  //  preset configuration (existingManifest) have priority over user azion.config.js
+  let existingManifest = {};
+
+  if (!existsSync(edgeDirPath)) {
+    mkdirSync(edgeDirPath);
   }
 
-  const AzionConfig = await loadAzionConfig(configPath, configModule);
-  const manifest = processManifestConfig(AzionConfig);
-
-  if (!existsSync(configPath)) {
-    const moduleExportStyle = useCommonJS()
-      ? 'module.exports ='
-      : 'export default';
-    writeFileSync(
-      configPath,
-      `${moduleExportStyle} ${JSON.stringify(AzionConfig, null, 2)};`,
-    );
+  if (existsSync(manifestPath)) {
+    const existingManifestRaw = readFileSync(manifestPath, 'utf8');
+    existingManifest = JSON.parse(existingManifestRaw);
   }
 
-  writeFileSync(finalManifestPath, JSON.stringify(manifest, null, 2));
+  const newManifestConfig = processManifestConfig(configModule);
+
+  // eslint-disable-next-line
+  function customizer(objValue, srcValue) {
+    if (Array.isArray(objValue)) {
+      return objValue.concat(
+        srcValue.filter(
+          (srcItem) =>
+            !objValue.some((objItem) => objItem?.name === srcItem?.name),
+        ),
+      );
+    }
+  }
+
+  // Merge the new configuration with the existing manifest with priority to the existing manifest
+  const mergeManifest = lodash.mergeWith(
+    existingManifest,
+    newManifestConfig,
+    customizer,
+  );
+
+  writeFileSync(manifestPath, JSON.stringify(mergeManifest, null, 2));
+
+  if (shouldGenerateFinalManifest) {
+    await generateFinalManifest();
+  }
 }
 
 export { processManifestConfig, generateManifest };

package/lib/utils/generateManifest/generateManifest.utils.test.js

@@ -1,7 +1,113 @@
 import { describe, expect } from '@jest/globals';
-import { processManifestConfig } from './generateManifest.utils.js';
+import { readFileSync } from 'node:fs';
+import mockFs from 'mock-fs';
+import {
+  generateManifest,
+  processManifestConfig,
+} from './generateManifest.utils.js';
 
 describe('Utils - generateManifest', () => {
+  it('should correctly merge config when generateManifest is called multiple times', async () => {
+    globalThis.vulcan = {};
+    const presetConfig = {
+      rules: {
+        request: [
+          {
+            name: 'Main_Rule',
+            match: '^\\/',
+            runFunction: {
+              path: '.edge/worker.js',
+            },
+          },
+        ],
+      },
+    };
+    const azionConfig = {
+      origin: [
+        {
+          name: 'my origin storage',
+          type: 'object_storage',
+          bucket: 'mybucket',
+          prefix: 'myfolder',
+        },
+      ],
+      rules: {
+        request: [
+          {
+            name: 'my-rule-origin',
+            match: '/^/_statics/;',
+            setOrigin: {
+              name: 'my origin storage',
+              type: 'object_storage',
+            },
+          },
+        ],
+      },
+    };
+    mockFs({
+      '.edge/manifest.json': '{}',
+    });
+    await generateManifest(presetConfig);
+    await generateManifest(azionConfig, true);
+    const manifest = readFileSync('.edge/manifest.json', 'utf8');
+    mockFs.restore();
+    expect(JSON.parse(manifest)).toEqual(
+      expect.objectContaining({
+        origin: expect.arrayContaining([
+          {
+            name: 'my origin storage',
+            origin_type: 'object_storage',
+            bucket: 'mybucket',
+            prefix: 'myfolder',
+          },
+        ]),
+        rules: expect.arrayContaining([
+          {
+            name: 'my-rule-origin',
+            criteria: [
+              [
+                {
+                  // eslint-disable-next-line no-template-curly-in-string
+                  variable: '${uri}',
+                  operator: 'matches',
+                  conditional: 'if',
+                  input_value: '/^/_statics/;',
+                },
+              ],
+            ],
+            behaviors: [
+              {
+                name: 'set_origin',
+                target: 'my origin storage',
+              },
+            ],
+          },
+          {
+            name: 'Main_Rule',
+            criteria: [
+              [
+                {
+                  // eslint-disable-next-line no-template-curly-in-string
+                  variable: '${uri}',
+                  operator: 'matches',
+                  conditional: 'if',
+                  input_value: '^\\/',
+                },
+              ],
+            ],
+            behaviors: [
+              {
+                name: 'run_function',
+                target: '.edge/worker.js',
+              },
+            ],
+          },
+        ]),
+        cache: [],
+      }),
+    );
+  });
+
   describe('processManifestConfig', () => {
     it('should throw an error for invalid mathematical expressions', () => {
       const azionConfig = {
@@ -67,19 +173,10 @@ describe('Utils - generateManifest', () => {
       const result = processManifestConfig(azionConfig);
       expect(result.rules[0].behaviors).toEqual(
         expect.arrayContaining([
-          expect.objectContaining(
-            {
-              name: 'capture_match_groups',
-              target: {
-                captured_array: 'other',
-                regex: '^(./)([^/])$',
-                // eslint-disable-next-line no-template-curly-in-string
-                subject: '${uri}',
-              },
-            },
-            // eslint-disable-next-line no-template-curly-in-string
-            { name: 'rewrite_request', target: '/${other[0]}/${other[1]}' },
-          ),
+          expect.objectContaining({
+            name: 'rewrite_request',
+            target: expect.stringContaining('/%{other[0]}/%{other[1]}'), // Updated from 'params' to 'target'
+          }),
         ]),
       );
     });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "edge-functions",
   "type": "module",
-  "version": "2.7.0-stage.1",
+  "version": "2.7.0",
   "description": "Tool to launch and build JavaScript/Frameworks. This tool automates polyfills for Edge Computing and assists in creating Workers, notably for the Azion platform.",
   "main": "lib/main.js",
   "bin": {