@joystick.js/cli-canary 0.0.0-canary.1

package/src/functions/push/deploy/index.js

@@ -0,0 +1,199 @@
+/* eslint-disable consistent-return */
+
+import fetch from 'node-fetch';
+import chalk from 'chalk';
+import _ from 'lodash';
+import fs from 'fs';
+import FormData from 'form-data';
+import Loader from '../../lib/loader.js';
+import domains from './domains.js';
+import checkIfValidJSON from '../../lib/checkIfValidJSON.js';
+import CLILog from '../../lib/CLILog.js';
+import build from '../build/index.js';
+import getAvailableCDN from "../getAvailableCDN.js";
+import initialDeployment from './initial.js';
+import versionDeployment from './version.js';
+
+const getAppSettings = (environment = '') => {
+  try {
+    if (fs.existsSync(`settings.${environment}.json`)) {
+      const file = fs.readFileSync(`settings.${environment}.json`, 'utf-8');
+      return file;
+    }
+
+    return '{}';
+  } catch (exception) {
+    throw new Error(`[initDeployment.getAppSettings] ${exception.message}`);
+  }
+};
+
+const startDeployment = async ({
+  isInitialDeployment = false,
+  loginSessionToken = '',
+  deployment = {},
+  version = '',
+  appSettings = '',
+  environment = 'production',
+  server = 'production',
+}) => {
+  try {
+    if (isInitialDeployment) {
+      return initialDeployment({
+        version,
+        deployment,
+        settings: appSettings,
+        environment,
+        loginSessionToken,
+        server,
+      });
+    }
+
+    return versionDeployment({
+      version,
+      deployment,
+      settings: appSettings,
+      environment,
+      loginSessionToken,
+      server,
+    });
+  } catch (exception) {
+    throw new Error(`[initDeployment.startDeployment] ${exception.message}`);
+  }
+};
+
+const uploadBuildToCDN = ({
+  mirror = '',
+  domain = '',
+  loginSessionToken = '',
+  deploymentId = '',
+  version = '',
+}) => {
+  try {
+    const formData = new FormData();
+    const timestamp = new Date().toISOString();
+
+    formData.append(
+      "version_tar",
+      fs.readFileSync(`.build/build.tar.xz`),
+      `${timestamp}.tar.xz`
+    );
+
+    formData.append('deploymentId', deploymentId);
+    formData.append('version', version);
+
+    fetch(`${mirror}/api/uploads/receive`, {
+      method: "POST",
+      headers: {
+        ...formData.getHeaders(),
+        "x-deployment-domain": domain,
+        "x-login-session-token": loginSessionToken,
+      },
+      body: formData,
+    }).then(async (response) => {
+      const data = await response.json();
+      return data?.data;
+    });
+  } catch (exception) {
+    throw new Error(`[initDeployment.uploadBuildToCDN] ${exception.message}`);
+  }
+};
+
+const uploadVersionToCDN = async ({
+  loader,
+  deployment,
+  loginSessionToken,
+  version,
+}) => {
+  try {
+    const availableCDN = await getAvailableCDN();
+
+    if (!availableCDN) {
+      loader.stop();
+      console.log(chalk.redBright(`\nUnable to upload version. Check status.cheatcode.co for availability.\n`));
+      process.exit();
+    }
+
+    // TODO: This doesn't work. The versions server needs access to a database, so we need to give
+    // it access to one and make sure it has user data similar to localhost. May be worth writing a
+    // localhost sync script to the database so we can still do local deploys.
+
+    await uploadBuildToCDN({
+      mirror: availableCDN,
+      domain: deployment?.domain,
+      loginSessionToken,
+      version,
+      deploymentId: deployment?._id,
+    });
+  } catch (exception) {
+    throw new Error(`[actionName.uploadVersionToCDN] ${exception.message}`);
+  }
+};
+
+const buildApp = (environment = 'production') => {
+  try {
+    return build({}, { isDeploy: true, type: 'tar', environment });
+  } catch (exception) {
+    throw new Error(`[initDeployment.buildApp] ${exception.message}`);
+  }
+};
+
+const validateOptions = (options) => {
+  try {
+    if (!options) throw new Error('options object is required.');
+    if (!options.loginSessionToken) throw new Error('options.loginSessionToken is required.');
+  } catch (exception) {
+    throw new Error(`[initDeployment.validateOptions] ${exception.message}`);
+  }
+};
+
+const initDeployment = async (options, { resolve, reject }) => {
+  try {
+    validateOptions(options);
+    
+    console.log("");
+    const loader = new Loader({ padding: '  ', defaultMessage: "Deploying app..." });
+    loader.text("Deploying app...");
+    
+    const deploymentTimestamp = new Date().toISOString();
+
+    // NOTE: If we're just doing a version update and not an initial deployment, we want to respect the
+    // existing environment for the deployment. Otherwise, fallback to the --environment flag.
+    await buildApp(options?.deployment?.environment || options?.environment);
+
+    const appSettings = getAppSettings(options?.environment);
+
+    loader.text("Uploading deployment...");
+
+    await uploadVersionToCDN({
+      loader,
+      loginSessionToken: options?.loginSessionToken,
+      deployment: options?.deployment,
+      version: deploymentTimestamp,
+    });
+
+    loader.text("Starting deployment...");
+
+    await startDeployment({
+      isInitialDeployment: options?.isInitialDeployment,
+      loginSessionToken: options?.loginSessionToken,
+      deployment: options.deployment,
+      version: deploymentTimestamp,
+      appSettings,
+      environment: options?.environment,
+      server: options?.server,
+    });
+
+    loader.stop();
+    console.log(chalk.greenBright(`Your app is deploying! To monitor progress, head to ${domains?.push}/deployments/${options?.deployment?.domain}\n`));
+
+    resolve();
+  } catch (exception) {
+    console.warn(exception);
+    reject(`[initDeployment] ${exception.message}`);
+  }
+};
+
+export default (options) =>
+  new Promise((resolve, reject) => {
+    initDeployment(options, { resolve, reject });
+  });

