@joystick.js/cli-canary 0.0.0-canary.162 → 0.0.0-canary.1621

package/src/commands/push/create_version.js

@@ -0,0 +1,20 @@
+import fetch from 'node-fetch';
+
+const create_version = (options = {}) => {
+	return fetch(`${options?.push_provision_domain}/api/versions/${options?.domain}`, {
+		method: 'POST',
+		headers: {
+			'Content-Type': 'application/json',
+			'x-push-session-token': options?.session_token,
+		},
+		body: JSON.stringify(options?.body),
+	})?.then(async (response) => {
+		// NOTE: We only care about the response body here so parse it out and return it.
+		const data = await response.json();
+		return data?.data;
+	}).catch((error) => {
+		console.warn(error);
+	});
+};
+
+export default create_version;

package/src/commands/push/definition.js

@@ -0,0 +1,43 @@
+import push from './index.js';
+
+const [_node, _bin, ...raw_args] = process.argv;
+
+const definition = {
+  description: 'Deploy your Joystick app using Push.',
+  args: {},
+  options: {
+    environment: {
+     flags: {
+       '-e': {
+         set: !!raw_args.includes('-e'),
+         value: !!raw_args.includes('-e') && raw_args[raw_args.indexOf('-e') + 1],
+         parent: 'push',
+       },
+       '--environment': {
+         set: !!raw_args.includes('--environment'),
+         value: !!raw_args.includes('--environment') && raw_args[raw_args.indexOf('--environment') + 1],
+         parent: 'push',
+       },
+     },
+     description: 'The value you want to use for NODE_ENV in the deployed app (e.g., staging or production). Default is production.',
+    },
+    provision_server: {
+     flags: {
+       '-s': {
+         set: !!raw_args.includes('-s'),
+         value: !!raw_args.includes('-s') && raw_args[raw_args.indexOf('-s') + 1],
+         parent: 'push',
+       },
+       '--server': {
+         set: !!raw_args.includes('--server'),
+         value: !!raw_args.includes('--server') && raw_args[raw_args.indexOf('--server') + 1],
+         parent: 'push',
+       },
+     },
+     description: 'The Push provision server to target (development or production).',
+    },
+  },
+  command: push,
+};
+
+export default definition;

package/src/commands/push/get_app_domain.js

@@ -0,0 +1,11 @@
+const get_app_domain = (provision_server = 'production') => {
+	// NOTE: Rely on provision_server CLI option flag here because that will need
+	// to be paired with the appropriate app server.
+	return {
+		development: 'http://localhost:2600',
+		staging: 'https://staging.push.cheatcode.co',
+		production: 'https://push.cheatcode.co',
+	}[provision_server];
+};
+
+export default get_app_domain;

package/src/commands/push/get_deployment.js

@@ -0,0 +1,19 @@
+import fetch from 'node-fetch';
+
+const get_deployment = (options = {}) => {
+	return fetch(`${options?.push_provision_domain}/api/deployments/${options?.domain}`, {
+		method: 'GET',
+		headers: {
+			'x-push-session-token': options?.session_token,
+			Accept: 'application/json',
+		},
+	})?.then(async (response) => {
+		// NOTE: We only care about the data in the response here so just return it.
+		const data = await response.json();
+		return data?.data;
+	}).catch((error) => {
+		console.warn(error);
+	});
+};
+
+export default get_deployment;

package/src/commands/push/get_provision_domain.js

@@ -0,0 +1,9 @@
+const get_provision_domain = (provision_server = 'production') => {
+	return {
+		development: 'http://localhost:2603',
+		staging: 'https://staging.provision.cheatcode.co',
+		production: 'https://provision.cheatcode.co',
+	}[provision_server];
+};
+
+export default get_provision_domain;

package/src/commands/push/get_session_token.js

@@ -0,0 +1,31 @@
+import os from 'os';
+import fs from 'fs';
+import inquirer from 'inquirer';
+import path_exists from '../../lib/path_exists.js';
+import session_token_prompt from './prompts/session_token.js';
+
+const { readFile, mkdir, writeFile } = fs.promises;
+
+const get_session_token = async () => {
+  const home_directory = os.homedir();
+  const session_token_path = `${home_directory}/.push/session_token`;
+  const session_token_exists = await path_exists(session_token_path);
+
+  if (session_token_exists) {
+    return readFile(session_token_path, 'utf-8');
+  }
+ 
+  const { session_token } = await inquirer.prompt(session_token_prompt());
+
+  if (session_token) {
+	  if (!(await path_exists(`${home_directory}/.push`))) {
+	    await mkdir(`${home_directory}/.push`);
+	  }
+
+	  await writeFile(`${home_directory}/.push/session_token`, session_token);
+
+	  return session_token;
+  }
+};
+
+export default get_session_token;

