edge-functions 3.2.1 → 3.3.0

package/lib/constants/index.js

@@ -1,5 +1,4 @@
 import RuntimeApis from './runtime-apis.constants.js';
-import AzionEdges from './azion-edges.constants.js';
 import Messages from './messages/index.js';
 
-export { AzionEdges, RuntimeApis, Messages };
+export { RuntimeApis, Messages };

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

@@ -6,19 +6,19 @@ Build messages object.
  */
 const build = {
   success: {
-    prebuild_succeeded: 'Prebuild succeeded!',
+    prebuild_succeeded: 'Preb-uild succeeded!',
     vulcan_build_succeeded: 'Build completed!',
-    manifest_succeeded: 'Manifest generated successfully!',
+    manifest_succeeded: 'Azion Manifest generated successfully!',
   },
   info: {
     rebuilding: 'We are rebuilding with the new changes...',
-    prebuild_starting: 'Starting prebuild...',
-    vulcan_build_starting: 'Starting Vulcan build...',
+    prebuild_starting: 'Starting pre-build...',
+    vulcan_build_starting: 'Starting Azion build...',
   },
   error: {
-    vulcan_build_failed: 'Vulcan build failed.',
+    vulcan_build_failed: 'Azion build failed.',
     invalid_preset:
-      'Invalid build preset. Run "vulcan preset ls" to view available presets.',
+      'Invalid build preset. Run "azion preset ls" to view available presets.',
     invalid_preset_mode: (mode, preset) =>
       `Mode '${mode}' does not exists in preset '${preset}'. Try 'deliver' or 'compute'.`,
     prebuild_error_validation_support: (framework, version, runtimes) =>
@@ -47,7 +47,7 @@ const build = {
   },
   warning: {
     use_node_polyfill_mode_deliver:
-      'The use of useNodePolyfills is not available for this deliver mode preset.',
+      'The use of polyfills is not available for this deliver mode preset.',
   },
 };
 

package/lib/env/env.test.js

@@ -1,145 +1,178 @@
-import { afterEach, beforeEach, describe, expect } from '@jest/globals';
+import { afterEach, beforeEach, describe, expect, it } from '@jest/globals';
 import mockFs from 'mock-fs';
 import fs from 'fs';
-import runtime from './runtime.env.js';
+import path from 'path';
 import vulcanEnv from './vulcan.env.js';
 
-describe('runtime env', () => {
-  it('Should instantiate a edge runtime', () => {
-    const code = `
-       addEventListener('fetch', event => {
-         const { searchParams } = new URL(event.request.url)
-         const url = searchParams.get('url')
-         return event.respondWith(fetch(url))
-       })`;
-    const edgeRuntime = runtime(code);
-
-    expect(edgeRuntime).toBeDefined();
-  });
-});
+jest.mock('prettier', () => ({
+  format: jest.fn().mockImplementation((content) => content),
+}));
+
+jest.mock('#utils', () => ({
+  feedback: {
+    error: jest.fn(),
+  },
+  debug: {
+    error: jest.fn(),
+  },
+}));
+
+jest.mock('#constants', () => ({
+  Messages: {
+    errors: {
+      folder_creation_failed: jest.fn(),
+      file_doesnt_exist: jest.fn(),
+      write_file_failed: jest.fn(),
+    },
+  },
+}));
 
 describe('vulcan env', () => {
-  const { env } = process;
+  const originalEnv = process.env;
+  const mockTempPath = '/mock/temp/path';
+
   beforeEach(() => {
     jest.resetModules();
-    process.env = { HOME: '/home/user' };
-    process.cwd = jest.fn(() => '/');
+    process.env = { ...originalEnv, HOME: '/home/user' };
+    process.cwd = jest.fn(() => '/project');
+    global.vulcan = {
+      tempPath: mockTempPath,
+    };
   });
 
   afterEach(() => {
-    process.env = env;
+    process.env = originalEnv;
+    mockFs.restore();
   });
 
-  it('Should create a vulcan env with global scope', async () => {
-    mockFs({});
-    await vulcanEnv.createVulcanEnv(
-      { API_KEY: 'abc123', ANOTHER_KEY: 'xyz' },
-      'global',
-    );
+  describe('createVulcanEnv', () => {
+    it('Should create a vulcan env with global scope', async () => {
+      mockFs({
+        [mockTempPath]: {},
+      });
+
+      await vulcanEnv.createVulcanEnv(
+        { API_KEY: 'abc123', ANOTHER_KEY: 'xyz' },
+        'global',
+      );
 
-    const vulcanEnvContent = fs.readFileSync(
-      '/home/user/.azion/.vulcan',
-      'utf8',
-    );
+      const vulcanEnvContent = fs.readFileSync(
+        path.join(mockTempPath, '.azion-bundler'),
+        'utf8',
+      );
 
-    expect(vulcanEnvContent.trim()).toEqual(
-      `API_KEY=abc123
+      expect(vulcanEnvContent.trim()).toEqual(
+        `API_KEY=abc123
 ANOTHER_KEY=xyz`,
-    );
-    mockFs.restore();
-  });
+      );
+    });
+
+    it('Should create a vulcan env with local scope', async () => {
+      mockFs({
+        '/project': {},
+      });
 
-  it('Should create a vulcan env with default scope', async () => {
-    mockFs({});
-    await vulcanEnv.createVulcanEnv({ API_KEY: 'abc123', ANOTHER_KEY: 'xyz' });
+      await vulcanEnv.createVulcanEnv(
+        { API_KEY: 'abc123', ANOTHER_KEY: 'xyz' },
+        'local',
+      );
 
-    const vulcanEnvContent = fs.readFileSync(
-      '/home/user/.azion/.vulcan',
-      'utf8',
-    );
+      const vulcanEnvContent = fs.readFileSync(
+        '/project/.azion-bundler',
+        'utf8',
+      );
 
-    expect(vulcanEnvContent.trim()).toEqual(
-      `API_KEY=abc123
+      expect(vulcanEnvContent.trim()).toEqual(
+        `API_KEY=abc123
 ANOTHER_KEY=xyz`,
-    );
-    mockFs.restore();
-  });
+      );
+    });
 
-  it('Should create a vulcan env with local scope', async () => {
-    mockFs({});
-    await vulcanEnv.createVulcanEnv(
-      { API_KEY: 'abc123', ANOTHER_KEY: 'xyz' },
-      'local',
-    );
+    it('Should update existing variables', async () => {
+      mockFs({
+        '/project/.azion-bundler': 'API_KEY=old_value\n',
+      });
+
+      await vulcanEnv.createVulcanEnv(
+        { API_KEY: 'new_value', NEW_KEY: 'new_key_value' },
+        'local',
+      );
+
+      const vulcanEnvContent = fs.readFileSync(
+        '/project/.azion-bundler',
+        'utf8',
+      );
+
+      expect(vulcanEnvContent.trim()).toEqual(
+        `API_KEY=new_value
+NEW_KEY=new_key_value`,
+      );
+    });
+  });
 
-    const vulcanEnvContent = fs.readFileSync('/.vulcan', 'utf8');
+  describe('readVulcanEnv', () => {
+    it('Should read a vulcan env with global scope', async () => {
+      mockFs({
+        [path.join(mockTempPath, '.azion-bundler')]: 'API_KEY=abc123',
+      });
 
-    expect(vulcanEnvContent.trim()).toEqual(
-      `API_KEY=abc123
-ANOTHER_KEY=xyz`,
-    );
-    mockFs.restore();
-  });
+      const envContent = await vulcanEnv.readVulcanEnv('global');
 
-  it('Should update a vulcan env with local scope', async () => {
-    mockFs({
-      '/.vulcan': `API_KEY=abc123`,
+      expect(envContent).toEqual({ API_KEY: 'abc123' });
     });
-    await vulcanEnv.createVulcanEnv({ API_KEY: 'abc456' }, 'local');
 
-    const vulcanEnvContent = fs.readFileSync('/.vulcan', 'utf8');
+    it('Should read a vulcan env with local scope', async () => {
+      mockFs({
+        '/project/.azion-bundler': 'API_KEY=abc123\nANOTHER_KEY=xyz',
+      });
 
-    expect(vulcanEnvContent.trim()).toEqual(`API_KEY=abc456`);
-    mockFs.restore();
-  });
+      const envContent = await vulcanEnv.readVulcanEnv('local');
 
-  it('Should read a vulcan env with default scope', async () => {
-    mockFs({
-      '/home/user/.azion/.vulcan': `API_KEY=abc123`,
+      expect(envContent).toEqual({ API_KEY: 'abc123', ANOTHER_KEY: 'xyz' });
     });
-    const envContent = await vulcanEnv.readVulcanEnv();
 
-    expect(envContent).toMatchObject({ API_KEY: 'abc123' });
-    mockFs.restore();
-  });
+    it('Should return null if file does not exist', async () => {
+      mockFs({});
 
-  it('Should read a vulcan env with global scope', async () => {
-    mockFs({
-      '/home/user/.azion/.vulcan': `API_KEY=abc123`,
-    });
-    const envContent = await vulcanEnv.readVulcanEnv('global');
+      const envContent = await vulcanEnv.readVulcanEnv('local');
 
-    expect(envContent).toMatchObject({ API_KEY: 'abc123' });
-    mockFs.restore();
+      expect(envContent).toBeNull();
+    });
   });
 
-  it('Should read a vulcan env with local scope', async () => {
-    mockFs({
-      '/.vulcan': `API_KEY=abc123`,
+  describe('loadAzionConfig', () => {
+    it('Should load an Azion config file', async () => {
+      const configContent = `
+        export default {
+          build: {
+            entry: './src/index.js',
+            output: './dist',
+          },
+        };
+      `;
+
+      mockFs({
+        '/project/azion.config.js': configContent,
+      });
+
+      const config = await vulcanEnv.loadAzionConfig(
+        '/project/azion.config.js',
+      );
+
+      expect(config).toEqual({
+        build: {
+          entry: './src/index.js',
+          output: './dist',
+        },
+      });
     });
-    const envContent = await vulcanEnv.readVulcanEnv('local');
 
-    expect(envContent).toMatchObject({ API_KEY: 'abc123' });
-    mockFs.restore();
-  });
+    it('Should return null if Azion config file does not exist', async () => {
+      mockFs({});
 
-  it('Should read a vulcanconfig file', async () => {
-    mockFs({
-      '/vulcan.config.js': `module.exports = {
-        memoryFS: {
-            injectionDirs: ['.faststore/@generated/graphql'],
-            removePathPrefix: '.faststore/',
-        }
-      };`,
+      const config = await vulcanEnv.loadAzionConfig();
+
+      expect(config).toBeNull();
     });
-    const expectedContent = {
-      memoryFS: {
-        injectionDirs: ['.faststore/@generated/graphql'],
-        removePathPrefix: '.faststore/',
-      },
-    };
-    const vulcaConfigFileContent = await vulcanEnv.loadVulcanConfigFile();
-    expect(vulcaConfigFileContent).toEqual(expectedContent);
-    mockFs.restore();
   });
 });

package/lib/env/polyfills/azion/storage/context/storage.context.js

@@ -102,7 +102,7 @@ class StorageContext {
         (entry) => entry.isFile() && !entry.name.includes(this.#metadataPrefix),
       )
       .map((file) => {
-        const pathFile = file.path.split(pathBucketRoot)?.[1];
+        const pathFile = file.path?.split(pathBucketRoot)?.[1];
         const key = pathFile ? `${pathFile}/${file.name}` : file.name;
         return { key };
       });

package/lib/env/server.env.js

@@ -89,7 +89,7 @@ async function initializeServer(port, workerCode) {
  * @param {boolean} isFirewall - (Experimental) Enable isFirewall for local environment.
  */
 async function buildToLocalServer(isFirewall) {
-  const vulcanEnv = await vulcan.readVulcanEnv('local');
+  const vulcanEnv = await vulcan.readVulcanEnv('global');
 
   if (!vulcanEnv) {
     const msg = Messages.env.server.errors.run_build_command;
@@ -149,10 +149,10 @@ async function handleFileChange(path, workerPath, port, isFirewall) {
   if (isChangeHandlerRunning) return;
 
   if (
-    path.startsWith('.vulcan') ||
-    (path.startsWith('vulcan') && path.includes('.temp')) ||
+    path.startsWith('.azion-bundler') ||
+    (path.startsWith('azion') && path.includes('.temp')) ||
     path.startsWith('.edge') ||
-    path.startsWith('node_modules/.cache') ||
+    path.startsWith('node_modules') ||
     path.startsWith('.vercel')
   ) {
     return;

package/lib/env/vulcan.env.js

@@ -3,6 +3,9 @@ import { Messages } from '#constants';
 import fs from 'fs';
 import fsPromises from 'fs/promises';
 import path from 'path';
+import { transpileModule } from 'typescript';
+import prettier from 'prettier';
+import { createRequire } from 'module';
 
 /**
  * Creates or updates Vulcan environment variables.
@@ -19,7 +22,7 @@ async function createVulcanEnv(variables, scope = 'global') {
   let basePath;
   switch (scope) {
     case 'global':
-      basePath = path.join(process.env.HOME, '.azion');
+      basePath = globalThis.vulcan.tempPath;
       break;
     case 'local':
       basePath = path.join(process.cwd());
@@ -28,7 +31,7 @@ async function createVulcanEnv(variables, scope = 'global') {
       basePath = scope;
       break;
   }
-  const vulcanEnvPath = path.join(basePath, '.vulcan');
+  const vulcanEnvPath = path.join(basePath, '.azion-bundler');
 
   try {
     await fsPromises.mkdir(basePath, { recursive: true });
@@ -86,11 +89,11 @@ async function createVulcanEnv(variables, scope = 'global') {
  *   .then(env => console.log(env))
  *   .catch(error => console.error(error));
  */
-async function readVulcanEnv(scope = 'global') {
+async function readVulcanEnv(scope = 'local') {
   let basePath;
   switch (scope) {
     case 'global':
-      basePath = path.join(process.env.HOME, '.azion');
+      basePath = globalThis.vulcan.tempPath;
       break;
     case 'local':
       basePath = path.join(process.cwd());
@@ -99,7 +102,7 @@ async function readVulcanEnv(scope = 'global') {
       basePath = scope;
       break;
   }
-  const vulcanEnvPath = path.join(basePath, '.vulcan');
+  const vulcanEnvPath = path.join(basePath, '.azion-bundler');
 
   try {
     await fsPromises.access(vulcanEnvPath);
@@ -121,37 +124,160 @@ async function readVulcanEnv(scope = 'global') {
       return null;
     }
     debug.error(error);
-    feedback.error(Messages.errors.read_file_failed(vulcanEnvPath));
+    feedback.error(Messages.errors.file_doesnt_exist(vulcanEnvPath));
+    throw error;
+  }
+}
+/**
+ * Loads the azion.config file and returns the entire configuration object.
+ * @async
+ * @param {string} [configPath] - Optional path to the config file. If not provided, it will search in the current working directory.
+ * @returns {Promise<object|null>} A promise that resolves to the entire configuration from azion.config, or null if not found.
+ * @throws {Error} Throws an error if there are issues reading or parsing the configuration file.
+ */
+async function loadAzionConfig(configPath) {
+  const require = createRequire(import.meta.url);
+  const extensions = ['.js', '.mjs', '.cjs', '.ts'];
+  const configName = 'azion.config';
+
+  if (!configPath) {
+    // eslint-disable-next-line no-restricted-syntax
+    for (const ext of extensions) {
+      const testPath = path.join(process.cwd(), `${configName}${ext}`);
+      if (fs.existsSync(testPath)) {
+        // eslint-disable-next-line no-param-reassign
+        configPath = testPath;
+        break;
+      }
+    }
+  }
+
+  if (!configPath || !fs.existsSync(configPath)) {
+    return null;
+  }
+
+  const extension = path.extname(configPath);
+  let configModule;
+
+  try {
+    switch (extension) {
+      case '.ts':
+        // eslint-disable-next-line no-case-declarations
+        const tsContent = await fsPromises.readFile(configPath, 'utf-8');
+        // eslint-disable-next-line no-case-declarations
+        const jsContent = transpileModule(tsContent, {
+          compilerOptions: {
+            module: 'commonjs',
+            target: 'es2020',
+            moduleResolution: 'node',
+          },
+        }).outputText;
+
+        // eslint-disable-next-line no-case-declarations
+        const tempJsPath = configPath.replace('.ts', '.temp.js');
+        await fsPromises.writeFile(tempJsPath, jsContent);
+
+        try {
+          // eslint-disable-next-line import/no-dynamic-require
+          configModule = require(tempJsPath);
+        } finally {
+          await fsPromises.unlink(tempJsPath);
+        }
+        break;
+      case '.mjs':
+        configModule = await import(configPath);
+        break;
+      case '.cjs':
+      case '.js':
+        try {
+          configModule = await import(configPath);
+        } catch (error) {
+          if (error.code === 'ERR_REQUIRE_ESM') {
+            throw error;
+          }
+          // eslint-disable-next-line import/no-dynamic-require
+          configModule = require(configPath);
+        }
+        break;
+      default:
+        throw new Error(`Unsupported file extension: ${extension}`);
+    }
+
+    return configModule.default || configModule;
+  } catch (error) {
+    debug.error(error);
+    feedback.error(Messages.errors.file_doesnt_exist(configPath));
     throw error;
   }
 }
 
 /**
- * Loads a custom Vulcan configuration file from the current working directory.
+ * Creates an Azion configuration file with the appropriate extension if it does not exist.
  * @async
- * @returns {Promise<object|null>} A promise that resolves to the custom Vulcan configuration module if it exists, or null otherwise.
- * @throws {Error} Throws an error if there are issues importing the configuration file.
- * @example
- * loadVulcanConfigFile()
- *   .then(config => {
- *     if (config) {
- *       console.log('Custom configuration loaded:', config);
- *     } else {
- *       console.log('No custom configuration found.');
- *     }
- *   })
- *   .catch(error => console.error('Failed to load custom configuration:', error));
+ * @param {boolean} useCommonJS - If true, uses the '.cjs' extension and CommonJS format; otherwise, uses '.mjs' for ES Modules.
+ * @param {object} module - The configuration object to be written to the file.
+ * @returns {Promise<void>}
  */
-async function loadVulcanConfigFile() {
-  const buildConfigPath = path.join(process.cwd(), 'vulcan.config.js');
-  let vulcanCustomConfig = null;
+async function createAzionConfigFile(useCommonJS, module) {
+  const extension = useCommonJS ? '.cjs' : '.mjs';
+  const configPath = path.join(process.cwd(), `azion.config${extension}`);
+  const moduleExportStyle = useCommonJS ? 'module.exports =' : 'export default';
+
+  const replacer = (key, value) => {
+    if (typeof value === 'function') {
+      return `__FUNCTION_START__${value.toString()}__FUNCTION_END__`;
+    }
+    return value;
+  };
+
+  let jsonString = JSON.stringify(module, replacer, 2);
+
+  jsonString = jsonString.replace(
+    /"__FUNCTION_START__(.*?)__FUNCTION_END__"/g,
+    (match, p1) => {
+      return p1.replace(/\\n/g, ' ').replace(/\\'/g, "'");
+    },
+  );
+
+  const formattedContent = await prettier.format(
+    `${moduleExportStyle} ${jsonString};`,
+    {
+      parser: 'babel',
+      semi: false,
+      singleQuote: true,
+      trailingComma: 'none',
+    },
+  );
 
-  if (fs.existsSync(buildConfigPath)) {
-    const vulcanCustomConfigModule = await import(buildConfigPath);
-    vulcanCustomConfig = vulcanCustomConfigModule.default || {};
+  if (!fs.existsSync(configPath)) {
+    await fsPromises.writeFile(configPath, formattedContent);
+  }
+}
+
+/**
+ * Gets the path of the existing Azion configuration file in the current working directory.
+ * @async
+ * @returns {Promise<string|null>} The path of the Azion configuration file if it exists, otherwise null.
+ */
+async function getAzionConfigPath() {
+  const extensions = ['.js', '.mjs', '.cjs', '.ts'];
+  const configName = 'azion.config';
+
+  // eslint-disable-next-line no-restricted-syntax
+  for (const ext of extensions) {
+    const configPath = path.join(process.cwd(), `${configName}${ext}`);
+    if (fs.existsSync(configPath)) {
+      return configPath;
+    }
   }
 
-  return vulcanCustomConfig;
+  return null;
 }
 
-export default { createVulcanEnv, readVulcanEnv, loadVulcanConfigFile };
+export default {
+  createVulcanEnv,
+  readVulcanEnv,
+  loadAzionConfig,
+  createAzionConfigFile,
+  getAzionConfigPath,
+};