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

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

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

@@ -1,211 +0,0 @@
-import dayjs from "dayjs";
-var queues_default = {
-  addJob: function(jobToAdd = {}) {
-    const db = process.databases._queues;
-    return db?.query(`
-      INSERT INTO queue_${this.queue.name} (
-        _id,
-        status,
-        job,
-        payload,
-        next_run_at
-      ) VALUES (
-        $1, $2, $3, $4, $5
-      )
-    `, [
-      jobToAdd?._id,
-      jobToAdd?.status,
-      jobToAdd?.job,
-      JSON.stringify(jobToAdd?.payload),
-      jobToAdd?.nextRunAt
-    ]);
-  },
-  countJobs: async function(status = "") {
-    const db = process.databases._queues;
-    const [jobs] = await db?.query(`
-      SELECT
-        count(*)
-      FROM
-        queue_${this.queue.name}
-      WHERE
-        status = $1
-    `, [
-      status
-    ]);
-    return Promise.resolve(jobs.count);
-  },
-  deleteJob: function(jobId = "") {
-    const db = process.databases._queues;
-    return db?.query(`
-      DELETE FROM
-        queue_${this.queue.name}
-      WHERE
-        _id = $1
-    `, [
-      jobId
-    ]);
-  },
-  getJobs: function(query = {}) {
-    const db = process.databases._queues;
-    return db?.query(`
-      SELECT * FROM
-        queue_${this.queue.name}
-      ${query?.status ? `
-        WHERE
-          status = $1
-      ` : ""}
-    `, [
-      query?.status
-    ]);
-  },
-  getNextJobToRun: async function() {
-    const db = process.databases._queues;
-    const [nextJob] = await db?.query(`
-      SELECT * FROM
-        queue_${this.queue.name}
-      WHERE
-        status = $1
-      AND
-        next_run_at::date <= NOW()
-      AND
-        locked_by IS NULL
-      ORDER BY
-        next_run_at ASC
-    `, [
-      "pending"
-    ]);
-    if (nextJob?._id) {
-      await db?.query(`
-        UPDATE
-          queue_${this.queue.name}
-        SET
-          status = $1,
-          started_at = $2,
-          locked_by = $3
-        WHERE
-          _id = $4
-      `, [
-        "running",
-        dayjs().format(),
-        this.machineId,
-        nextJob?._id
-      ]);
-    }
-    return nextJob ? {
-      ...nextJob,
-      payload: nextJob?.payload ? JSON.parse(nextJob?.payload || "") : {}
-    } : {};
-  },
-  initializeDatabase: async function() {
-    const db = process.databases._queues;
-    await db?.query(`
-      CREATE TABLE IF NOT EXISTS queue_${this.queue.name} (
-        _id text PRIMARY KEY,
-        status text,
-        job text,
-        payload text,
-        next_run_at text,
-        locked_by text,
-        started_at text,
-        completed_at text,
-        failed_at text,
-        error text
-      )
-    `);
-    db?.query(`CREATE INDEX IF NOT EXISTS status_index ON queue_${this.queue.name} (status)`);
-    db?.query(`CREATE INDEX IF NOT EXISTS status_nextRunAt_index ON queue_${this.queue.name} (status, next_run_at)`);
-    db?.query(`CREATE INDEX IF NOT EXISTS completedAt_index ON queue_${this.queue.name} (completed_at)`);
-    db?.query(`CREATE INDEX IF NOT EXISTS failedAt_index ON queue_${this.queue.name} (failed_at)`);
-  },
-  requeueJob: function(jobId = "", nextRunAt = null) {
-    const db = process.databases._queues;
-    return db?.query(`
-      UPDATE
-        queue_${this.queue.name}
-      SET
-        status = $1,
-        next_run_at = $2,
-        locked_by = $3
-      WHERE
-        _id = $4
-    `, [
-      "pending",
-      nextRunAt,
-      null,
-      jobId
-    ]);
-  },
-  setJobsForMachineIncomplete: function() {
-    const db = process.databases._queues;
-    return db?.query(`
-      UPDATE
-        queue_${this.queue.name}
-      SET
-        status = $1
-      WHERE
-        status = $2
-      AND
-        locked_by = $3
-    `, [
-      "incomplete",
-      "running",
-      this.machineId
-    ]);
-  },
-  setJobCompleted: function(jobId = "") {
-    const db = process.databases._queues;
-    return db?.query(`
-      UPDATE
-        queue_${this.queue.name}
-      SET
-        status = $1,
-        completed_at = $2
-      WHERE
-        _id = $3
-    `, [
-      "completed",
-      dayjs().format(),
-      jobId
-    ]);
-  },
-  setJobFailed: function(jobId = "", error = "") {
-    const db = process.databases._queues;
-    return db?.query(`
-      UPDATE
-        queue_${this.queue.name}
-      SET
-        status = $1,
-        failed_at = $2,
-        error = $3
-      WHERE
-        _id = $4
-    `, [
-      "failed",
-      dayjs().format(),
-      error,
-      jobId
-    ]);
-  },
-  setJobsForMachinePending: function() {
-    const db = process.databases._queues;
-    return db?.query(`
-      UPDATE
-        queue_${this.queue.name}
-      SET
-        status = $1,
-        locked_by = $2
-      WHERE
-        status = ANY($3)
-      AND
-        locked_by = $4
-    `, [
-      "pending",
-      null,
-      ["pending", "running"],
-      this.machineId
-    ]);
-  }
-};
-export {
-  queues_default as default
-};

