@joystick.js/cli-canary 0.0.0-canary.174 → 0.0.0-canary.176

package/_package.json

@@ -40,11 +40,11 @@
     "kill-port-process": "^3.1.0",
     "lodash": "^4.17.21",
     "mongo-uri-tool": "^1.0.1",
-    "mongodb": "^4.1.3",
+    "mongodb": "^4.16.0",
     "netstats": "^0.0.6",
     "node-fetch": "^3.2.0",
     "node-watch": "^0.7.2",
-    "pg": "^8.7.3",
+    "pg": "^8.11.2",
     "port-pid": "^0.0.7",
     "ps-node": "^0.1.6",
     "replace-in-files": "^3.0.0",

package/dist/lib/dev/databases/drivers/index.js

@@ -0,0 +1,50 @@
+import loadSettings from "../../loadSettings.js";
+import connectMongoDB from "./mongodb/index.js";
+import connectPostgreSQL from "./postgresql/index.js";
+var drivers_default = async (callback) => {
+  const settings = (await loadSettings())?.parsed;
+  const databases = settings?.config?.databases?.map((database) => {
+    return {
+      provider: database?.provider,
+      settings: database
+    };
+  });
+  for (let databaseIndex = 0; databaseIndex < databases?.length; databaseIndex += 1) {
+    const database = databases[databaseIndex];
+    const hasMultipleOfProvider = databases?.filter((database2) => database2?.provider === database2?.provider)?.length > 1;
+    const databasePort = parseInt(process.env.PORT, 10) + 10 + databaseIndex;
+    if (database?.provider === "mongodb") {
+      const mongodb = await connectMongoDB(database?.settings, databasePort);
+      process.databases = {
+        ...process.databases || {},
+        mongodb: !hasMultipleOfProvider ? mongodb : {
+          ...process?.databases?.mongodb || {},
+          [database?.settings?.name || `mongodb_${databasePort}`]: mongodb
+        }
+      };
+    }
+    if (database?.provider === "postgresql") {
+      const postgresql = await connectPostgreSQL(
+        database?.settings,
+        databasePort
+      );
+      process.databases = {
+        ...process.databases || {},
+        postgresql: !hasMultipleOfProvider ? {
+          ...postgresql?.pool,
+          query: postgresql?.query
+        } : {
+          ...process?.databases?.postgresql || {},
+          [database?.settings?.name || `postgresql_${databasePort}`]: {
+            ...postgresql?.pool,
+            query: postgresql?.query
+          }
+        }
+      };
+    }
+  }
+  return process.databases;
+};
+export {
+  drivers_default as default
+};

package/dist/lib/dev/databases/drivers/mongodb/availableQueryParameters.js

@@ -0,0 +1,42 @@
+var availableQueryParameters_default = [
+  "replicaSet",
+  "tls",
+  "ssl",
+  "tlsCertificateKeyFile",
+  "tlsCertificateKeyFilePassword",
+  "tlsCAFile",
+  "tlsAllowInvalidCertificates",
+  "tlsAllowInvalidHostnames",
+  "tlsInsecure",
+  "connectTimeoutMS",
+  "socketTimeoutMS",
+  "compressors",
+  "zlibCompressionLevel",
+  "maxPoolSize",
+  "minPoolSize",
+  "maxIdleTimeMS",
+  "waitQueueMultiple",
+  "waitQueueTimeoutMS",
+  "w",
+  "wtimeoutMS",
+  "journal",
+  "readConcernLevel",
+  "readPreference",
+  "maxStalenessSeconds",
+  "readPreferenceTags",
+  "authSource",
+  "authMechanism",
+  "authMechanismProperties",
+  "gssapiServiceName",
+  "localThresholdMS",
+  "serverSelectionTimeoutMS",
+  "serverSelectionTryOnce",
+  "heartbeatFrequencyMS",
+  "appName",
+  "retryReads",
+  "retryWrites",
+  "uuidRepresentation"
+];
+export {
+  availableQueryParameters_default as default
+};

