edge-functions 1.0.0 → 1.3.0

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

@@ -16,6 +16,8 @@ const build = {
   },
   error: {
     vulcan_build_failed: 'Vulcan build failed.',
+    invalid_preset: 'Invalid build preset. Run "vulcan preset ls" to view available presets.',
+    invalid_preset_mode: (mode, preset) => `Mode '${mode}' does not exists in preset '${preset}'. Try 'deliver' or 'compute'.`,
   },
 
 };

package/lib/constants/messages/env.messages.js

@@ -19,18 +19,20 @@ const env = {
       unknown_error: 'An error occurred while executing the script',
       fetch_event_missing: 'No fetch event handler was defined',
       fetch_event_unknown_error: 'An error occurred while handling the fetch event:',
+      fetch_event_remove_listener: 'Unable to remove event listener.',
+      fetch_event_type: (type) => `Unsupported event type: ${type}`,
       undefined_response: 'No response was defined',
     },
   },
   server: {
     success: {
-      server_running: (port) => `Server running on port ${port}`,
+      server_running: (port) => `Function running on port ${port}`,
     },
     info: {
-      code_change_detect: 'Code change detected. Restarting server...',
+      code_change_detect: 'Code change detected. Restarting...',
     },
     errors: {
-      load_worker_failed: 'Failed to load code:',
+      load_worker_failed: (path) => `Failed load worker: ${path}`,
     },
   },
 };

package/lib/constants/messages/global.messages.js