package/dist/app/databases/queryMap.js

@@ -1,17 +0,0 @@
-import mongodbAccountsQueries from "./mongodb/queries/accounts";
-import mongodbQueuesQueries from "./mongodb/queries/queues";
-import postgresqlAccountsQueries from "./postgresql/queries/accounts";
-import postgresqlQueuesQueries from "./postgresql/queries/queues";
-var queryMap_default = {
-  mongodb: {
-    accounts: mongodbAccountsQueries,
-    queues: mongodbQueuesQueries
-  },
-  postgresql: {
-    accounts: postgresqlAccountsQueries,
-    queues: postgresqlQueuesQueries
-  }
-};
-export {
-  queryMap_default as default
-};

package/dist/app/databases/typesMap.js

@@ -1,7 +0,0 @@
-var typesMap_default = {
-  mongodb: "nosql",
-  postgresql: "sql"
-};
-export {
-  typesMap_default as default
-};

package/dist/app/getAPIContext.js

@@ -1,25 +0,0 @@
-import parseDatabasesFromEnvironment from "../lib/parseDatabasesFromEnvironment.js";
-var getAPIContext_default = (httpContext = {}, context = null) => {
-  return new Promise(async (resolve, reject) => {
-    if (typeof context === "function") {
-      const compiledContext = await context(httpContext.req, httpContext.res);
-      return resolve({
-        ...compiledContext,
-        ...httpContext?.req?.context || {},
-        req: httpContext.req,
-        res: httpContext.res,
-        ...process.databases || {}
-      });
-    }
-    return resolve({
-      ...context,
-      ...httpContext?.req?.context || {},
-      req: httpContext.req,
-      res: httpContext.res,
-      ...process.databases || {}
-    });
-  });
-};
-export {
-  getAPIContext_default as default
-};

package/dist/app/getAPIURLComponent.js

@@ -1,6 +0,0 @@
-var getAPIURLComponent_default = (string = "") => {
-  return string.toLowerCase().replace(/\ /g, "-");
-};
-export {
-  getAPIURLComponent_default as default
-};

package/dist/app/getBrowserSafeRequest.js

@@ -1,14 +0,0 @@
-import getBrowserSafeUser from "./accounts/getBrowserSafeUser";
-import escapeKeyValuePair from "../lib/escapeKeyValuePair.js";
-var getBrowserSafeRequest_default = (req = {}) => {
-  const browserSafeRequest = {};
-  browserSafeRequest.params = escapeKeyValuePair(req.params);
-  browserSafeRequest.query = escapeKeyValuePair(req.query);
-  browserSafeRequest.context = {
-    user: getBrowserSafeUser(req.context.user)
-  };
-  return browserSafeRequest;
-};
-export {
-  getBrowserSafeRequest_default as default
-};

package/dist/app/getOutput.js

