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

package/src/lib/development_server/watch_for_changes/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;

package/src/lib/development_server/watch_for_changes/get_after_run_tasks.js

@@ -0,0 +1,31 @@
+import constants from "../../constants.js";
+import get_platform_safe_path from "../../get_platform_safe_path.js";
+
+const get_after_run_tasks = (path = '') => {
+	const is_html_update = path === 'index.html';
+  const is_client_index_update = path === 'index.client.js';
+  const is_client_lib_update = path.includes(
+    get_platform_safe_path('lib/')
+  ) && !path.includes(
+    get_platform_safe_path('lib/node')
+  );
+  const is_i18n_path = path.includes('i18n');
+  const is_settings_path = (path.match(constants.SETTINGS_FILE_NAME_REGEX))?.length > 0;
+  const is_ui_path = path.includes(
+    get_platform_safe_path("ui/")
+  ) || path === 'index.css' || is_html_update || is_client_index_update || is_client_lib_update;
+  const is_ui_update = (process.hmr_server_process && process.hmr_server_process.has_connections) &&
+    (is_ui_path || is_i18n_path || is_settings_path) ||
+    false;
+
+  if (is_ui_update) {
+    // NOTE: As part of hot_module_reload, the server will be restarted after a client has
+    // signaled that the HMR update is complete (see handle_hmr_server_process_messages in
+    // lib/development_server/index.js for the event handler).
+  	return ['hot_module_reload'];
+  }
+
+  return ['restart_app_server'];
+};
+
+export default get_after_run_tasks;

package/src/lib/development_server/watch_for_changes/get_file_codependencies.js

@@ -0,0 +1,48 @@
+import read_file_dependency_map from "./read_file_dependency_map.js";
+import path_exists from '../../path_exists.js';
+import get_platform_safe_path from '../../get_platform_safe_path.js';
+
+const find_codependencies_in_map = (path_to_find = '', map = {}) => {
+  // TODO: I don't care about path variations anymore because I have the absolute paths
+  // of the child dependencies in the map. Basically I just need to ask, can I find an absolute
+  // path that matches the current path being rebuilt? If I do, give me the codependent_path name
+  // as that is a codependency of the file being rebuilt.
+  return Object.entries(map)
+    .filter(([_codependent_path, codependent_dependencies]) => {
+      const has_matching_imports =
+        codependent_dependencies &&
+        codependent_dependencies.imports &&
+        codependent_dependencies.imports.some((codependent_dependency) => {
+          return codependent_dependency.absolute_path.includes(path_to_find);
+        });
+
+      const has_matching_requires =
+        codependent_dependencies &&
+        codependent_dependencies.requires &&
+        codependent_dependencies.requires.some((codependent_dependency) => {
+          return codependent_dependency.absolute_path.includes(path_to_find);
+        });
+
+      return has_matching_imports || has_matching_requires;
+    })
+    .map(([matching_codependent_path]) => {
+      return matching_codependent_path.replace(
+        get_platform_safe_path(`${process.cwd()}/`),
+        ""
+      );
+    });
+};
+
+const get_file_codependencies = async (path_to_find = "") => {
+  const file_dependency_map = await read_file_dependency_map();
+  const codpendencies = find_codependencies_in_map(
+    path_to_find,
+    file_dependency_map
+  );
+
+  return Promise.all(codpendencies.filter((codependency) => {
+    return path_exists(codependency);
+  }));
+};
+
+export default get_file_codependencies;

package/src/lib/development_server/watch_for_changes/get_platform_safe_path.js

@@ -0,0 +1,6 @@
+const get_platform_safe_path = (path = '') => {
+  // NOTE: This is why serial killers exist.
+  return process.platform === 'win32' ? path.replace('/', '\\') : path;
+};
+
+export default get_platform_safe_path;

package/src/lib/development_server/watch_for_changes/index.js

