@jsenv/database 0.0.1

package/src/cli/setup.js

@@ -0,0 +1,171 @@
+import { UNICODE } from "@jsenv/humanize";
+import { urlToRelativeUrl } from "@jsenv/urls";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import postgres from "postgres";
+import { readParamsFromContext } from "../read_params_from_context.js";
+
+const {
+  host,
+  port,
+  defaultUsername,
+  userRoleName,
+  username,
+  database,
+  password,
+} = readParamsFromContext();
+const databaseUrl = `postgresql://${defaultUsername}@${host}:${port}`;
+console.log(`${UNICODE.INFO} Connecting to ${databaseUrl}...`);
+const sql = postgres({
+  host,
+  port,
+  username: defaultUsername,
+  password: "",
+  database: "postgres",
+});
+console.log(`${UNICODE.OK} Connected to database`);
+console.log("");
+
+const setupIndent = "  ";
+role_setup: {
+  console.log(`- Setup role "${userRoleName}":`);
+  const roles = await sql`
+    SELECT
+      rolname AS role_name,
+      rolcreatedb AS can_create_db,
+      rolcanlogin AS can_login
+    FROM
+      pg_roles
+    WHERE
+      rolname = ${userRoleName};
+  `;
+  if (roles.length === 0) {
+    console.log(
+      `${setupIndent}${UNICODE.INFO} Role "${userRoleName}" not found, creating it...`,
+    );
+    await sql`CREATE ROLE ${sql(userRoleName)} LOGIN CREATEDB;`;
+    console.log(`${setupIndent}${UNICODE.OK} Role "${userRoleName}" created`);
+  } else {
+    const [{ role_name, can_create_db, can_login }] = roles;
+    if (can_create_db && can_login) {
+      console.log(
+        `${setupIndent}${UNICODE.OK} "${role_name}" role exists with the right attributes.`,
+      );
+    } else {
+      console.log(
+        `${setupIndent}${UNICODE.INFO} LOGIN and CREATEDB attributes are missing on role "${userRoleName}".`,
+      );
+      await sql`ALTER ROLE ${sql(userRoleName)} LOGIN CREATEDB;`;
+      console.log(
+        `${setupIndent}${UNICODE.OK} LOGIN and CREATEDB attributes added to role "${userRoleName}".`,
+      );
+    }
+  }
+}
+user_setup: {
+  console.log(`- Setup user "${username}":`);
+  const users = await sql`
+    SELECT
+      usename AS user_name,
+      usecreatedb AS can_create_db
+    FROM
+      pg_user
+    WHERE
+      usename = ${username};
+  `;
+  if (users.length === 0) {
+    console.log(`${setupIndent}${UNICODE.INFO} not found, creating it...`);
+    await sql`
+      CREATE USER ${sql(username)}
+      WITH
+        PASSWORD '${sql(password)}';
+    `;
+    console.log(`${setupIndent}${UNICODE.OK} "${username}" created`);
+    await sql`GRANT ${sql(userRoleName)} TO ${sql(username)};`;
+    console.log(
+      `${setupIndent}${UNICODE.OK} Role "${userRoleName}" granted to user "${username}"`,
+    );
+  } else {
+    const roleGrantResults = await sql`
+      SELECT
+        1
+      FROM
+        pg_user u
+        JOIN pg_auth_members m ON u.usesysid = m.member
+        JOIN pg_roles r ON m.roleid = r.oid
+      WHERE
+        u.usename = ${username}
+    `;
+    if (roleGrantResults.length === 0) {
+      console.log(
+        `${setupIndent}${UNICODE.INFO} Role "${userRoleName}" is missing on user.`,
+      );
+      await sql`GRANT ${sql(userRoleName)} TO ${sql(username)};`;
+      console.log(
+        `${setupIndent}${UNICODE.OK} Role "${userRoleName}" assigned to user.`,
+      );
+    } else {
+      console.log(
+        `${setupIndent}${UNICODE.OK} User found with role "${userRoleName}".`,
+      );
+    }
+  }
+}
+database_setup: {
+  console.log(`- Setup database "${database}":`);
+  const databases = await sql`
+    SELECT
+      1
+    FROM
+      pg_database
+    WHERE
+      datname = ${database};
+  `;
+  if (databases.length === 0) {
+    console.log(`${setupIndent}${UNICODE.INFO} not found, creating it...`);
+    await sql`CREATE DATABASE ${sql(database)} OWNER ${sql(username)}`;
+    console.log(`${setupIndent}${UNICODE.OK} Database "${database}" created.`);
+  } else {
+    console.log(`${setupIndent}${UNICODE.OK} Database "${database}" found.`);
+  }
+}
+schemas_setup: {
+  console.log(`- Setup schemas:`);
+  const schemaFiles = process.env.DB_SCHEMA_FILES;
+  if (!schemaFiles) {
+    console.log(
+      `${setupIndent}${UNICODE.INFO} No schema files configured, skipping.`,
+    );
+    break schemas_setup;
+  }
+
+  const directoryUrl = `${pathToFileURL(process.cwd())}/`;
+  console.log(
+    `${setupIndent}${UNICODE.INFO} Search files matching "${schemaFiles}" in ${directoryUrl}...`,
+  );
+  const { listFilesMatching } = await import("@jsenv/filesystem");
+  const patterns = {};
+  for (const pattern of schemaFiles.split(", ")) {
+    patterns[pattern] = true;
+  }
+
+  const files = await listFilesMatching({ patterns, directoryUrl });
+  if (files.length === 0) {
+    console.log(`${setupIndent}${UNICODE.INFO} No files found, skipping.`);
+    break schemas_setup;
+  }
+  console.log(`${setupIndent}${UNICODE.OK} ${files.length} file(s) found`);
+  for (const file of files) {
+    console.log(
+      `${setupIndent}${UNICODE.INFO} executing ${urlToRelativeUrl(file, directoryUrl)}...`,
+    );
+    await sql.file(fileURLToPath(new URL(file)));
+    // const sqlToExecute = readFileSync(, "utf8");
+    // await sql`${sqlToExecute}`.simple();
+    console.log(`${setupIndent}${UNICODE.OK} done.`);
+  }
+}
+
+console.log("");
+console.log(`${UNICODE.INFO} Disconnecting from database...`);
+await sql.end();
+console.log(`${UNICODE.OK} Disconnected`);