@@ -1,74 +0,0 @@
-import { isObject } from "../validation/lib/typeValidators";
-const getOutput = (object = {}, fields = []) => {
-  Object.entries(object || {}).forEach(([key, value]) => {
-    const keyInFields = fields.find((field) => field.key === key);
-    if (!keyInFields) {
-      delete object[key];
-    }
-    if (keyInFields && isObject(value) && keyInFields.children.length === 0) {
-      return value;
-    }
-    if (keyInFields && isObject(value) && keyInFields.children.length > 0) {
-      return getOutput(value, keyInFields.children);
-    }
-    if (keyInFields && Array.isArray(value) && keyInFields.children && keyInFields.children.length > 0) {
-      value.forEach((valueElement) => {
-        if (valueElement && isObject(valueElement)) {
-          return getOutput(valueElement, keyInFields.children);
-        }
-      });
-    }
-  });
-  return object;
-};
-const getPathPartArrays = (paths = []) => {
-  return paths.map((path) => {
-    return path.split(".");
-  });
-};
-const getHeadTail = (pathPartArray = []) => {
-  const [head, ...tail] = pathPartArray;
-  return {
-    head,
-    tail
-  };
-};
-const getHeadTailForPaths = (pathPartArrays = []) => {
-  return pathPartArrays.map((pathPartArray) => {
-    return getHeadTail(pathPartArray);
-  });
-};
-const addToMap = (map = [], headTailForPaths = []) => {
-  headTailForPaths.forEach((headTailForPath) => {
-    const existingMapEntry = map.find((mapEntry) => mapEntry.key === headTailForPath.head);
-    if (!existingMapEntry) {
-      const headTailForChildren = headTailForPath.tail && headTailForPath.tail.length > 0 ? getHeadTail(headTailForPath.tail) : null;
-      map.push({
-        key: headTailForPath.head,
-        children: headTailForChildren ? addToMap([], [headTailForChildren]) : []
-      });
-    }
-    if (existingMapEntry) {
-      const headTailForChildren = headTailForPath.tail && headTailForPath.tail.length > 0 ? getHeadTail(headTailForPath.tail) : null;
-      existingMapEntry.children = [
-        ...headTailForChildren ? addToMap(existingMapEntry.children, [headTailForChildren]) : []
-      ];
-    }
-  });
-  return map;
-};
-var getOutput_default = (output = {}, outputFields = []) => {
-  const map = [];
-  const pathPartArrays = getPathPartArrays(outputFields);
-  const headTailForPaths = getHeadTailForPaths(pathPartArrays);
-  addToMap(map, headTailForPaths);
-  if (Array.isArray(output)) {
-    return output.map((element) => {
-      return getOutput(element, map);
-    });
-  }
-  return getOutput(output, map);
-};
-export {
-  getOutput_default as default
-};

package/dist/app/handleProcessErrors.js

@@ -1,73 +0,0 @@
-var handleProcessErrors_default = (listeners = {}) => {
-  process.on("exit", async () => {
-  });
-  process.on("beforeExit", async (code) => {
-    if (listeners?.beforeExit && typeof listeners.beforeExit === "function") {
-      listeners.beforeExit(code);
-    }
-  });
-  process.on("disconnect", async () => {
-    if (listeners?.disconnect && typeof listeners.disconnect === "function") {
-      listeners.disconnect();
-    }
-  });
-  process.on("exit", async (code) => {
-    if (listeners?.exit && typeof listeners.exit === "function") {
-      listeners.exit(code);
-    }
-  });
-  process.on("message", async (message, sendHandle) => {
-    if (process.env.NODE_ENV !== "test") {
-      console.log(message);
-    }
-    if (listeners?.message && typeof listeners.message === "function") {
-      listeners.message(message, sendHandle);
-    }
-  });
-  process.on("multipleResolves", async (type, promise, value) => {
-    if (listeners?.multipleResolves && typeof listeners.multipleResolves === "function") {
-      listeners.multipleResolves(type, promise, value);
-    }
-  });
-  process.on("rejectionHandled", async (promise) => {
-    if (listeners?.rejectionHandled && typeof listeners.rejectionHandled === "function") {
-      listeners.rejectionHandled(promise);
-    }
-  });
-  process.on("uncaughtException", async (error, origin) => {
-    console.warn(error);
-    if (listeners?.error && typeof listeners.error === "function") {
-      listeners.error(error);
-    }
-    if (listeners?.uncaughtException && typeof listeners.uncaughtException === "function") {
-      listeners.uncaughtException(error, origin);
-    }
-  });
-  process.on("uncaughtExceptionMonitor", async (error) => {
-    if (listeners?.uncaughtExceptionMonitor && typeof listeners.uncaughtExceptionMonitor === "function") {
-      listeners.uncaughtExceptionMonitor(error);
-    }
-  });
-  process.on("unhandledRejection", async (error) => {
-    console.warn(error);
-    if (listeners?.error && typeof listeners.error === "function") {
-      listeners.error(error);
-    }
-    if (listeners?.unhandledRejection && typeof listeners.unhandledRejection === "function") {
-      listeners.unhandledRejection(error);
-    }
-  });
-  process.on("warning", async (warning) => {
-    if (listeners?.warning && typeof listeners.warning === "function") {
-      listeners.warning(warning);
-    }
-  });
-  process.on("worker", async (event) => {
-    if (listeners?.worker && typeof listeners.worker === "function") {
-      listeners.worker(event);
-    }
-  });
-};
-export {
-  handleProcessErrors_default as default
-};