@@ -0,0 +1,216 @@
+import chokidar from 'chokidar';
+import fs from 'fs';
+import { dirname } from 'path';
+import build_files from '../../build/build_files.js';
+import debounce from '../../debounce.js';
+import get_after_run_tasks from './get_after_run_tasks.js';
+import get_file_codependencies from './get_file_codependencies.js';
+import get_file_operation from '../../build/get_file_operation.js';
+import get_path_platform from '../../build/get_path_platform.js';
+import types from '../../types.js';
+import watch_paths from './watch_paths.js';
+
+const { mkdir, copyFile, rm: remove } = fs.promises;
+
+const handle_build_files = async (job = {}, options = {}) => {
+	const codependencies = process.initial_build_complete ? await get_file_codependencies(job?.path) : [];
+
+	// NOTE: If we have codependencies, make sure that the file triggering the current job is rebuilt first
+	// *before* rebuilding its codependencies. This ensures that codependencies get the latest build of the
+	// file. If we do them all together in parallel, the latest build is missed.
+	if (options?.is_build_file) {
+		await build_files({
+			files: [{ path: job?.path, platform: get_path_platform(job?.path) }],
+		}).catch((errors = []) => {
+			if (!process.initial_build_complete && errors?.length > 0) {
+				process.exit(0);
+			}
+
+			if (process.initial_build_complete && errors?.length > 0) {
+				process.app_server_process.send(
+	        JSON.stringify({
+	          type: "BUILD_ERROR",
+	          paths: errors.filter(({ success }) => !success),
+	        })
+	      );
+				
+				process.hmr_server_process.send(JSON.stringify({
+			    type: 'BUILD_ERROR',
+			  }));
+
+				throw new Error('BUILD_ERROR');
+			}
+		});
+	}
+
+	// NOTE: Run handle_build_files() recursively against codependencies as each of *that* files codependencies
+	// need to be rebuilt, too. This is because we bundle code into a single file, so all files up the "tree"
+	// need to be updated to reflect any changes of their children.
+	if (codependencies?.length > 0) {
+		for (let i = 0; i < codependencies?.length; i += 1) {
+			const codependency = codependencies[i];
+			await handle_build_files({ path: codependency }, options);
+		}
+	}
+
+	return Promise.resolve();
+};
+
+const run_job = async (job = {}) => {
+	switch(job?.operation) {
+		case 'add_directory':
+			return mkdir(`.joystick/build/${job?.path}`, { recursive: true });
+		case 'build_file':
+			return handle_build_files(job, { is_build_file: true });
+		case 'copy_file':
+			await mkdir(dirname(`.joystick/build/${job?.path}`), { recursive: true });
+			await copyFile(job?.path, `.joystick/build/${job?.path}`);
+			return handle_build_files(job, { is_build_file: false });
+		case 'delete_directory':
+			return remove(`.joystick/build/${job?.path}`, { recursive: true });
+		case 'delete_file':
+			await remove(`.joystick/build/${job?.path}`, { recursive: true });
+			return handle_build_files(job, { is_build_file: false });
+		default:
+			return true;
+	}
+};
+
+const get_delete_directory_job = (job = {}) => {
+	return {
+		operation: job?.event,
+		path: job?.path,
+		after_run_tasks: process.initial_build_complete ? get_after_run_tasks(job?.path) : ['start_app_server', 'start_hmr_server'],
+	};
+};
+
+const get_add_directory_job = (job = {}) => {
+	return {
+		operation: job?.event,
+		path: job?.path,
+		after_run_tasks: process.initial_build_complete ? get_after_run_tasks(job?.path) : ['start_app_server', 'start_hmr_server'],
+	};
+};
+
+const get_delete_file_job = (job = {}) => {
+	return {
+		operation: job?.event,
+		path: job?.path,
+		after_run_tasks: process.initial_build_complete ? get_after_run_tasks(job?.path) : ['start_app_server', 'start_hmr_server'],
+	};
+};
+
+const get_change_file_job = (job = {}) => {
+	return {
+		operation: job?.is_custom_copy_path ? 'copy_file' : get_file_operation(job?.path),
+		path: job?.path,
+		after_run_tasks: process.initial_build_complete ? get_after_run_tasks(job?.path) : ['start_app_server', 'start_hmr_server'],
+	};
+};
+
+const get_add_file_job = (job = {}) => {
+	return {
+		operation: job?.is_custom_copy_path ? 'copy_file' : get_file_operation(job?.path),
+		path: job?.path,
+		after_run_tasks: process.initial_build_complete ? get_after_run_tasks(job?.path) : ['start_app_server', 'start_hmr_server'],
+	};
+};
+
+const get_job_to_be_done = (job = {}) => {
+	switch(job?.event) {
+		case 'add_file':
+			return get_add_file_job(job);
+		case 'change_file':
+			return get_change_file_job(job);
+		case 'delete_file':
+			return get_delete_file_job(job);
+		case 'add_directory':
+			return get_add_directory_job(job);
+		case 'delete_directory':
+			return get_delete_directory_job(job);
+	}
+};
+
+const process_file_watcher_jobs = async (jobs = [], after_run_functions = {}) => {
+	try {
+		const after_run_tasks = new Set([]);
+
+		for (let i = 0; i < jobs?.length; i += 1) {
+			const job_to_run = jobs[i];
+			const job = get_job_to_be_done(job_to_run);
+
+			await run_job(job);
+
+			if (job?.after_run_tasks) {
+				for (let i = 0; i < job?.after_run_tasks?.length; i += 1) {
+					const after_run_task = job?.after_run_tasks[i];
+					after_run_tasks.add(after_run_task);
+				}
+			}
+		}
+
+		const tasks_to_run = Array.from(after_run_tasks);
+
+		for (let i = 0; i < tasks_to_run?.length; i += 1) {
+			const after_run_task = tasks_to_run[i];
+
+			if (types.is_function(after_run_functions[after_run_task])) {
+				await after_run_functions[after_run_task](jobs);
+			}
+		}
+	} catch(error) {
+		// NOTE: Dead catch as we just want to avoid after_run_tasks from running. Actual
+		// errors are handled as part of run_job() (e.g., build errors are handled as a part
+		// of handle_build_files()).
+	}
+};
+
+const transform_chokidar_event = (event = '') => {
+	switch(event) {
+		case 'add':
+			return 'add_file';
+		case 'change':
+			return 'change_file';
+		case 'unlink':
+			return 'delete_file';
+		case 'addDir':
+			return 'add_directory';
+		case 'unlinkDir':
+			return 'delete_directory';
+	}
+};
+
+const watch_for_changes = (after_run_functions = {}, watch_for_changes_options = {}) => {
+	const file_watcher = chokidar.watch([...watch_paths, ...(watch_for_changes_options?.custom_copy_paths || [])].map(({ path }) => path), {
+		ignored: '.joystick',
+	});
+
+	let file_watcher_jobs = [];
+
+	process.initial_build_complete = false;
+
+	file_watcher.on('error', (error) => console.error(error));
+
+	file_watcher.on('all', (event, path) => {
+		file_watcher_jobs.push({
+			event: transform_chokidar_event(event),
+			path,
+			is_custom_copy_path: watch_for_changes_options?.custom_copy_paths?.length ? watch_for_changes_options?.custom_copy_paths.some((custom_copy_path) => {
+			  return path.includes(custom_copy_path?.path);
+			}) : false,
+		});
+
+		// NOTE: Depending on the watch event, we expect multiple events to be emitted
+		// by chokidar. Debouncing here allows us to "collect" the jobs for the current
+		// chain of events and *then* process them all together. This is done to avoid
+		// triggering multiple HMR calls or server restarts for files related to the
+		// same job. This is near-instant, so there's no delay for the developer.
+		debounce(async () => {
+			await process_file_watcher_jobs(file_watcher_jobs, after_run_functions);
+			process.initial_build_complete = true;
+			file_watcher_jobs = [];
+		}, 100);
+	});
+};
+
+export default watch_for_changes;

