edge-functions 1.0.0

package/lib/utils/copyDirectory/copyDirectory.utils.test.js

@@ -0,0 +1,43 @@
+import {
+  mkdtempSync, writeFileSync, mkdirSync, rmdirSync, existsSync, readFileSync,
+} from 'fs';
+import { join } from 'path';
+
+import copyDirectory from './index.js';
+
+describe('copyDirectory utils', () => {
+  let sourceDir;
+  let targetDir;
+
+  beforeAll(async () => {
+    sourceDir = mkdtempSync(join(__dirname, 'tmp-source'));
+    targetDir = mkdtempSync(join(__dirname, 'tmp-target'));
+
+    writeFileSync(join(sourceDir, 'file1.txt'), 'Test example 1.');
+    mkdirSync(join(sourceDir, 'subdir'));
+    writeFileSync(join(sourceDir, 'subdir', 'file2.txt'), 'Text example 2.');
+  });
+
+  afterAll(() => {
+    rmdirSync(sourceDir, { recursive: true });
+    rmdirSync(targetDir, { recursive: true });
+  });
+
+  test('Should recursively copy a directory to the target directory.', async () => {
+    copyDirectory(sourceDir, targetDir);
+
+    const copiedFile1 = existsSync(join(targetDir, 'file1.txt'));
+    const copiedFile2 = existsSync(join(targetDir, 'subdir', 'file2.txt'));
+
+    expect(copiedFile1).toBeTruthy();
+    expect(copiedFile2).toBeTruthy();
+
+    const originalFile1Contents = readFileSync(join(sourceDir, 'file1.txt'), 'utf-8');
+    const originalFile2Contents = readFileSync(join(sourceDir, 'subdir', 'file2.txt'), 'utf-8');
+    const copiedFile1Contents = readFileSync(join(targetDir, 'file1.txt'), 'utf-8');
+    const copiedFile2Contents = readFileSync(join(targetDir, 'subdir', 'file2.txt'), 'utf-8');
+
+    expect(copiedFile1Contents).toBe(originalFile1Contents);
+    expect(copiedFile2Contents).toBe(originalFile2Contents);
+  });
+});

package/lib/utils/copyDirectory/index.js

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

package/lib/utils/debug/debug.utils.js

@@ -0,0 +1,36 @@
+/**
+ * Debug method that conditionally logs based on process.env.DEBUG.
+ * Inherits all methods from console.log.
+ * @function
+ * @name debug
+ * @memberof utils
+ * @param {...*} args - Arguments to be logged.
+ * @description By default, process.env.DEBUG is set to false.
+ * When enabled, this method overrides console.log and allows you to log debug messages during
+ * development without showing them to the end user. It provides a convenient way to debug your
+ * code without the need to manually remove console.log statements.
+ * @example
+ * // Enable debug mode by setting process.env.DEBUG to true
+ * process.env.DEBUG = true;
+ *
+ * // Log a debug message
+ * debug.log('This is a debug message');
+ */
+
+const debug = {};
+const debugEnabled = process.env.DEBUG === 'true';
+
+/**
+ * Iterate over the console methods and create corresponding debug methods.
+ */
+Object.keys(console).forEach((method) => {
+  if (typeof console[method] === 'function') {
+    debug[method] = (...args) => {
+      if (debugEnabled) {
+        console[method](...args);
+      }
+    };
+  }
+});
+
+export default debug;

package/lib/utils/debug/debug.utils.test.js

@@ -0,0 +1,43 @@
+describe('debug utils', () => {
+  let originalDebugValue;
+
+  beforeAll(() => {
+    originalDebugValue = process.env.DEBUG;
+  });
+
+  afterAll(() => {
+    process.env.DEBUG = originalDebugValue;
+    jest.restoreAllMocks();
+  });
+
+  test('Should log if debug flag is enabled', async () => {
+    process.env.DEBUG = 'true';
+    jest.resetModules();
+
+    const { default: debug } = await import('./index.js');
+
+    const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+
+    debug.error('test');
+
+    expect(consoleSpy).toHaveBeenCalledTimes(1);
+    expect(consoleSpy.mock.calls[0][0]).toBe('test');
+
+    consoleSpy.mockRestore();
+  });
+
+  test('Should NOT log if debug flag is disabled', async () => {
+    process.env.DEBUG = 'false';
+    jest.resetModules();
+
+    const { default: debug } = await import('./index.js');
+
+    const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+
+    debug.error('test');
+
+    expect(consoleSpy).not.toHaveBeenCalled();
+
+    consoleSpy.mockRestore();
+  });
+});

