@joystick.js/node-canary 0.0.0-canary.47 → 0.0.0-canary.471

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
-};

package/dist/app/databases/postgresql/queries/accounts.js

@@ -1,186 +0,0 @@
-import generateId from "../../../../lib/generateId";
-import objectToSQLKeysString from "../../../../lib/objectToSQLKeysString";
-import objectToSQLValuesString from "../../../../lib/objectToSQLValuesString";
-import camelPascalToSnake from "../../../../lib/camelPascalToSnake.js";
-var accounts_default = {
-  existingUser: async (input = {}) => {
-    let existingUserWithEmailAddress;
-    let existingUserWithUsername;
-    if (input?.emailAddress) {
-      const [existingUser] = await process.databases._users?.query(`SELECT * FROM users WHERE email_address = $1;`, [input?.emailAddress]);
-      existingUserWithEmailAddress = existingUser;
-    }
-    if (input?.username) {
-      const [existingUser] = await process.databases._users?.query(`SELECT * FROM users WHERE username = $1;`, [input?.username]);
-      existingUserWithUsername = existingUser;
-    }
-    return existingUserWithEmailAddress || existingUserWithUsername ? {
-      existingEmailAddress: existingUserWithEmailAddress?.email_address,
-      existingUsername: existingUserWithUsername?.username
-    } : null;
-  },
-  createUser: async (input = {}) => {
-    const userId = generateId();
-    const keys = ["user_id", ...Object.keys(input) || []]?.map((inputKey) => {
-      return camelPascalToSnake(inputKey);
-    })?.join(",");
-    const values = [userId, ...Object.values(input) || []];
-    await process.databases._users?.query(`INSERT INTO users(${keys}) VALUES (${values?.map((_, index) => `$${index + 1}`)});`, values);
-    return userId;
-  },
-  user: async (input) => {
-    if (input?.emailAddress) {
-      const [user] = await process.databases._users?.query(`SELECT * FROM users WHERE email_address = $1;`, [input?.emailAddress]);
-      return user;
-    }
-    if (input?.username) {
-      const [user] = await process.databases._users?.query(`SELECT * FROM users WHERE username = $1;`, [input?.username]);
-      return user;
-    }
-    if (input?._id) {
-      const [user] = await process.databases._users?.query(`SELECT * FROM users WHERE user_id = $1;`, [input?._id]);
-      return user;
-    }
-    return null;
-  },
-  deleteOldSessions: async (input = {}) => {
-    await process.databases._users?.query(`DELETE FROM users_sessions WHERE user_id = $1 AND token_expires_at::date < NOW()`, [input?.userId]);
-  },
-  addSession: async (input = {}) => {
-    await process.databases._users?.query(`INSERT INTO users_sessions(user_id, token, token_expires_at) VALUES ($1, $2, $3);`, [input?.userId, input?.session?.token, input?.session?.tokenExpiresAt]);
-  },
-  userWithLoginToken: async (input) => {
-    const [existingUser] = await process.databases._users?.query(`SELECT user_id FROM users_sessions WHERE token = $1;`, [input.token]);
-    const [user] = await process.databases._users?.query(`SELECT * FROM users WHERE user_id = $1;`, [existingUser?.user_id]);
-    return user;
-  },
-  createEmailVerificationToken: async (input) => {
-    const token = generateId();
-    await process.databases._users?.query(`INSERT INTO users_verify_email_tokens(user_id, token) VALUES ($1, $2);`, [input?.userId, token]);
-    return token;
-  },
-  userWithVerifyEmailToken: async (input) => {
-    const [existingUser] = await process.databases._users?.query(`SELECT user_id FROM users_verify_email_tokens WHERE token = $1;`, [input.token]);
-    const [user] = await process.databases._users?.query(`SELECT * FROM users WHERE user_id = $1;`, [existingUser?.user_id]);
-    return user;
-  },
-  markEmailVerifiedAt: async (input) => {
-    await process.databases._users?.query(`UPDATE users SET email_verified = true, email_verified_at = $1 WHERE user_id = $2;`, [new Date().toISOString(), input?.userId]);
-    await process.databases._users?.query(`DELETE FROM users_verify_email_tokens WHERE token = $1`, [input?.token]);
-  },
-  addPasswordResetToken: async (input = {}) => {
-    const [user] = await process.databases._users?.query(`SELECT user_id FROM users WHERE email_address = $1;`, [input?.emailAddress]);
-    await process.databases._users?.query(`INSERT INTO users_password_reset_tokens(user_id, token, requested_at) VALUES ($1, $2, $3);`, [user?.user_id, input?.token, new Date().toISOString()]);
-  },
-  userWithResetToken: async (input) => {
-    const [existingUser] = await process.databases._users?.query(`SELECT user_id FROM users_password_reset_tokens WHERE token = $1;`, [input["passwordResetTokens.token"]]);
-    const [user] = await process.databases._users?.query(`SELECT * FROM users WHERE user_id = $1;`, [existingUser?.user_id]);
-    return user;
-  },
-  setNewPassword: async (input = {}) => {
-    await process.databases._users?.query(`UPDATE users SET password = $1 WHERE user_id = $2;`, [input?.hashedPassword, input?.userId]);
-  },
-  removeResetToken: async (input = {}) => {
-    await process.databases._users?.query(`DELETE FROM users_password_reset_tokens WHERE user_id = $1 AND token = $2;`, [input?.userId, input?.token]);
-    const [user] = await process.databases._users?.query(`SELECT * FROM users WHERE user_id = $1;`, [input?.userId]);
-    return user;
-  },
-  addRole: async (input = {}) => {
-    const [existingRole] = await process.databases._users?.query(`SELECT * FROM roles WHERE role = $1;`, [input?.role]);
-    if (!existingRole && input?.role) {
-      await process.databases._users?.query(`INSERT INTO roles(role) VALUES ($1);`, [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] = await process.databases._users?.query(`SELECT * FROM roles WHERE role = $1;`, [input?.role]);
-    if (existingRole) {
-      await process.databases._users?.query(`DELETE FROM users_roles WHERE role = $1;`, [input?.role]);
-      await process.databases._users?.query(`DELETE FROM roles WHERE role = $1;`, [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?.query(`SELECT * FROM roles;`);
-    return (roles || []).map(({ role }) => role);
-  },
-  grantRole: async (input = {}) => {
-    const user = await process.databases._users?.query(`SELECT * FROM users WHERE user_id = $1;`, [input?.userId]);
-    if (user) {
-      await process.databases._users?.query(`INSERT INTO users_roles(user_id, role) VALUES ($1, $2) ON CONFLICT DO NOTHING;`, [input?.userId, input?.role]);
-      const [existingRole] = await process.databases._users?.query(`SELECT * FROM roles WHERE role = $1;`, [input?.role]);
-      if (!existingRole) {
-        await process.databases._users?.query(`INSERT INTO roles(role) VALUES ($1) ON CONFLICT DO NOTHING;`, [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?.query(`SELECT * FROM users WHERE user_id = $1;`, [input?.userId]);
-    if (user) {
-      await process.databases._users?.query(`DELETE FROM users_roles WHERE user_id = $1 AND role = $2;`, [input?.userId, 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?.query(`SELECT * FROM users WHERE user_id = $1;`, [input?.userId]);
-    if (user) {
-      const [existingRole] = await process.databases._users?.query(`SELECT * FROM users_roles WHERE user_id = $1 AND role = $2;`, [input?.userId, input?.role]);
-      return !!existingRole;
-    }
-    return false;
-  }
-};
-export {
-  accounts_default as default
-};