package/dist/lib/dev/databases/drivers/mongodb/buildConnectionString.js

@@ -0,0 +1,22 @@
+import buildQueryParameters from "./buildQueryParameters.js";
+import serializeQueryParameters from "../../../../serializeQueryParameters.js";
+var buildConnectionString_default = (connection = {}) => {
+  let connectionString = "mongodb://";
+  if (connection && (connection.username || connection.password)) {
+    connectionString = `${connectionString}${connection.username || connection.password ? `${connection.username || ""}${!!connection.username && !!connection.password ? ":" : ""}${connection.password || ""}@` : ""}`;
+  }
+  if (connection && connection.hosts && Array.isArray(connection.hosts)) {
+    connectionString = `${connectionString}${connection.hosts.map((host) => `${host.hostname}:${host.port}`).join(",")}`;
+  }
+  if (connection && connection.database) {
+    connectionString = `${connectionString}/${connection.database}`;
+  }
+  const queryParameters = buildQueryParameters(connection);
+  if (Object.keys(queryParameters)?.length > 0) {
+    connectionString = `${connectionString}?${serializeQueryParameters(queryParameters)}`;
+  }
+  return connectionString;
+};
+export {
+  buildConnectionString_default as default
+};

package/dist/lib/dev/databases/drivers/mongodb/buildQueryParameters.js

@@ -0,0 +1,14 @@
+import availableQueryParameters from "./availableQueryParameters.js";
+var buildQueryParameters_default = (connection = {}) => {
+  const queryParameters = {};
+  for (let i = 0; i < availableQueryParameters.length; i += 1) {
+    const availableParameter = availableQueryParameters[i];
+    if (connection && connection[availableParameter]) {
+      queryParameters[availableParameter] = connection[availableParameter];
+    }
+  }
+  return queryParameters;
+};
+export {
+  buildQueryParameters_default as default
+};

package/dist/lib/dev/databases/drivers/mongodb/index.js

@@ -0,0 +1,45 @@
+import { MongoClient } from "mongodb";
+import chalk from "chalk";
+import mongoUri from "mongo-uri-tool";
+import fs from "fs";
+import buildConnectionString from "./buildConnectionString.js";
+var mongodb_default = async (settings = {}, databasePort = 2610) => {
+  const connection = settings?.connection || {
+    hosts: [
+      // NOTE: By default, expect databases start from 2610 (assuming a PORT of 2600).
+      { hostname: "127.0.0.1", port: databasePort }
+    ],
+    database: "app",
+    replicaSet: `joystick_${databasePort}`
+  };
+  const connectionString = buildConnectionString(connection);
+  const parsedURI = mongoUri.parseUri(connectionString);
+  try {
+    const connectionOptions = {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+      ssl: !["development", "test"].includes(process.env.NODE_ENV),
+      ...settings?.options || {}
+    };
+    if (settings?.options?.ca) {
+      connectionOptions.ca = fs.readFileSync(settings?.options?.ca);
+    }
+    const client = await MongoClient.connect(connectionString, connectionOptions);
+    const db = client.db(parsedURI.db);
+    return db;
+  } catch (exception) {
+    console.warn(
+      chalk.yellowBright(
+        `
+Failed to connect to MongoDB. Please double-check connection settings and try again.
+
+Error from MongoDB:
+
+${chalk.redBright(exception?.message)}`
+      )
+    );
+  }
+};
+export {
+  mongodb_default as default
+};

package/dist/lib/dev/databases/drivers/mongodb/queries/accounts.js

