edge-functions 1.4.0 → 1.6.0

package/.eslintrc.json

@@ -65,6 +65,10 @@
           [
             "#edge",
             "./lib/platform/edgehooks/index.js"
+          ],
+          [
+            "#commands",
+            "./lib/commands/index.js"
           ]
         ],
         "extensions": [

package/.github/workflows/release.yml

@@ -0,0 +1,36 @@
+name: Release
+on:
+  push:
+    branches:
+      - main
+      - dev
+
+permissions:
+  contents: read #
+
+jobs:
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+      id-token: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: "lts/*"
+      - name: Install dependencies
+        run: yarn install
+      - name: Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: npx semantic-release

package/.releaserc

@@ -0,0 +1,31 @@
+{
+  "branches": [
+    "main",
+    {
+      "name": "dev",
+      "prerelease": true,
+      "channel": "stage"
+    }
+  ],
+  "analyzeCommits": {
+    "preset": "conventionalcommits",
+    "parserOpts": {
+      "headerPattern": "^(\\[ISSUE-.*])?\\s?(\\w+):\\s(.*)$",
+      "headerCorrespondence": ["scope", "type", "subject"]
+    }
+  },
+  "generateNotes": {
+    "preset": "conventionalcommits",
+    "parserOpts": {
+      "headerPattern": "^(\\[ISSUE-.*])?\\s?(\\w+):\\s(.*)$",
+      "headerCorrespondence": ["scope", "type", "subject"]
+    },
+    "options": {
+      "preset": {
+        "name": "conventionalchangelog",
+        "issuePrefixes": ["ISSUE-"],
+        "issueUrlFormat": "https://github.com/aziontech/vulcan/issues/{id}"
+      }
+    }
+  }
+}

package/aliases.js

@@ -10,4 +10,5 @@ export default [
   ['#platform', './lib/platform/index.js'],
   ['#constants', './lib/constants/index.js'],
   ['#edge', './lib/platform/edgehooks/index.js'],
+  ['#commands', './lib/commands/index.js'],
 ];

package/examples/simple-js-esm/main.js

@@ -2,9 +2,9 @@
 
 import messages from './messages.js';
 
-const message = messages[Math.floor(Math.random() * messages.length)];
-
 function main(event) {
+  const message = messages[Math.floor(Math.random() * messages.length)];
+  
   console.log('selected message:', message);
   console.log('VERSION_ID =', AZION_VERSION_ID);
 

package/jsconfig.json

@@ -34,6 +34,9 @@
       ],
       "#edge": [
         "./lib/platform/edgehooks/index.js"
+      ],
+      "#commands": [
+        "./lib/commands/index.js"
       ]
     }
   }

package/lib/build/dispatcher/dispatcher.js

@@ -8,6 +8,7 @@ import {
   feedback, debug, generateTimestamp, getAbsoluteLibDirPath, presets,
 } from '#utils';
 import { Messages } from '#constants';
+import { vulcan } from '#env';
 
 const vulcanLibPath = getAbsoluteLibDirPath();
 const vulcanRootPath = resolve(vulcanLibPath, '..');
@@ -148,21 +149,24 @@ async function loadBuildContext(preset, entry, mode) {
 }
 
 /**
- * Generates a build ID and saves it in the .env file (for deploy).
- * @returns {Promise<string>} The generated build ID.
+Create a .env file in the build folder with specified parameters.
+ * @param {string} buildId - The version ID to write into the .env file.
+ * @param {string} entry - Entrypoint path.
+ * @param {string} preset - The preset to write into the .env file.
+ * @param {string} mode - The mode to write into the .env file.
+ * @param {boolean} useNodePolyfills - The flag to indicates polyfills use.
  */