package/src/functions/push/deploy/initial.js

@@ -0,0 +1,108 @@
+/* eslint-disable consistent-return */
+
+import fs from 'fs';
+import fetch from 'node-fetch';
+import domains from '../domains.js';
+import checkIfValidJSON from "../../../lib/checkIfValidJSON.js";
+import CLILog from "../../../lib/CLILog.js";
+
+const pushDeploymentToProvision = ({
+  deploymentPayload = null,
+  loginSessionToken,
+  server = 'production',
+}) => {
+  try {
+    return fetch(`${domains?.provision[server][0]}/api/deployments/initial`, {
+      method: 'POST',
+      headers: {
+        ...deploymentPayload.getHeaders(),
+        'x-login-session-token': loginSessionToken,
+      },
+      body: formData
+    }).then(async (response) => {
+      const text = await response.text();
+      const data = checkIfValidJSON(text);
+      const isPayloadSizeError = text?.includes('payload');
+
+      if (data?.error || isPayloadSizeError) {
+        CLILog(
+          data.error?.message || text,
+          {
+            level: 'danger',
+            docs: isPayloadSizeError ? 'https://cheatcode.co/docs/push/considerations/payload-size' : 'https://cheatcode.co/docs/push'
+          }
+          );
+
+        process.exit(0);
+      }
+
+      return data?.data;
+    });
+  } catch (exception) {
+    throw new Error(`[initialDeployment.pushDeploymentToProvision] ${exception.message}`);
+  }
+};
+
+const getDeploymentPayload = ({
+  version,
+  deployment,
+  settings,
+  environment,
+}) => {
+  try {
+    const formData = new FormData();
+
+    formData.append('deployment', JSON.stringify({
+      ...(deployment || {}),
+      version,
+      settings,
+      environment,
+    }));
+    
+    return formData;
+  } catch (exception) {
+    throw new Error(`[initialDeployment.getDeploymentPayload] ${exception.message}`);
+  }
+};
+
+const validateOptions = (options) => {
+  try {
+    if (!options) throw new Error('options object is required.');
+    if (!options.version) throw new Error('options.version is required.');
+    if (!options.deployment) throw new Error('options.deployment is required.');
+    if (!options.settings) throw new Error('options.settings is required.');
+    if (!options.environment) throw new Error('options.environment is required.');
+    if (!options.loginSessionToken) throw new Error('options.loginSessionToken is required.');
+  } catch (exception) {
+    throw new Error(`[initialDeployment.validateOptions] ${exception.message}`);
+  }
+};
+
+const initialDeployment = async (options, { resolve, reject }) => {
+  try {
+    validateOptions(options);
+    
+    const deploymentPayload = getDeploymentPayload({
+      version: options?.version,
+      deployment: options?.deployment,
+      settings: options?.settings,
+      environment: options?.environment,
+    });
+    
+    await pushDeploymentToProvision({
+      deploymentPayload,
+      loginSessionToken: options?.loginSessionToken,
+      server: options?.server,
+    });
+    
+    resolve();
+  } catch (exception) {
+    reject(`[initialDeployment] ${exception.message}`);
+  }
+};
+
+export default (options) =>
+  new Promise((resolve, reject) => {
+    initialDeployment(options, { resolve, reject });
+  });
+

