edge-functions 2.0.0 → 2.1.0

package/lib/constants/framework-initializer.constants.js

@@ -1,3 +1,33 @@
+import { exec } from '#utils';
+import { writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+const FrameworksDefaultVersions = {
+  Angular: {
+    options: [{ value: 'latest', message: 'static supported' }],
+  },
+  Astro: {
+    options: [{ value: 'latest', message: 'static supported' }],
+  },
+  Hexo: {
+    options: [{ value: 'latest', message: 'static supported' }],
+  },
+  Next: {
+    options: [
+      { value: '12.3.1', message: 'SSR supported' },
+      { value: 'latest', message: 'static supported' },
+    ],
+  },
+  React: {
+    options: [{ value: 'latest', message: 'static supported' }],
+  },
+  Vue: {
+    options: [{ value: 'latest', message: 'static supported' }],
+  },
+  Vite: {
+    options: [{ value: 'latest', message: 'static supported' }],
+  },
+};
 /**
  * FrameworkInitializer contains various methods to initialize new projects
  * in different JavaScript frameworks.
@@ -22,30 +52,83 @@
  * // Initialize a new React project called 'myReactProject'
  * await React('myReactProject');
  */
-import { exec } from '#utils';
-
 const FrameworkInitializer = {
-  Angular: async (projectName) => {
-    await exec(`npx @angular/cli new ${projectName}`, 'Angular', false, true);
+  JavaScript: async (projectName) => {
+    const projectPath = join(process.cwd(), projectName);
+    mkdirSync(projectPath);
+
+    const workerContent = `
+export default function myWorker(event) {
+  return new Response('Hello World');
+}
+    `;
+
+    writeFileSync(join(projectPath, 'main.js'), workerContent.trim());
+  },
+  TypeScript: async (projectName) => {
+    const projectPath = join(process.cwd(), projectName);
+    mkdirSync(projectPath);
+
+    const content = `
+export default function myWorker(event: FetchEvent): Response {
+  return new Response('Hello World');
+}`;
+    const vulcanFile = `preset=typescript\nentry=main.ts\n`;
+
+    writeFileSync(join(projectPath, '.vulcan'), vulcanFile);
+    writeFileSync(join(projectPath, 'main.ts'), content.trim());
+  },
+  Angular: async (projectName, version = FrameworksDefaultVersions.Angular) => {
+    await exec(
+      `npx @angular/cli@${version} new ${projectName}`,
+      'Angular',
+      false,
+      true,
+    );
   },
-  Astro: async (projectName) => {
-    await exec(`npx create-astro ${projectName}`, 'Astro', false, true);
+  Astro: async (projectName, version = FrameworksDefaultVersions.Astro) => {
+    await exec(
+      `npx create-astro@${version} ${projectName}`,
+      'Astro',
+      false,
+      true,
+    );
   },
-  Hexo: async (projectName) => {
-    await exec(`npx hexo init ${projectName}`, 'Hexo', false, true);
+  Hexo: async (projectName, version = FrameworksDefaultVersions.Hexo) => {
+    await exec(`npx hexo@${version} init ${projectName}`, 'Hexo', false, true);
   },
-  Next: async (projectName) => {
-    await exec(`npx create-next-app ${projectName}`, 'Next', false, true);
+  Next: async (projectName, version = FrameworksDefaultVersions.Next) => {
+    await exec(
+      `npx create-next-app@${version} ${projectName} && cd ${projectName} && npm i next@${version}`,
+      'Next',
+      false,
+      true,
+    );
   },
-  React: async (projectName) => {
-    await exec(`npx create-react-app ${projectName}`, 'React', false, true);
+  React: async (projectName, version = FrameworksDefaultVersions.React) => {
+    await exec(
+      `npx create-react-app@${version} ${projectName}`,
+      'React',
+      false,
+      true,
+    );
   },
-  Vue: async (projectName) => {
-    await exec(`npx @vue/cli create ${projectName}`, 'Vue', false, true);
+  Vue: async (projectName, version = FrameworksDefaultVersions.Vue) => {
+    await exec(
+      `npx @vue/cli@${version} create ${projectName}`,
+      'Vue',
+      false,
+      true,
+    );
   },
-  Vite: async (projectName) => {
-    await exec(`npx create-vue ${projectName}`, 'Vue/Vite', false, true);
+  Vite: async (projectName, version = FrameworksDefaultVersions.Vite) => {
+    await exec(
+      `npx create-vue@${version} ${projectName}`,
+      'Vue/Vite',
+      false,
+      true,
+    );
   },
 };
 
-export default FrameworkInitializer;
+export { FrameworkInitializer, FrameworksDefaultVersions };

package/lib/constants/index.js

@@ -1,6 +1,15 @@
 import RuntimeApis from './runtime-apis.constants.js';
 import AzionEdges from './azion-edges.constants.js';
 import Messages from './messages/index.js';
-import FrameworkInitializer from './framework-initializer.constants.js';
+import {
+  FrameworkInitializer,
+  FrameworksDefaultVersions,
+} from './framework-initializer.constants.js';
 
-export { AzionEdges, RuntimeApis, Messages, FrameworkInitializer };
+export {
+  AzionEdges,
+  RuntimeApis,
+  Messages,
+  FrameworkInitializer,
+  FrameworksDefaultVersions,
+};

package/lib/env/env.test.js

@@ -0,0 +1,145 @@
+import { afterEach, beforeEach, describe, expect } from '@jest/globals';
+import mockFs from 'mock-fs';
+import fs from 'fs';
+import runtime from './runtime.env.js';
+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();
+  });
+});
+
+describe('vulcan env', () => {
+  const { env } = process;
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = { HOME: '/home/user' };
+    process.cwd = jest.fn(() => '/');
+  });
+
+  afterEach(() => {
+    process.env = env;
+  });
+
+  it('Should create a vulcan env with global scope', async () => {
+    mockFs({});
+    await vulcanEnv.createVulcanEnv(
+      { API_KEY: 'abc123', ANOTHER_KEY: 'xyz' },
+      'global',
+    );
+
+    const vulcanEnvContent = fs.readFileSync(
+      '/home/user/.azion/.vulcan',
+      'utf8',
+    );
+
+    expect(vulcanEnvContent.trim()).toEqual(
+      `API_KEY=abc123
+ANOTHER_KEY=xyz`,
+    );
+    mockFs.restore();
+  });
+
+  it('Should create a vulcan env with default scope', async () => {
+    mockFs({});
+    await vulcanEnv.createVulcanEnv({ API_KEY: 'abc123', ANOTHER_KEY: 'xyz' });
+
+    const vulcanEnvContent = fs.readFileSync(
+      '/home/user/.azion/.vulcan',
+      'utf8',
+    );
+
+    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',
+    );
+
+    const vulcanEnvContent = fs.readFileSync('/.vulcan', 'utf8');
+
+    expect(vulcanEnvContent.trim()).toEqual(
+      `API_KEY=abc123
+ANOTHER_KEY=xyz`,
+    );
+    mockFs.restore();
+  });
+
+  it('Should update a vulcan env with local scope', async () => {
+    mockFs({
+      '/.vulcan': `API_KEY=abc123`,
+    });
+    await vulcanEnv.createVulcanEnv({ API_KEY: 'abc456' }, 'local');
+
+    const vulcanEnvContent = fs.readFileSync('/.vulcan', 'utf8');
+
+    expect(vulcanEnvContent.trim()).toEqual(`API_KEY=abc456`);
+    mockFs.restore();
+  });
+
+  it('Should read a vulcan env with default scope', async () => {
+    mockFs({
+      '/home/user/.azion/.vulcan': `API_KEY=abc123`,
+    });
+    const envContent = await vulcanEnv.readVulcanEnv();
+
+    expect(envContent).toMatchObject({ API_KEY: 'abc123' });
+    mockFs.restore();
+  });
+
+  it('Should read a vulcan env with global scope', async () => {
+    mockFs({
+      '/home/user/.azion/.vulcan': `API_KEY=abc123`,
+    });
+    const envContent = await vulcanEnv.readVulcanEnv('global');
+
+    expect(envContent).toMatchObject({ API_KEY: 'abc123' });
+    mockFs.restore();
+  });
+
+  it('Should read a vulcan env with local scope', async () => {
+    mockFs({
+      '/.vulcan': `API_KEY=abc123`,
+    });
+    const envContent = await vulcanEnv.readVulcanEnv('local');
+
+    expect(envContent).toMatchObject({ API_KEY: 'abc123' });
+    mockFs.restore();
+  });
+
+  it('Should read a vulcanconfig file', async () => {
+    mockFs({
+      '/vulcan.config.js': `module.exports = {
+        memoryFS: {
+            injectionDirs: ['.faststore/@generated/graphql'],
+            removePathPrefix: '.faststore/',
+        }
+      };`,
+    });
+    const expectedContent = {
+      memoryFS: {
+        injectionDirs: ['.faststore/@generated/graphql'],
+        removePathPrefix: '.faststore/',
+      },
+    };
+    const vulcaConfigFileContent = await vulcanEnv.loadVulcanConfigFile();
+    expect(vulcaConfigFileContent).toEqual(expectedContent);
+    mockFs.restore();
+  });
+});

package/lib/env/polyfills/fetch.polyfills.test.js

@@ -0,0 +1,46 @@
+import mockFS from 'mock-fs';
+import { Headers, Response, Request, URL } from '@edge-runtime/primitives';
+import { expect } from '@jest/globals';
+import fetchPolyfill from './fetch.polyfills.js';
+
+describe('fetchPolyfill', () => {
+  it('should call the global fetch function for non-file URLs', async () => {
+    const resource = 'https://example.com/api/data';
+    const options = { method: 'GET' };
+    const mockContext = {
+      Headers,
+      Response,
+      Request,
+      URL,
+      RESERVED_FETCH: () => {
+        const response = '{ "statusText": "Not Found"  }';
+        return JSON.parse(response);
+      },
+    };
+
+    const response = await fetchPolyfill(mockContext, resource, options);
+
+    expect(response.statusText).toBe('Not Found');
+  });
+
+  it('should return a response when the begin with file://', async () => {
+    mockFS({
+      '.edge': {
+        '.env': 'VERSION_ID=123456',
+        storage: {
+          data: { build: { 'file.js': "console.log('ops')" } },
+        },
+      },
+    });
+
+    const resource = 'file:///data/build/file.js';
+    const options = { method: 'GET' };
+    const mockContext = { Headers, Response };
+
+    const response = await fetchPolyfill(mockContext, resource, options);
+
+    expect(response.headers.get('Content-Type')).toBe('application/javascript');
+    expect(response.status).toBe(200);
+    mockFS.restore();
+  });
+});

package/lib/env/server.env.js

@@ -1,12 +1,10 @@
 import { debug, readWorkerFile, feedback, exec } from '#utils';
 import { Messages } from '#constants';
-import edgeRuntimePackage from 'edge-runtime';
+import { runServer, EdgeRuntime } from 'edge-runtime';
 import chokidar from 'chokidar';
 import runtime from './runtime.env.js';
 import vulcan from './vulcan.env.js';
 
-const { runServer, EdgeRuntimeServer } = edgeRuntimePackage;
-
 let currentServer;
 let isChangeHandlerRunning = false;
 
@@ -32,11 +30,11 @@ async function readWorkerCode(workerPath) {
  * Initialize and run the server with the given port and worker code.
  * @param {number} port - The port number.
  * @param {string} workerCode - The worker code.
- * @returns {Promise<EdgeRuntimeServer>} - The initialized server.
+ * @returns {Promise<EdgeRuntime>} - The initialized server.
  */
 async function initializeServer(port, workerCode) {
   const execution = runtime(workerCode);
-  return runServer({ port, host: 'localhost', runtime: execution });
+  return runServer({ port, host: '0.0.0.0', runtime: execution });
 }
 
 /**
@@ -55,7 +53,9 @@ async function manageServer(workerPath, port) {
     try {
       currentServer = await initializeServer(port, workerCode);
       feedback.server.success(
-        Messages.env.server.success.server_running(`http://localhost:${port}`),
+        Messages.env.server.success.server_running(
+          `0.0.0.0:${port}, url: http://localhost:${port}`,
+        ),
       );
     } catch (error) {
       if (error.code === 'EADDRINUSE') {

package/lib/env/vulcan.env.js

@@ -147,7 +147,7 @@ async function loadVulcanConfigFile() {
   let vulcanCustomConfig = null;
 
   if (fs.existsSync(buildConfigPath)) {
-    const vulcanCustomConfigModule = await import(`file://${buildConfigPath}`);
+    const vulcanCustomConfigModule = await import(buildConfigPath);
     vulcanCustomConfig = vulcanCustomConfigModule.default || {};
   }
 

package/lib/presets/custom/astro/deliver/prebuild.js

@@ -1,5 +1,10 @@
 import { rm, readFile } from 'fs/promises';
-import { exec, getPackageManager, copyDirectory } from '#utils';
+import {
+  exec,
+  getPackageManager,
+  copyDirectory,
+  generateManifest,
+} from '#utils';
 
 const packageManager = await getPackageManager();
 
@@ -25,6 +30,7 @@ async function prebuild() {
 
   // move files to vulcan default path
   copyDirectory(outDir, newOutDir);
+  generateManifest('*', '*', 'deliver');
   rm(outDir, { recursive: true, force: true });
 }
 

package/lib/presets/custom/next/compute/config.js

@@ -68,6 +68,9 @@ const config = {
         async_hooks: false,
         tls: false,
         net: false,
+        child_process: false,
+        https: require.resolve('https-browserify'),
+        tty: require.resolve('tty-browserify'),
         http: require.resolve('stream-http'),
         buffer: require.resolve('buffer/'),
         crypto: require.resolve('crypto-browserify/'),

package/lib/presets/custom/next/compute/node/index.js

@@ -5,6 +5,22 @@ import fs from 'fs';
 import { copyDirectory, feedback, getAbsoluteLibDirPath } from '#utils';
 import BuildStatic from './prebuild/index.js';
 
+/**
+ * If a relative path exists, copy public path to root
+ * @param {string} pathPrefix - prefix
+ * @param {string} rootDir - application root dir
+ */
+function handlePublicDir(pathPrefix, rootDir) {
+  const validPathPrefix =
+    pathPrefix && typeof pathPrefix === 'string' && pathPrefix !== '';
+
+  if (validPathPrefix) {
+    const srcPublicDir = path.resolve(pathPrefix, 'public');
+    const destPublicDir = path.resolve(rootDir, 'public');
+    copyDirectory(srcPublicDir, destPublicDir);
+  }
+}
+
 /**
  * Run actions to build next for node runtime.
  * @param {string} nextVersion - project next version in package.json
@@ -50,10 +66,15 @@ async function run(nextVersion, buildContext) {
     }
 
     // STATICS
+    // copy to root public dir if necessary
+    if (buildContext.memoryFS) {
+      handlePublicDir(buildContext.memoryFS.removePathPrefix, rootDir);
+    }
+
     const buildStatic = new BuildStatic({
       rootDir,
       includeDirs: ['./.next', './public'],
-      staticDirs: ['public', '.next/static'],
+      staticDirs: ['./public', '.next/static'],
       excludeDirs: ['./.next/cache', 'node_modules'],
       out: OUT_DIR_CUSTOM_SERVER,
       versionId: buildContext.buildId,

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

@@ -0,0 +1,30 @@
+import { join } from 'path';
+import { writeFileSync } from 'fs';
+import { Utils } from '#namespaces';
+
+/**
+ * @function
+ * @memberof Utils
+ * @description Generates manifest object and writes it to a file.
+ * @param {string} route - the route to be used,  or all represented by '*'
+ * @param {string} filePath - the file path for the route, or all represented by '*'
+ * @param {string} mode - The mode of the operation, either 'compute', 'deliver', or both represented by '*'.
+ */
+function generateManifest(route, filePath, mode) {
+  const manifestPath = join(process.cwd(), '.edge/manifest.json');
+  const manifest = { routes: {} };
+
+  // Check the mode and add the route to the manifest appropriately.
+  if (mode === 'compute' || mode === 'deliver' || mode === '*') {
+    manifest.routes[mode] = {};
+    manifest.routes[mode][route] = filePath;
+  } else {
+    throw new Error('Invalid mode. Must be "compute", "deliver", or "*".');
+  }
+
+  // Write the new manifest back to the file.
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+  console.log(`New manifest created with ${mode} information.`);
+}
+
+export default generateManifest;

package/lib/utils/generateManifest/index.js

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

package/lib/utils/generateWebpackBanner/generateWebpackBanner.utils.test.js

@@ -0,0 +1,22 @@
+import mockFS from 'mock-fs';
+import generateWebpackBanner from './generateWebpackBanner.utils.js';
+
+describe('generateWebpackBanner', () => {
+  it('should generate a webpack banner', () => {
+    const arrayOfPaths = ['path/to/file1.js', 'path/to/file2.js'];
+    const expectedBanner = 'file-1-content\nfile-2-content\n';
+    mockFS({
+      path: {
+        to: {
+          'file1.js': 'file-1-content',
+          'file2.js': 'file-2-content',
+        },
+      },
+    });
+
+    const bannerArray = generateWebpackBanner(arrayOfPaths);
+
+    expect(bannerArray).toBe(expectedBanner);
+    mockFS.restore();
+  });
+});

package/lib/utils/getExportedFunctionBody/getExportedFunctionBody.utils.test.js

@@ -1,6 +1,7 @@
+/* eslint-disable jest/no-disabled-tests */
 import getExportedFunctionBody from './getExportedFunctionBody.utils.js';
 
-describe('getExportedFunctionBody', () => {
+describe.skip('getExportedFunctionBody', () => {
   it('should extract the body from a default exported function declaration', () => {
     const inputCode = `
       export default function test() {

package/lib/utils/getUrlFromResource/getUrlFromResource.utils.test.js

@@ -0,0 +1,43 @@
+import { URL, Request } from '@edge-runtime/primitives';
+import getUrlFromResource from './getUrlFromResource.utils.js';
+
+describe('getUrlFromResource', () => {
+  it('should return a URL when passed a valid string', () => {
+    const urlString = 'https://example.com/';
+    const context = { Request, URL };
+    const result = getUrlFromResource(context, urlString);
+    expect(result).toBeInstanceOf(URL);
+    expect(result.href).toBe(urlString);
+  });
+
+  it('should return a URL when passed a Request object', () => {
+    const request = new Request('https://example.com');
+    const context = { Request, URL };
+    const result = getUrlFromResource(context, request);
+    expect(result).toBeInstanceOf(URL);
+    expect(result.href).toBe(request.url);
+  });
+
+  it('should return the same URL when passed a URL object', () => {
+    const url = new URL('https://example.com');
+    const context = { Request, URL };
+    const result = getUrlFromResource(context, url);
+    expect(result).toBe(url);
+  });
+
+  it('should throw an error when passed an invalid url', () => {
+    const invalidInput = 'example.com'; // Invalid input (not a string, Request, or URL)
+    const context = { Request, URL };
+    expect(() => getUrlFromResource(context, invalidInput)).toThrow(
+      'Invalid URL',
+    );
+  });
+
+  it('should throw an error when passed an invalid input', () => {
+    const invalidInput = 123; // Invalid input (not a string, Request, or URL)
+    const context = { Request, URL };
+    expect(() => getUrlFromResource(context, invalidInput)).toThrow(
+      "Invalid resource input. 'resource' must be 'URL', 'Request' or 'string'.",
+    );
+  });
+});

package/lib/utils/getVulcanBuildId/getVulcanBuildId.utils.test.js

@@ -1,36 +1,16 @@
-import { writeFileSync, mkdirSync, rmSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-
+import mockFs from 'mock-fs';
 import getVulcanBuildId from './index.js';
 
-const FILE_NAME = '.env';
-const FILE_DIR = '.edge';
-const CURRENT_DIR = process.cwd();
-const TMP_DIR = tmpdir();
-const DIR_PATH = join(TMP_DIR, FILE_DIR);
-const FILE_PATH = join(TMP_DIR, FILE_DIR, FILE_NAME);
-
 describe('getVulcanBuildId utils', () => {
-  beforeAll(() => {
-    process.chdir(TMP_DIR);
-
-    mkdirSync(DIR_PATH);
-
-    writeFileSync(FILE_PATH, 'VERSION_ID=20230627142534');
-  });
-
-  afterAll(() => {
-    process.chdir(CURRENT_DIR);
-
-    rmSync(DIR_PATH, { recursive: true, force: true });
-  });
-
   test('Should fetch the unique build ID for the current project', async () => {
+    mockFs({
+      '.edge': { '.env': 'VERSION_ID=20230627142534' },
+    });
     const expectedOutput = '20230627142534';
 
     const result = getVulcanBuildId();
 
     expect(result).toBe(expectedOutput);
+    mockFs.restore();
   });
 });

package/lib/utils/index.js

@@ -18,6 +18,7 @@ import generateWebpackBanner from './generateWebpackBanner/index.js';
 import relocateImportsAndRequires from './relocateImportsAndRequires/index.js';
 import getExportedFunctionBody from './getExportedFunctionBody/index.js';
 import injectFilesInMem from './injectFilesInMem/index.js';
+import generateManifest from './generateManifest/index.js';
 
 export {
   copyDirectory,
@@ -40,4 +41,5 @@ export {
   generateWebpackBanner,
   relocateImportsAndRequires,
   injectFilesInMem,
+  generateManifest,
 };

package/lib/utils/injectFilesInMem/injectFilesInMem.utils.test.js

@@ -26,10 +26,10 @@ describe('injectFilesInMem', () => {
       '/path/to/dir2',
     ]);
 
-    expect(codeToInject).toContain('globalThis.__FILES__');
+    expect(codeToInject).toContain('globalThis.vulcan.__FILES__');
 
     const strData = codeToInject
-      .replace('globalThis.__FILES__=', '')
+      .replace('globalThis.vulcan.__FILES__=', '')
       .replace('};', '}');
     const data = JSON.parse(strData);