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

package/src/lib/development_server/databases/mongodb/build_query_parameters.js

@@ -0,0 +1,17 @@
+import available_query_parameters from "./available_query_parameters.js";
+
+const build_query_parameters = (connection = {}) => {
+  const query_parameters = {};
+
+  for (let i = 0; i < available_query_parameters.length; i += 1) {
+    const available_query_parameter = available_query_parameters[i];
+
+    if (connection && connection[available_query_parameter]) {
+      query_parameters[available_query_parameter] = connection[available_query_parameter];
+    }
+  }
+
+  return query_parameters;
+};
+
+export default build_query_parameters;

package/src/lib/development_server/databases/mongodb/check_connection.js

@@ -0,0 +1,41 @@
+import { MongoClient } from "mongodb";
+import fs from 'fs';
+import build_connection_string from "./build_connection_string.js";
+import color_log from '../../../color_log.js';
+
+const { readFile } = fs.promises;
+
+const check_connection = async (connection = {}, mongodb_options = {}) => {
+  const connection_string = build_connection_string(connection);
+  
+  try {
+    const connectionOptions = {
+      connectTimeoutMS: 3000,
+      socketTimeoutMS: 3000,
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+      ssl: false,
+      ...(mongodb_options || {}),
+    };
+
+    if (mongodb_options?.ca) {
+      connectionOptions.ca = await readFile(mongodb_options?.ca);
+    }
+
+    const connection = await MongoClient.connect(connection_string, connectionOptions);
+    connection.close();
+
+    return true;
+  } catch (exception) {
+    console.warn(exception);
+
+    color_log(
+    	`\n✖ Failed to connect to MongoDB. Please double-check connection settings and try again.`,
+    	'yellow'
+    );
+
+    process.exit(1);
+  }
+};
+
+export default check_connection;

package/src/lib/development_server/databases/mongodb/connect.js

@@ -0,0 +1,27 @@
+import check_connection from "./check_connection.js";
+import mongodb from "./index.js";
+
+const connect = async (settings = {}, port = 2610) => {
+  const has_connection = settings.connection && Object.keys(settings.connection).length > 0;
+
+  if (has_connection) {
+    await check_connection(settings.connection, settings.options);
+  }
+
+  return {
+    pid: !has_connection ? await mongodb(port) : null,
+    connection: has_connection ? settings.connection : {
+      hosts: [
+        {
+          hostname: "127.0.0.1",
+          port,
+        },
+      ],
+      database: "app",
+      username: "",
+      password: "",
+    },
+  };
+};
+
+export default connect;

package/src/lib/development_server/databases/mongodb/index.js

