@joystick.js/node-canary 0.0.0-canary.35 → 0.0.0-canary.350

package/_package.json

@@ -1,7 +1,6 @@
 {
   "name": "@joystick.js/node",
-  "version": "1.0.0-beta.165",
-  "developmentVersion": "1.0.0-beta.1419",
+  "version": "1.0.0-beta.183",
   "type": "module",
   "description": "A Node.js framework for building web apps.",
   "main": "./dist/index.js",
@@ -17,7 +16,6 @@
   "author": "",
   "license": "SAUCR",
   "dependencies": {
-    "@tuskdb/node": "^0.11.0",
     "aws-sdk": "^2.1046.0",
     "bcrypt": "^5.0.1",
     "chalk": "^4.1.2",
@@ -39,6 +37,7 @@
     "node-html-parser": "^5.1.0",
     "nodemailer": "^6.7.0",
     "pg": "^8.7.3",
+    "pg-escape": "^0.2.0",
     "process": "^0.11.10",
     "query-string": "^7.0.1",
     "sanitize-html": "^2.7.3",

package/dist/action/class.js

@@ -1,5 +1,6 @@
 import formatAPIError from "../lib/formatAPIError";
 import validate from "../validation";
+import trackFunctionCall from "../test/trackFunctionCall.js";
 class Action {
   constructor(input = {}) {
     this.name = input?.name;
@@ -14,9 +15,17 @@ class Action {
     return Object.entries(this?.config?.steps || {})?.reduce((serializedSteps = {}, [stepName = "", stepOptions = {}]) => {
       serializedSteps[stepName] = async (...args) => {
         try {
+          trackFunctionCall(`node.actions.${this?.name}.steps.${stepName}`, [
+            ...args,
+            this
+          ]);
           const result = await stepOptions?.run(...args, this);
           if (typeof stepOptions?.onSuccess === "function") {
             stepOptions.onSuccess(result, this);
+            trackFunctionCall(`node.actions.${this?.name}.steps.${stepName}.onSuccess`, [
+              result,
+              this
+            ]);
           }
           return result;
         } catch (exception) {
@@ -25,6 +34,10 @@ class Action {
           }
           if (typeof stepOptions?.onError === "function") {
             stepOptions.onError(exception, this);
+            trackFunctionCall(`node.actions.${this?.name}.steps.${stepName}.onError`, [
+              exception,
+              this
+            ]);
           }
         }
       };
@@ -45,6 +58,9 @@ class Action {
     return new Promise(async (resolve, reject) => {
       try {
         this.abort = (error) => {
+          trackFunctionCall(`node.actions.${this?.name}.abort`, [
+            error
+          ]);
           reject(error);
           throw error;
         };
@@ -63,6 +79,11 @@ class Action {
             return reject(new Error(formattedValidationErrors));
           }
         }
+        trackFunctionCall(`node.actions.${this.name}.run`, [
+          input || {},
+          this.steps,
+          this
+        ]);
         const result = await this.config?.run(input || {}, this?.steps, this);
         return resolve(result);
       } catch (exception) {

package/dist/api/get.js

@@ -2,26 +2,28 @@ import runGetter from "../app/runGetter.js";
 var get_default = ({
   getterName = "",
   getterOptions = {},
+  skip = false,
   input = null,
   output = null,
   context = {},
   APIOptions = {}
 }) => {
   return new Promise((resolve, reject) => {
-    if (!getterOptions?.skip) {
-      runGetter({
-        getterName,
-        getterOptions,
-        input,
-        output,
-        APIOptions,
-        context
-      }).then((response) => {
-        return resolve(response);
-      }).catch((response) => {
-        return reject(JSON.stringify(response));
-      });
+    if (skip) {
+      return resolve();
     }
+    runGetter({
+      getterName,
+      getterOptions,
+      input,
+      output,
+      APIOptions,
+      context
+    }).then((response) => {
+      return resolve(response);
+    }).catch((response) => {
+      return reject(JSON.stringify(response));
+    });
   });
 };
 export {

package/dist/api/set.js

@@ -2,26 +2,28 @@ import runSetter from "../app/runSetter.js";
 var set_default = ({
   setterName = "",
   setterOptions = {},
+  skip = false,
   input = null,
   output = null,
   context = {},
   APIOptions = {}
 }) => {
   return new Promise((resolve, reject) => {
-    if (!setterOptions?.skip) {
-      runSetter({
-        setterName,
-        setterOptions,
-        input,
-        output,
-        APIOptions,
-        context
-      }).then((response) => {
-        return resolve(response);
-      }).catch((response) => {
-        return reject(JSON.stringify(response));
-      });
+    if (skip) {
+      return resolve();
     }
+    runSetter({
+      setterName,
+      setterOptions,
+      input,
+      output,
+      APIOptions,
+      context
+    }).then((response) => {
+      return resolve(response);
+    }).catch((response) => {
+      return reject(JSON.stringify(response));
+    });
   });
 };
 export {

package/dist/app/accounts/createMetadataTableColumns.js

@@ -0,0 +1,12 @@
+import escape from "pg-escape";
+var createMetadataTableColumns_default = async (usersDatabase = "", sqlizedMetadata = {}) => {
+  if (usersDatabase === "postgresql") {
+    const columns = Object.keys(sqlizedMetadata || {});
+    for (let i = 0; i < columns?.length; i += 1) {
+      await process.databases.postgresql.query(escape(`ALTER TABLE users ADD COLUMN IF NOT EXISTS %I TEXT;`, columns[i]));
+    }
+  }
+};
+export {
+  createMetadataTableColumns_default as default
+};

package/dist/app/accounts/deleteUser.js

@@ -0,0 +1,7 @@
+import runUserQuery from "./runUserQuery.js";
+var deleteUser_default = (userId = "") => {
+  return runUserQuery("deleteUser", { userId });
+};
+export {
+  deleteUser_default as default
+};

package/dist/app/accounts/generateSession.js

@@ -1,9 +1,7 @@
 import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc.js";
 import generateId from "../../lib/generateId";
-if (process.env.NODE_ENV !== "test") {
-  const utc = await import("dayjs/plugin/utc");
-  dayjs.extend(utc.default);
-}
+dayjs.extend(utc);
 var generateSession_default = () => {
   return {
     token: generateId(64),

package/dist/app/accounts/getBrowserSafeUser.js

@@ -1,14 +1,17 @@
 import { isObject } from "../../validation/lib/typeValidators";
+import escapeKeyValuePair from "../../lib/escapeKeyValuePair.js";
 var getBrowserSafeUser_default = (user = null) => {
   if (!user || !isObject(user)) {
     return null;
   }
   const unsafeFields = [
     "password",
+    "passwordResetTokens",
     "sessions",
-    "oauth"
+    "oauth",
+    "verifyEmailTokens"
   ];
-  const browserSafeUser = Object.entries(user).filter(([field]) => {
+  const browserSafeUser = Object.entries(user || {}).filter(([field]) => {
     return !unsafeFields.includes(field);
   }).reduce((fields, [field, value]) => {
     if (!fields[field]) {

package/dist/app/accounts/hasLoginTokenExpired.js

@@ -5,8 +5,7 @@ var hasLoginTokenExpired_default = async (res, token = null, tokenExpiresAt = nu
     unsetAuthenticationCookie(res);
     return true;
   }
-  const _dayjs = process.env.NODE_ENV === "test" ? (await import("../../tests/mocks/dayjs")).default : null;
-  const hasExpired = process.env.NODE_ENV === "test" ? _dayjs().isAfter(_dayjs(tokenExpiresAt)) : dayjs().isAfter(dayjs(tokenExpiresAt));
+  const hasExpired = dayjs().isAfter(dayjs(tokenExpiresAt));
   if (hasExpired) {
     unsetAuthenticationCookie(res);
     return true;

package/dist/app/accounts/index.js

@@ -1,6 +1,7 @@
 import _setAuthenticationCookie from "./setAuthenticationCookie.js";
 import _unsetAuthenticationCookie from "./unsetAuthenticationCookie.js";
 import defaultUserOutputFields from "./defaultUserOutputFields";
+import deleteUser from "./deleteUser.js";
 import getBrowserSafeUser from "./getBrowserSafeUser";
 import login from "./login";
 import recoverPassword from "./recoverPassword";
@@ -14,6 +15,7 @@ var accounts_default = {
   _setAuthenticationCookie,
   _unsetAuthenticationCookie,
   defaultUserOutputFields,
+  deleteUser,
   getBrowserSafeUser,
   login,
   recoverPassword,

package/dist/app/accounts/login.js

@@ -41,6 +41,12 @@ const login = async (options, { resolve, reject }) => {
     const session = await generateSession();
     await addSessionToUser(user?._id || user?.user_id, session);
     const { password, sessions, ...restOfUser } = user;
+    if (typeof process.joystick?._app?.options?.accounts?.onLogin === "function") {
+      process.joystick?._app?.options?.accounts?.onLogin({
+        ...session,
+        user
+      });
+    }
     return resolve({
       ...session,
       user: getOutput({

package/dist/app/accounts/recoverPassword.js

@@ -11,6 +11,9 @@ var recoverPassword_default = async (options = {}) => {
     if (process.env.NODE_ENV === "development") {
       console.log({ url });
     }
+    if (typeof process.joystick?._app?.options?.accounts?.onRecoverPassword === "function") {
+      process.joystick?._app?.options?.accounts?.onRecoverPassword(options?.emailAddress);
+    }
     await sendEmail({
       to: options.emailAddress,
       from: settings?.config?.email?.from,

package/dist/app/accounts/resetPassword.js

@@ -57,6 +57,12 @@ const resetPassword = async (options, { resolve, reject }) => {
       password: hashedNewPassword
     });
     await addSessionToUser(updatedUser?._id || updatedUser?.user_id, session);
+    if (typeof process.joystick?._app?.options?.accounts?.onResetPassword === "function") {
+      process.joystick?._app?.options?.accounts?.onResetPassword({
+        user: updatedUser,
+        ...session
+      });
+    }
     resolve({
       user: getOutput(updatedUser, options?.output),
       ...session

package/dist/app/accounts/signup.js

@@ -6,6 +6,9 @@ import { isObject } from "../../validation/lib/typeValidators";
 import getOutput from "../getOutput";
 import typesMap from "../databases/typesMap";
 import getTargetDatabaseProvider from "../databases/getTargetDatabaseProvider.js";
+import stringToSnakeCase from "../databases/stringToSnakeCase.js";
+import createMetadataTableColumns from "./createMetadataTableColumns.js";
+import roles from "./roles/index.js";
 const addSessionToUser = (userId = null, session = null) => {
   try {
     return runUserQuery("addSession", { userId, session });
@@ -27,6 +30,16 @@ const insertUserInDatabase = async (user = {}) => {
     throw new Error(formatErrorString("signup.insertUserInDatabase", exception));
   }
 };
+const sqlizeMetadata = (metadata = {}) => {
+  try {
+    return Object.entries(metadata || {}).reduce((sqlized = {}, [key, value]) => {
+      sqlized[stringToSnakeCase(key)] = value;
+      return sqlized;
+    }, {});
+  } catch (exception) {
+    throw new Error(`[actionName.sqlizeMetadata] ${exception.message}`);
+  }
+};
 const getUserToCreate = async (options = {}) => {
   try {
     const usersDatabase = getTargetDatabaseProvider("users");
@@ -40,12 +53,25 @@ const getUserToCreate = async (options = {}) => {
     if (options?.username) {
       user.username = options?.username;
     }
-    if (options?.metadata && isObject(options.metadata) && usersDatabaseType === "sql" && options?.metadata?.language) {
-      user.language = options?.metadata?.language;
+    if (options?.metadata && isObject(options.metadata) && usersDatabaseType === "sql") {
+      const sqlizedMetadata = sqlizeMetadata(options.metadata);
+      await createMetadataTableColumns(usersDatabase, sqlizedMetadata);
+      const metadata = { ...options?.metadata || {} };
+      if (metadata?.roles) {
+        delete metadata.roles;
+      }
+      user = {
+        ...sqlizeMetadata(metadata),
+        ...user
+      };
     }
     if (options?.metadata && isObject(options.metadata) && usersDatabaseType === "nosql") {
+      let metadata = { ...options?.metadata || {} };
+      if (metadata?.roles) {
+        delete metadata.roles;
+      }
       user = {
-        ...options.metadata,
+        ...metadata || {},
         ...user
       };
     }
@@ -70,15 +96,32 @@ const signup = async (options, { resolve, reject }) => {
       return reject("Password is required.");
     }
     const existingUser = await getExistingUser(options.emailAddress, options.metadata?.username);
-    if (existingUser) {
+    if (existingUser && process.env.NODE_ENV !== "test") {
       throw new Error(`A user with the ${existingUser.existingUsername ? "username" : "email address"} ${existingUser.existingUsername || existingUser.existingEmailAddress} already exists.`);
     }
-    const userToCreate = await getUserToCreate(options);
-    const userId = await insertUserInDatabase(userToCreate);
+    let userToCreate;
+    let userId = existingUser?._id || existingUser?.user_id;
+    if (!existingUser) {
+      userToCreate = await getUserToCreate(options);
+      userId = await insertUserInDatabase(userToCreate);
+    }
     const user = await getUserByUserId(userId);
     const session = generateSession();
     if (user?._id || user?.user_id) {
-      await addSessionToUser(user._id || user?.user_id, session);
+      await addSessionToUser(user?._id || user?.user_id, session);
+    }
+    if (options?.metadata?.roles?.length > 0 && process.env.NODE_ENV === "test") {
+      for (let i = 0; i < options?.metadata?.roles?.length; i += 1) {
+        const role = options?.metadata?.roles[i];
+        roles.grant(user?._id || user?.user_id, role);
+      }
+    }
+    if (typeof process.joystick?._app?.options?.accounts?.onSignup === "function") {
+      process.joystick?._app?.options?.accounts?.onSignup({
+        ...session,
+        userId,
+        user
+      });
     }
     return resolve({
       ...session,

package/dist/app/accounts/verifyEmail.js

@@ -33,6 +33,9 @@ const verifyEmail = async (options, { resolve, reject }) => {
       throw new Error(`A user with this token could not be found.`);
     }
     await markEmailVerifiedAt(user?._id || user?.user_id, options?.token);
+    if (typeof process.joystick?._app?.options?.accounts?.onVerifyEmail === "function") {
+      process.joystick?._app?.options?.accounts?.onVerifyEmail(user?.emailAddress || user?.email_address);
+    }
     resolve();
   } catch (exception) {
     reject(`[verifyEmail] ${exception.message}`);

package/dist/app/cluster.js

@@ -0,0 +1,26 @@
+import cluster from "cluster";
+import os from "os";
+var cluster_default = (callback = null) => {
+  const cpus = os.cpus().length;
+  if (cluster.isMaster) {
+    for (let i = 0; i < cpus; i++) {
+      const worker = cluster.fork();
+      worker.on("message", (message) => {
+        if (process.send) {
+          process.send(message);
+        }
+      });
+      process.on("message", (message) => {
+        worker.send(message);
+      });
+    }
+    cluster.on("exit", (worker) => {
+      console.warn(`Worker ${worker.process.pid} died.`);
+    });
+  } else {
+    callback();
+  }
+};
+export {
+  cluster_default as default
+};

package/dist/app/databases/generate_sql_from_object.js

@@ -0,0 +1,60 @@
+var generate_sql_from_object_default = {
+  create_table: (options = {}) => {
+    const columns = Object.entries(options?.columns)?.map(([column_name, column_type]) => {
+      return `${column_name} ${column_type}`;
+    })?.join(",");
+    return {
+      statement: `CREATE TABLE IF NOT EXISTS ${options?.table} (${columns})`,
+      columns
+    };
+  },
+  add_column: (options = {}) => {
+    return {
+      statement: `ALTER TABLE ${options?.table} ADD COLUMN IF NOT EXISTS ${options?.column_name} ${options?.column_type}`
+    };
+  },
+  select: (options = {}) => {
+    const column_names = Array.isArray(options?.columns) ? options?.columns?.join(",") : "*";
+    const whereEntries = Object.entries(options?.where);
+    const where = whereEntries?.map(([key], index) => {
+      return `${key} = $${index + 1}`;
+    })?.join(",");
+    return {
+      statement: `SELECT ${column_names} FROM ${options?.table} ${options?.where ? `WHERE ${where}` : ""}`,
+      column_names,
+      where,
+      values: Object.values(options?.where)
+    };
+  },
+  insert: (options = {}) => {
+    const column_names = Object.keys(options?.data)?.join(",");
+    const value_placeholders = Object.keys(options?.data)?.map((_, index) => `$${index + 1}`)?.join(",");
+    return {
+      statement: `INSERT INTO ${options?.table} (${column_names}) VALUES (${value_placeholders})`,
+      column_names,
+      value_placeholders,
+      values: Object.values(options?.data)
+    };
+  },
+  update: (options = {}) => {
+    const whereEntries = Object.entries(options?.where);
+    const sets = Object.keys(options?.data).map((key, index) => {
+      return `${key} = $${whereEntries.length + index + 1}`;
+    })?.join(",");
+    const where = whereEntries?.map(([key], index) => {
+      return `${key} = $${index + 1}`;
+    })?.join(",");
+    return {
+      statement: `UPDATE ${options?.table} SET ${sets} WHERE ${where}`,
+      sets,
+      where,
+      values: [
+        ...Object.values(options?.where),
+        ...Object.values(options?.data)
+      ]
+    };
+  }
+};
+export {
+  generate_sql_from_object_default as default
+};

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

@@ -12,7 +12,7 @@ var buildConnectionString_default = (connection = {}) => {
     connectionString = `${connectionString}/${connection.database}`;
   }
   const queryParameters = buildQueryParameters(connection);
-  if (Object.keys(queryParameters)?.length > 0) {
+  if (Object.keys(queryParameters || {})?.length > 0) {
     connectionString = `${connectionString}?${serializeQueryParameters(queryParameters)}`;
   }
   return connectionString;

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

@@ -0,0 +1,18 @@
+const createIndex = async (collectionName = "", index = {}) => {
+  return process.databases._users?.collection(collectionName).createIndex(index);
+};
+var createAccountsIndexes_default = async () => {
+  await createIndex("users", { _id: 1 });
+  await createIndex("users", { emailAddress: 1 });
+  await createIndex("users", { username: 1 });
+  await createIndex("users", { "sessions.token": 1 });
+  await createIndex("users", { "passwordResetTokens.token": 1 });
+  await createIndex("users", { "passwordResetTokens.token": 1, _id: 1 });
+  await createIndex("users", { roles: 1 });
+  await createIndex("users", { roles: 1, _id: 1 });
+  await createIndex("roles", { role: 1 });
+  await createIndex("roles", { role: 1, userId: 1 });
+};
+export {
+  createAccountsIndexes_default as default
+};

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

@@ -0,0 +1,10 @@
+const createIndex = async (collectionName = "", index = {}, options = {}) => {
+  return process.databases._users?.collection(collectionName).createIndex(index, options);
+};
+var createSessionsIndexes_default = async () => {
+  await createIndex("sessions", { _id: 1 });
+  await createIndex("sessions", { createdAt: 1 }, { expireAfterSeconds: 3600 });
+};
+export {
+  createSessionsIndexes_default as default
+};

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

@@ -17,7 +17,7 @@ var mongodb_default = async (settings = {}, databasePort = 2610) => {
     const connectionOptions = {
       useNewUrlParser: true,
       useUnifiedTopology: true,
-      ssl: !process.env.NODE_ENV?.includes("development"),
+      ssl: !["development", "test"].includes(process.env.NODE_ENV),
       ...settings?.options || {}
     };
     if (settings?.options?.ca) {

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

@@ -1,5 +1,7 @@
 import generateId from "../../../../lib/generateId";
 import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc.js";
+dayjs.extend(utc);
 var accounts_default = {
   existingUser: async (input = {}) => {
     let existingUserWithEmailAddress;
@@ -35,6 +37,11 @@ var accounts_default = {
     }
     return null;
   },
+  deleteUser: async (input = {}) => {
+    return process.databases._users?.collection("users").deleteOne({
+      _id: input?.userId
+    });
+  },
   deleteOldSessions: async (input = {}) => {
     const user = await process.databases._users?.collection("users").findOne({
       _id: input?.userId
@@ -67,7 +74,7 @@ var accounts_default = {
     });
     return user;
   },
-  createVerifyEmailToken: async (input) => {
+  createEmailVerificationToken: async (input) => {
     const token = generateId();
     await process.databases._users?.collection("users").updateOne({
       _id: input?.userId