@@ -6,9 +6,12 @@ Global messages object.
  */
 const global = {
   success: {},
-  info: {},
+  info: {
+    name_required: 'A name is required.',
+  },
   errors: {
     unknown_error: 'An error occurred.',
+    invalid_choice: 'Invalid choice.',
     folder_creation_failed: (folder) => `An error occurred while creating the ${folder} folder.`,
     write_file_failed: (file) => `An error occurred while writing the ${file} file.`,
     file_doesnt_exist: (file) => `An error occurred while reading the ${file} file.`,

package/lib/env/polyfills/FetchEvent.polyfills.js

@@ -0,0 +1,13 @@
+import primitives from '@edge-runtime/primitives';
+import { feedback } from '#utils';
+
+class FetchEventPolyfill extends primitives.FetchEvent {
+  constructor(request) {
+    super(request);
+    this.console = {
+      log: (log) => feedback.server.log(log),
+    };
+  }
+}
+
+export default FetchEventPolyfill;

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

@@ -0,0 +1,39 @@
+import { join } from 'path';
+import { readFileSync } from 'fs';
+import mime from 'mime-types';
+import { EdgeRuntime } from 'edge-runtime';
+
+/**
+ * A custom fetch implementation that adds an additional path to the URL if it starts with 'file://'.
+ * This function is used to simulate the local edge environment. When a 'file://' request is made,
+ * it behaves as if the request is made from within the edge itself. In this case, an additional
+ * '.edge/storage' folder is appended to the URL to represent the edge environment.
+ * @param {EdgeRuntime} context - VMContext
+ * @param {URL} url - The URL to fetch.
+ * @param {object} [options] - The fetch options.
+ * @returns {Promise<Response>} A Promise that resolves to the Response object.
+ */
+async function fetchPolyfill(context, url, options) {
+  const {
+    URL, Headers, Response,
+  } = context;
+
+  const urlOBJ = new URL(url);
+  if (urlOBJ.href.startsWith('file://')) {
+    // url pathname = /VERSION_ID/filePath
+    const file = url.pathname.slice(15);
+    const filePath = join(process.cwd(), '.edge', 'storage', file);
+    const fileContent = readFileSync(filePath);
+    const contentType = mime.lookup(filePath) || 'application/octet-stream';
+
+    const headers = new Headers();
+    headers.append('Content-Type', contentType);
+
+    const response = new Response(fileContent, { headers, ...options });
+    return response;
+  }
+
+  return fetch(url, options);
+}
+
+export default fetchPolyfill;

package/lib/env/polyfills/index.js

@@ -0,0 +1,4 @@
+import fetchPolyfill from './fetch.polyfills.js';
+import FetchEventPolyfill from './FetchEvent.polyfills.js';
+
+export { fetchPolyfill, FetchEventPolyfill };

package/lib/env/runtime.env.js

@@ -1,69 +1,63 @@
-import { NodeVM } from 'vm2';
-import { RuntimeApis, Messages } from '#constants';
-import { feedback, debug } from '#utils';
+import { EdgeRuntime } from 'edge-runtime';
+
+import { fetchPolyfill, FetchEventPolyfill } from './polyfills/index.js';
 
 /**
- * Execute the specified code with the provided event object.
+ * Executes the specified JavaScript code within a sandbox environment,
+ * simulating the behavior of edges that use isolates.
  * @param {string} code - The JavaScript code to be executed.
- * @param {object} event - The event object containing the request and other properties.
- * @returns {Promise<object>} A Promise that resolves with the Response object.
+ * @returns {EdgeRuntime} An instance of the 'EdgeRuntime' class that represents
+ *                        the sandboxed environment where the code will be executed.
+ *
+ * This function allows you to run JavaScript code within a sandboxed environment,
+ * similar to how it would behave on edges that use isolates. It uses the 'EdgeRuntime'
+ * class provided by the 'edge-runtime' library to create the sandboxed environment.
+ *
+ * Example usage:
+ * ```
+ * const code = `
+ *   addEventListener('fetch', event => {
+ *     const { searchParams } = new URL(event.request.url)
+ *     const url = searchParams.get('url')
+ *     return event.respondWith(fetch(url))
+ *   })`;
+ *
+ * const isolate = new runtime(code);
+ *
+ *   const response = await isolate.dispatchFetch('http://localhost:3000');
+ *
+ *   // If your code logic performs asynchronous tasks, you should await them.
+ *   // https://developer.mozilla.org/en-US/docs/Web/API/ExtendableEvent/waitUntil
+ *   await response.waitUntil();
+ *
+ *   // `response` is a Web standard, you can use any of its methods
+ *   console.log(response.status);
+ * ```
  */
-async function run(code, event) {
-  let fetchEventHandler = null;
-  let respondWithPromise = null;
-
-  const vm = new NodeVM({
-    console: 'inherit',
-    sandbox: {
-      Headers,
-      ...event,
-      Response,
-      addEventListener: (type, handler) => {
-        if (type !== 'fetch') {
-          throw new Error(`Unsupported event type: ${type}`);
-        }
-        fetchEventHandler = handler;
-      },
-    },
-    require: {
-      external: true,
-      builtin: RuntimeApis,
-    },
-  });
-
-  try {
-    vm.run(code);
-  } catch (error) {
-    debug.error(error);
-    feedback.error(Messages.env.runtime.errors.unknown_error);
-    throw error;
-  }
-
-  if (!fetchEventHandler) {
-    throw new Error(Messages.env.runtime.errors.fetch_event_missing);
-  }
-
-  let response;
-  try {
-    const fetchEvent = {
-      request: event.request,
-      respondWith: (responsePromise) => {
-        respondWithPromise = responsePromise;
-      },
-    };
-    fetchEventHandler(fetchEvent);
-    response = respondWithPromise;
-  } catch (error) {
-    debug.error(error);
-    feedback.error(Messages.env.runtime.errors.fetch_event_unknown_error);
-    throw error;
-  }
-
-  if (!response) {
-    throw new Error(Messages.env.runtime.errors.undefined_response);
-  }
-
-  return response;
+function runtime(code) {
+  const extend = (context) => {
+    context.fetch = (url, options) => fetchPolyfill(context, url, options);
+    context.FetchEvent = FetchEventPolyfill;
+    context.FirewallEvent = {}; // TODO: Firewall Event
+    /*
+     * According to the Vercel documentation at https://vercel.com/docs/concepts/functions/edge-functions/edge-runtime#unsupported-apis,
+     * the default runtime doesn't support `eval`.
+     * However, in our Runtime environment (Cells Runtime/Azion)
+     * we've enabled and support its functionality.
+     */
+    // eslint-disable-next-line no-eval
+    context.eval = eval;
+
+    /* ==== Cells Runtime/Azion does not have this interface ==== */
+    context.File = undefined;
+    context.WebSocket = undefined;
+    /* ========================================================== */
+
+    return context;
+  };
+
+  const edgeRuntime = new EdgeRuntime({ extend, initialCode: code });
+  return edgeRuntime;
 }
 
-export default run;
+export default runtime;

package/lib/env/server.env.js

@@ -1,90 +1,46 @@
-import http from 'http';
-import chokidar from 'chokidar';
-
-import { debug, feedback, readWorkerFile } from '#utils';
+import { debug, readWorkerFile, feedback } from '#utils';
 import { Messages } from '#constants';
-import run from './runtime.env.js';
+import { runServer } from 'edge-runtime';
+import runtime from './runtime.env.js';
 
 /**
- * Create a new HTTP server.
- * @param {string} filePath - The path to the file containing the code.
- * @returns {http.Server} The created server.
+ * Read the worker code from the file.
+ * @param {string} workerPath - The path to the file containing the code.
+ * @returns {Promise<string>} A promise that resolves to the worker code.
  */
-function createServer(filePath) {
-  return http.createServer(async (request, response) => {
-    let code;
-
-    try {
-      // Load the code to be executed on the server for each request
-      code = await readWorkerFile(filePath);
-    } catch (error) {
-      debug.error(error);
-      response.statusCode = 500;
-      response.setHeader('Content-Type', 'text/plain');
-      response.end(JSON.stringify({ error: error.message }));
-      return;
-    }
-
-    try {
-      const responseBody = await run(code, { request, response });
-
-      if (responseBody instanceof Response) {
-        responseBody.headers.forEach((value, name) => {
-          response.setHeader(name, value);
-        });
-
-        const body = await responseBody.text();
-        response.statusCode = responseBody.status;
-        response.end(body);
-      } else {
-        response.statusCode = 200;
-        response.setHeader('Content-Type', 'text/plain');
-        response.end(responseBody);
-      }
-    } catch (error) {
-      let errorMessage = error.message;
-      if (error.message.includes('is not defined')) {
-        errorMessage = `${error.message} in Edge runtime.`;
-      }
-
-      error.message = errorMessage;
-      debug.error(error);
-      feedback.error(Messages.env.server.errors.load_worker_failed);
-      response.statusCode = 500;
-      response.setHeader('Content-Type', 'text/plain');
-      response.end(JSON.stringify({ error: { message: errorMessage, status: 500 } }));
-    }
-  });
+async function readWorkerCode(workerPath) {
+  try {
+    const worker = await readWorkerFile(workerPath);
+    return worker;
+  } catch (error) {
+    debug.error(error);
+    feedback.server.error(
+      Messages.env.server.errors.load_worker_failed(workerPath),
+    );
+    throw error;
+  }
 }
 
 /**
  * Start the HTTP server with the specified port and file path to load the code from.
- * @param {string} filePath - The path to the file containing the code.
+ * @param {string} workerPath - The path to the file containing the worker code.
  * @param {number} port - The port to listen on.
- * @returns {http.Server} The created server.
  */
-async function startServer(filePath, port) {
-  let server = createServer(filePath);
-
-  // Use chokidar to watch for changes in the file
-  const watcher = chokidar.watch(filePath);
-
-  watcher.on('change', async () => {
-    feedback.info(Messages.env.server.info.code_change_detect);
-    // Close the current server
-    server.close();
-    // And create a new one
-    server = createServer(filePath);
-    server.listen(port, () => {
-      feedback.success(Messages.env.server.success.server_running(port));
+async function startServer(workerPath, port) {
+  try {
+    const workerCode = await readWorkerCode(workerPath);
+    const execution = runtime(workerCode);
+    const server = await runServer({
+      port,
+      host: 'localhost',
+      runtime: execution,
     });
-  });
-
-  server.listen(port, () => {
-    feedback.success(Messages.env.server.success.server_running(port));
-  });
-
-  return server;
+    feedback.server.success(
+      Messages.env.server.success.server_running(server.url),
+    );
+  } catch (error) {
+    debug.error(error);
+  }
 }
 
 export default startServer;