package/src/functions/push/deploy/version.js

@@ -0,0 +1,108 @@
+/* eslint-disable consistent-return */
+
+import fs from 'fs';
+import fetch from 'node-fetch';
+import domains from './domains.js';
+import checkIfValidJSON from "../../../lib/checkIfValidJSON.js";
+import CLILog from "../../../lib/CLILog.js";
+
+const pushDeploymentToProvision = ({
+  deploymentPayload = null,
+  loginSessionToken,
+  server = 'production',
+}) => {
+  try {
+    return fetch(`${domains?.provision[server][0]}/api/deployments/version`, {
+      method: 'POST',
+      headers: {
+        ...deploymentPayload.getHeaders(),
+        'x-login-session-token': loginSessionToken,
+      },
+      body: formData
+    }).then(async (response) => {
+      const text = await response.text();
+      const data = checkIfValidJSON(text);
+      const isPayloadSizeError = text?.includes('payload');
+
+      if (data?.error || isPayloadSizeError) {
+        CLILog(
+          data.error?.message || text,
+          {
+            level: 'danger',
+            docs: isPayloadSizeError ? 'https://cheatcode.co/docs/push/considerations/payload-size' : 'https://cheatcode.co/docs/push'
+          }
+          );
+
+        process.exit(0);
+      }
+
+      return data?.data;
+    });
+  } catch (exception) {
+    throw new Error(`[versionDeployment.pushDeploymentToProvision] ${exception.message}`);
+  }
+};
+
+const getDeploymentPayload = ({
+  version,
+  deployment,
+  settings,
+  environment,
+}) => {
+  try {
+    const formData = new FormData();
+
+    formData.append('deployment', JSON.stringify({
+      ...(deployment || {}),
+      version,
+      settings,
+      environment,
+    }));
+    
+    return formData;
+  } catch (exception) {
+    throw new Error(`[versionDeployment.getDeploymentPayload] ${exception.message}`);
+  }
+};
+
+const validateOptions = (options) => {
+  try {
+    if (!options) throw new Error('options object is required.');
+    if (!options.version) throw new Error('options.version is required.');
+    if (!options.deployment) throw new Error('options.deployment is required.');
+    if (!options.settings) throw new Error('options.settings is required.');
+    if (!options.environment) throw new Error('options.environment is required.');
+    if (!options.loginSessionToken) throw new Error('options.loginSessionToken is required.');
+  } catch (exception) {
+    throw new Error(`[versionDeployment.validateOptions] ${exception.message}`);
+  }
+};
+
+const versionDeployment = async (options, { resolve, reject }) => {
+  try {
+    validateOptions(options);
+    
+    const deploymentPayload = getDeploymentPayload({
+      version: options?.version,
+      deployment: options?.deployment,
+      settings: options?.settings,
+      environment: options?.environment,
+    });
+    
+    await pushDeploymentToProvision({
+      deploymentPayload,
+      loginSessionToken: options?.loginSessionToken,
+      server: options?.server,
+    });
+    
+    resolve();
+  } catch (exception) {
+    reject(`[versionDeployment] ${exception.message}`);
+  }
+};
+
+export default (options) =>
+  new Promise((resolve, reject) => {
+    versionDeployment(options, { resolve, reject });
+  });
+

package/src/functions/push/domains.js