@@ -0,0 +1,118 @@
+import child_process from "child_process";
+import fs from "fs";
+import cli_log from "../../../cli_log.js";
+import command_exists from '../../../command_exists.js';
+import get_platform_safe_path from '../../../get_platform_safe_path.js';
+import get_process_id_from_port from "../../../get_process_id_from_port.js";
+import kill_port_process from "../../../kill_port_process.js";
+import path_exists from "../../../path_exists.js";
+
+const { rename, readdir, mkdir } = fs.promises;
+
+const warn_mongodb_not_installed = () => {
+  cli_log(
+    ` MongoDB is not installed on this computer.\n\n Download MongoDB at https://www.mongodb.com/try/download/community\n\n After you've installed MongoDB, run joystick start again, or, remove MongoDB from your config.databases array in your settings.development.json file to skip starting it up.`,
+    {
+    	level: 'danger',
+    	docs: 'https://github.com/cheatcode/joystick#databases',
+  	}
+  );
+};
+
+const check_if_mongodb_exists = async () => {
+  if (process.platform === "win32") {
+    const mongodb_versions = await get_mongodb_windows_versions();
+    return mongodb_versions && mongodb_versions.length > 0;
+  }
+
+  return command_exists("mongod");
+};
+
+const get_mongodb_windows_versions = async () => {
+  const mongodb_versions = (await readdir(`C:\\Program Files\\MongoDB\\Server\\`));
+  return mongodb_versions;
+};
+
+const get_mongo_command = (mongodb_windows_versions = []) => {
+  if (process.platform === 'win32') {
+    const has_mongodb_six_or_greater = ['6.0', '7.0', '8.0', '9.0', '10.0'].some((mongodb_version) => {
+      return mongodb_windows_versions.includes(mongodb_version);
+    });
+
+    return has_mongodb_six_or_greater ? 'mongosh' : 'mongo';
+  }
+
+  return 'mongo';
+};
+
+const start_mongodb_process = (mongodb_port = 2610, mongodb_windows_versions = []) => {
+  return new Promise((resolve) => {
+    const database_process_flags = [
+      '--port',
+      mongodb_port,
+      '--dbpath',
+      get_platform_safe_path(`./.joystick/data/mongodb_${mongodb_port}`),
+      '--quiet',
+      '--replSet',
+      `joystick_${mongodb_port}`,
+    ];
+
+    const database_process = child_process.spawn(
+      `mongod`,
+      database_process_flags.filter((command) => !!command),
+    );
+
+    database_process.stdout.on('data', async (data) => {
+      const stdout = data?.toString();
+
+      if (stdout.includes('Waiting for connections')) {
+        const mongo_command = get_mongo_command(mongodb_windows_versions);
+        child_process.exec(`${mongo_command} --eval "rs.initiate()" --verbose --port ${mongodb_port}`, async (error, _stdout, stderr) => {
+          const process_id = await get_process_id_from_port(mongodb_port);
+          return resolve(parseInt(process_id, 10));
+        });
+      }
+    });
+  });
+};
+
+const setup_data_directory = async (mongodb_port = 2610) => {
+  // NOTE: MongoDB was originally started as a standalone server. To enable additional functionality,
+  // we moved to a replica set config which necessitated multiple data directories in order to support
+  // running the same app on multiple ports (a limitation of MongoDB).
+  const legacy_data_directory_exists = await path_exists(".joystick/data/mongodb");
+  const data_directory_exists = await path_exists(`.joystick/data/mongodb_${mongodb_port}`);
+
+  if (legacy_data_directory_exists && !data_directory_exists) {
+    await rename('.joystick/data/mongodb', `.joystick/data/mongodb_${mongodb_port}`);
+  }
+
+  if (!data_directory_exists) {
+    await mkdir(`.joystick/data/mongodb_${mongodb_port}`, { recursive: true });
+  }
+
+  return data_directory_exists;
+};
+
+const start_mongodb = async (mongodb_port = 2610) => {
+  const mongodb_exists = await check_if_mongodb_exists();
+  const mongodb_windows_versions = process.platform === 'win32' ? await get_mongodb_windows_versions() : null;
+
+  if (!mongodb_exists) {
+    warn_mongodb_not_installed();
+    process.exit(1);
+  }
+
+  await setup_data_directory(mongodb_port);
+
+  try {
+    await kill_port_process(mongodb_port);
+    const mongo_process_id = await start_mongodb_process(mongodb_port, mongodb_windows_versions);
+    return mongo_process_id;
+  } catch (exception) {
+    console.warn(exception);
+    process.exit(1);
+  }
+};
+
+export default start_mongodb;

package/src/lib/development_server/databases/postgresql/check_connection.js

@@ -0,0 +1,56 @@
+import fs from 'fs';
+import postgresql from "pg";
+import color_log from "../../../color_log.js";
+
+const { Client } = postgresql;
+const { readFile } = fs.promises;
+
+const test_query = (client = {}) => {
+  return new Promise((resolve, reject) => {
+    client.query('SELECT NOW()', (error) => {
+      if (error) {
+        reject();
+      } else {
+        resolve();
+      }
+
+      client.end();
+    });
+  });
+};
+
+const check_connection = async (connection = {}, options = {}) => {
+  try {
+    const host = connection?.hosts && connection?.hosts[0];
+    const connection_config = {
+      user: connection?.username,
+      host: host?.hostname,
+      database: connection?.database,
+      password: connection?.password,
+      port: host?.port,
+    };
+
+    if (options?.ssl?.ca) {
+      connection_config.ssl = {
+        ca: await readFile(options?.ssl?.ca)
+      };
+    }
+
+    const client = new Client(connection_config);
+
+    client.connect();
+    await test_query(client);
+
+    return true;
+  } catch (exception) {
+    console.warn(exception);
+  	color_log(
+  		`\n✖ Failed to connect to PostgreSQL. Please double-check connection settings and try again.`,
+  		'yellow'
+  	);
+
+    process.exit(1);
+  }
+};
+
+export default check_connection;

package/src/lib/development_server/databases/postgresql/connect.js