package/src/commands/push/get_settings_file.js

@@ -0,0 +1,47 @@
+import fs from 'fs';
+import cli_log from '../../lib/cli_log.js';
+import is_valid_json_string from '../../lib/is_valid_json_string.js';
+import path_exists from '../../lib/path_exists.js';
+
+const { readFile } = fs.promises;
+
+const read_settings_file = async (environment = '') => {
+  const settings_file_name = `settings.${environment}.json`;
+  const settings_file_exists = await path_exists(settings_file_name);
+
+  if (!settings_file_exists) {
+    cli_log(
+      `Could not find a ${settings_file_name} in your project. Double-check this exists and try again.`,
+      {
+        level: "danger",
+        docs: "https://cheatcode.co/docs/push/config"
+      }
+    );
+
+    return process.exit(0);
+  }
+
+  return readFile(settings_file_name);
+};
+
+const get_settings_file = async (options) => {
+  const settings_file_name = `settings.${options?.environment}.json`;
+  const raw_settings_file = await read_settings_file(options?.environment);
+  const settings_file_is_valid_json = is_valid_json_string(raw_settings_file);
+
+  if (!settings_file_is_valid_json) {
+    cli_log(
+      `${settings_file_name} contains invalid JSON. Double-check the syntax and try again.`,
+      {
+        level: "danger",
+        docs: "https://cheatcode.co/docs/push/config"
+      }
+    );
+
+    return process.exit(0);
+  }
+
+  return JSON.parse(raw_settings_file);
+};
+
+export default get_settings_file;

package/src/commands/push/handle_initial_deployment.js

@@ -0,0 +1,24 @@
+import fetch from "node-fetch";
+
+const handle_initial_deployment = async (options = {}) => {
+  return fetch(`${options?.push_provision_domain}/api/deployments/${options?.deployment?.domain}`, {
+   method: "POST",
+   headers: {
+     "x-push-session-token": options?.session_token,
+     'Content-Type': 'application/json',
+   },
+   body: JSON.stringify({
+     environment: options?.environment,
+     build_timestamp: options?.build_timestamp,
+     domain: options?.deployment?.domain,
+     deployment_id: options?.deployment?._id,
+   }),
+  }).then(async (response) => {
+   const data = await response.json();
+   return data?.data;
+  }).catch((error) => {
+    console.warn(error);
+  });
+};
+
+export default handle_initial_deployment;

package/src/commands/push/handle_version_deployment.js

@@ -0,0 +1,23 @@
+import fetch from "node-fetch";
+
+const handle_version_deployment = async (options = {}) => {
+  return fetch(`${options?.push_provision_domain}/api/deployments/${options?.deployment?.domain}`, {
+   method: "PUT",
+   headers: {
+     "x-push-session-token": options?.session_token,
+     'Content-Type': 'application/json',
+   },
+   body: JSON.stringify({
+     build_timestamp: options?.build_timestamp,
+     domain: options?.deployment?.domain,
+     deployment_id: options?.deployment?._id,
+   }),
+  }).then(async (response) => {
+   const data = await response.json();
+   return data?.data;
+  }).catch((error) => {
+    console.warn(error);
+  });
+};
+
+export default handle_version_deployment;

package/src/commands/push/index.js