package/lib/utils/debug/index.js

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

package/lib/utils/exec/exec.utils.js

@@ -0,0 +1,58 @@
+import { spawn } from 'child_process';
+import signale from 'signale';
+
+/**
+ * Execute a command asynchronously and retrieve the standard output and standard error.
+ * @function
+ * @name exec
+ * @memberof utils
+ * @param {string} command - The command to be executed.
+ * @param {string} [scope='Process'] - Log scope. The default is 'Process'.
+ * @param {boolean} [verbose=false] - Whether to display the output in real-time.
+ * @returns {Promise<void>} A promise that resolves when the command completes successfully.
+ * @example
+ * // Executing a command without verbose output
+ * await exec('npm install');
+ *
+ * // Executing a command with verbose output
+ * await exec('npm run build', 'Build', true);
+ */
+async function exec(command, scope = 'Process', verbose = false) {
+  const stream = new signale.Signale({ interactive: true, scope: ['Process', scope] });
+
+  return new Promise((resolve, reject) => {
+    const args = command.split(' ');
+    const cmd = args.shift();
+
+    const buildProcess = spawn(cmd, args, { shell: true });
+
+    if (verbose) {
+      buildProcess.stdout.on('data', (data) => {
+        stream.info(data.toString());
+      });
+
+      buildProcess.stderr.on('data', (data) => {
+        // Some tools and libraries choose to use stderr for process logging or informational messages.
+        const dataStr = data.toString();
+        if (dataStr.toLowerCase().includes('error')) {
+          stream.error(dataStr);
+        } else {
+          stream.info(dataStr);
+        }
+      });
+    }
+
+    buildProcess.on('error', (error) => {
+      reject(error);
+    });
+
+    buildProcess.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Command '${command}' failed with code ${code}`));
+      }
+    });
+  });
+}
+export default exec;

package/lib/utils/exec/exec.utils.test.js

@@ -0,0 +1,84 @@
+import { spawn } from 'child_process';
+import signale from 'signale';
+
+import exec from './index.js';
+
+jest.mock('child_process');
+jest.mock('signale');
+
+describe('exec utils', () => {
+  let mockSignaleInstance;
+  let mockChildProcess;
+
+  beforeEach(() => {
+    mockSignaleInstance = {
+      info: jest.fn(),
+      error: jest.fn(),
+    };
+    signale.Signale.mockReturnValue(mockSignaleInstance);
+
+    mockChildProcess = {
+      stdout: { on: jest.fn() },
+      stderr: { on: jest.fn() },
+      on: jest.fn(),
+    };
+    spawn.mockReturnValue(mockChildProcess);
+  });
+
+  test('Should resolve when process closes with code 0', async () => {
+    mockChildProcess.on.mockImplementation((event, callback) => {
+      if (event === 'close') {
+        callback(0);
+      }
+    });
+
+    await expect(exec('echo test')).resolves.toBeUndefined();
+  });
+
+  test('Should reject when process closes with non-zero code', async () => {
+    mockChildProcess.on.mockImplementation((event, callback) => {
+      if (event === 'close') {
+        callback(1);
+      }
+    });
+
+    await expect(exec('echo test')).rejects.toThrow('Command \'echo test\' failed with code 1');
+  });
+
+  test('Should reject when process emits an error', async () => {
+    const error = new Error('Test error');
+
+    mockChildProcess.on.mockImplementation((event, callback) => {
+      if (event === 'error') {
+        callback(error);
+      }
+    });
+
+    await expect(exec('echo test')).rejects.toEqual(error);
+  });
+
+  test('Should log stdout and stderr when verbose is true', async () => {
+    mockChildProcess.on.mockImplementation((event, callback) => {
+      if (event === 'close') {
+        callback(0);
+      }
+    });
+
+    mockChildProcess.stdout.on.mockImplementation((event, callback) => {
+      if (event === 'data') {
+        callback('Test stdout');
+      }
+    });
+
+    mockChildProcess.stderr.on.mockImplementation((event, callback) => {
+      if (event === 'data') {
+        callback('Test stderr');
+      }
+    });
+
+    await exec('echo test', 'Test', true);
+
+    expect(mockSignaleInstance.info).toHaveBeenCalledWith('Test stdout');
+    expect(mockSignaleInstance.error).toHaveBeenCalledWith('Test stderr');
+  });
+});

package/lib/utils/exec/index.js

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

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

@@ -0,0 +1,81 @@
+import signale from 'signale';
+
+const cleanOutputEnabled = process.env.CLEAN_OUTPUT_MODE === 'true';
+const cleanOutputConfig = {
+  displayScope: false,
+  displayBadge: false,
+  displayDate: false,
+  displayFilename: false,
+  displayLabel: false,
+  displayTimestamp: false,
+  underlineLabel: false,
+  underlineMessage: false,
+  underlinePrefix: false,
+  underlineSuffix: false,
+  uppercaseLabel: false,
+};
+
+/**
+ * Helper function to create a custom interactive logger object.
+ * @param {object} options - Configuration options for the logger.
+ * @returns {object} A custom logger object.
+ */
+const getLogger = (options = {}) => {
+  const logger = new signale.Signale({ ...options });
+  if (cleanOutputEnabled) {
+    logger.config(cleanOutputConfig);
+  }
+  return Object.assign(logger, {
+    breakInteractiveChain: () => console.log(),
+  });
+};
+
+const methods = {
+  deployed: {
+    badge: '🚀',
+    color: 'green',
+    label: 'forged',
+    logLevel: 'info',
+  },
+  option: {
+    badge: '🟣',
+    color: 'magenta',
+    label: 'option',
+    logLevel: 'info',
+  },
+};
+
+const global = new signale.Signale({ interactive: false, scope: 'Vulcan', types: methods });
+
+if (cleanOutputEnabled) {
+  global.config(cleanOutputConfig);
+}
+
+/**
+ * Predefined log scopes.
+ * @type {object}
+ */
+const scopes = {
+  ...global,
+  prebuild: { ...global.scope('Vulcan', 'Pre Build'), interactive: getLogger({ interactive: true, scope: ['Vulcan', 'Pre Build'], types: methods }) },
+  build: { ...global.scope('Vulcan', 'Build'), interactive: getLogger({ interactive: true, scope: ['Vulcan', 'Build'], types: methods }) },
+  platform: { ...global.scope('Vulcan', 'Platform'), interactive: getLogger({ interactive: true, scope: ['Vulcan', 'Plataform'], types: methods }) },
+  statics: { ...global.scope('Vulcan', 'Statics'), interactive: getLogger({ interactive: true, scope: ['Vulcan', 'Statics'], types: methods }) },
+  propagation: { ...global.scope('Azion', 'Edge Network'), interactive: getLogger({ interactive: true, scope: ['Vulcan', 'Azion Network'], types: methods }) },
+};
+/**
+ * @name feedback
+ * @memberof utils
+ * @description
+ * Feedback object that facilitates log display.
+ * It includes all logging methods provided by 'signale'.
+ * If the environment variable CLEAN_OUTPUT_MODE is set to 'true', all log methods use console.log,
+ * providing cleaner and unstyled output. This is particularly useful
+ * for other clients intending to use Vulcan
+ * in the background, where stylized console output may be less desirable.
+ * For more information about the Signale logging methods, refer to its documentation (https://github.com/klaussinani/signale).
+ * @type {object}
+ */
+const feedback = { ...scopes };
+
+export default feedback;

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

@@ -0,0 +1,11 @@
+import feedback from './index.js';
+
+describe('feedback utils', () => {
+  test('Should create a feedback object that facilitates log display.', async () => {
+    const prebuildInfo = feedback.prebuild.info;
+    const prebuildError = feedback.prebuild.error;
+
+    expect(typeof prebuildInfo).toBe('function');
+    expect(typeof prebuildError).toBe('function');
+  });
+});

package/lib/utils/feedback/index.js

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

package/lib/utils/generateTimestamp/generateTimestamp.utils.js

@@ -0,0 +1,25 @@
+/**
+ * Generates a timestamp string in the format "YYYYMMDDHHmmss".
+ * @function
+ * @name generateTimestamp
+ * @memberof utils
+ * @returns {string} The generated timestamp.
+ * @example
+ *
+ * // Example usage:
+ * const timestamp = generateTimestamp();
+ * console.log(timestamp); // "20220623123456"
+ */
+function generateTimestamp() {
+  const now = new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const day = String(now.getDate()).padStart(2, '0');
+  const hours = String(now.getHours()).padStart(2, '0');
+  const minutes = String(now.getMinutes()).padStart(2, '0');
+  const seconds = String(now.getSeconds()).padStart(2, '0');
+
+  return `${year}${month}${day}${hours}${minutes}${seconds}`;
+}
+
+export default generateTimestamp;

package/lib/utils/generateTimestamp/generateTimestamp.utils.test.js

@@ -0,0 +1,10 @@
+import generateTimestamp from './index.js';
+
+describe('generateTimestamp utils', () => {
+  test('Should generate a timestamp string in the format "YYYYMMDDHHmmss".', async () => {
+    const timestamp = generateTimestamp();
+    const regex = /^\d{14}$/;
+
+    expect(timestamp).toMatch(regex);
+  });
+});

package/lib/utils/generateTimestamp/index.js

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

package/lib/utils/getAbsoluteLibDirPath/getAbsoluteLibDirPath.utils.js

@@ -0,0 +1,21 @@
+/**
+ * Get the absolute path of the lib directory based on the current module.
+ * @function
+ * @name getAbsoluteLibDirPath
+ * @memberof utils
+ * @returns {string} The full path to the lib directory.
+ * @example
+ *
+ * // Example usage:
+ * const libDirPath = getAbsoluteLibDirPath();
+ * console.log(libDirPath); // "lib/full/path/to/directory"
+ */
+function getAbsoluteLibDirPath() {
+  const currentModuleFullPath = import.meta.url;
+  let baselibPath = currentModuleFullPath.match(/(.*lib)(.*)/)[1];
+  baselibPath = baselibPath.replace('file://', '');
+
+  return baselibPath;
+}
+
+export default getAbsoluteLibDirPath;

package/lib/utils/getAbsoluteLibDirPath/getAbsoluteLibDirPath.utils.test.js

@@ -0,0 +1,13 @@
+import { join } from 'path';
+
+import getAbsoluteLibDirPath from './index.js';
+
+describe('getAbsoluteLibDirPath utils', () => {
+  test('Should get the absolute path of the lib directory based on the current module.', async () => {
+    const expectedOutput = join(process.cwd(), 'lib');
+
+    const result = getAbsoluteLibDirPath();
+
+    expect(result).toBe(expectedOutput);
+  });
+});

package/lib/utils/getAbsoluteLibDirPath/index.js

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

package/lib/utils/getPackageManager/getPackageManager.utils.js

@@ -0,0 +1,118 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { exec } from 'child_process';
+
+/**
+ * @function
+ * @name pathExists
+ * @description Checks if a path exists.
+ * @param {string} p - The path to check.
+ * @returns {Promise<boolean>} A Promise that resolves to `true`
+ * if the path exists, `false` otherwise.
+ */
+async function pathExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const cache = new Map();
+
+/**
+ * Check if a global package manager (PM) is available.
+ * @param {string} pm - The package manager to check (e.g., "npm", "yarn", "pnpm").
+ * @returns {Promise<boolean>} A Promise that resolves to true if the global PM is available,
+ * false otherwise.
+ */
+async function hasGlobalInstallation(pm) {
+  const key = `has_global_${pm}`;
+  if (cache.has(key)) {
+    return cache.get(key);
+  }
+
+  return new Promise((resolve) => {
+    exec(`${pm} --version`, (error, stdout) => {
+      if (error) {
+        resolve(false);
+      } else {
+        const isAvailable = /^\d+\.\d+\.\d+$/.test(stdout);
+        cache.set(key, isAvailable);
+        resolve(isAvailable);
+      }
+    });
+  });
+}
+
+/**
+ * Get the type of lock file (npm, yarn, pnpm) in a specific directory.
+ * @param {string} [cwd] - The directory to check. Defaults to the current working directory.
+ * @returns {Promise<string|null>} A Promise that resolves to the type of lock file
+ * (npm, yarn, pnpm), or null if no lock file is found.
+ */
+async function getTypeofLockFile(cwd = '.') {
+  const key = `lockfile_${cwd}`;
+  if (cache.has(key)) {
+    return cache.get(key);
+  }
+
+  const isYarn = await pathExists(path.resolve(cwd, 'yarn.lock'));
+  const isNpm = await pathExists(path.resolve(cwd, 'package-lock.json'));
+  const isPnpm = await pathExists(path.resolve(cwd, 'pnpm-lock.yaml'));
+
+  let value = null;
+  if (isYarn) {
+    value = 'yarn';
+  } else if (isPnpm) {
+    value = 'pnpm';
+  } else if (isNpm) {
+    value = 'npm';
+  }
+
+  cache.set(key, value);
+  return value;
+}
+
+/**
+ * Detects the package manager (npm, yarn, pnpm) being used.
+ * @async
+ * @function
+ * @name getPackageManager
+ * @memberof utils
+ * @param {object} options - Options for detecting the package manager.
+ * @param {string} [options.cwd] - The directory to check.
+ * Defaults to the current working directory.
+ * @returns {Promise<string>} A Promise that resolves to the detected
+ *  package manager (npm, yarn, pnpm).
+ * @example
+ *
+ * // Example usage:
+ * getPackageManager({ cwd: './my-project' })
+ *   .then(pm => console.log(pm)) // Logs: 'yarn', 'npm', or 'pnpm'
+ *   .catch(err => console.error(err));
+ */
+async function getPackageManager({ cwd } = {}) {
+  const type = await getTypeofLockFile(cwd);
+  if (type) {
+    return type;
+  }
+
+  const [hasYarn, hasPnpm] = await Promise.all([
+    hasGlobalInstallation('yarn'),
+    hasGlobalInstallation('pnpm'),
+  ]);
+
+  if (hasYarn) {
+    return 'yarn';
+  }
+
+  if (hasPnpm) {
+    return 'pnpm';
+  }
+
+  return 'npm';
+}
+
+export default getPackageManager;

package/lib/utils/getPackageManager/getPackageManager.utils.test.js

@@ -0,0 +1,35 @@
+import { writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+import getPackageManager from './index.js';
+
+const FILE_NAME = 'yarn.lock';
+const CURRENT_DIR = process.cwd();
+const TMP_DIR = tmpdir();
+const FILE_PATH = join(TMP_DIR, FILE_NAME);
+
+describe('getPackageManager utils', () => {
+  beforeAll(() => {
+    writeFileSync(FILE_PATH, `
+    {
+      "name": "next",
+      "version": "0.1.0"
+    }
+    `);
+
+    process.chdir(TMP_DIR);
+  });
+
+  afterAll(() => {
+    process.chdir(CURRENT_DIR);
+  });
+
+  test('Should detect the package manager (npm, yarn, pnpm) being used.', async () => {
+    const expectedOutput = 'yarn';
+
+    const result = await getPackageManager();
+
+    expect(result).toBe(expectedOutput);
+  });
+});

package/lib/utils/getPackageManager/index.js

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

package/lib/utils/getPackageVersion/getPackageVersion.utils.js

@@ -0,0 +1,25 @@
+import { join } from 'path';
+import { readFileSync } from 'fs';
+
+/**
+ * Get package version from user project.
+ * @param {string} packageName - The depency name.
+ * @returns {string} The package version.
+ */
+function getPackageVersion(packageName) {
+  if (!packageName || packageName === '' || packageName === ' ') {
+    throw new Error('Invalid package name!');
+  }
+
+  const packageJsonPath = join(process.cwd(), 'package.json');
+  const packageJsonContent = readFileSync(packageJsonPath, 'utf8');
+  const packageJson = JSON.parse(packageJsonContent);
+
+  if (!packageJson.dependencies || !packageJson.dependencies[packageName]) {
+    throw new Error(`'${packageName}' not detected in project dependencies!`);
+  }
+
+  return packageJson.dependencies[packageName];
+}
+
+export default getPackageVersion;