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

package/src/app/databases/queries/mongodb/queues.js

@@ -0,0 +1,164 @@
+import cluster from 'cluster';
+import timestamps from '../../../../lib/timestamps.js';
+
+const queues ={
+  add_job: function (job_to_add = {}) {
+    const db = this.db?.collection(`queue_${this.queue.name}`);
+    return db.insertOne({
+      ...job_to_add,
+      attempts: 0,
+    });
+  },
+  count_jobs: function (status = '') {
+    const db = this.db?.collection(`queue_${this.queue.name}`);
+    return db.countDocuments({ status, locked_by: this.machine_id });
+  },
+  delete_job: function (job_id = '') {
+    const db = this.db?.collection(`queue_${this.queue.name}`);
+    return db.deleteOne({ _id: job_id });
+  },
+  delete_incomplete_jobs_for_machine: function () {
+    const db = this.db?.collection(`queue_${this.queue.name}`);
+    return db.deleteMany({ status: { $in: ['incomplete', 'running'] }, locked_by: this.machine_id });
+  },
+  get_jobs: function (query = {}) {
+    const db = this.db?.collection(`queue_${this.queue.name}`);
+    return db.find({
+      ...query,
+      environment: process.env.NODE_ENV,
+    }).toArray();
+  },
+  get_next_job_to_run: async function () {
+    const db = this.db?.collection(`queue_${this.queue.name}`);
+
+    const next_job = await db.findOneAndUpdate({
+      $or: [
+        {
+          status: 'pending',
+          environment: process.env.NODE_ENV,
+          // NOTE: Do this to avoid accidentally running jobs intended for the future too early.
+          next_run_at: { $lte: timestamps.get_current_time() },
+          locked_by: { $exists: false }
+        },
+        {
+          status: 'pending',
+          environment: process.env.NODE_ENV,
+          // NOTE: Do this to avoid accidentally running jobs intended for the future too early.
+          next_run_at: { $lte: timestamps.get_current_time() },
+          locked_by: null,
+        }
+      ]
+    }, {
+      $set: {
+        status: 'running',
+        started_at: timestamps.get_current_time(),
+        locked_by: this.machine_id,
+      },
+    }, {
+      sort: {
+        next_run_at: 1,
+      },
+    });
+
+    return next_job;
+  },
+  initialize_database: async function () {
+    // NOTE: Add this check to avoid clustered apps from creating a race condition
+    // when initializing indexes below (they step on each other's toes and cause
+    // errors to be thrown). Only a primary or 1st worker should run this.
+
+    if (cluster.isPrimary || (cluster.isWorker && cluster.worker.id === 1)) {
+      try {
+        await this.db.createCollection(`queue_${this.queue.name}`);
+      } catch {
+        // NOTE: Drop the error. We anticipate it after the first run.
+      }
+
+      const db = this.db?.collection(`queue_${this.queue.name}`);
+
+      const indexes = await db?.indexes();
+
+      await db.createIndex({ status: 1 });
+      await db.createIndex({ status: 1, next_run_at: 1 });
+      await db.createIndex({ status: 1, environment: 1, next_run_at: 1, locked_by: 1 });
+
+      if (this.queue.options?.cleanup?.completedAfterSeconds || this.queue.options?.cleanup?.completed_after_seconds) {
+        if (indexes?.find((index) => index?.name === 'completed_at_1')) {
+          await db.dropIndex({ completed_at: 1 });
+        }
+
+        await db.createIndex({ completed_at: 1 }, { expireAfterSeconds: this?.queue?.options?.cleanup?.completedAfterSeconds || this.queue.options?.cleanup?.completed_after_seconds });
+      }
+
+      if (this.queue.options?.cleanup?.failedAfterSeconds || this.queue.options?.cleanup?.failed_after_seconds) {
+        if (indexes?.find((index) => index?.name === 'failed_at_1')) {
+          await db.dropIndex({ failed_at: 1 });
+        }
+
+        await db.createIndex({ failed_at: 1 }, { expireAfterSeconds: this?.queue?.options?.cleanup?.failedAfterSeconds || this.queue.options?.cleanup?.failed_after_seconds });
+      }
+    }
+  },
+  log_attempt: function (job_id = '') {
+    const db = this.db?.collection(`queue_${this.queue.name}`);
+    return db.updateOne({ _id: job_id }, {
+      $inc: {
+        attempts: 1,
+      },
+    });
+  },
+  requeue_job: function (job_id = '', next_run_at = null) {
+    const db = this.db?.collection(`queue_${this.queue.name}`);
+    return db.updateOne({ _id: job_id }, {
+      $set: {
+        status: 'pending',
+        next_run_at,
+      },
+      $unset: {
+        locked_by: '',
+      }
+    });
+  },
+  set_job_completed: function (job_id = '') {
+    const db = this.db?.collection(`queue_${this.queue.name}`);
+    return db.updateOne({ _id: job_id }, {
+      $set: {
+        status: 'completed',
+        // NOTE: Format this way for ttl indexes.
+        completed_at: timestamps.get_current_time({ mongodb_ttl: true }),
+      },
+    });
+  },
+  set_job_failed: function (job_id = '', error = '') {
+    const db = this.db?.collection(`queue_${this.queue.name}`);
+    return db.updateOne({ _id: job_id }, {
+      $set: {
+        status: 'failed',
+        // NOTE: Format this way for ttl indexes.
+        failed_at: timestamps.get_current_time({ mongodb_ttl: true }),
+        error,
+      },
+    });
+  },
+  set_jobs_for_machine_pending: function () {
+    const db = this.db?.collection(`queue_${this.queue.name}`);
+    
+    // NOTE: Do NOT change the next_run_at as we want priority to remain intact. Oldest jobs
+    // should still be FIFO.
+    return db.updateMany({
+      status: { $in: ['pending', 'running'] },
+      locked_by: this.machine_id
+    }, {
+      $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: {
+        locked_by: '',
+      }
+    });
+  },
+};
+
+export default queues;