package/src/lib/development_server/watch_for_changes/node_paths.js

@@ -0,0 +1,16 @@
+import get_platform_safe_path from "./get_platform_safe_path.js";
+
+export default [
+  get_platform_safe_path("api/"),
+  get_platform_safe_path("cronJobs/"),
+  get_platform_safe_path("cron_jobs/"),
+  get_platform_safe_path("fixtures/"),
+  get_platform_safe_path("indexes/"),
+  get_platform_safe_path("lib/node"),
+  get_platform_safe_path("queues/"),
+  get_platform_safe_path("routes/"),
+  get_platform_safe_path("tests/"),
+  get_platform_safe_path("uploaders/"),
+  get_platform_safe_path("websockets/"),
+  "index.server.js",
+];

package/src/lib/development_server/watch_for_changes/read_file_dependency_map.js

@@ -0,0 +1,18 @@
+import fs from 'fs';
+import path_exists from '../../path_exists.js';
+
+const { readFile } = fs.promises;
+
+const read_file_dependency_map = async () => {
+  const file_map_path = `.joystick/build/file_map.json`;
+
+  if (await path_exists(file_map_path)) {
+    const file_map_as_json = await readFile(file_map_path, "utf-8");
+    const file_map = file_map_as_json ? JSON.parse(file_map_as_json) : {};
+    return file_map;
+  }
+
+  return {};
+};
+
+export default read_file_dependency_map;