package/src/cli/start.js

@@ -0,0 +1,26 @@
+import { execSync } from "node:child_process";
+import { platform } from "node:os";
+
+const platformName = platform();
+
+if (platformName === "darwin") {
+  console.log("Detected macOS. Starting PostgreSQL...");
+  execSync("brew services start postgresql", { stdio: "inherit" });
+  process.exit(0);
+}
+
+if (platformName === "linux") {
+  console.log("Detected Linux. Starting PostgreSQL...");
+  execSync("sudo service postgresql start", { stdio: "inherit" });
+  process.exit(0);
+}
+
+if (platformName === "win32") {
+  console.log("Detected Windows. Starting PostgreSQL...");
+  execSync('pg_ctl -D "C:\\Program Files\\PostgreSQL\\14\\data" start', {
+    stdio: "inherit",
+  });
+  process.exit(0);
+}
+
+throw new Error(`Unsupported operating system: ${platformName}`);

package/src/cli/stop.js

@@ -0,0 +1,26 @@
+import { execSync } from "node:child_process";
+import { platform } from "node:os";
+
+const platformName = platform();
+
+if (platformName === "darwin") {
+  console.log("Detected macOS. Stopping PostgreSQL...");
+  execSync("brew services stop postgresql", { stdio: "inherit" });
+  process.exit(0);
+}
+
+if (platformName === "linux") {
+  console.log("Detected Linux. Stopping PostgreSQL...");
+  execSync("sudo service postgresql stop", { stdio: "inherit" });
+  process.exit(0);
+}
+
+if (platformName === "win32") {
+  console.log("Detected Windows. Stopping PostgreSQL...");
+  execSync('pg_ctl -D "C:\\Program Files\\PostgreSQL\\14\\data" stop', {
+    stdio: "inherit",
+  });
+  process.exit(0);
+}
+
+throw new Error(`Unsupported operating system: ${platformName}`);