@@ -0,0 +1,23 @@
+const push = {
+  local: ['http://localhost:2600'],
+  staging: [],
+  production: ['https://push.cheatcode.co'],
+};
+
+const provision = {
+  local: ['http://localhost:2602'],
+  staging: [],
+  production: ['https://provision.cheatcode.co'],
+};
+
+const versions = {
+  local: ['http://localhost:2603', 'http://localhost:2604', 'http://localhost:2605'],
+  staging: [],
+  production: ['https://push-versions-1.cheatcode.co', 'https://push-versions-2.cheatcode.co', 'https://push-versions-3.cheatcode.co'],
+};
+
+export default {
+  push,
+  provision,
+  versions,
+};

package/src/functions/push/getAvailableCDN.js

@@ -0,0 +1,27 @@
+import fetch from "node-fetch";
+import _ from 'lodash';
+import domains from './domains.js';
+
+export default async () => {
+  // NOTE: Even though we can pass a separate server, we always want to use production as that
+  // is where the instance-cli will pull versions from.
+  const results = (await Promise.allSettled(domains?.versions?.production?.map(async (mirror) => {
+    const controller = new AbortController();
+    setTimeout(() => controller.abort(), 2000);
+
+    const result = await fetch(`${mirror}/api/ping`, { signal: controller.signal }).catch((error) => {
+      return { status: 503 };
+    });
+
+    return {
+      mirror,
+      status: result.status,
+    };
+  })))?.map((result) => {
+    return result.value;
+  });
+
+  const firstAvailable = _.orderBy(results, ['status', 'mirror'])[0];
+
+  return firstAvailable?.status === 200 ? firstAvailable?.mirror : null;
+};

package/src/functions/push/getDeployment.js

@@ -0,0 +1,43 @@
+import fetch from "node-fetch";
+import chalk from "chalk";
+import { URL, URLSearchParams } from 'url';
+import domains from "./domains.js";
+import checkIfValidJSON from "./checkIfValidJSON.js";
+import CLILog from "./CLILog.js";
+
+export default ({
+  domain = '',
+  environment = 'production',
+  loginSessionToken = '',
+}) => {
+  const url = new URL(`${domains?.provision}/api/deployments`);
+  url.search = new URLSearchParams({
+    domain,
+    environment,
+  });
+
+  return fetch(url, {
+    method: 'GET',
+    headers: {
+      'x-login-session-token': loginSessionToken,
+      'content-type': 'application/json',
+    },
+  }).then(async (response) => {
+    const text = await response.text();
+    const data = checkIfValidJSON(text);
+
+    if (data?.error) {
+      CLILog(
+        data?.error?.message,
+        {
+          level: 'danger',
+          docs: 'https://cheatcode.co/docs/push'
+        }
+      );
+  
+      process.exit(0);
+    }
+
+    return data?.data?.deployment;
+  });
+};

package/src/functions/push/getDeploymentSummary.js

@@ -0,0 +1,39 @@
+import fetch from "node-fetch";
+import domains from "./domains.js";
+import checkIfValidJSON from "../../lib/checkIfValidJSON.js";
+import CLILog from "../../lib/CLILog.js";
+
+export default (answers = {}, loginSessionToken = '', deploymentDomain = '') => {
+  return fetch(`${domains.provision}/api/deployments/summary`, {
+    method: 'POST',
+    headers: {
+      'x-login-session-token': loginSessionToken,
+      'x-deployment-domain': deploymentDomain,
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      provider: answers?.provider,
+      sizes: [
+        { type: 'loadBalancers', quantity: answers?.loadBalancerInstances, id: answers?.loadBalancer_size },
+        { type: 'instances', quantity: answers?.appInstances, id: answers?.app_size }
+      ],
+    })
+  }).then(async (response) => {
+    const text = await response.text();
+    const data = checkIfValidJSON(text);
+
+    if (data?.error) {
+      CLILog(
+        data.error?.message,
+        {
+          level: 'danger',
+          docs: 'https://cheatcode.co/docs/push'
+        }
+      );
+  
+      process.exit(0);
+    }
+
+    return data?.data?.summary;
+  });
+};

package/src/functions/push/getInstanceSizeRegions.js