package/src/lib/development_server/watch_for_changes/watch_paths.js

@@ -0,0 +1,21 @@
+import copy_paths from "../../build/copy_paths.js";
+
+const watch_paths = [
+  { path: "api" },
+  { path: "cronJobs" },
+  { path: "cron_jobs" },
+  { path: "email" },
+  { path: "fixtures" },
+  { path: "indexes" },
+  { path: "lib" },
+  { path: "queues" },
+  { path: "routes" },
+  { path: "ui" },
+  { path: "uploaders" },
+  { path: "websockets" },
+  { path: "index.client.js" },
+  { path: "index.server.js" },
+  ...copy_paths,
+];
+
+export default watch_paths;

package/src/lib/dynamic_import.js

@@ -0,0 +1,6 @@
+const dynamic_import = async (path = '') => {  
+  const file = await import(path);
+  return file?.default;
+};
+
+export default dynamic_import;

package/src/lib/encrypt_buffer.js

@@ -0,0 +1,10 @@
+import crypto from 'crypto';
+
+const encrypt_buffer = (buffer, key) => {
+	const initialization_vector = crypto.randomBytes(16);
+	const hashed_encryption_key = crypto.createHash('sha256').update(key).digest('hex').substring(0, 32);
+	const cipher = crypto.createCipheriv('aes256', hashed_encryption_key, initialization_vector);
+	return Buffer.concat([initialization_vector, cipher.update(buffer), cipher.final()]);
+};
+
+export default encrypt_buffer;

package/src/lib/generate_id.js

@@ -0,0 +1,15 @@
+const characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890'.split('');
+
+const generate_id = (length = 16) => {
+	let id = '';
+  let i = 0;
+
+  while (i < length) {
+    id += characters[Math.floor(Math.random() * (characters.length - 1))];
+    i += 1;
+  }
+
+  return id;
+};
+
+export default generate_id;

package/src/lib/get_files_in_path.js

@@ -0,0 +1,25 @@
+import fs from 'fs';
+import { join } from 'path';
+
+const { readdir, stat } = fs.promises;
+
+const get_files_in_path = async (path = './', existing_files = []) => {
+	const files_in_path = (await readdir(path))?.map((file_in_path) => {
+		return join(path, file_in_path);
+	});
+
+	existing_files.push(...files_in_path);
+
+	for (let i = 0; i < files_in_path?.length; i += 1) {
+		const file = files_in_path[i];
+		const is_directory = (await stat(file)).isDirectory();
+
+		if (is_directory) {
+			await get_files_in_path(file, existing_files);
+		}
+	}
+
+	return existing_files;
+};
+
+export default get_files_in_path;