package/src/cli.mjs

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+
+import { execSync } from "node:child_process";
+import { platform } from "node:os";
+import { parseArgs } from "node:util";
+
+const options = {
+  help: {
+    type: "boolean",
+  },
+};
+const commands = {
+  help: () => {
+    console.log(`@jsenv/database: CLI to manage database.
+
+Usage: npx @jsenv/database [command]
+
+https://github.com/jsenv/importmap-node-module
+
+Command:
+  help      Display this message.
+  install   Install the database (postgresql) on the current machine.`);
+  },
+  install: () => {
+    const platformName = platform();
+    if (platformName === "darwin") {
+      console.log("Detected macOS. Installing PostgreSQL using Homebrew...");
+      execSync("brew install postgresql", { stdio: "inherit" });
+      return;
+    }
+    if (platformName === "linux") {
+      console.log("Detected Linux. Installing PostgreSQL using apt...");
+      execSync("sudo apt-get update && sudo apt-get install -y postgresql", {
+        stdio: "inherit",
+      });
+      return;
+    }
+    if (platformName === "win32") {
+      console.log(
+        "Detected Windows. Installing PostgreSQL using Chocolatey...",
+      );
+      execSync("choco install postgresql --confirm", { stdio: "inherit" });
+      return;
+    }
+    throw new Error(`Unsupported operating system: ${platformName}`);
+  },
+  start: async () => {
+    await import("./cli/start.js");
+  },
+  stop: async () => {
+    await import("./cli/stop.js");
+  },
+  setup: async () => {
+    await import("./cli/setup.js");
+  },
+  manage: async () => {
+    await import("./cli/manage.js");
+  },
+};
+
+const { values, positionals } = parseArgs({ options, allowPositionals: true });
+if (values.help || positionals.length === 0) {
+  commands.help();
+  process.exit(0);
+}
+if (positionals.length > 1) {
+  console.error("Error: too many inputs.");
+  process.exit(1);
+}
+const command = positionals[0];
+if (command === "help") {
+  commands.help();
+  process.exit(0);
+}
+const commandFunction = commands[command];
+if (!commandFunction) {
+  console.error(`Error: unknown command "${command}".`);
+  commands.help();
+  process.exit(1);
+}
+await commandFunction(values);

package/src/main.js

@@ -0,0 +1,26 @@
+/**
+ * Next steps:
+ *
+ * - Faire un test unitaires capable de faire les choses suivantes:
+ * ajouter un entrée en DB, vérifier ensuite qu'elle a bien été ajoutée puis la supprimer et verifier qu'elle a bien été supprimée
+ *
+ * https://github.com/ikalnytskyi/action-setup-postgres/blob/master/action.yml
+ *
+ * - The user we create during setup don't need to be able to create a database as superuser might create it
+ * it would be "safer" or just more precise not to give a right that is not needed
+ */
+
+import postgres from "postgres";
+
+export { readParamsFromContext } from "./read_params_from_context.js";
+
+export const connectAs = ({ host, port, username, password, database }) => {
+  const sql = postgres({
+    host,
+    port,
+    username,
+    password,
+    database,
+  });
+  return sql;
+};

package/src/read_params_from_context.js

@@ -0,0 +1,53 @@
+import { config } from "dotenv";
+import { execSync } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+export const readParamsFromContext = ({
+  directoryUrl = pathToFileURL(process.cwd()),
+} = {}) => {
+  directoryUrl = String(directoryUrl);
+  if (!directoryUrl.endsWith("/")) {
+    directoryUrl += "/";
+  }
+  const envFile =
+    process.env.NODE_ENV === "production" || process.env.NODE_ENV === "prod"
+      ? ".env.prod"
+      : ".env.dev";
+  const envFileUrl = new URL(envFile, directoryUrl);
+  const envFilePath = fileURLToPath(envFileUrl);
+
+  config({
+    path: envFilePath,
+  });
+
+  if (!process.env.DB_NAME) {
+    throw new Error("process.env.DB_NAME is not set");
+  }
+  if (!process.env.DB_USER_ROLE_NAME) {
+    throw new Error("process.env.DB_USER_ROLE_NAME is not set");
+  }
+  if (!process.env.DB_USER_NAME) {
+    throw new Error("process.env.DB_USER_NAME is not set");
+  }
+  if (!process.env.DB_USER_PASSWORD) {
+    throw new Error("process.env.DB_USER_PASSWORD is not set");
+  }
+
+  const host = process.env.DB_HOST || "localhost";
+  const port = process.env.DB_PORT || 5432;
+  const database = process.env.DB_NAME;
+  const userRoleName = process.env.DB_USER_ROLE_NAME;
+  const username = process.env.DB_USER_NAME;
+  const password = process.env.DB_USER_PASSWORD;
+  const defaultUsername = execSync("whoami").toString().trim();
+
+  return {
+    host,
+    port,
+    database,
+    userRoleName,
+    username,
+    password,
+    defaultUsername,
+  };
+};