edge-functions 1.3.0 → 1.5.0

package/lib/main.js

@@ -1,13 +1,12 @@
 #! /usr/bin/env node
-import { join, resolve } from 'path';
+import { resolve } from 'path';
 import { readFileSync } from 'fs';
 import { Command } from 'commander';
-import { createPromptModule } from 'inquirer';
 import { satisfies } from 'semver';
 import {
   feedback, debug, getAbsoluteLibDirPath,
 } from '#utils';
-import { Messages, FrameworkInitializer } from '#constants';
+import { Messages } from '#constants';
 
 const MIN_NODE_VERSION = '18.0.0';
 
@@ -19,7 +18,6 @@ const vulcanVersion = vulcanPackageJSON.version;
 const debugEnabled = process.env.DEBUG === 'true';
 
 const program = new Command();
-const prompt = createPromptModule();
 
 /**
  * Validates if user is using the minimum Node version
@@ -27,7 +25,6 @@ const prompt = createPromptModule();
  */
 function validateNodeMinVersion() {
   const isAValidVersion = satisfies(process.version, `>= ${MIN_NODE_VERSION}`);
-
   return isAValidVersion;
 }
 
@@ -71,48 +68,18 @@ function startVulcanProgram() {
     .option('--name <project_name>', 'Project name')
     .description('Initialize a new project')
     .action(async (options) => {
-      const AVALIABLE_TEMPLATES = Object.keys(FrameworkInitializer);
-      let projectName = options.name;
-
-      const { frameworkChoice } = await prompt([
-        {
-          type: 'list',
-          name: 'frameworkChoice',
-          message: 'Choose a template for your project:',
-          choices: AVALIABLE_TEMPLATES,
-        },
-      ]);
-
-      while (!projectName) {
-      // eslint-disable-next-line no-await-in-loop
-        const { projectName: inputName } = await prompt([
-          {
-            type: 'input',
-            name: 'projectName',
-            message: 'Enter your project name:',
-          },
-        ]);
-
-        if (inputName) {
-          projectName = inputName;
-        }
-        if (!inputName) {
-          feedback.pending(Messages.info.name_required);
-        }
-      }
-
-      const createFrameworkTemplate = FrameworkInitializer[frameworkChoice];
-
-      if (createFrameworkTemplate) {
-        await createFrameworkTemplate(projectName);
-      } else {
-        feedback.error(Messages.errors.invalid_choice);
-      }
+      const { initCommand } = await import('#commands');
+      await initCommand(options);
     });
 
   program
     .command('build')
     .description('Build a project for edge deployment')
+    .option(
+      '--entry <string>',
+      'Code entrypoint (default: ./main.js)',
+      './main.js',
+    )
     .option(
       '--preset <type>',
       'Preset of build target (e.g., vue, next, javascript)',
@@ -123,151 +90,44 @@ function startVulcanProgram() {
       'Mode of build target (e.g., deliver, compute)',
       'compute',
     )
-    .option(
-      '--entry <string>',
-      'Code entrypoint (default: ./main.js)',
-      './main.js',
-    )
     .option(
       '--useNodePolyfills',
       'Use node polyfills in build.',
+      'false',
     )
-    .action(async ({
-      preset, mode, entry, versionId, useNodePolyfills,
-    }) => {
-      let entryPoint = entry;
-
-      if (preset === 'javascript') {
-        feedback.info('Using main.js as entrypoint by default');
-      }
-      if (preset === 'typescript') {
-        feedback.info('Using main.ts as entrypoint by default');
-        entryPoint = './main.ts';
-      }
-
-      const BuildDispatcher = (await import('#build')).default;
-      const buildDispatcher = new BuildDispatcher(
-        preset,
-        mode,
-        entryPoint,
-        versionId,
-        useNodePolyfills,
-      );
-      await buildDispatcher.run();
+    .action(async (options) => {
+      const { buildCommand } = await import('#commands');
+      await buildCommand(options);
     });
 
   program
     .command('dev')
     .description('Start local environment')
-    .arguments('[file]')
+    .arguments('[entry]')
     .option('-p, --port <port>', 'Specify the port', '3000')
-    .action(async (file, options) => {
-      const { port } = options;
-      const parsedPort = parseInt(port, 10);
-      const { server } = await import('#env');
-      const entryPoint = file || join(process.cwd(), '.edge/worker.js');
-      server(entryPoint, parsedPort);
+    .action(async (entry, options) => {
+      const { devCommand } = await import('#commands');
+      await devCommand(entry, options);
     });
 
   program
-    .command('presets <type>')
+    .command('presets <command>')
     .description('Create or use defined project presets for Edge')
-    .action(async (type) => {
-      const { presets } = await import('#utils');
-
-      let name;
-      let mode;
-
-      switch (type) {
-        case 'create':
-          // eslint-disable-next-line no-constant-condition
-          while (true) {
-            // eslint-disable-next-line no-await-in-loop
-            const { inputPresetName } = await prompt([
-              {
-                type: 'input',
-                name: 'inputPresetName',
-                message: 'Enter the preset name:',
-              },
-            ]);
-
-            const presetExists = presets
-              .getKeys()
-              .map((existingPresetName) => existingPresetName.toLowerCase())
-              .includes(inputPresetName.toLowerCase());
-
-            if (presetExists) {
-              feedback.error('A preset with this name already exists.');
-            } else if (!inputPresetName) {
-              feedback.error('Preset name cannot be empty.');
-            } else {
-              name = inputPresetName;
-              break;
-            }
-          }
-
-          // eslint-disable-next-line no-constant-condition
-          while (true) {
-            // eslint-disable-next-line no-await-in-loop
-            const { inputMode } = await prompt([
-              {
-                type: 'list',
-                name: 'inputMode',
-                message: 'Choose the mode:',
-                choices: ['compute', 'deliver'],
-              },
-            ]);
-
-            if (['compute', 'deliver'].includes(inputMode)) {
-              mode = inputMode;
-              break;
-            } else {
-              feedback.error('Invalid mode. Choose either "compute" or "deliver".');
-            }
-          }
-
-          try {
-            presets.set(name, mode);
-            feedback.success(`${name}(${mode}) created with success!`);
-            feedback.info(`Now open './lib/presets/${name}/${mode}' and work on your preset.`);
-          } catch (error) {
-            debug.error(error);
-            feedback.error(Messages.errors.folder_creation_failed(name));
-          }
-          break;
-
-        case 'ls':
-          presets.getBeautify().forEach((preset) => feedback.option(preset));
-          break;
-
-        default:
-          feedback.error('Invalid argument provided.');
-          break;
-      }
-    });
-
-  program
-    .command('logs <type> [id]')
-    .description('Perform operations on function or application logs')
-    .option('-w, --watch', 'Show real-time logs')
-    .action(async (type, id, options) => {
-      const { functions } = await import('#platform');
-      const { watch } = options;
-
-      if (!['function', 'application'].includes(type)) {
-        feedback.error(Messages.platform.logs.errors.invalid_log_type);
-        return;
-      }
-
-      if (type === 'function') {
-        functions.actions.showFunctionLogs(id, watch);
-      }
-      if (type === 'application') {
-        feedback.info(Messages.platform.logs.info.unsupported_log_type);
-      }
+    .action(async (command) => {
+      const { presetsCommand } = await import('#commands');
+      await presetsCommand(command);
     });
 
   if (debugEnabled) {
+    program
+      .command('logs <type> [id]')
+      .description('Perform operations on function or application logs')
+      .option('-w, --watch', 'Show real-time logs')
+      .action(async (type, id, options) => {
+        const { logsCommand } = await import('#commands');
+        await logsCommand(type, id, options);
+      });
+
     program
       .command('auth')
       .option(
@@ -277,65 +137,8 @@ function startVulcanProgram() {
       .option('--token <token>', 'Authenticate using personal token')
       .description('Authenticate the CLI')
       .action(async (options) => {
-        const { core } = await import('#platform');
-
-        const authOptions = [
-          {
-            name: 'Username and Password',
-            value: 'password',
-          },
-          {
-            name: 'Personal Token',
-            value: 'token',
-          },
-        ];
-
-        if (options.password) {
-          const [username, password] = options.password.split(':');
-          core.actions.auth('password', { username, password });
-        }
-
-        if (options.token) {
-          const { token } = options;
-          core.actions.auth('token', { token });
-        }
-
-        if (!options.token && !options.password) {
-          const { authOption } = await prompt([
-            {
-              type: 'list',
-              name: 'authOption',
-              message: 'Choose your login option:',
-              choices: authOptions.map((option) => option.name),
-            },
-          ]);
-
-          if (authOption === 'Username and Password') {
-            const { username, password } = await prompt([
-              {
-                type: 'input',
-                name: 'username',
-                message: 'Enter your username:',
-              },
-              {
-                type: 'password',
-                name: 'password',
-                message: 'Enter your password:',
-              },
-            ]);
-            core.actions.auth('password', { username, password });
-          }
-          if (authOption === 'Personal Token') {
-            const { token } = await prompt([
-              {
-                type: 'password',
-                name: 'token',
-                message: 'Enter your personal token:',
-              },
-            ]);
-            core.actions.auth('token', { token });
-          }
-        }
+        const { authCommand } = await import('#commands');
+        await authCommand(options);
       });
 
     program
@@ -344,44 +147,16 @@ function startVulcanProgram() {
         'Synchronize local .edge/storage with the Edge Function storage',
       )
       .action(async () => {
-        const { core } = await import('#platform');
-        const { getVulcanBuildId } = await import('#utils');
-
-        const versionId = getVulcanBuildId();
-        const basePath = join(process.cwd(), '.edge/storage/');
-        await core.actions.uploadStatics(versionId, basePath);
+        const { storageCommand } = await import('#commands');
+        await storageCommand();
       });
 
     program
       .command('deploy')
       .description('Create and deploy an application with a function')
       .action(async () => {
-        const { core } = await import('#platform');
-        const { getVulcanBuildId } = await import('#utils');
-
-        const versionId = getVulcanBuildId();
-        const staticsPath = join(process.cwd(), '/.edge/storage');
-
-        const answers = await prompt([
-          {
-            type: 'input',
-            name: 'applicationName',
-            message:
-              'Enter the name of the application (optional, leave empty for random name):',
-          },
-          {
-            type: 'input',
-            name: 'functionName',
-            message:
-              'Enter the name of the function (optional, leave empty for random name):',
-          },
-        ]);
-
-        const { applicationName, functionName } = answers;
-
-        await core.actions.uploadStatics(versionId, staticsPath);
-        const domain = await core.actions.deploy(applicationName, functionName);
-        core.actions.watchPropagation(domain);
+        const { deployCommand } = await import('#commands');
+        await deployCommand();
       });
   }
 

package/lib/platform/actions/core/auth.actions.js

@@ -44,12 +44,12 @@ async function auth(loginOption, credentials) {
         feedback.error(responseJSON);
       }
       if (responseJSON.token) {
-        await vulcan.createVulcanEnv('API_TOKEN', responseJSON.token);
+        await vulcan.createVulcanEnv({ API_TOKEN: credentials.token }, 'global');
         feedback.success(Messages.platform.auth.success.auth_success);
       }
     }
     if (loginOption === 'token') {
-      await vulcan.createVulcanEnv('API_TOKEN', credentials.token);
+      await vulcan.createVulcanEnv({ API_TOKEN: credentials.token }, 'global');
       const validateTokenJSON = await (await FunctionService.getAll()).json();
       if (validateTokenJSON.results) {
         feedback.success(Messages.platform.auth.success.auth_success);
@@ -59,8 +59,8 @@ async function auth(loginOption, credentials) {
       }
     }
   } catch (error) {
+    feedback.error(Messages.platform.auth.error.auth_failed);
     debug.error(error);
-    feedback.success(Messages.platform.auth.error.auth_failed);
   }
 }
 

package/lib/platform/services/base.service.js

@@ -2,7 +2,6 @@ import { vulcan } from '#env';
 import _ from 'lodash';
 
 const env = globalThis.vulcan?.env ? globalThis.vulcan.env : 'production';
-
 const APIS = {
   local: 'http://localhost:8082',
   stage: 'https://stage-api.azion.net',
@@ -29,7 +28,7 @@ and returns it as a header object.
  * containing the token in the format { headers: { Authorization: 'Token ${value}' } }.
  */
 const getAuthHeaders = async () => {
-  const token = (await vulcan.readVulcanEnv()).API_TOKEN;
+  const token = (await vulcan.readVulcanEnv('global')).API_TOKEN;
   return { headers: { Authorization: `Token ${token}` } };
 };
 

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

@@ -134,7 +134,10 @@ async function getNextConfig() {
  */
 function validateStaticSiteMode(nextConfig) {
   if (!nextConfig.output || nextConfig.output !== 'export') {
-    throw Error('Static site mode not enabled in config!');
+    const errorMessage = `Static site mode not enabled in project config.
+    You must add 'output: "export"' in your 'next.config.js' file if you are trying to build a Next.js v >= 13.3 static project.
+    For more details go to https://nextjs.org/docs/pages/building-your-application/deploying/static-exports \n`;
+    throw Error(errorMessage);
   }
 }
 

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

@@ -2,7 +2,6 @@ import {
   exec, getPackageManager, copyDirectory,
 } from '#utils';
 import { lstat, readFile, rm } from 'fs/promises';
-import { join } from 'path';
 
 const packageManager = await getPackageManager();
 const edgeStorageDir = '.edge/storage';
@@ -41,7 +40,7 @@ async function prebuild() {
   const npmArgsForward = packageManager === 'npm' ? '--' : '';
 
   let outDir = defaultViteOutDir;
-  let destPath = edgeStorageDir;
+  const destPath = edgeStorageDir;
 
   const isViteProject = await viteConfigExists();
 
@@ -58,9 +57,7 @@ async function prebuild() {
       outDir = config.build.outDir;
     }
 
-    const srcPath = join('.', outDir);
-    destPath = join(edgeStorageDir);
-    copyDirectory(outDir, srcPath);
+    copyDirectory(outDir, destPath);
     rm(outDir, { recursive: true, force: true });
   }
 

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

@@ -0,0 +1,16 @@
+/**
+ * Creates a URL object based on a received resource
+ * @param {URL|Request|string} resource received resource.
+ * @returns {URL} Generated URL object.
+ */
+function getUrlFromResource(resource) {
+  if (typeof resource === 'string') return new URL(resource);
+
+  if (resource instanceof Request) return new URL(resource.url);
+
+  if (resource instanceof URL) return resource;
+
+  throw new Error('Invalid resource input. \'resource\' must be \'URL\', \'Request\' or \'string\'.');
+}
+
+export default getUrlFromResource;

package/lib/utils/getUrlFromResource/index.js

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

package/lib/utils/index.js

@@ -12,6 +12,7 @@ import overrideStaticOutputPath from './overrideStaticOutputPath/index.js';
 import getProjectJsonFile from './getProjectJsonFile/index.js';
 import getPackageVersion from './getPackageVersion/index.js';
 import Spinner from './spinner/index.js';
+import getUrlFromResource from './getUrlFromResource/index.js';
 
 export {
   copyDirectory,
@@ -24,6 +25,7 @@ export {
   getPackageVersion,
   getProjectJsonFile,
   getVulcanBuildId,
+  getUrlFromResource,
   presets,
   overrideStaticOutputPath,
   readWorkerFile,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "edge-functions",
   "type": "module",
-  "version": "1.3.0",
+  "version": "1.5.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": {
@@ -99,7 +99,8 @@
     "#env": "./lib/env/index.js",
     "#platform": "./lib/platform/index.js",
     "#constants": "./lib/constants/index.js",
-    "#edge": "./lib/platform/edgehooks/index.js"
+    "#edge": "./lib/platform/edgehooks/index.js",
+    "#commands": "./lib/commands/index.js"
   },
   "repository": {
     "type": "git",
@@ -109,4 +110,4 @@
     "url": "https://github.com/aziontech/vulcan/issues"
   },
   "homepage": "https://github.com/aziontech/vulcan#readme"
-}
+}

package/releaserc.json

@@ -1,4 +1,5 @@
 {
+  "branches": ["main", "dev"],
   "analyzeCommits": {
     "preset": "conventionalcommits",
     "parserOpts": {

package/lib/polyfills/FetchEvent.polyfills.js

@@ -1,13 +0,0 @@
-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/polyfills/fetch.polyfills.js

@@ -1,39 +0,0 @@
-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/polyfills/index.js

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