package/src/lib/get_platform_safe_path.js

@@ -0,0 +1,8 @@
+import os from 'os';
+
+const get_platform_safe_path = (path = '') => {
+  // NOTE: This is why serial killers exist.
+  return os.platform() === "win32" ? path.replace(/\//g, '\\') : path;
+};
+
+export default get_platform_safe_path;

package/src/lib/get_process_id_from_port.js

@@ -0,0 +1,26 @@
+import child_process from 'child_process';
+import util from 'util';
+
+const exec = util.promisify(child_process.exec);
+
+const get_process_id_from_port = async (port = 0) => {
+	if (process.platform === 'win32') {
+		return exec(`netstat -a -n -o | find "${port}"`)
+			.then((stat) => {
+				const stat_result = stat.stdout?.split('\n');
+				const process_id_response = stat_result && stat_result[0] && stat_result[0]?.split(' ')?.filter((value) => value !== '')?.map((value) => {
+					return value?.replace('\r', '');
+				})?.pop();
+
+				return process_id_response || null;
+			})
+			.catch(() => {
+				return null;
+			});
+	}
+
+	const process_id_response = await exec(`lsof -n -i:${port} | grep LISTEN | awk '{ print $2 }' | uniq`);
+	return process_id_response?.stdout || null;
+};
+
+export default get_process_id_from_port;

package/src/lib/is_valid_json_string.js

@@ -0,0 +1,10 @@
+const is_valid_json_string = (string = '') => {
+	try {
+		JSON.parse(string);
+		return true;
+	} catch {
+		return false;
+	}
+};
+
+export default is_valid_json_string;

package/src/lib/kill_port_process.js

@@ -0,0 +1,12 @@
+import get_process_id_from_port from "./get_process_id_from_port.js";
+import kill_process_id from "./kill_process_id.js";
+
+const kill_port_process = async (port = 0) => {
+	const process_id = await get_process_id_from_port(port);
+
+	if (process_id) {
+		await kill_process_id(process_id);
+	}
+};
+
+export default kill_port_process;

package/src/lib/kill_process_id.js

@@ -0,0 +1,19 @@
+import child_process from 'child_process';
+import util from 'util';
+
+const exec = util.promisify(child_process.exec);
+
+const kill_process_id = async (process_id = 0) => {
+	const process_id_as_integer = parseInt(process_id, 10);
+	
+	if (process_id_as_integer) {
+		if (process.platform === 'win32') {
+			await exec(`taskkill /F /PID ${process_id_as_integer}`);
+			return;
+		}
+
+		await exec(`kill -9 ${process_id_as_integer}`);
+	}
+};
+
+export default kill_process_id;

package/src/lib/load_settings.js

@@ -0,0 +1,43 @@
+import fs from 'fs';
+import cli_log from './cli_log.js';
+import is_valid_json_string from './is_valid_json_string.js';
+import path_exists from './path_exists.js';
+
+const { readFile } = fs.promises;
+
+const load_settings = async (environment = null) => {
+  const settings_file_path = `${process.cwd()}/settings.${environment}.json`;
+  const has_settings_file = await path_exists(settings_file_path);
+
+  if (!has_settings_file) {
+    cli_log(`A settings file could not be found for this environment (${environment}). Create a settings.${environment}.json file at the root of your project and restart Joystick.`, {
+      level: 'danger',
+      docs: 'https://github.com/cheatcode/joystick#settings',
+    });
+
+    process.exit(0);
+  }
+
+  const raw_settings_file = await readFile(settings_file_path, "utf-8");
+  const is_valid_json = is_valid_json_string(raw_settings_file);
+
+  if (!is_valid_json) {
+    cli_log(`Failed to parse settings file. Double-check the syntax in your settings.${environment}.json file at the root of your project and restart Joystick.`, {
+      level: 'danger',
+      docs: 'https://github.com/cheatcode/joystick#settings',
+      tools: [
+        { title: 'JSON Linter', url: 'https://jsonlint.com/' }
+      ],
+    });
+    process.exit(0);
+  }
+
+  const settings_file = is_valid_json ? raw_settings_file : "{}";
+
+  // NOTE: Child process will inherit this env var from this parent process.
+  process.env.JOYSTICK_SETTINGS = settings_file;
+
+  return JSON.parse(settings_file);
+};
+
+export default load_settings;

package/src/lib/loader.js

@@ -1,93 +1,20 @@
 import chalk from "chalk";
-import readline from 'readline';
 
 class Loader {
   constructor(options = {}) {
-    this.message = options.defaultMessage;
-    this.frame = 0;
-    this.frames = [
-      chalk.yellowBright((options.padding || '') + ">>-----"),
-      chalk.yellowBright((options.padding || '') + "->>----"),
-      chalk.yellowBright((options.padding || '') + "-->>---"),
-      chalk.yellowBright((options.padding || '') + "--->>--"),
-      chalk.yellowBright((options.padding || '') + "---->>-"),
-      chalk.yellowBright((options.padding || '') + "----->>"),
-      chalk.yellowBright((options.padding || '') + "----<<-"),
-      chalk.yellowBright((options.padding || '') + "---<<--"),
-      chalk.yellowBright((options.padding || '') + "--<<---"),
-      chalk.yellowBright((options.padding || '') + "-<<----"),
-      chalk.yellowBright((options.padding || '') + "<<-----"),
-    ];
-    this.freezeFrames = {
-      stable: chalk.yellowBright((options.padding || '') + "--->---"),
-      error: chalk.redBright((options.padding || '') + "!!!"),
-    };
+    this.message = options.default_message;
   }
 
-  getFrame() {
-    if (this.frame === this.frames.length - 1) {
-      this.frame = 0;
-      return this.frame;
-    }
-
-    this.frame += 1;
-    return this.frame;
-  }
-
-  start(message = "") {
+  print(message = "", error = false) {
     if (message) {
       this.message = message;
     }
 
-    this.interval = setInterval(() => {
-      const frameToRender = this.getFrame();
-      readline.cursorTo(process.stdout, 0);
-      process.stdout.write(`${this.frames[frameToRender]} ${this.message}`);
-    }, 80);
-  }
-
-  stop() {
-    clearInterval(this.interval);
-    readline.cursorTo(process.stdout, 0);
-    readline.clearLine(process.stdout);
-    this.message = "";
-    this.interval = null;
-  }
-
-  text(message = "") {
-    readline.clearLine(process.stdout);
-
-    if (message) {
-      this.message = message;
-    }
-
-    if (!this.interval) {
-      this.start();
-    }
-  }
-
-  pause(message = "", frame = "stable") {
-    readline.clearLine(process.stdout);
-
-    if (message) {
-      this.message = message;
-    }
-
-    clearInterval(this.interval);
-    this.interval = null;
-    const freezeFrame = this.freezeFrames[frame];
-    readline.cursorTo(process.stdout, 0);
-    process.stdout.write(
-      `${freezeFrame ? `${freezeFrame} ` : ""}${this.message}`
-    );
-  }
-
-  stable(message = "") {
-    this.pause(message);
+    process.stdout.write(`${chalk[error ? 'redBright' : 'yellowBright']('>')} ${this.message}\n`);
   }
 
   error(message = "") {
-    this.pause(message, "error");
+    this.print(message, true);
   }
 }
 

package/src/lib/log_bars.js

@@ -0,0 +1,7 @@
+import chalk from 'chalk';
+
+const log_bars = () => {
+  return `${chalk.yellowBright('=')}${chalk.gray('=')}${chalk.yellowBright('=')}${chalk.gray('=')}${chalk.yellowBright('=')}${chalk.gray('=')}`;
+};
+
+export default log_bars;