@joystick.js/node-canary 0.0.0-canary.42 → 0.0.0-canary.420

package/dist/app/databases/mongodb/buildConnectionString.js

@@ -1,22 +0,0 @@
-import buildQueryParameters from "./buildQueryParameters";
-import serializeQueryParameters from "../../../lib/serializeQueryParameters";
-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/app/databases/mongodb/buildQueryParameters.js

@@ -1,14 +0,0 @@
-import availableQueryParameters from "./availableQueryParameters";
-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/app/databases/mongodb/index.js

@@ -1,40 +0,0 @@
-import { MongoClient } from "mongodb";
-import chalk from "chalk";
-import mongoUri from "mongo-uri-tool";
-import fs from "fs";
-import buildConnectionString from "./buildConnectionString";
-var mongodb_default = async (settings = {}, databasePort = 2610) => {
-  const connection = settings?.connection || {
-    hosts: [
-      { 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: !process.env.NODE_ENV?.includes("development"),
-      ...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/app/databases/mongodb/queries/accounts.js

@@ -1,266 +0,0 @@
-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: 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: 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/app/databases/mongodb/queries/queues.js

@@ -1,111 +0,0 @@
-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",
-          nextRunAt: { $lte: dayjs().format() },
-          lockedBy: { $exists: false }
-        },
-        {
-          status: "pending",
-          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"
-      },
-      $unset: {
-        lockedBy: ""
-      }
-    });
-  }
-};
-export {
-  queues_default as default
-};

package/dist/app/databases/postgresql/addColumnToTable.js

@@ -1,6 +0,0 @@
-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/app/databases/postgresql/createAccountsIndexes.js

@@ -1,21 +0,0 @@
-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/app/databases/postgresql/createAccountsTables.js

@@ -1,39 +0,0 @@
-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
-};

package/dist/app/databases/postgresql/index.js

@@ -1,55 +0,0 @@
-import postgresql from "pg";
-import chalk from "chalk";
-import os from "os";
-const { Pool } = postgresql;
-var postgresql_default = async (settings = {}, databasePort = 2610) => {
-  const connection = settings?.connection || {
-    hosts: [
-      { hostname: "127.0.0.1", port: databasePort }
-    ],
-    database: "app",
-    username: (os.userInfo() || {}).username || "",
-    password: ""
-  };
-  try {
-    const host = connection.hosts && connection.hosts[0];
-    const pool = new Pool({
-      user: connection?.username || "",
-      database: connection?.database,
-      password: connection?.password || "",
-      host: host?.hostname,
-      port: host?.port,
-      ...settings?.options || {}
-    });
-    return {
-      pool,
-      query: (...args) => {
-        return pool.query(...args).then((response) => {
-          return response?.rows || [];
-        }).catch((error) => {
-          console.log(chalk.redBright(`
-Failed SQL Statement:
-`));
-          console.log(args[0]);
-          console.log(`
-`);
-          console.log(chalk.redBright(`
-Failed Values:
-`));
-          console.log(args[1]);
-          throw error;
-        });
-      }
-    };
-  } catch (exception) {
-    console.warn(chalk.yellowBright(`
-Failed to connect to PostgreSQL. Please double-check connection settings and try again.
-
-Error from PostgreSQL:
-
-${chalk.redBright(exception?.message)}`));
-  }
-};
-export {
-  postgresql_default as default
-};