@joystick.js/cli-canary 0.0.0-canary.66 → 0.0.0-canary.661

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;

package/src/commands/test/definition.js

@@ -0,0 +1,28 @@
+import test from './index.js';
+
+const [_node, _bin, ...raw_args] = process.argv;
+
+const definition = {
+  description: 'Start an existing Joystick app and run its tests.',
+  args: {},
+  options: {
+    watch: {
+      flags: {
+        '-w': {
+          set: !!raw_args.includes('-w'),
+          value: !!raw_args.includes('-w'),
+          parent: 'test'
+        },
+        '--watch': {
+          set: !!raw_args.includes('--watch'),
+          value: !!raw_args.includes('--watch'),
+          parent: 'test'
+        },
+      },
+      description: 'Run joystick test in watch mode.',
+    },
+  },
+  command: test,
+};
+
+export default definition;

package/src/commands/test/index.js

@@ -0,0 +1,12 @@
+import development_server from "../../lib/development_server/index.js";
+
+const test = async (args = {}, options = {}) => {
+  await development_server({
+    environment: 'test',
+    process,
+    port: 1977,
+    watch: options?.watch,
+  });
+};
+
+export default test;

package/src/commands/update/definition.js

@@ -0,0 +1,28 @@
+import update from './index.js';
+
+const [_node, _bin, ...raw_args] = process.argv;
+
+const definition = {
+  description: 'Update all Joystick packages to their latest version.',
+  args: {},
+  options: {
+    release: {
+      flags: {
+        '-r': {
+          set: !!raw_args.includes('-r'),
+          value: !!raw_args.includes('-r') && raw_args[raw_args.indexOf('-r') + 1],
+          parent: 'create',
+        },
+        '--release': {
+          set: !!raw_args.includes('--release'),
+          value: !!raw_args.includes('--release') && raw_args[raw_args.indexOf('--release') + 1],
+          parent: 'create',
+        },
+      },
+      description: 'The release of Joystick to update (production or canary).',
+    },
+  },
+  command: update,
+};
+
+export default definition;

package/src/commands/update/index.js

@@ -0,0 +1,29 @@
+import chalk from 'chalk';
+import child_process from "child_process";
+import util from 'util';
+import color_log from "../../lib/color_log.js";
+import Loader from "../../lib/loader.js";
+
+const exec = util.promisify(child_process.exec);
+
+const update = async (args = {}, options = {}) => {
+	process.loader = new Loader();
+  process.loader.print('Updating Joystick dependencies...');
+
+  process.loader.print(`Updating @joystick.js/node${options?.relase === 'canary' ? '-canary' : ''}...`);
+  await exec(`npm i @joystick.js/node${options?.relase === 'canary' ? '-canary' : ''}@latest`);
+
+  process.loader.print(`Updating @joystick.js/test${options?.relase === 'canary' ? '-canary' : ''}...`);
+  await exec(`npm i @joystick.js/test${options?.relase === 'canary' ? '-canary' : ''}@latest`);
+
+  process.loader.print(`Updating @joystick.js/ui${options?.relase === 'canary' ? '-canary' : ''}...`);
+  await exec(`npm i @joystick.js/ui${options?.relase === 'canary' ? '-canary' : ''}@latest`);
+	
+	process.loader.print(`Updating @joystick.js/cli${options?.relase === 'canary' ? '-canary' : ''}...`);
+	await exec(`npm i -g @joystick.js/cli${options?.relase === 'canary' ? '-canary' : ''}@latest`);
+
+  color_log('✔ Joystick updated!', 'green');
+  process.exit(0);
+};
+
+export default update;

package/src/commands/use/definition.js

@@ -0,0 +1,19 @@
+import use from './index.js';
+
+const [_node, _bin, ...raw_args] = process.argv;
+
+const definition = {
+  description: 'Decides which release of Joystick to use (production or canary).',
+  args: {
+    release: {
+      set: !!raw_args.includes('use') && !!raw_args[raw_args.indexOf('use') + 1],
+      parent: 'use',
+      value: !!raw_args.includes('use') && raw_args[raw_args.indexOf('use') + 1],
+      description: 'The release of Joystick to use (production or canary).',
+    },
+  },
+  options: {},
+  command: use
+};
+
+export default definition;

package/src/commands/use/index.js

@@ -0,0 +1,54 @@
+import child_process from "child_process";
+import util from 'util';
+import Loader from '../../lib/loader.js';
+import replace_in_files from '../../lib/replace_in_files.js';
+
+const exec = util.promisify(child_process.exec);
+
+const use = async (args = {}, options = {}) => {
+  const loader = new Loader();
+
+  if (args?.release === 'canary') {
+    await replace_in_files(process.cwd(), {
+      match: [/\.js$/],
+      exclude: [/node_modules/],
+      replace_regex: /(@joystick\.js\/node)(?!-)/g,
+      replace_with: '@joystick.js/node-canary',
+    });
+
+    await replace_in_files(process.cwd(), {
+      match: [/\.js$/],
+      exclude: [/node_modules/],
+      replace_regex: /(@joystick\.js\/ui)(?!-)/g,
+      replace_with: '@joystick.js/ui-canary',
+    });
+    
+    loader.print('Swapping production packages for canary versions...');
+    
+    await exec('npm uninstall @joystick.js/node && npm i @joystick.js/node-canary');
+    await exec('npm uninstall @joystick.js/ui && npm i @joystick.js/ui-canary');
+  }
+  
+  if (args?.release === 'production') {
+    await replace_in_files(process.cwd(), {
+      match: [/\.js$/],
+      exclude: [/node_modules/],
+      replace_regex: /(@joystick\.js\/node-canary)/g,
+      replace_with: '@joystick.js/node',
+    });
+
+    await replace_in_files(process.cwd(), {
+      match: [/\.js$/],
+      exclude: [/node_modules/],
+      replace_regex: /(@joystick.js\/ui-canary)/g,
+      replace_with: '@joystick.js/ui',
+    });
+    
+    loader.print('Swapping canary packages for production versions...');
+    
+    await exec('npm uninstall @joystick.js/node-canary && npm i @joystick.js/node');
+    await exec('npm uninstall @joystick.js/ui-canary && npm i @joystick.js/ui');
+  }
+};
+
+export default use;

package/src/lib/build/browser_path_exclusions.js

@@ -0,0 +1,8 @@
+import get_platform_safe_path from "./get_platform_safe_path.js";
+
+const browser_path_exclusions = [
+  get_platform_safe_path("lib/node"),
+  get_platform_safe_path("tests/"),
+];
+
+export default browser_path_exclusions;

package/src/lib/build/browser_paths.js

@@ -0,0 +1,11 @@
+import get_platform_safe_path from "../get_platform_safe_path.js";
+
+const browser_paths = [
+  get_platform_safe_path("email/"),
+  get_platform_safe_path("lib/"),
+  get_platform_safe_path("lib/browser"),
+  get_platform_safe_path("ui/"),
+  "index.client.js",
+];
+
+export default browser_paths;