@@ -0,0 +1,40 @@
+import fetch from 'node-fetch';
+import chalk from 'chalk';
+import domains from "./domains.js";
+import CLILog from "../../lib/CLILog.js";
+import checkIfValidJSON from '../../lib/checkIfValidJSON.js';
+
+export default (target = '', answers = {}, loginSessionToken = '') => {
+  const url = new URL(`${domains.provision}/api/providers/${answers?.provider}/regions`);
+  const params = new URLSearchParams({
+    size: answers[target],
+    loadBalancerRegion: answers?.loadBalancer_region,
+  });
+
+  url.search = params.toString();
+
+  return fetch(url, {
+    method: 'GET',
+    headers: {
+      'x-login-session-token': loginSessionToken,
+      'content-type': 'application/json',
+    },
+  }).then(async (response) => {
+    const text = await response.text();
+    const data = checkIfValidJSON(text);
+
+    if (data?.error) {
+      CLILog(
+        data.error?.message,
+        {
+          level: 'danger',
+          docs: 'https://cheatcode.co/docs/push/deployment-tokens'
+        }
+      );
+  
+      process.exit(0);
+    }
+
+    return data?.data;
+  });
+};

package/src/functions/push/getInstanceSizesForRegion.js

@@ -0,0 +1,35 @@
+import fetch from 'node-fetch';
+import chalk from 'chalk';
+import domains from "./domains.js";
+import CLILog from "../../lib/CLILog.js";
+import checkIfValidJSON from '../../lib/checkIfValidJSON.js';
+
+export default (provider = '', region = '', loginSessionToken = '') => {
+  return fetch(
+    `${domains.provision}/api/providers/${provider}/sizes?region=${region}`,
+    {
+      method: 'GET',
+      headers: {
+        'x-login-session-token': loginSessionToken,
+        'Content-Type': 'application/json',
+      },
+    }
+  ).then(async (response) => {
+    const text = await response.text();
+    const data = checkIfValidJSON(text);
+
+    if (data?.error) {
+      CLILog(
+        data.error?.message,
+        {
+          level: 'danger',
+          docs: 'https://cheatcode.co/docs/push/deployment-tokens'
+        }
+      );
+  
+      process.exit(0);
+    }
+
+    return data?.data?.sizes;
+  });
+};

package/src/functions/push/getProviderInstanceSizes.js

@@ -0,0 +1,35 @@
+import fetch from 'node-fetch';
+import chalk from 'chalk';
+import domains from "./domains.js";
+import CLILog from "../../lib/CLILog.js";
+import checkIfValidJSON from '../../lib/checkIfValidJSON.js';
+
+export default (answers = {}, loginSessionToken = '') => {
+  return fetch(
+    `${domains.provision}/api/providers/${answers?.provider}/sizes`,
+    {
+      method: 'GET',
+      headers: {
+        'x-login-session-token': loginSessionToken,
+        'Content-Type': 'application/json',
+      },
+    }
+  ).then(async (response) => {
+    const text = await response.text();
+    const data = checkIfValidJSON(text);
+
+    if (data?.error) {
+      CLILog(
+        data.error?.message,
+        {
+          level: 'danger',
+          docs: 'https://cheatcode.co/docs/push/deployment-tokens'
+        }
+      );
+  
+      process.exit(0);
+    }
+
+    return data?.data;
+  });
+};

package/src/functions/push/getProviderRegions.js

@@ -0,0 +1,39 @@
+import fetch from 'node-fetch';
+import chalk from 'chalk';
+import domains from "./domains.js";
+import CLILog from "../../lib/CLILog.js";
+import checkIfValidJSON from '../../lib/checkIfValidJSON.js';
+
+export default (provider = '', loginSessionToken = '') => {
+  const url = new URL(`${domains.provision}/api/providers/${provider}/regions`);
+  const params = new URLSearchParams({
+    provider,
+  });
+
+  url.search = params.toString();
+
+  return fetch(url, {
+    method: 'GET',
+    headers: {
+      'x-login-session-token': loginSessionToken,
+      'content-type': 'application/json',
+    },
+  }).then(async (response) => {
+    const text = await response.text();
+    const data = checkIfValidJSON(text);
+
+    if (data?.error) {
+      CLILog(
+        data.error?.message,
+        {
+          level: 'danger',
+          docs: 'https://cheatcode.co/docs/push/deployment-tokens'
+        }
+      );
+  
+      process.exit(0);
+    }
+
+    return data?.data?.regions;
+  });
+};