@@ -0,0 +1,33 @@
+import os from 'os';
+import check_connection from "./check_connection.js";
+import postgresql from "./index.js";
+
+const connect = async (settings = {}, port = 2610) => {
+  try {
+    const has_connection = settings.connection && Object.keys(settings.connection).length > 0;
+
+    if (has_connection) {
+      await check_connection(settings.connection, settings.options);
+    }
+
+    return {
+      pid: !has_connection ? await postgresql(port) : null,
+      connection: has_connection ? settings.connection : {
+        hosts: [
+          {
+            hostname: "127.0.0.1",
+            port,
+          },
+        ],
+        database: "app",
+        // NOTE: PostgreSQL creates a default superuser based on the OS username.
+        username: (os.userInfo() || {}).username || "",
+        password: "",
+      },
+    };
+  } catch (exception) {
+    console.warn(exception);
+  }
+};
+
+export default connect;

package/src/lib/development_server/databases/postgresql/index.js

@@ -0,0 +1,126 @@
+import child_process from "child_process";
+import fs from "fs";
+import util from "util";
+import cli_log from "../../../cli_log.js";
+import command_exists from "../../../command_exists.js";
+import get_platform_safe_path from "../../../get_platform_safe_path.js";
+import get_process_id_from_port from "../../../get_process_id_from_port.js";
+import kill_port_process from "../../../kill_port_process.js";
+import path_exists from "../../../path_exists.js";
+
+const exec = util.promisify(child_process.exec);
+const { rename } = fs.promises;
+
+const setup_data_directory = async (postgresql_port = 2610) => {
+  const legacy_data_directory_exists = await path_exists(".joystick/data/postgresql");
+  let data_directory_exists = await path_exists(`.joystick/data/postgresql_${postgresql_port}`);
+
+  if (legacy_data_directory_exists && !data_directory_exists) {
+    await rename ('.joystick/data/postgresql', `.joystick/data/postgresql_${postgresql_port}`);
+    data_directory_exists = true;
+  }
+
+  return data_directory_exists;
+};
+
+const warn_postgresql_is_missing = () => {
+  cli_log(
+    'PostgreSQL is not installed on this computer. You can download PostgreSQL at https://www.postgresql.org/download. After you\'ve installed PostgreSQL, run joystick start again, or, remove PostgreSQL from your databases list in your settings.development.json file to skip startup.',
+    {
+      level: 'danger',
+      docs: 'https://cheatcode.co/docs/joystick/cli#databases'
+    }
+  );
+};
+
+const check_if_postgresql_exists = () => {
+  return command_exists("psql");
+};
+
+const check_if_postgresql_control_exists = () => {
+  return command_exists("pg_ctl");
+};
+
+const start_postgresql = async (port = 2610) => {
+  const postgresql_exists = await check_if_postgresql_exists();
+
+  if (!postgresql_exists) {
+    warn_postgresql_is_missing();
+    process.exit(1);
+  }
+
+  const postgresql_control_exists = await check_if_postgresql_control_exists();
+
+  if (!postgresql_control_exists) {
+    cli_log(
+      'PostgreSQL is installed on this computer, but pg_ctl (what Joystick uses to start and manage PostgreSQL) is not in your command line\'s PATH variable. Add pg_ctl to your command line\'s PATH, restart your command line, and try again.',
+      {
+        level: 'danger',
+        docs: 'https://cheatcode.co/docs/joystick/postgresql#path'
+      }
+    );
+  }
+
+  try {
+    const data_directory_exists = await setup_data_directory(port);
+
+    if (!data_directory_exists && postgresql_control_exists) {
+      await exec(
+        `pg_ctl init -D .joystick/data/postgresql_${port}`
+      );
+    }
+
+    const postgresql_port = port;
+    const existing_process_id = parseInt(await get_process_id_from_port(postgresql_port), 10);
+
+    if (existing_process_id) {
+      await exec(`pg_ctl kill KILL ${existing_process_id}`);
+    }
+
+    const database_process = child_process.spawn(
+      `pg_ctl`,
+      [
+        '-o',
+        `"-p ${postgresql_port}"`,
+        '-D',
+        get_platform_safe_path(`.joystick/data/postgresql_${port}`),
+        'start',
+      ].filter((command) => !!command),
+    );
+
+    return new Promise((resolve) => {
+      database_process.stderr.on('data', async (data) => {
+        const stderr = data?.toString();
+
+        if (!stderr?.includes('another server might be running')) {
+          console.warn(stderr);
+        }
+      });
+
+      database_process.stdout.on('data', async (data) => {
+        const stdout = data?.toString();
+
+        if (stdout.includes('database system is ready to accept connections')) {
+          const process_id = (await get_process_id_from_port(postgresql_port))?.replace('\n', '');
+
+          exec(`createdb -h 127.0.0.1 -p ${postgresql_port} app`).then((data) => {
+            resolve(parseInt(process_id, 10));
+          }).catch(({ stderr: error }) => {
+            // NOTE: PostgreSQL does not have a clean way to create database if it doesn't exist. Use this as a hack
+            // to get around the "already exists" error (if the database exists, it's not an issue).
+            if (error && error.includes('database "app" already exists')) {
+              resolve(parseInt(process_id, 10));
+            } else {
+              console.log(error);
+            }
+          });
+        }
+      });
+    });
+  } catch (exception) {
+    console.warn(exception);
+    process.exit(1);
+  }
+};
+
+export default start_postgresql;