@@ -0,0 +1,190 @@
+import chalk from 'chalk';
+import inquirer from "inquirer";
+import build from '../../lib/build/index.js';
+import cli_log from '../../lib/cli_log.js';
+import confirm_deployment_prompt from './prompts/confirm_deployment.js';
+import create_version from './create_version.js';
+import get_app_domain from './get_app_domain.js';
+import get_deployment from './get_deployment.js';
+import get_provision_domain from './get_provision_domain.js';
+import get_settings_file from './get_settings_file.js';
+import get_session_token from './get_session_token.js';
+import handle_initial_deployment from './handle_initial_deployment.js';
+import handle_version_deployment from './handle_version_deployment.js';
+import Loader from '../../lib/loader.js';
+import upload_build_to_cdn from './upload_build_to_cdn.js';
+import validate_deployment from './validate_deployment.js';
+import validate_push_config from './validate_push_config.js';
+
+const log_validation_error_response = (validation_type = '', root_error = '', validation_response = {}) => {
+	let errors_list = ``;
+
+	for (let i = 0; i < validation_response?.errors?.length; i += 1) {
+		const validation_error = validation_response?.errors[i];
+
+		if (validation_type === 'push_config') {
+			errors_list += `${chalk.yellowBright(`> ${validation_error.field}`)}\n`;
+		}
+
+		errors_list += `${validation_error?.error}\n${i + 1 === validation_response?.errors?.length ? '' : '\n'}`;
+	}
+
+	cli_log(
+    `${root_error ? `${chalk.yellowBright(root_error)}\n\n\n` : ''}${errors_list}`,
+    {
+      level: "danger",
+      docs: {
+      	push_config: "https://cheatcode.co/docs/push/config",
+      	deployment: "https://cheatcode.co/docs/push/subscription",
+      }[validation_type],
+    }
+  );
+
+  process.exit(0);
+};
+
+const get_session_for_deployment = async () => {
+	const session_token = await get_session_token();
+
+	if (!session_token) {
+    cli_log(
+      data?.error?.message,
+      {
+        level: "danger",
+        docs: "https://cheatcode.co/docs/push/cli#authentication"
+      }
+    );
+
+    return process.exit(0);
+	}
+
+	return session_token;
+};
+
+const warn_no_push_config = (environment = '') => {
+  cli_log(
+    `settings.${environment}.json must contain a push config object. Add this following the docs link below and try again.`,
+    {
+      level: "danger",
+      docs: "https://cheatcode.co/docs/push/config"
+    }
+  );
+
+  return process.exit(0);
+};
+
+const push = async (args = {}, options = {}) => {
+	process.loader = new Loader();
+	process.loader.print('Starting deployment...');
+
+	const session_token = await get_session_for_deployment();
+	const environment = options?.environment || 'production';
+  const settings = await get_settings_file({ environment });
+
+  if (!settings?.push) {
+    return warn_no_push_config(environment);
+  }
+
+  const push_provision_domain = get_provision_domain(options?.provision_server);
+	const push_app_domain = get_app_domain(options?.provision_server);
+	const deployment = await get_deployment({
+		domain: settings?.push?.domain,
+		session_token,
+		push_provision_domain,
+	});
+
+	let push_config_validation_response;
+
+	if (deployment?.status === 'undeployed') {
+		push_config_validation_response = await validate_push_config({
+			push_provision_domain,
+			push_config: settings?.push,
+		});
+
+		if (push_config_validation_response?.errors?.length > 0) {
+			log_validation_error_response(
+				'push_config',
+				`Push config in settings.${environment}.json failed validation with the following errors:`,
+				push_config_validation_response,
+			);
+		}
+	}
+
+	const deployment_validation_response = await validate_deployment({
+		session_token,
+		push_provision_domain,
+		push_config: settings?.push,
+	});
+
+	if (deployment_validation_response?.errors?.length > 0) {
+		log_validation_error_response(
+			'deployment',
+			`Deployment failed validation with the following errors:`,
+			deployment_validation_response,
+		);
+	}
+
+	// NOTE: A bit hacky but removes need for weird if {} statement nesting.
+	const { confirm_deployment } = deployment?.status === 'undeployed' ? await inquirer.prompt(
+		confirm_deployment_prompt(push_config_validation_response?.instances)
+	) : { confirm_deployment: true };
+
+	if (confirm_deployment) {
+		// NOTE: Do this to create a gap between the confirmation text above (only applies if
+		// the deployment is a first-run).
+		if (deployment?.status === 'undeployed') {
+			console.log('\n');
+		}
+
+		const build_timestamp = new Date().toISOString();
+		await build({
+			environment,
+			encrypt_build: true,
+			encryption_key: deployment?.deployment_secret,
+			silence_confirmation: true,
+		});
+
+		process.loader.print('Uploading version...');
+
+		await upload_build_to_cdn(
+			build_timestamp,
+			deployment,
+			session_token,
+		);
+
+		const create_version_response = await create_version({
+			push_provision_domain,
+			domain: settings?.push?.domain,
+			session_token,
+			body: {
+				// NOTE: Endpoint anticipates a stringified version of settings.
+				settings: JSON.stringify(settings),
+				build_timestamp,
+			},
+		});
+
+		process.loader.print('Deploying app...');
+
+		if (deployment?.status === 'undeployed') {
+			return handle_initial_deployment({
+				push_provision_domain,
+				push_app_domain,
+				session_token,
+				environment,
+				build_timestamp,
+				deployment,
+			});
+		}
+
+		return handle_version_deployment({
+			push_provision_domain,
+			push_app_domain,
+			session_token,
+			environment,
+			build_timestamp,
+			deployment,
+		});
+	}
+};
+
+export default push;