package/src/app/databases/queries/mongodb/sessions.js

@@ -0,0 +1,22 @@
+import generate_id from "../../../../lib/generate_id.js";
+
+const sessions = {
+	create_session: async () => {
+		const session_id = generate_id(16);
+		
+		await process.databases._sessions?.collection('sessions').insertOne({
+			_id: session_id,
+			csrf: generate_id(32),
+			created_at: new Date(new Date().toISOString()),
+		});
+
+		return session_id;
+	},
+	get_session: async (input = {}) => {
+		return process.databases._sessions?.collection('sessions').findOne({
+			_id: input?.session_id,
+		});
+	},
+};
+
+export default sessions;

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

@@ -0,0 +1,379 @@
+import generate_id from "../../../../lib/generate_id.js";
+import camel_pascal_to_snake from "../../../../lib/camel_pascal_to_snake.js";
+
+const accounts = {
+  add_password_reset_token: async (input = {}) => {
+    const [user] = await process.databases._users?.query(
+      `SELECT user_id FROM users WHERE email_address = $1;`,
+      [input?.email_address]
+    );
+
+    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()],
+    );
+  },
+  add_role: async (input = {}) => {
+    const [existing_role] = await process.databases._users?.query(
+      `SELECT * FROM roles WHERE role = $1;`,
+      [input?.role]
+    );
+
+    if (!existing_role && input?.role) {
+      await process.databases._users?.query(
+        `INSERT INTO roles(role) VALUES ($1);`,
+        [input?.role],
+      );
+
+      return {
+        _id: input?.user_id,
+        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.`,
+    };
+  },
+	add_session: async (input = {}) => {
+    await process.databases._users?.query(
+      `INSERT INTO users_sessions(user_id, token, token_expires_at) VALUES ($1, $2, $3);`,
+      [input?.user_id, input?.session?.token, input?.session?.token_expires_at]
+    );
+  },
+  create_email_verification_token: async (input = {}) => {
+    const token = generate_id(16);
+
+    await process.databases._users?.query(
+      `INSERT INTO users_verify_email_tokens(user_id, token) VALUES ($1, $2);`,
+      [input?.user_id, token]
+    );
+
+    return token;
+  },
+  create_user: async (input = {}) => {
+    const user_id = generate_id(16);
+
+    const keys = ['user_id', ...(Object.keys(input || {}) || [])]?.map((input_key) => {
+      return camel_pascal_to_snake(input_key);
+    })?.join(',');
+
+    const values = [user_id, ...(Object.values(input) || [])];
+
+    await process.databases._users?.query(
+      `INSERT INTO users(${keys}) VALUES (${values?.map((_, index) => `$${index + 1}`)});`,
+      values,
+    );
+
+    return user_id;
+  },
+  delete_old_sessions: async (input = {}) => {
+    await process.databases._users?.query(
+      `DELETE FROM users_sessions WHERE user_id = $1 AND token_expires_at::timestamp < NOW()`,
+      [input?.user_id]
+    );
+  },
+  delete_user: async (input = {}) => {
+    await process.databases._users?.query(
+      `DELETE FROM users WHERE user_id = $1`,
+      [input?.user_id]
+    );
+  },
+  existing_user: async (input = {}) => {
+    let existing_user_with_email_address;
+    let existing_user_with_username;
+
+    if (input?.email_address) {
+      const [existing_user] = await process.databases._users?.query(
+        `SELECT * FROM users WHERE email_address = $1;`,
+        [input?.email_address]
+      );
+
+      existing_user_with_email_address = existing_user;
+    }
+
+    if (input?.username) {
+      const [existing_user] = await process.databases._users?.query(
+        `SELECT * FROM users WHERE username = $1;`,
+        [input?.username]
+      );
+
+      existing_user_with_username = existing_user;
+    }
+
+    return existing_user_with_email_address || existing_user_with_username ? {
+      existing_email_address: existing_user_with_email_address?.email_address,
+      existing_username: existing_user_with_username?.username,
+    } : null;
+  },
+  get_existing_session: async (input = {}) => {
+    const user_sessions = await process.databases._users?.query(
+      `SELECT * FROM users_sessions WHERE user_id = $1;`,
+      [input.user_id]
+    );
+
+    if (user_sessions?.length > 0) {
+      const sessions_by_last_to_expire = user_sessions.sort((a, b) => {
+        return a.token_expires_at > b.token_expires_at ? -1 : 1;
+      });
+      
+      return sessions_by_last_to_expire.shift();
+    }
+
+    return null;
+  },
+  get_password_reset_token: async (input = {}) => {
+    const [password_reset_token] = await process.databases._users?.query(
+      `SELECT * FROM users_password_reset_tokens WHERE user_id = $1`,
+      [input?.user_id],
+    );
+
+    if (password_reset_token) {
+      return password_reset_token?.token || null;
+    }
+
+    return null;
+  },
+  grant_role: async (input = {}) => {
+    const user = await process.databases._users?.query(
+      `SELECT * FROM users WHERE user_id = $1;`,
+      [input?.user_id]
+    );
+
+    if (user) {
+      await process.databases._users?.query(
+        `INSERT INTO users_roles(user_id, role) VALUES ($1, $2) ON CONFLICT DO NOTHING;`,
+        [input?.user_id, input?.role]
+      );
+
+      const [existing_role] = await process.databases._users?.query(
+        `SELECT * FROM roles WHERE role = $1;`,
+        [input?.role]
+      );
+
+      if (!existing_role) {
+        await process.databases._users?.query(
+          `INSERT INTO roles(role) VALUES ($1) ON CONFLICT DO NOTHING;`,
+          [input?.role]
+        );
+      }
+
+      return {
+        _id: input?.user_id,
+        action: "grant",
+        role: input?.role,
+        ok: true,
+        error: null,
+      };
+    }
+
+    return {
+      _id: input?.user_id,
+      action: "grant",
+      role: input?.role,
+      ok: false,
+      error: `User not found with the _id ${input?.user_id}.`,
+    };
+  },
+  list_roles: async () => {
+    const roles = await process.databases._users?.query(
+      `SELECT * FROM roles;`
+    );
+
+    return (roles || []).map(({ role }) => role);
+  },
+  mark_email_verified_at: 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?.user_id]
+    );
+
+    await process.databases._users?.query(
+      `DELETE FROM users_verify_email_tokens WHERE token = $1`,
+      [input?.token]
+    );
+  },
+  remove_reset_token: async (input = {}) => {
+    await process.databases._users?.query(
+      `DELETE FROM users_password_reset_tokens WHERE user_id = $1 AND token = $2;`,
+      [input?.user_id, input?.token],
+    );
+
+    const [user] = await process.databases._users?.query(
+      `SELECT * FROM users WHERE user_id = $1;`,
+      [input?.user_id]
+    );
+
+    return user;
+  },
+  remove_role: async (input = {}) => {
+    const [existing_role] = await process.databases._users?.query(
+      `SELECT * FROM roles WHERE role = $1;`,
+      [input?.role]
+    );
+
+    if (existing_role) {
+      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?.user_id,
+        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}.`,
+    };
+  },
+  reset_user_sessions: async (input = {}) => {
+    await process.databases._users?.query(
+      `DELETE FROM users_sessions WHERE user_id = $1;`,
+      [input.user_id]
+    );
+  },
+  revoke_role: async (input = {}) => {
+    const user = await process.databases._users?.query(
+      `SELECT * FROM users WHERE user_id = $1;`,
+      [input?.user_id]
+    );
+
+    if (user) {
+      await process.databases._users?.query(
+        `DELETE FROM users_roles WHERE user_id = $1 AND role = $2;`,
+        [input?.user_id, input?.role]
+      );
+
+      return {
+        _id: input?.user_id,
+        action: "revoke",
+        role: input?.role,
+        ok: true,
+        error: null,
+      };
+    }
+
+    return {
+      _id: input?.user_id,
+      action: "revoke",
+      role: input?.role,
+      ok: false,
+      error: `User not found with the _id ${input?.user_id}.`,
+    };
+  },
+  set_new_password: async (input = {}) => {
+    await process.databases._users?.query(
+      `UPDATE users SET password = $1 WHERE user_id = $2;`,
+      [input?.hashed_password, input?.user_id],
+    );
+  },
+  user: async (input = {}) => {
+    if (input?.email_address) {
+      const [user] = await process.databases._users?.query(
+        `SELECT * FROM users WHERE email_address = $1;`,
+        [input?.email_address]
+      );
+
+      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;
+  },
+  user_has_role: async (input = {}) => {
+    const user = await process.databases._users?.query(
+      `SELECT * FROM users WHERE user_id = $1;`,
+      [input?.user_id]
+    );
+
+    if (user) {
+      const [existing_role] = await process.databases._users?.query(
+        `SELECT * FROM users_roles WHERE user_id = $1 AND role = $2;`,
+        [input?.user_id, input?.role]
+      );
+
+      return !!existing_role;
+    }
+
+    return false;
+  },
+  user_with_login_token: async (input = {}) => {
+    const [existing_user] = 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;`,
+      [existing_user?.user_id],
+    );
+
+    return user;
+  },
+  user_with_reset_token: async (input = {}) => {
+    const [existing_user] = 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;`,
+      [existing_user?.user_id]
+    );
+
+    return user;
+  },
+  user_with_verify_email_token: async (input = {}) => {
+    const [existing_user] = 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;`,
+      [existing_user?.user_id],
+    );
+
+    return user;
+  },
+};
+
+export default accounts;