package/src/lib/development_server/databases/provider_map.js

@@ -0,0 +1,15 @@
+import connect_mongodb from './mongodb/connect.js';
+import connect_postgresql from './postgresql/connect.js';
+
+const provider_map = {
+  mongodb: {
+    name: 'MongoDB',
+    connect: connect_mongodb,
+  },
+  postgresql: {
+    name: 'PostgreSQL',
+    connect: connect_postgresql,
+  },
+};
+
+export default provider_map;

package/src/lib/development_server/get_database_process_ids.js

@@ -0,0 +1,28 @@
+const get_database_process_ids = () => {
+  const database_process_ids = [];
+  const databases = Object.entries(process._databases || {});
+
+  for (let i = 0; i < databases?.length; i += 1) {
+    const [_provider, provider_connection] = databases[i];
+
+    if (provider_connection?.pid) {
+      database_process_ids.push(provider_connection.pid);
+    }
+
+    if (!provider_connection?.pid) {
+      const provider_connections = Object.entries(provider_connection);
+
+      for (let pc = 0; pc < provider_connections?.length; pc += 1) {
+        const [_connection_name, connection] = provider_connections[pc];
+
+        if (connection?.pid) {
+          database_process_ids.push(connection.pid);
+        }
+      }
+    }
+  }
+
+  return database_process_ids;
+};
+
+export default get_database_process_ids;

package/src/lib/development_server/get_translations.js

@@ -0,0 +1,85 @@
+import fs from 'fs';
+import load_settings from "../load_settings.js";
+import types from '../types.js';
+import dynamic_import from '../dynamic_import.js';
+
+const settings = await load_settings(process.env.NODE_ENV);
+
+const get_translations_file = async (language_file_path = '', joystick_build_path = '', render_component_path = '') => {
+  const language_file = await dynamic_import(`${process.cwd()}/${joystick_build_path}/i18n/${language_file_path}?v=${new Date().getTime()}`);
+  const is_valid_language_file = language_file && types.is_object(language_file);
+
+  if (is_valid_language_file) {
+    const translations_for_page = language_file[render_component_path];
+    return translations_for_page ? translations_for_page : language_file;
+  }
+
+  return {};
+};
+
+const get_language_preference_regexes = (user_language = '', browser_languages = []) => {
+  let language_preferences = [];
+
+  if (user_language) {
+    language_preferences.push(user_language);
+  }
+
+  const filtered_browser_languages = browser_languages?.filter((language) => {
+    return !language?.includes('*');
+  });
+
+  language_preferences.push(...filtered_browser_languages);
+  language_preferences.push(settings?.config?.i18n?.defaultLanguage);
+
+  return language_preferences?.flatMap((language) => {
+    const variants = [language];
+
+    if (language?.length === 2) {
+      variants.push(`${language.substring(0, 2)}-`);
+    }
+
+    if (language?.length > 2) {
+      variants.push(`${language?.split('-')[0]}`);
+      variants.push(`${language?.split('-')[0]}-`);
+    }
+
+    return variants;
+  })?.map((language_string) => {
+    const last_character = language_string[language_string?.length - 1];
+
+    if (last_character === '-') {
+      return new RegExp(`^${language_string}[A-Z]+.js`, 'g');
+    }
+
+    return new RegExp(`^${language_string}.js`, 'g');
+  });
+};
+
+const parse_browser_languages = (languages = '') => {
+  const raw_languages = languages.split(',');
+  return raw_languages?.map((raw_language) => raw_language.split(';')[0]);
+};
+
+const get_translations = async (joystick_build_path = '', render_component_path = '', req = {}) => {
+  const language_files = fs.readdirSync(`${joystick_build_path}/i18n`);
+  const browser_languages = parse_browser_languages(req?.headers['accept-language']);
+  const language_preferences = get_language_preference_regexes(req?.context?.user?.language, browser_languages);
+
+  let matching_file = null;
+
+  for (let i = 0; i < language_preferences.length; i += 1) {
+    const language_regex = language_preferences[i];
+    const match = language_files.find((language_file) => !!language_file.match(language_regex));
+
+    if (match) {
+      matching_file = match;
+      break;
+    }
+  }
+
+  const translations_file = await get_translations_file(matching_file, joystick_build_path, render_component_path);
+
+  return translations_file;
+};
+
+export default get_translations;