package/src/commands/push/prompts/confirm_deployment.js

@@ -0,0 +1,73 @@
+import AsciiTable from 'ascii-table';
+import chalk from 'chalk';
+
+const render_instance_row = (table, [continent_name = '', continent_instances = []]) => {
+	table.addRow(`${chalk.magenta(continent_name)}\n`);
+
+	for (let i = 0; i < continent_instances?.length; i += 1) {
+		const instance = continent_instances[i];
+		table.addRow(
+			`${chalk.yellow(instance?.provider)} (${chalk.green(instance?.region)})`,
+			`${chalk.white(instance?.size)}  $${chalk.green(instance?.pricePerMonth)}/mo.  x${chalk.blue(instance?.quantity)}  ${chalk.white('=')}  $${chalk.green((instance?.quantity * instance?.pricePerMonth))}/mo.${i + 1 === continent_instances?.length ? '\n' : ''}`,
+		);
+	}
+};
+
+const get_total_monthly_cost_for_instances = (instances = []) => {
+	const instances_by_continent = Object.values(instances)?.flatMap((instances_for_continent) => instances_for_continent);
+	return instances_by_continent?.reduce((total = 0, instance = {}) => {
+		total += instance?.pricePerMonth * instance?.quantity;
+		return total;
+	}, 0);
+};
+
+const confirm_deployment = (instances = {}) => {
+	const load_balancer_total_per_month = get_total_monthly_cost_for_instances(instances?.load_balancer);
+	const app_total_per_month = get_total_monthly_cost_for_instances(instances?.app);
+	const total_monthly_cost = load_balancer_total_per_month + app_total_per_month;
+
+	const table = new AsciiTable();
+
+	table.removeBorder();
+	table.addRow(`${chalk.blue('Load Balancer')}\n`);
+
+	const load_balancer_continents = Object.entries(instances?.load_balancer);
+	const app_continents = Object.entries(instances?.app);
+
+	for (let i = 0; i < load_balancer_continents?.length; i += 1) {
+		render_instance_row(table, load_balancer_continents[i]);
+	}
+
+	table.addRow(`\n  ${chalk.blue('App')}\n`);
+
+	for (let i = 0; i < app_continents?.length; i += 1) {
+		render_instance_row(table, app_continents[i]);
+	}
+	
+	table.addRow(chalk.white('\n  ---\n'));
+	
+	table.addRow(
+		chalk.green('Monthly Cost'),
+		chalk.white(`$${chalk.green(total_monthly_cost)}/mo.`)
+	);
+
+	table.addRow(
+		chalk.green('Annual Cost'),
+		chalk.white(`$${chalk.green(total_monthly_cost * 12)}/yr.`)
+	);
+
+	const is_abnormal = total_monthly_cost > 100;
+
+	return [{
+	  name: 'confirm_deployment',
+	  type: 'confirm',
+	  prefix: '',
+	  message: `\n ${chalk.greenBright('>')} Start deployment and provision these instances?`,
+	  suffix: `
+	  \n${table.toString()}
+	  ${is_abnormal ? `\n\n  ${chalk.yellowBright(`!!! >>> These costs are ${chalk.magenta('high')}. Be absolutely ${chalk.magenta('CERTAIN')} you want to run this deployment. <<< !!!`)}
+	  \n ` : '\n'}`,
+	}];
+};
+
+export default confirm_deployment;

package/src/commands/push/prompts/session_token.js

@@ -0,0 +1,11 @@
+import chalk from 'chalk';
+
+const session_token = () => [{
+  name: 'session_token',
+  type: 'text',
+  prefix: '',
+  message: `\n${chalk.yellowBright('>')} To login to Push, paste your session token below:\n`,
+  suffix: `  ${chalk.yellowBright('Find your session token here:')} https://push.cheatcode.co/account/profile\n\n`,
+}];
+
+export default session_token;

package/src/commands/push/upload_build_to_cdn.js