-function generateBuildId() {
+function createDotEnvFile(buildId) {
   const projectRoot = process.cwd();
   const outputPath = isWindows ? fileURLToPath(new URL(`file:///${join(projectRoot, '.edge')}`)) : join(projectRoot, '.edge');
-
   const envFilePath = join(outputPath, '.env');
-  const BUILD_VERSION___AKA__VERSION_ID = generateTimestamp();
-  const envContent = `VERSION_ID=${BUILD_VERSION___AKA__VERSION_ID}`;
+
+  const envContent = [
+    `VERSION_ID=${buildId}`,
+  ].join('\n');
 
   mkdirSync(outputPath, { recursive: true });
   writeFileSync(envFilePath, envContent);
-
-  return BUILD_VERSION___AKA__VERSION_ID;
 }
 
 /**
@@ -177,15 +181,14 @@ class Dispatcher {
    * @param {string} preset - The preset for the build.
    * @param {string} mode - The mode of build target.
    * @param {string} entry - The entry point for the build.
-   * @param {string} versionId - The version ID for the build.
    * @param {boolean} useNodePolyfills - The flag to indicates polyfills use.
    */
-  constructor(preset, mode, entry, versionId, useNodePolyfills) {
+  constructor(preset, mode, entry, useNodePolyfills) {
     this.preset = preset;
     this.mode = mode;
     this.entry = entry;
-    this.versionId = versionId;
     this.useNodePolyfills = useNodePolyfills;
+    this.buildId = generateTimestamp();
   }
 
   /**
@@ -199,29 +202,27 @@ class Dispatcher {
       this.mode,
     );
 
-    const buildId = generateBuildId();
-
     const buildContext = {
       preset: this.preset,
-      entry: this.entry,
       mode: this.mode,
-      cliVersionId: this.versionId,
-      useNodePolyfills: this.useNodePolyfills,
-      buildId,
-      config,
+      entry: this.entry,
       entryContent,
+      config,
+      useNodePolyfills: this.useNodePolyfills,
+      buildId: this.buildId,
     };
 
     // Run prebuild actions
     try {
       feedback.prebuild.info(Messages.build.info.prebuild_starting);
       await prebuild(buildContext);
+      createDotEnvFile(this.buildId);
       feedback.prebuild.success(Messages.build.success.prebuild_succeeded);
 
       feedback.build.info(Messages.build.info.vulcan_build_starting);
       // create tmp entrypoint
       const currentDir = process.cwd();
-      let tempEntryFile = `vulcan-${buildId}.temp.`;
+      let tempEntryFile = `vulcan-${this.buildId}.temp.`;
       tempEntryFile += (this.preset === 'typescript') ? 'ts' : 'js';
       const tempBuilderEntryPath = join(currentDir, tempEntryFile);
 
@@ -229,7 +230,7 @@ class Dispatcher {
 
       // builder entry
       config.entry = tempBuilderEntryPath;
-      config.buildId = buildId;
+      config.buildId = this.buildId;
       config.useNodePolyfills = this.useNodePolyfills;
 
       let builder;
@@ -250,9 +251,17 @@ class Dispatcher {
 
       // delete .temp files
       rmSync(tempBuilderEntryPath);
+
+      await vulcan.createVulcanEnv({
+        entry: this.entry,
+        preset: this.preset,
+        mode: this.mode,
+        useNodePolyfills: this.useNodePolyfills,
+      }, 'local');
+
       feedback.build.success(Messages.build.success.vulcan_build_succeeded);
     } catch (error) {
-      debug.error(error);
+      feedback.build.error(error);
       process.exit(1);
     }
   };

package/lib/commands/auth.commands.js

@@ -0,0 +1,85 @@
+import { createPromptModule } from 'inquirer';
+
+const prompt = createPromptModule();
+/**
+ * A command to handle authentication through various methods.
+ * @memberof commands
+ * @param {object} options - Configuration options for authentication
+ * @param {string} [options.password] - Credentials in the format "username:password"
+ * @param {string} [options.token] - Personal authentication token
+ * @returns {Promise<void>} - A promise that resolves when authentication is complete
+ * @example
+ *
+ * authCommand({
+ *   password: 'username:password'
+ * });
+ *
+ * authCommand({
+ *   token: 'your_personal_token'
+ * });
+ *
+ * authCommand({});
+ */
+async function authCommand(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 });
+    }
+  }
+}
+
+export default authCommand;

package/lib/commands/build.commands.js