package/src/lib/development_server/hmr_server.js

@@ -0,0 +1,94 @@
+import queryString from 'query-string';
+import { WebSocketServer } from "ws";
+import generate_id from "../generate_id.js";
+import get_translations from './get_translations.js';
+
+process.title = 'joystick_hmr';
+
+export default (() => {
+  const websocket_server = new WebSocketServer({
+    port: parseInt(process.env.PORT, 10) + 1,
+    path: "/_joystick/hmr",
+  });
+
+  process.on("message", async (message) => {
+    const parsed_message = JSON.parse(message);
+
+    if (typeof process.HMR_CONNECTIONS === "object" && !!parsed_message?.type) {
+      const connections = Object.values(process.HMR_CONNECTIONS);
+
+      for (let i = 0; i < connections?.length; i += 1) {
+        const connection = connections[i];
+
+        if (connection?.connection?.send) {
+          if (parsed_message?.type === 'BUILD_ERROR') {
+            connection.connection.send(JSON.stringify({ type: 'BUILD_ERROR' }));
+          }
+
+          if (parsed_message?.type === 'FILE_CHANGE') {
+            connection.connection.send(
+              JSON.stringify({
+                type: "FILE_CHANGE",
+                settings: parsed_message?.settings ? {
+                  global: parsed_message?.settings?.global,
+                  public: parsed_message?.settings?.public,
+                } : null,
+                i18n: parsed_message?.i18n_change ? await get_translations('./.joystick/build', connection?.page_component_path, {
+                  headers: {
+                    'accept-language': connection?.browser_language,
+                  },
+                  context: {
+                    user: {
+                      language: connection?.user_language,
+                    },
+                  }
+                }) : null,
+                index_html_changed: parsed_message?.index_html_change,
+                index_css_changed: parsed_message?.index_css_change,
+                index_client_changed: parsed_message?.index_client_change,
+              })
+            );
+          }
+        }
+      }
+    }
+  });
+
+  websocket_server.on("connection", function connection(websocket_connection, connection_request = {}) {
+    const connection_id = generate_id(16);
+    const [_path, params] = connection_request?.url?.split("?");
+    const connection_params = queryString.parse(params);
+
+    process.HMR_CONNECTIONS = {
+      ...(process.HMR_CONNECTIONS || {}),
+      [connection_id]: {
+        connection: websocket_connection,
+        browser_language: connection_params?.browser_language,
+        user_language: connection_params?.user_language,
+        page_component_path: connection_params?.page_component_path,
+      },
+    };
+
+    if (Object.keys(process.HMR_CONNECTIONS || {})?.length > 0) {
+      process.send({ type: "HAS_HMR_CONNECTIONS" });
+    }
+
+    websocket_connection.on("message", (message) => {
+      const parsed_message = JSON.parse(message);
+
+      if (parsed_message?.type === "HMR_UPDATE_COMPLETE") {
+        process.send({ type: "HMR_UPDATE_COMPLETE" });
+      }
+    });
+
+    websocket_connection.on("close", () => {
+      if (process.HMR_CONNECTIONS[connection_id]) {
+        delete process.HMR_CONNECTIONS[connection_id];
+
+        if (Object.keys(process.HMR_CONNECTIONS || {})?.length === 0) {
+          process.send({ type: "HAS_NO_HMR_CONNECTIONS" });
+        }
+      }
+    });
+  });
+})();