@@ -0,0 +1,59 @@
+import fetch from "node-fetch";
+import FormData from "form-data";
+import fs from "fs";
+import _ from 'lodash';
+import cdn_mirrors from './cdn_mirrors.js';
+
+const { readFile } = fs.promises;
+
+const get_first_available_mirror = async () => {
+  const results = (await Promise.allSettled(cdn_mirrors?.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;
+  });
+
+  return _.orderBy(results, ['status', 'mirror'])[0];
+};
+
+const upload_build_to_cdn = async (build_timestamp = '', deployment = {}, session_token = '') => {
+  const first_available_mirror = await get_first_available_mirror();
+  const form_data = new FormData();
+
+  form_data.append(
+    "version_tar",
+    await readFile(`.build/build.encrypted.tar.gz`),
+    `${build_timestamp}.tar.gz`
+  );
+
+  form_data.append("build_timestamp", build_timestamp);
+  form_data.append("domain", deployment?.domain);
+  form_data.append("deployment_id", deployment?._id);
+
+  return fetch(`${first_available_mirror?.mirror}/api/versions`, {
+   method: "POST",
+   headers: {
+     ...form_data.getHeaders(),
+     "x-push-session-token": session_token,
+   },
+   body: form_data,
+  }).then(async (response) => {
+   const data = await response.json();
+   return data?.data;
+  }).catch((error) => {
+    console.warn(error);
+  });
+};
+
+export default upload_build_to_cdn;
+

package/src/commands/push/validate_deployment.js

@@ -0,0 +1,19 @@
+import fetch from 'node-fetch';
+
+const validate_deployment = (options = {}) => {
+	return fetch(`${options?.push_provision_domain}/api/deployments/${options?.push_config?.domain}/validate`, {
+		method: 'POST',
+		headers: {
+			'Content-Type': 'application/json',
+			'x-push-session-token': options?.session_token,
+		},
+		body: JSON.stringify(options?.push_config),
+	})?.then(async (response) => {
+		const data = await response.json();
+		return data?.data;
+	}).catch((error) => {
+		console.warn(error);
+	});
+};
+
+export default validate_deployment;

package/src/commands/push/validate_push_config.js

@@ -0,0 +1,18 @@
+import fetch from 'node-fetch';
+
+const validate_push_config = (options = {}) => {
+	return fetch(`${options?.push_provision_domain}/api/validate/config`, {
+		method: 'POST',
+		headers: {
+			'Content-Type': 'application/json',
+		},
+		body: JSON.stringify(options?.push_config),
+	})?.then(async (response) => {
+		const data = await response.json();
+		return data?.data;
+	}).catch((error) => {
+		console.warn(error);
+	});
+};
+
+export default validate_push_config;

package/src/commands/start/definition.js

@@ -0,0 +1,58 @@
+import start from './index.js';
+
+const [_node, _bin, ...raw_args] = process.argv;
+
+const definition = {
+  description: 'Start an existing Joystick app.',
+  args: {},
+  options: {
+    environment: {
+      flags: {
+        '-e': {
+          set: !!raw_args.includes('-e'),
+          value: !!raw_args.includes('-e') && raw_args[raw_args.indexOf('-e') + 1],
+          parent: 'start'
+        },
+        '--environment': {
+          set: !!raw_args.includes('--environment'),
+          value: !!raw_args.includes('--environment') && raw_args[raw_args.indexOf('--environment') + 1],
+          parent: 'start'
+        },
+      },
+      description: 'Environment to set for process.env.NODE_ENV.',
+    },
+    port: {
+      flags: {
+        '-p': {
+          set: !!raw_args.includes('-p'),
+          value: !!raw_args.includes('-p') && parseInt(raw_args[raw_args.indexOf('-p') + 1], 10),
+          parent: 'start'
+        },
+        '--port': {
+          set: !!raw_args.includes('--port'),
+          value: !!raw_args.includes('--port') && parseInt(raw_args[raw_args.indexOf('--port') + 1], 10),
+          parent: 'start'
+        },
+      },
+      description: 'Port number to run the app on.',
+    },
+    debug: {
+      flags: {
+        '-d': {
+          set: !!raw_args.includes('-d'),
+          value: !!raw_args.includes('-d'),
+          parent: 'start'
+        },
+        '--debug': {
+          set: !!raw_args.includes('--debug'),
+          value: !!raw_args.includes('--debug'),
+          parent: 'start'
+        },
+      },
+      description: 'Run the Joystick app\'s Node.js process in debug mode with --inspect.',
+    }
+  },
+  command: start,
+}
+
+export default definition;

package/src/commands/start/index.js

@@ -0,0 +1,11 @@
+import development_server from "../../lib/development_server/index.js";
+
+const start = async (args = {}, options = {}) => {
+  await development_server({
+    environment: options?.environment || 'development',
+    port: options?.port || 2600,
+    debug: !!options?.debug,
+  });
+};
+
+export default start;