@@ -0,0 +1,300 @@
+import generateId from "../../../../lib/generateId";
+import dayjs from "dayjs";
+var accounts_default = {
+  existingUser: async (input = {}) => {
+    let existingUserWithEmailAddress;
+    let existingUserWithUsername;
+    if (input?.emailAddress) {
+      existingUserWithEmailAddress = await process.databases._users?.collection("users").findOne({ emailAddress: input.emailAddress });
+    }
+    if (input?.username) {
+      existingUserWithUsername = await process.databases._users?.collection("users").findOne({ username: input.username });
+    }
+    return existingUserWithEmailAddress || existingUserWithUsername ? {
+      existingEmailAddress: existingUserWithEmailAddress?.emailAddress,
+      existingUsername: existingUserWithUsername?.username
+    } : null;
+  },
+  createUser: async (input = {}) => {
+    const userId = generateId();
+    await process.databases._users?.collection("users").insertOne({ _id: userId, ...input });
+    return userId;
+  },
+  user: async (input) => {
+    if (input?.emailAddress) {
+      const user = await process.databases._users?.collection("users").findOne({ emailAddress: input.emailAddress });
+      return user;
+    }
+    if (input?.username) {
+      const user = await process.databases._users?.collection("users").findOne({ username: input.username });
+      return user;
+    }
+    if (input?._id) {
+      const user = await process.databases._users?.collection("users").findOne({ _id: input._id });
+      return user;
+    }
+    return null;
+  },
+  deleteOldSessions: async (input = {}) => {
+    const user = await process.databases._users?.collection("users").findOne({
+      _id: input?.userId
+    });
+    if (user) {
+      const sessions = user?.sessions?.filter((session) => {
+        return dayjs(session?.tokenExpiresAt).isAfter(dayjs().utc().format());
+      });
+      await process.databases._users?.collection("users").updateOne(
+        {
+          _id: input.userId
+        },
+        {
+          $set: {
+            sessions
+          }
+        }
+      );
+    }
+  },
+  addSession: async (input = {}) => {
+    await process.databases._users?.collection("users").updateOne(
+      {
+        _id: input.userId
+      },
+      {
+        $addToSet: {
+          sessions: input.session
+        }
+      }
+    );
+  },
+  userWithLoginToken: async (input) => {
+    const user = await process.databases._users?.collection("users").findOne({
+      "sessions.token": input?.token
+    });
+    return user;
+  },
+  createVerifyEmailToken: async (input) => {
+    const token = generateId();
+    await process.databases._users?.collection("users").updateOne(
+      {
+        _id: input?.userId
+      },
+      {
+        $addToSet: {
+          verifyEmailTokens: {
+            userId: input?.userId,
+            token
+          }
+        }
+      }
+    );
+    return token;
+  },
+  userWithVerifyEmailToken: async (input) => {
+    const user = await process.databases._users?.collection("users").findOne({
+      "verifyEmailTokens.token": input?.token
+    });
+    return user;
+  },
+  markEmailVerifiedAt: async (input) => {
+    const user = await process.databases._users?.collection("users").findOne({
+      _id: input?.userId
+    });
+    await process.databases._users?.collection("users").updateOne(
+      {
+        _id: input?.userId
+      },
+      {
+        $set: {
+          emailVerified: true,
+          emailVerifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          verifyEmailTokens: user?.verifyEmailTokens?.filter(
+            (verifyEmailToken) => {
+              return verifyEmailToken?.token === input?.token;
+            }
+          )
+        }
+      }
+    );
+    return true;
+  },
+  addPasswordResetToken: (input = {}) => {
+    return process.databases._users?.collection("users").updateOne(
+      {
+        emailAddress: input.emailAddress
+      },
+      {
+        $addToSet: {
+          passwordResetTokens: {
+            token: input.token,
+            requestedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        }
+      }
+    );
+  },
+  userWithResetToken: async (input) => {
+    const user = await process.databases._users?.collection("users").findOne({
+      "passwordResetTokens.token": input["passwordResetTokens.token"]
+    });
+    return user;
+  },
+  setNewPassword: async (input = {}) => {
+    return process.databases._users?.collection("users").updateOne(
+      {
+        _id: input?.userId
+      },
+      {
+        $set: {
+          password: input?.hashedPassword
+        }
+      }
+    );
+  },
+  removeResetToken: async (input = {}) => {
+    const user = await process.databases._users?.collection("users").findOne({ _id: input?.userId });
+    await process.databases._users?.collection("users").updateOne(
+      {
+        _id: input?.userId
+      },
+      {
+        $set: {
+          passwordResetTokens: user?.passwordResetTokens?.filter(
+            ({ token }) => {
+              return token !== input?.token;
+            }
+          )
+        }
+      }
+    );
+    return process.databases._users?.collection("users").findOne({ _id: input?.userId });
+  },
+  addRole: async (input = {}) => {
+    const existingRole = input?.role ? await process.databases._users?.collection("roles").findOne({ role: input?.role }) : null;
+    if (!existingRole && input?.role) {
+      await process.databases._users?.collection("roles").insertOne({
+        _id: generateId(),
+        role: input?.role
+      });
+      return {
+        _id: input?.userId,
+        action: "add",
+        role: input?.role,
+        ok: true,
+        error: null
+      };
+    }
+    return {
+      action: "add",
+      role: input?.role,
+      ok: false,
+      error: input?.role ? `Role already exists: ${input?.role}.` : `Must pass a name for role to add.`
+    };
+  },
+  removeRole: async (input = {}) => {
+    const existingRole = input?.role ? await process.databases._users?.collection("roles").findOne({ role: input?.role }) : null;
+    if (existingRole) {
+      await process.databases._users?.collection("users").updateMany(
+        {
+          roles: { $in: [input?.role] }
+        },
+        {
+          $pull: {
+            roles: input?.role
+          }
+        }
+      );
+      await process.databases._users?.collection("roles").deleteOne({
+        role: input?.role
+      });
+      return {
+        _id: input?.userId,
+        action: "remove",
+        role: input?.role,
+        ok: true,
+        error: null
+      };
+    }
+    return {
+      action: "add",
+      role: input?.role,
+      ok: false,
+      error: `Could not find an existing role with the name ${input?.role}.`
+    };
+  },
+  listRoles: async (input = {}) => {
+    const roles = await process.databases._users?.collection("roles").find().toArray();
+    return (roles || []).map(({ role }) => role);
+  },
+  grantRole: async (input = {}) => {
+    const user = await process.databases._users?.collection("users").findOne({ _id: input?.userId });
+    if (user) {
+      await process.databases._users?.collection("users").updateOne(
+        { _id: input?.userId },
+        {
+          $addToSet: {
+            roles: input?.role
+          }
+        }
+      );
+      const existingRole = await process.databases._users?.collection("roles").findOne({ role: input?.role });
+      if (!existingRole) {
+        await process.databases._users?.collection("roles").insertOne({
+          _id: generateId(),
+          role: input?.role
+        });
+      }
+      return {
+        _id: input?.userId,
+        action: "grant",
+        role: input?.role,
+        ok: true,
+        error: null
+      };
+    }
+    return {
+      _id: input?.userId,
+      action: "grant",
+      role: input?.role,
+      ok: false,
+      error: `User not found with the _id ${input?.userId}.`
+    };
+  },
+  revokeRole: async (input = {}) => {
+    const user = await process.databases._users?.collection("users").findOne({ _id: input?.userId });
+    if (user && user.roles) {
+      await process.databases._users?.collection("users").updateOne(
+        { _id: input?.userId },
+        {
+          $pull: {
+            roles: input?.role
+          }
+        }
+      );
+      return {
+        _id: input?.userId,
+        action: "revoke",
+        role: input?.role,
+        ok: true,
+        error: null
+      };
+    }
+    return {
+      _id: input?.userId,
+      action: "revoke",
+      role: input?.role,
+      ok: false,
+      error: `User not found with the _id ${input?.userId}.`
+    };
+  },
+  userHasRole: async (input = {}) => {
+    const user = await process.databases._users?.collection("users").findOne({ _id: input?.userId });
+    if (user && user.roles) {
+      return user?.roles?.includes(input?.role);
+    }
+    return false;
+  }
+};
+export {
+  accounts_default as default
+};

package/dist/lib/dev/databases/drivers/mongodb/queries/queues.js

@@ -0,0 +1,115 @@
+import dayjs from "dayjs";
+var queues_default = {
+  addJob: function(jobToAdd = {}) {
+    const db = process.databases._queues?.collection(`queue_${this.queue.name}`);
+    return db.insertOne(jobToAdd);
+  },
+  countJobs: function(status = "") {
+    const db = process.databases._queues?.collection(`queue_${this.queue.name}`);
+    return db.countDocuments({ status });
+  },
+  deleteJob: function(jobId = "") {
+    const db = process.databases._queues?.collection(`queue_${this.queue.name}`);
+    return db.deleteOne({ _id: jobId });
+  },
+  getJobs: function(query = {}) {
+    const db = process.databases._queues?.collection(`queue_${this.queue.name}`);
+    return db.find(query).toArray();
+  },
+  getNextJobToRun: async function() {
+    const db = process.databases._queues?.collection(`queue_${this.queue.name}`);
+    const nextJob = await db.findOneAndUpdate({
+      $or: [
+        {
+          status: "pending",
+          // NOTE: Do this to avoid accidentally running jobs intended for the future too early.
+          nextRunAt: { $lte: dayjs().format() },
+          lockedBy: { $exists: false }
+        },
+        {
+          status: "pending",
+          // NOTE: Do this to avoid accidentally running jobs intended for the future too early.
+          nextRunAt: { $lte: dayjs().format() },
+          lockedBy: null
+        }
+      ]
+    }, {
+      $set: {
+        status: "running",
+        startedAt: dayjs().format(),
+        lockedBy: this.machineId
+      }
+    }, {
+      sort: {
+        nextRunAt: 1
+      }
+    });
+    return nextJob?.value;
+  },
+  initializeDatabase: function() {
+    const db = process.databases._queues?.collection(`queue_${this.queue.name}`);
+    db.createIndex({ status: 1 });
+    db.createIndex({ status: 1, nextRunAt: 1 });
+    if (this.queue.options?.cleanup?.completedAfterSeconds) {
+      db.createIndex({ completedAt: 1 }, { expireAfterSeconds: this?.queue?.options?.cleanup?.completedAfterSeconds });
+    }
+    if (this.queue.options?.cleanup?.failedAfterSeconds) {
+      db.createIndex({ failedAt: 1 }, { expireAfterSeconds: this?.queue?.options?.cleanup?.failedAfterSeconds });
+    }
+  },
+  requeueJob: function(jobId = "", nextRunAt = null) {
+    const db = process.databases._queues?.collection(`queue_${this.queue.name}`);
+    return db.updateOne({ _id: jobId }, {
+      $set: {
+        status: "pending",
+        nextRunAt
+      },
+      $unset: {
+        lockedBy: ""
+      }
+    });
+  },
+  setJobsForMachineIncomplete: function() {
+    const db = process.databases._queues?.collection(`queue_${this.queue.name}`);
+    return db.updateMany({ status: "running", lockedBy: this.machineId }, {
+      $set: {
+        status: "incomplete"
+      }
+    });
+  },
+  setJobCompleted: function(jobId = "") {
+    const db = process.databases._queues?.collection(`queue_${this.queue.name}`);
+    return db.updateOne({ _id: jobId }, {
+      $set: {
+        status: "completed",
+        completedAt: dayjs().format()
+      }
+    });
+  },
+  setJobFailed: function(jobId = "", error = "") {
+    const db = process.databases._queues?.collection(`queue_${this.queue.name}`);
+    return db.updateOne({ _id: jobId }, {
+      $set: {
+        status: "failed",
+        failedAt: dayjs().format(),
+        error
+      }
+    });
+  },
+  setJobsForMachinePending: function() {
+    const db = process.databases._queues?.collection(`queue_${this.queue.name}`);
+    return db.updateMany({ status: { $in: ["pending", "running"] }, lockedBy: this.machineId }, {
+      $set: {
+        status: "pending"
+      },
+      // NOTE: Unpin job from the machine that originally had it and toss it back in the queue
+      // for any machine to pick it up.
+      $unset: {
+        lockedBy: ""
+      }
+    });
+  }
+};
+export {
+  queues_default as default
+};

package/dist/lib/dev/databases/drivers/postgresql/addColumnToTable.js

@@ -0,0 +1,6 @@
+var addColumnToTable_default = (table = "", columnName = "", columnSchema = "") => {
+  return process.databases._users?.query(`ALTER TABLE ${table} ADD COLUMN ${columnName} ${columnSchema}`);
+};
+export {
+  addColumnToTable_default as default
+};

package/dist/lib/dev/databases/drivers/postgresql/createAccountsIndexes.js

@@ -0,0 +1,21 @@
+const createUniqueIndex = async (indexName = "", tableName = "", tableColumns = []) => {
+  return process.databases._users?.query(`CREATE UNIQUE INDEX IF NOT EXISTS ${indexName} ON ${tableName}(${tableColumns.join(", ")})`);
+};
+const createIndex = async (indexName = "", tableName = "", tableColumns = []) => {
+  return process.databases._users?.query(`CREATE INDEX IF NOT EXISTS ${indexName} ON ${tableName}(${tableColumns.join(", ")})`);
+};
+var createAccountsIndexes_default = async () => {
+  await createIndex("user_by_email", "users", ["email_address"]);
+  await createIndex("user_by_username", "users", ["username"]);
+  await createIndex("user_by_user_id", "users", ["user_id"]);
+  await createIndex("user_session_by_token", "users_sessions", ["token"]);
+  await createIndex("user_password_reset_token_by_token", "users_password_reset_tokens", ["token"]);
+  await createIndex("user_password_reset_token_by_user_id_token", "users_password_reset_tokens", ["user_id", "token"]);
+  await createIndex("user_role", "users_roles", ["role"]);
+  await createIndex("user_roles_by_user_id_role", "users_roles", ["user_id", "role"]);
+  await createIndex("role", "roles", ["role"]);
+  await createUniqueIndex("user_roles", "users_roles", ["user_id", "role"]);
+};
+export {
+  createAccountsIndexes_default as default
+};

package/dist/lib/dev/databases/drivers/postgresql/createAccountsTables.js

@@ -0,0 +1,41 @@
+const createTable = async (table = "", tableColumns = []) => {
+  return process.databases._users?.query(
+    `CREATE TABLE IF NOT EXISTS ${table} (${tableColumns.join(", ")})`
+  );
+};
+var createAccountsTables_default = async () => {
+  await createTable("users", [
+    "id bigserial primary key",
+    "user_id text",
+    "email_address text",
+    "password text",
+    "username text",
+    "language text"
+  ]);
+  await createTable("users_sessions", [
+    "id bigserial primary key",
+    "user_id text",
+    "token text",
+    "token_expires_at text"
+  ]);
+  await createTable("users_password_reset_tokens", [
+    "id bigserial primary key",
+    "user_id text",
+    "token text",
+    "requested_at text"
+  ]);
+  await createTable("users_verify_email_tokens", [
+    "id bigserial primary key",
+    "user_id text",
+    "token text"
+  ]);
+  await createTable("roles", ["id bigserial primary key", "role text"]);
+  await createTable("users_roles", [
+    "id bigserial primary key",
+    "user_id text",
+    "role text"
+  ]);
+};
+export {
+  createAccountsTables_default as default
+};