@@ -0,0 +1,47 @@
+import { feedback } from '#utils';
+
+/**
+ * A command to initiate the build process.
+ * @memberof commands
+ * @param {object} options - Configuration options for the build command
+ * @param {string} options.entry - The entry point file for the build
+ * @param {string} options.preset - Preset to be used (e.g., 'javascript', 'typescript')
+ * @param {string} options.mode - Mode in which to run the build (e.g., 'deliver', 'compute')
+ * @param {boolean} options.useNodePolyfills - Whether to use Node.js polyfills
+ * @returns {Promise<void>} - A promise that resolves when the build is complete
+ * @example
+ *
+ * buildCommand({
+ *   entry: './src/index.js',
+ *   preset: 'javascript',
+ *   mode: 'compute',
+ *   useNodePolyfills: false
+ * });
+ */
+async function buildCommand({
+  entry, preset, mode, useNodePolyfills,
+}) {
+  let entryPoint = null;
+
+  if (preset === 'javascript') {
+    entryPoint = entry;
+    feedback.info('Using main.js as entrypoint by default');
+  }
+  if (preset === 'typescript') {
+    if (entry) { entryPoint = entry; }
+    feedback.info('Using main.ts as entrypoint by default');
+    if (!entry) { entryPoint = './main.ts'; }
+  }
+
+  const BuildDispatcher = (await import('#build')).default;
+  const buildDispatcher = new BuildDispatcher(
+    preset,
+    mode,
+    entryPoint,
+    useNodePolyfills,
+  );
+
+  await buildDispatcher.run();
+}
+
+export default buildCommand;

package/lib/commands/deploy.commands.js

@@ -0,0 +1,45 @@
+import { join } from 'path';
+import { createPromptModule } from 'inquirer';
+
+const prompt = createPromptModule();
+/**
+ * A Command to deploy a web application.
+ * @memberof commands
+ * This command will ask for the application name and function name via the terminal.
+ * Then, it will upload static files and deploy the application.
+ * Finally, it watches for the propagation of the deployment.
+ * @returns {Promise<void>} - A promise that resolves when the deployment is complete.
+ * @example
+ *
+ * deployCommand();
+ */
+async function deployCommand() {
+  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);
+}
+
+export default deployCommand;

package/lib/commands/dev.commands.js

@@ -0,0 +1,26 @@
+import { join } from 'path';
+
+/**
+ * A command to start the development server.
+ * @memberof commands
+ *
+ * This function takes a file path and options object as arguments.
+ * The file path is the entry point for the development server,
+ * and the options object contains the port number.
+ * @param {string} entry - The path to the file that serves as the
+ *  entry point for the development server.
+ * @param {object} options - An object containing configuration options.
+ * @param {string|number} options.port - The port number on which the development server will run.
+ * @returns {Promise<void>} - A promise that resolves when the development server starts.
+ * @example
+ *
+ * devCommand('./path/to/entry.js', { port: 3000 });
+ */
+async function devCommand(entry, { port }) {
+  const parsedPort = parseInt(port, 10);
+  const { server } = await import('#env');
+  const entryPoint = entry || join(process.cwd(), '.edge/worker.js');
+  server(entryPoint, parsedPort);
+}
+
+export default devCommand;

package/lib/commands/index.js

@@ -0,0 +1,13 @@
+import authCommand from './auth.commands.js';
+import buildCommand from './build.commands.js';
+import deployCommand from './deploy.commands.js';
+import devCommand from './dev.commands.js';
+import initCommand from './init.commands.js';
+import logsCommand from './logs.commands.js';
+import presetsCommand from './presets.commands.js';
+import storageCommand from './storage.commands.js';
+
+export {
+  authCommand, buildCommand, deployCommand, devCommand,
+  initCommand, logsCommand, presetsCommand, storageCommand,
+};

package/lib/commands/init.commands.js

