@joystick.js/cli-canary 0.0.0-canary.172 → 0.0.0-canary.1721

package/src/lib/development_server/databases/mongodb/installers/macos.js

@@ -0,0 +1,109 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { promisify } from 'util';
+import { pipeline } from 'stream';
+import { execFile } from 'child_process';
+
+const streamPipeline = promisify(pipeline);
+const execFileAsync = promisify(execFile);
+
+const download_mongodb_macos = async (version_path = null) => {
+  const base_directory = path.join(os.homedir(), '.joystick', 'databases', 'mongodb');
+  const bin_directory = path.join(base_directory, 'bin');
+  const bin_bin_directory = path.join(bin_directory, 'bin');
+
+  if (await check_if_file_exists(base_directory)) {
+    return;
+  }
+
+  await create_directories(base_directory, bin_directory, bin_bin_directory);
+
+  const cpu_info = await get_cpu_info();
+  const is_arm = cpu_info.includes('ARM');
+  
+  const mongodb_url = is_arm
+    ? 'https://fastdl.mongodb.org/osx/mongodb-macos-arm64-7.0.2.tgz'
+    : 'https://fastdl.mongodb.org/osx/mongodb-macos-x86_64-7.0.2.tgz';
+
+  const mongosh_url = is_arm
+    ? 'https://downloads.mongodb.com/compass/mongosh-2.2.12-darwin-arm64.zip'
+    : 'https://downloads.mongodb.com/compass/mongosh-2.2.12-darwin-x64.zip';
+
+  const mongodb_file_name = path.basename(new URL(mongodb_url).pathname);
+  const mongodb_file_path = path.join(base_directory, mongodb_file_name);
+
+  const mongosh_file_name = path.basename(new URL(mongosh_url).pathname);
+  const mongosh_file_path = path.join(base_directory, mongosh_file_name);
+
+  process.loader.print('MongoDB not found. Downloading... (this may take a few minutes)');
+  await download_file(mongodb_url, mongodb_file_path);
+  await download_file(mongosh_url, mongosh_file_path);
+
+  process.loader.print('Installing MongoDB...');
+  
+  // Extract MongoDB
+  await execFileAsync('tar', ['-xzf', mongodb_file_path, '-C', bin_directory, '--strip-components=1']);
+  
+  // Extract mongosh
+  const mongosh_temp_directory = path.join(base_directory, 'mongosh_temp');
+  await fs.promises.mkdir(mongosh_temp_directory, { recursive: true });
+  await execFileAsync('unzip', ['-q', mongosh_file_path, '-d', mongosh_temp_directory]);
+  
+  // Find and copy mongosh executable
+  const mongosh_contents = await fs.promises.readdir(mongosh_temp_directory);
+  const mongosh_dir = mongosh_contents.find(item => item.startsWith('mongosh-'));
+  if (!mongosh_dir) {
+    throw new Error('Could not find mongosh directory in extracted contents');
+  }
+  
+  const mongosh_bin_path = path.join(mongosh_temp_directory, mongosh_dir, 'bin', 'mongosh');
+  const final_mongosh_path = path.join(bin_bin_directory, 'mongosh');
+  await fs.promises.copyFile(mongosh_bin_path, final_mongosh_path);
+
+  // Clean up
+  await fs.promises.unlink(mongodb_file_path);
+  await fs.promises.unlink(mongosh_file_path);
+  await fs.promises.rm(mongosh_temp_directory, { recursive: true, force: true });
+
+  await make_file_executable(bin_directory);
+  await make_file_executable(bin_bin_directory);
+  process.loader.print('MongoDB installed!');
+};
+
+const download_file = async (url, file_path) => {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download: ${response.statusText}`);
+  }
+  await streamPipeline(response.body, fs.createWriteStream(file_path));
+};
+
+const check_if_file_exists = async (file_path) => {
+  try {
+    await fs.promises.access(file_path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const get_cpu_info = async () => {
+  const { stdout } = await execFileAsync('sysctl', ['-n', 'machdep.cpu.brand_string']);
+  return stdout.trim();
+};
+
+const create_directories = async (base_directory, bin_directory, bin_bin_directory) => {
+  await fs.promises.mkdir(base_directory, { recursive: true });
+  await fs.promises.mkdir(bin_directory, { recursive: true });
+  await fs.promises.mkdir(bin_bin_directory, { recursive: true });
+};
+
+const make_file_executable = async (directory) => {
+  const files = await fs.promises.readdir(directory);
+  for (const file of files) {
+    await fs.promises.chmod(path.join(directory, file), '755');
+  }
+};
+
+export default download_mongodb_macos;

package/src/lib/development_server/databases/mongodb/installers/windows.js

@@ -0,0 +1,90 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { promisify } from 'util';
+import { pipeline } from 'stream';
+import { execFile } from 'child_process';
+
+const stream_pipeline = promisify(pipeline);
+const exec_file_async = promisify(execFile);
+
+const download_mongodb_windows = async () => {
+  const base_directory = path.join(os.homedir(), '.joystick', 'databases', 'mongodb');
+  const bin_directory = path.join(base_directory, 'bin');
+
+  if (await check_if_file_exists(base_directory)) {
+    return;
+  }
+
+  await create_directories(base_directory, bin_directory);
+
+  const download_url = 'https://fastdl.mongodb.org/windows/mongodb-windows-x86_64-7.0.2.zip';
+  const file_name = path.basename(new URL(download_url).pathname);
+  const file_path = path.join(base_directory, file_name);
+
+  if (await check_if_file_exists(file_path)) {
+    return;
+  }
+
+  process.loader.print('MongoDB not found. Downloading... (this may take a few minutes)');
+  await download_file(download_url, file_path);
+  process.loader.print('Installing MongoDB...');
+  
+  const temp_directory = path.join(base_directory, 'temp');
+  await exec_file_async('powershell', ['Expand-Archive', '-Path', file_path, '-DestinationPath', temp_directory]);
+  const extracted_folder = (await fs.promises.readdir(temp_directory))[0];
+  const extracted_path = path.join(temp_directory, extracted_folder);
+  
+  // Remove existing bin directory if it exists
+  if (await check_if_file_exists(bin_directory)) {
+    await fs.promises.rm(bin_directory, { recursive: true, force: true });
+  }
+  
+  // Copy the entire contents of the extracted folder to the bin directory
+  await fs.promises.cp(extracted_path, bin_directory, { recursive: true });
+
+  // Download and install mongosh
+  const mongosh_url = 'https://downloads.mongodb.com/compass/mongosh-2.2.12-win32-x64.zip';
+  const mongosh_file_path = path.join(base_directory, 'mongosh.zip');
+  await download_file(mongosh_url, mongosh_file_path);
+  
+  const mongosh_temp_directory = path.join(base_directory, 'mongosh_temp');
+  await exec_file_async('powershell', ['Expand-Archive', '-Path', mongosh_file_path, '-DestinationPath', mongosh_temp_directory]);
+  
+  const mongosh_extracted_folder = (await fs.promises.readdir(mongosh_temp_directory))[0];
+  const mongosh_bin_path = path.join(mongosh_temp_directory, mongosh_extracted_folder, 'bin', 'mongosh.exe');
+  
+  await fs.promises.copyFile(mongosh_bin_path, path.join(bin_directory, 'bin', 'mongosh.exe'));
+  
+  // Clean up temporary files
+  await fs.promises.unlink(file_path);
+  await fs.promises.unlink(mongosh_file_path);
+  await fs.promises.rm(temp_directory, { recursive: true, force: true });
+  await fs.promises.rm(mongosh_temp_directory, { recursive: true, force: true });
+
+  process.loader.print('MongoDB installed!');
+};
+
+const download_file = async (url, file_path) => {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download: ${response.statusText}`);
+  }
+  await stream_pipeline(response.body, fs.createWriteStream(file_path));
+};
+
+const check_if_file_exists = async (file_path) => {
+  try {
+    await fs.promises.access(file_path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const create_directories = async (base_directory, bin_directory) => {
+  await fs.promises.mkdir(base_directory, { recursive: true });
+  await fs.promises.mkdir(bin_directory, { recursive: true });
+};
+
+export default download_mongodb_windows;

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,157 @@
+import child_process from "child_process";
+import fs from "fs";
+import util from "util";
+import os from "os";
+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 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 get_createdb_command = () => {
+  if (process.platform === 'win32') {
+    return 'createdb.exe';
+  }
+
+  return 'createdb';
+};
+
+const get_postgres_command = () => {
+  if (process.platform === 'win32') {
+    return 'postgres.exe';
+  }
+
+  return 'postgres';
+};
+
+const get_initdb_command = () => {
+  if (process.platform === 'win32') {
+    return 'initdb.exe';
+  }
+
+  return 'initdb';
+};
+
+const get_pg_ctl_command = () => {
+  if (process.platform === 'win32') {
+    return 'pgctl.exe';
+  }
+
+  return 'pgctl';
+};
+
+const start_postgresql = async (port = 2610) => {
+  try {
+    const postgresql_port = port;
+    const joystick_postgresql_bin_path = `${os.homedir()}/.joystick/databases/postgresql/bin/bin`;
+
+    const joystick_pg_ctl_command = get_pg_ctl_command();
+    const joystick_initdb_command = get_initdb_command();
+    const joystick_postgres_command = get_postgres_command();
+    const joystick_createdb_command = get_createdb_command();
+    
+    const joystick_pg_ctl_path = `${joystick_postgresql_bin_path}/${joystick_pg_ctl_command}`;
+    const joystick_initdb_path = `${joystick_postgresql_bin_path}/${joystick_initdb_command}`;
+    const joystick_postgres_path = `${joystick_postgresql_bin_path}/${joystick_postgres_command}`;
+    const joystick_createdb_path = `${joystick_postgresql_bin_path}/${joystick_createdb_command}`;
+
+    const data_directory_exists = await setup_data_directory(port);
+
+    if (!data_directory_exists) {
+      if (process.platform === 'linux') {
+        await exec(`sudo -u postgres ./initdb -D ${process.cwd()}/.joystick/data/postgresql_${port} --no-locale`, {
+          cwd: joystick_postgresql_bin_path
+        });
+
+        // NOTE: For Linux, we need to set granular permissions on the data directory path
+        // to avoid access denied errors from the OS.
+        await exec(`sudo chmod 755 /root`);
+        await exec(`sudo chmod 755 /root/${process.project_folder}`);
+        await exec(`sudo chmod 755 /root/${process.project_folder}/.joystick`);
+        await exec(`sudo chmod 700 /root/${process.project_folder}/.joystick/data/postgresql_${postgresql_port}`);
+        await exec(`sudo chown -R postgres:postgres /root/${process.project_folder}/.joystick/data/postgresql_${postgresql_port}`);
+      } else {
+        await exec(`${joystick_initdb_path} -D .joystick/data/postgresql_${port} --no-locale`);
+      }
+    }
+
+    const existing_process_id = parseInt(await get_process_id_from_port(postgresql_port), 10);
+
+    if (existing_process_id) {
+      if (process.platform === 'linux') {
+        await exec(`${joystick_pg_ctl_path} kill KILL ${existing_process_id}`);
+      } else {
+        await exec(`${joystick_pg_ctl_path} kill KILL ${existing_process_id}`);
+      }
+    }
+
+    const database_process = process.platform === 'linux' ? child_process.spawn(
+      'sudo',
+      [
+        '-u',
+        'postgres',
+        './postgres',
+        `-p ${postgresql_port}`,
+        '-D',
+        get_platform_safe_path(`${process.cwd()}/.joystick/data/postgresql_${port}`),
+        '-c log_destination=stderr -c logging_collector=off -c log_min_messages=WARNING',
+      ],
+      { cwd: joystick_postgresql_bin_path, shell: '/bin/bash' }
+    ) : child_process.spawn(
+      joystick_postgres_path,
+      [
+        `-p ${postgresql_port}`,
+        '-D',
+        get_platform_safe_path(`.joystick/data/postgresql_${port}`),
+      ],
+    );
+
+    return new Promise((resolve) => {
+      database_process.stderr.on('data', async (data) => {
+        const stderr = data?.toString();
+
+        if (stderr.includes('database system is ready to accept connections')) {
+          const process_id = (await get_process_id_from_port(postgresql_port))?.replace('\n', '');
+          const createdb_command = process.platform === 'linux'
+            ? `sudo -u postgres ${joystick_createdb_path} -h 127.0.0.1 -p ${postgresql_port} app`
+            : `${joystick_createdb_path} -h 127.0.0.1 -p ${postgresql_port} app`;
+
+          exec(createdb_command).then(() => {
+            resolve(parseInt(process_id, 10));
+          }).catch(({ stderr: error }) => {
+            if (error && error.includes('database "app" already exists')) {
+              resolve(parseInt(process_id, 10));
+            } else {
+              console.log(error);
+            }
+          });
+        }
+      });
+
+      database_process.stdout.on('data', async (data) => {
+        // NOTE: PostgreSQL (16) appears to route all output to stderr(?!). Have this for posterity
+        // sake and to avoid trapping useful information.
+        const stdout = data?.toString();
+        console.log(stdout);
+      });
+    });
+  } catch (exception) {
+    console.warn(exception);
+    process.exit(1);
+  }
+};
+
+export default start_postgresql;

package/src/lib/development_server/databases/postgresql/installers/linux.js

@@ -0,0 +1,80 @@
+import { promisify } from 'util';
+import { execFile, exec } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+const exec_file_async = promisify(execFile);
+const exec_async = promisify(exec);
+const mkdir_async = promisify(fs.mkdir);
+const symlink_async = promisify(fs.symlink);
+const access_async = promisify(fs.access);
+const writeFile_async = promisify(fs.writeFile);
+
+const download_postgresql_linux = async () => {
+  try {
+    const postgresql_version = '16';
+    const system_bin_path = `/usr/lib/postgresql/${postgresql_version}/bin`;
+    const joystick_bin_path = path.join(os.homedir(), '.joystick', 'databases', 'postgresql', 'bin');
+    const symlink_path = path.join(joystick_bin_path, 'bin');
+    const postgres_executable = path.join(symlink_path, 'postgres');
+
+    // Check if PostgreSQL is already installed in the desired location
+    try {
+      await access_async(postgres_executable, fs.constants.X_OK);
+      return;
+    } catch (error) {
+      // PostgreSQL is not installed or not in the desired location, proceed with installation
+    }
+
+    process.loader.print('PostgreSQL not found. Installing... (this may take a few minutes)');
+    
+    // Ensure wget is installed
+    await exec_file_async('sudo', ['apt-get', 'install', '-y', 'wget']);
+
+    // Add PostgreSQL 16 repository
+    await exec_file_async('sudo', ['sh', '-c', 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list']);
+    
+    // Download the PostgreSQL public key
+    const { stdout: keyContent } = await exec_async('wget -qO- https://www.postgresql.org/media/keys/ACCC4CF8.asc');
+    
+    // Save the key to a temporary file
+    const tempKeyPath = '/tmp/postgresql-ACCC4CF8.asc';
+    await writeFile_async(tempKeyPath, keyContent);
+    
+    // Add the key
+    await exec_file_async('sudo', ['apt-key', 'add', tempKeyPath]);
+    
+    // Remove the temporary key file
+    await exec_file_async('rm', [tempKeyPath]);
+
+    // Update package list and install PostgreSQL 16
+    await exec_file_async('sudo', ['apt-get', 'update']);
+    await exec_file_async('sudo', ['apt-get', 'install', '-y', `postgresql-${postgresql_version}`, `postgresql-client-${postgresql_version}`, `postgresql-server-dev-${postgresql_version}`]);
+
+    await mkdir_async(joystick_bin_path, { recursive: true });
+    
+    try {
+      await symlink_async(system_bin_path, symlink_path);
+    } catch (symlink_error) {
+      if (symlink_error.code !== 'EEXIST') {
+        console.error('Error creating symlink:', symlink_error);
+        throw symlink_error;
+      }
+    }
+
+    try {
+      await access_async(postgres_executable, fs.constants.X_OK);
+    } catch (access_error) {
+      console.error('Error accessing PostgreSQL executable:', access_error);
+      throw access_error;
+    }
+    
+    process.loader.print('PostgreSQL installed!');
+  } catch (error) {
+    console.error('Error installing PostgreSQL:', error);
+    throw error;
+  }
+};
+
+export default download_postgresql_linux;

package/src/lib/development_server/databases/postgresql/installers/macos.js

@@ -0,0 +1,91 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { promisify } from 'util';
+import { pipeline } from 'stream';
+import { execFile } from 'child_process';
+
+const streamPipeline = promisify(pipeline);
+const execFileAsync = promisify(execFile);
+
+const download_postgresql_macos = async (version_path = null) => {
+  const base_directory = path.join(os.homedir(), '.joystick', 'databases', 'postgresql');
+  const bin_directory = path.join(base_directory, 'bin');
+  const bin_bin_directory = path.join(bin_directory, 'bin');
+
+  if (await check_if_file_exists(base_directory)) {
+    return;
+  }
+
+  await create_directories(base_directory, bin_directory, bin_bin_directory);
+
+  const download_url = 'https://get.enterprisedb.com/postgresql/postgresql-16.0-1-osx-binaries.zip';
+  const file_name = path.basename(new URL(download_url).pathname);
+  const file_path = path.join(base_directory, file_name);
+
+  process.loader.print('PostgreSQL not found. Downloading... (this may take a few minutes)');
+  await download_file(download_url, file_path);
+
+  process.loader.print('Installing PostgreSQL...');
+  
+  // Extract PostgreSQL
+  const temp_directory = path.join(base_directory, 'temp');
+  await fs.promises.mkdir(temp_directory, { recursive: true });
+  await execFileAsync('unzip', ['-q', file_path, '-d', temp_directory]);
+
+  // Move binaries to bin/bin
+  const extracted_bin_path = path.join(temp_directory, 'pgsql', 'bin');
+  const files = await fs.promises.readdir(extracted_bin_path);
+  for (const file of files) {
+    await fs.promises.rename(path.join(extracted_bin_path, file), path.join(bin_bin_directory, file));
+  }
+
+  // Move other necessary directories
+  const directories_to_move = ['share', 'lib', 'include'];
+  for (const dir of directories_to_move) {
+    const src_path = path.join(temp_directory, 'pgsql', dir);
+    const dest_path = path.join(bin_directory, dir);
+    if (await fs.promises.access(src_path).then(() => true).catch(() => false)) {
+      await fs.promises.rename(src_path, dest_path);
+    }
+  }
+
+  // Clean up
+  await fs.promises.unlink(file_path);
+  await fs.promises.rm(temp_directory, { recursive: true, force: true });
+
+  await make_file_executable(bin_bin_directory);
+  process.loader.print('PostgreSQL installed!');
+};
+
+const download_file = async (url, file_path) => {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download: ${response.statusText}`);
+  }
+  await streamPipeline(response.body, fs.createWriteStream(file_path));
+};
+
+const check_if_file_exists = async (file_path) => {
+  try {
+    await fs.promises.access(file_path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const create_directories = async (base_directory, bin_directory, bin_bin_directory) => {
+  await fs.promises.mkdir(base_directory, { recursive: true });
+  await fs.promises.mkdir(bin_directory, { recursive: true });
+  await fs.promises.mkdir(bin_bin_directory, { recursive: true });
+};
+
+const make_file_executable = async (directory) => {
+  const files = await fs.promises.readdir(directory);
+  for (const file of files) {
+    await fs.promises.chmod(path.join(directory, file), '755');
+  }
+};
+
+export default download_postgresql_macos;