@@ -0,0 +1,71 @@
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { createPromptModule } from 'inquirer';
+import { FrameworkInitializer, Messages } from '#constants';
+import { feedback, debug } from '#utils';
+import { vulcan } from '#env';
+
+const prompt = createPromptModule();
+
+/**
+ * Initializes a new project based on the selected framework template.
+ * @param {object} options - Configuration options for initialization.
+ * @param {string} options.name - Name of the new project.
+ * If not provided, the function will prompt for it.
+ * @example
+ * initCommand({ name: 'my_new_project' });
+ */
+async function initComamnd({ name }) {
+  try {
+    const AVALIABLE_TEMPLATES = Object.keys(FrameworkInitializer);
+    let projectName = name;
+
+    const { frameworkChoice } = await prompt([
+      {
+        type: 'list',
+        name: 'frameworkChoice',
+        message: 'Choose a template for your project:',
+        choices: AVALIABLE_TEMPLATES,
+      },
+    ]);
+
+    while (!projectName) {
+      const dirExists = (dirName) => existsSync(join(process.cwd(), dirName));
+
+      // eslint-disable-next-line no-await-in-loop
+      const { projectName: inputName } = await prompt([
+        {
+          type: 'input',
+          name: 'projectName',
+          message: 'Enter your project name:',
+        },
+      ]);
+
+      if (inputName && !dirExists(inputName)) {
+        projectName = inputName;
+      } else if (dirExists(inputName)) {
+        feedback.pending(
+          Messages.errors.folder_name_already_exists(inputName),
+        );
+      } else {
+        feedback.pending(Messages.info.name_required);
+      }
+    }
+
+    const createFrameworkTemplate = FrameworkInitializer[frameworkChoice];
+    if (createFrameworkTemplate) {
+      const dest = join(process.cwd(), projectName);
+      await createFrameworkTemplate(projectName);
+      await vulcan.createVulcanEnv(
+        { preset: frameworkChoice.toLowerCase() },
+        dest,
+      );
+    } else {
+      feedback.error(Messages.errors.invalid_choice);
+    }
+  } catch (error) {
+    debug.error(error);
+  }
+}
+
+export default initComamnd;

package/lib/commands/logs.commands.js

@@ -0,0 +1,34 @@
+import { feedback } from '#utils';
+import { Messages } from '#constants';
+/**
+ * A comamnd to display logs for a specified function or application.
+ * @memberof commands
+ * This function allows the user to view logs for a specific function or application.
+ * Note that viewing logs for applications is currently unsupported.
+ * @param {string} type - The type of entity to show logs for.
+ * Accepted values are 'function' and 'application'.
+ * @param {string} id - The identifier for the function or application.
+ * @param {object} options - Additional options for fetching logs.
+ * @param {boolean} options.watch - If true, keep watching the logs and updating in real-time.
+ * @returns {Promise<void>} - A promise that resolves when logs are fetched and displayed.
+ * @example
+ *
+ * logsCommand('function', 'functionId123', { watch: true });
+ */
+async function logsCommand(type, id, { watch }) {
+  const { functions } = await import('#platform');
+
+  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);
+  }
+}
+
+export default logsCommand;

package/lib/commands/presets.commands.js

@@ -0,0 +1,97 @@
+import { createPromptModule } from 'inquirer';
+import { Messages } from '#constants';
+import { feedback, debug } from '#utils';
+
+const prompt = createPromptModule();
+
+/**
+ * Manages presets for the application.
+ * @memberof commands
+ * This command allows the user to create or list presets.
+ * The user is guided by a series of prompts to enter a preset name and mode.
+ * @param {string} command - The operation to be performed:
+ * 'create' to create a preset, 'ls' to list presets.
+ * @returns {Promise<void>} - A promise that resolves when the action is complete.
+ * @example
+ *
+ * // To create a new preset
+ * presetsCommand('create');
+ *
+ * // To list existing presets
+ * presetsCommand('ls');
+ */
+async function presetsCommand(command) {
+  const { presets } = await import('#utils');
+
+  let name;
+  let mode;
+
+  switch (command) {
+    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;
+  }
+}
+
+export default presetsCommand;

package/lib/commands/storage.commands.js

@@ -0,0 +1,22 @@
+import { join } from 'path';
+
+/**
+ * A command to uploads static files for a given version of the application.
+ * @memberof commands
+ * The function identifies the build version, prepares a base path for static files,
+ * and uploads these files to the storage of the core platform.
+ * @returns {Promise<void>} - A promise that resolves when static files are successfully uploaded.
+ * @example
+ *
+ * storageCommand();
+ */
+async function storageCommand() {
+  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);
+}
+
+export default storageCommand;