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

package/src/app/databases/postgresql/connect.js

@@ -0,0 +1,128 @@
+import chalk from "chalk";
+import fs from 'fs';
+import os from 'os';
+import postgresql from 'pg';
+import sql from '../sql.js';
+
+const { Pool } = postgresql;
+
+const connect_postgresql = async (database_settings = {}, database_port = 2610) => {
+  const connection = database_settings?.connection || {
+    hosts: [
+      { hostname: "127.0.0.1", port: database_port },
+    ],
+    database: "app",
+    // NOTE: PostgreSQL creates a default superuser based on the OS username.
+    username: (os.userInfo() || {}).username || "",
+    password: "",
+  };
+
+  try {
+    const host = connection.hosts && connection.hosts[0];
+    const connection_config = {
+      user: connection?.username || '',
+      database: connection?.database,
+      password: connection?.password || '',
+      host: host?.hostname,
+      port: host?.port,
+      ...(database_settings?.options || {})
+    };
+    
+    if (database_settings?.options?.ssl?.ca) {
+      connection_config.ssl = {
+        ca: fs.readFileSync(database_settings?.options?.ssl?.ca),
+      };
+    }
+
+    const pool = new Pool(connection_config);
+  
+    return {
+      pool,
+      query: (...args) => {
+        return pool.query(...args).then((response) => {
+          return response?.rows || [];
+        }).catch((error) => {
+          console.log(chalk.redBright(`\nFailed SQL Statement:\n`));
+          console.log(args[0]);
+          console.log(`\n`);
+          console.log(chalk.redBright(`\nFailed Values:\n`));
+          console.log(args[1]);
+
+          throw error;
+        });
+      },
+      add_column: (options = {}) => {
+        const column = sql.add_column(options);
+        return pool.query(column.statement).then((response) => {
+          return response?.rows || [];
+        }).catch((error) => {
+          console.log(chalk.redBright(`\nFailed SQL Statement:\n`));
+          console.log(column.statement);
+
+          throw error;
+        });
+      },
+      create_table: (options = {}) => {
+        const table = sql.create_table(options);
+        return pool.query(table.statement).then((response) => {
+          return response?.rows || [];
+        }).catch((error) => {
+          console.log(chalk.redBright(`\nFailed SQL Statement:\n`));
+          console.log(table.statement);
+
+          throw error;
+        });
+      },
+      insert: (options = {}) => {
+        const insert = sql.insert(options);
+        return pool.query(insert.statement, insert.values).then((response) => {
+          return response?.rows || [];
+        }).catch((error) => {
+          console.log(chalk.redBright(`\nFailed SQL Statement:\n`));
+          console.log(insert.statement);
+          console.log(`\n`);
+          console.log(chalk.redBright(`\nFailed Values:\n`));
+          console.log(insert.values);
+
+          throw error;
+        });
+      },
+      select: (options = {}) => {
+        const select = sql.select(options);
+        return pool.query(select.statement, select.values).then((response) => {
+          return response?.rows || [];
+        }).catch((error) => {
+          console.log(chalk.redBright(`\nFailed SQL Statement:\n`));
+          console.log(select.statement);
+          console.log(`\n`);
+          console.log(chalk.redBright(`\nFailed Values:\n`));
+          console.log(select.where);
+
+          throw error;
+        });
+      },
+      update: (options = {}) => {
+        const update = sql.update(options);
+        return pool.query(update.statement, update.values).then((response) => {
+          return response?.rows || [];
+        }).catch((error) => {
+          console.log(chalk.redBright(`\nFailed SQL Statement:\n`));
+          console.log(update.statement);
+          console.log(`\n`);
+          console.log(chalk.redBright(`\nFailed Values:\n`));
+          console.log(update.values);
+
+          throw error;
+        });
+      },
+    };
+  } catch (exception) {
+    console.warn(
+      chalk.yellowBright(
+        `\nFailed to connect to PostgreSQL. Please double-check connection settings and try again.\n\nError from PostgreSQL:\n\n${chalk.redBright(exception?.message)}`
+      ),
+    );
+  }
+};
+
+export default connect_postgresql;

package/src/app/databases/postgresql/create_indexes.js

@@ -0,0 +1,58 @@
+import cron from 'node-cron';
+import types from "../../../lib/types.js";
+import handle_cleanup_sessions from "./handle_cleanup_sessions.js";
+
+const create_unique_index = async (target_database = '', index_name = '', table_name = '', table_columns = []) => {
+  return process.databases[target_database]?.query(`CREATE UNIQUE INDEX IF NOT EXISTS ${index_name} ON ${table_name}(${table_columns.join(', ')})`);
+};
+
+const create_index = async (target_database = '', index_name = '', table_name = '', table_columns = []) => {
+  return process.databases[target_database]?.query(`CREATE INDEX IF NOT EXISTS ${index_name} ON ${table_name}(${table_columns.join(', ')})`);
+};
+
+const indexes = {
+	// NOTE: queue indexes are set dynamically when initializing the queue in
+	// app/databases/queries/<provider>/queues.js initialize_database function
+	// to account for developer customization options.
+	sessions: async () => {
+	  await create_index('_sessions', 'session_by_id', 'sessions', ['session_id']);
+	  await create_index('_sessions', 'session_created_at', 'sessions', ['created_at']);
+
+	  // NOTE: Simulate a TTL index using cron to wipe out sessions older than 1 hour.
+    cron.schedule('*/30 * * * * *', () => {
+      handle_cleanup_sessions();
+    });
+	},
+	users: async () => {
+	  // users
+	  await create_index('_users', 'user_by_email', 'users', ['email_address']);
+	  await create_index('_users', 'user_by_username', 'users', ['username']);
+	  await create_index('_users', 'user_by_user_id', 'users', ['user_id']);
+	  
+	  // users_sessions
+	  await create_index('user_session_by_token', 'users_sessions', ['token']);
+
+	  // users_password_reset_tokens
+	  await create_index('_users', 'user_password_reset_token_by_token', 'users_password_reset_tokens', ['token']);
+	  await create_index('_users', 'user_password_reset_token_by_user_id_token', 'users_password_reset_tokens', ['user_id', 'token']);
+	 
+	  // users_roles
+	  await create_index('_users', 'user_role', 'users_roles', ['role']);
+	  await create_index('_users', 'user_roles_by_user_id_role', 'users_roles', ['user_id', 'role']);
+	  
+	  // roles
+	  await create_index('_users', 'role', 'roles', ['role']);
+	  await create_unique_index('_users', 'user_roles', 'users_roles', ['user_id', 'role']);
+	},
+};
+
+const create_indexes = async (database_types_to_index = []) => {
+	for (let i = 0; i < database_types_to_index?.length; i += 1) {
+		const database_type = database_types_to_index[i];
+		if (types.is_function(indexes[database_type])) {
+			await indexes[database_type]();
+		}
+	}
+};
+
+export default create_indexes;

package/src/app/databases/postgresql/create_tables.js

@@ -0,0 +1,70 @@
+import types from "../../../lib/types.js";
+
+const create_table = (target_database = '', table_name = '', table_columns = []) => {
+  return process.databases[target_database]?.query(
+    `CREATE TABLE IF NOT EXISTS ${table_name} (${table_columns.join(", ")})`
+  );
+};
+
+const tables = {
+	// NOTE: queue tables are created dynamically when initializing the queue in
+	// app/databases/queries/<provider>/queues.js initialize_database function
+	// to account for dynamic table names.
+	sessions: async () => {
+	  await create_table('_sessions', 'sessions', [
+	    'id bigserial primary key',
+	    'session_id text',
+	    'csrf text',
+	    'created_at text'
+	  ]);
+	},
+	users: async () => {
+	  await create_table('_users', 'users', [
+	    'id bigserial primary key',
+	    'user_id text',
+	    'email_address text',
+	    'password text',
+	    'username text',
+	    'language text',
+	  ]);
+
+	  await create_table('_users', 'users_sessions', [
+	    'id bigserial primary key',
+	    'user_id text',
+	    'token text',
+	    'token_expires_at text',
+	  ]);
+
+	  await create_table('_users', 'users_password_reset_tokens', [
+	    'id bigserial primary key',
+	    'user_id text',
+	    'token text',
+	    'requested_at text',
+	  ]);
+
+	  await create_table('_users', 'users_verify_email_tokens', [
+	    'id bigserial primary key',
+	    'user_id text',
+	    'token text',
+	  ]);
+
+	  await create_table('_users', 'roles', ['id bigserial primary key', 'role text']);
+
+	  await create_table('_users', 'users_roles', [
+	    'id bigserial primary key',
+	    'user_id text',
+	    'role text',
+	  ]);
+	},
+};
+
+const create_tables = async (database_types_to_index = []) => {
+	for (let i = 0; i < database_types_to_index?.length; i += 1) {
+		const database_type = database_types_to_index[i];
+		if (types.is_function(tables[database_type])) {
+			await tables[database_type]();
+		}
+	}
+};
+
+export default create_tables;

package/src/app/databases/postgresql/handle_cleanup_queues.js

@@ -0,0 +1,36 @@
+import timestamps from "../../../lib/timestamps.js";
+
+const handle_cleanup_queues = async ({
+  database = {},
+  table = '',
+  seconds = 0,
+}) => {
+	const jobs_with_status = await database.query(`
+		SELECT * FROM ${table} WHERE status = ANY($1) AND environment = $2
+	`, [
+		['completed', 'failed'],
+		process.env.NODE_ENV,
+	]);
+
+	const jobs_to_cleanup = jobs_with_status?.filter((job = {}) => {
+		if (job?.status === 'completed') {
+			const completed_at_with_seconds = timestamps.get_future_time('seconds', seconds, { start_from: job?.completed_at });
+			return completed_at_with_seconds <= timestamps.get_current_time();
+		}
+
+		if (job?.status === 'failed') {
+			const failed_at_with_seconds = timestamps.get_future_time('seconds', seconds, { start_from: job?.failed_at });
+			return failed_at_with_seconds <= timestamps.get_current_time();
+		}
+
+		return false;
+	});
+
+	await database.query(`
+		DELETE FROM ${table} WHERE _id = ANY($1)
+	`, [
+		jobs_to_cleanup?.map(({ _id }) => _id)
+	]);
+};
+
+export default handle_cleanup_queues;

package/src/app/databases/postgresql/handle_cleanup_sessions.js

@@ -0,0 +1,5 @@
+const handle_cleanup_sessions = async () => {
+	await process.databases._sessions.query(`DELETE FROM sessions where created_at::timestamp <= timezone('utc', now() - interval '1 hour')`);
+};
+
+export default handle_cleanup_sessions;

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

@@ -0,0 +1,17 @@
+import get_target_database_connection from "../get_target_database_connection.js";
+import query_map from "./map.js";
+
+const accounts_query = async (query_name = "", inputs = {}) => {
+  const users_database = get_target_database_connection('users');
+  const query_map_for_database = users_database && query_map && query_map[users_database?.provider] && query_map[users_database?.provider]?.accounts;
+  const query = query_map_for_database && query_map_for_database[query_name];
+
+  if (users_database?.connection && query) {
+    const response = await query_map_for_database[query_name](inputs, users_database?.connection);
+    return Promise.resolve(response);
+  }
+
+  return null;
+};
+
+export default accounts_query;

package/src/app/databases/queries/map.js

@@ -0,0 +1,21 @@
+import mongodb_accounts_queries from './mongodb/accounts.js';
+import mongodb_queues_queries from './mongodb/queues.js';
+import mongodb_sessions_queries from './mongodb/sessions.js';
+import postgresql_accounts_queries from './postgresql/accounts.js';
+import postgresql_queues_queries from './postgresql/queues.js';
+import postgresql_sessions_queries from './postgresql/sessions.js';
+
+const map = {
+  mongodb: {
+    accounts: mongodb_accounts_queries,
+    queues: mongodb_queues_queries,
+    sessions: mongodb_sessions_queries,
+  },
+  postgresql: {
+    accounts: postgresql_accounts_queries,
+    queues: postgresql_queues_queries,
+    sessions: postgresql_sessions_queries,
+  },
+};
+
+export default map;

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

@@ -0,0 +1,360 @@
+import generate_id from "../../../../lib/generate_id.js";
+
+const accounts = {
+	add_password_reset_token: (input = {}) => {
+    return process.databases._users?.collection("users").updateOne({
+      emailAddress: input.email_address,
+    }, {
+      $addToSet: {
+        passwordResetTokens: {
+          token: input.token,
+          requestedAt: new Date().toISOString(),
+        },
+      },
+    });
+  },
+  add_role: async (input = {}) => {
+    const existing_role = input?.role
+      ? await process.databases._users?.collection("roles").findOne({ role: input?.role })
+      : null;
+
+    if (!existing_role && input?.role) {
+      await process.databases._users?.collection("roles").insertOne({
+        _id: generate_id(16),
+        role: 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?.collection("users").updateOne({
+      _id: input.user_id,
+    }, {
+      $addToSet: {
+        sessions: input.session,
+      },
+    });
+  },
+  create_email_verification_token: async (input = {}) => {
+    const token = generate_id(16);
+
+    await process.databases._users?.collection("users").updateOne({
+      _id: input?.user_id,
+    }, {
+      $addToSet: {
+        verifyEmailTokens: {
+          userId: input?.user_id,
+          token,
+        },
+      },
+    });
+
+    return token;
+  },
+  create_user: async (input = {}) => {
+    const user_id = generate_id(16);
+    await process.databases._users?.collection("users").insertOne({
+      _id: user_id,
+      ...input,
+      sessions: [],
+    });
+
+    return user_id;
+  },
+  delete_old_sessions: async (input = {}) => {
+    const user = await process.databases._users?.collection('users').findOne({
+      _id: input?.user_id,
+    });
+
+    if (user) {
+      const sessions = user?.sessions?.filter((session) => {
+        // NOTE: If tokenExpiresAt is after today, it hasn't expired yet, so keep it.
+        return new Date(session?.tokenExpiresAt || session?.token_expires_at).toISOString() > new Date().toISOString();
+      });
+
+      await process.databases._users?.collection("users").updateOne({
+        _id: input.user_id,
+      }, {
+        $set: {
+          sessions,
+        },
+      });
+    }
+  },
+  delete_user: async (input = {}) => {
+    return process.databases._users?.collection('users').deleteOne({
+      _id: input?.user_id,
+    });
+  },
+  existing_user: async (input = {}) => {
+    let existing_user_with_email_address;
+    let existing_user_with_username;
+
+    if (input?.email_address) {
+      existing_user_with_email_address = await process.databases._users?.collection("users").findOne({ emailAddress: input.email_address });
+    }
+
+    if (input?.username) {
+      existing_user_with_username = await process.databases._users?.collection("users").findOne({ username: input.username });
+    }
+
+    return existing_user_with_email_address || existing_user_with_username ? {
+      existing_email_address: existing_user_with_email_address?.emailAddress,
+      existing_username: existing_user_with_username?.username,
+    } : null;
+  },
+  get_existing_session: async (input = {}) => {
+    const user = await process.databases._users?.collection("users").findOne({ _id: input?.user_id });
+
+    if (user?.sessions?.length > 0) {
+      const sessions_by_last_to_expire = user?.sessions.sort((a, b) => {
+        return (a.tokenExpiresAt || a.token_expires_at) > (b.tokenExpiresAt || b.token_expires_at) ? -1 : 1;
+      });
+
+      return sessions_by_last_to_expire.shift();
+    }
+
+    return null;
+  },
+  get_password_reset_token: async (input = {}) => {
+    const user = await process.databases._users?.collection("users").findOne({ _id: input?.user_id });
+
+    if (user) {
+      return user?.passwordResetTokens && user?.passwordResetTokens[0]?.token || null;
+    }
+
+    return null;
+  },
+  grant_role: async (input = {}) => {
+    const user = await process.databases._users?.collection("users").findOne({ _id: input?.user_id });
+
+    if (user) {
+      await process.databases._users?.collection("users").updateOne({
+      	_id: input?.user_id
+      }, {
+        $addToSet: {
+          roles: input?.role,
+        },
+      });
+
+      const existing_role = await process.databases._users?.collection("roles").findOne({ role: input?.role });
+
+      if (!existing_role) {
+        await process.databases._users?.collection("roles").insertOne({
+          _id: generate_id(16),
+          role: 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?.collection("roles").find().toArray();
+    return (roles || []).map(({ role }) => role);
+  },
+  mark_email_verified_at: async (input = {}) => {
+    const user = await process.databases._users?.collection("users").findOne({
+      _id: input?.user_id,
+    });
+
+    await process.databases._users?.collection("users").updateOne({
+      _id: input?.user_id,
+    }, {
+      $set: {
+        emailVerified: true,
+        emailVerifiedAt: new Date().toISOString(),
+        verifyEmailTokens: user?.verifyEmailTokens?.filter(
+          (verify_email_token) => {
+            return verify_email_token?.token === input?.token;
+          }
+        ),
+      },
+    });
+
+    return true;
+  },
+  remove_reset_token: async (input = {}) => {
+    const user = await process.databases._users?.collection("users").findOne({ _id: input?.user_id });
+
+    await process.databases._users?.collection("users").updateOne({
+      _id: input?.user_id,
+    }, {
+      $set: {
+        passwordResetTokens: user?.passwordResetTokens?.filter(
+          ({ token }) => {
+            return token !== input?.token;
+          }
+        ),
+      },
+    });
+
+    return process.databases._users?.collection("users").findOne({ _id: input?.user_id });
+  },
+  remove_role: async (input = {}) => {
+    const existing_role = input?.role
+      ? await process.databases._users?.collection("roles").findOne({ role: input?.role })
+      : null;
+
+    if (existing_role) {
+      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?.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 = {}) => {
+    const user = await process.databases._users?.collection('users').findOne({
+      _id: input?.user_id,
+    });
+
+    if (user) {
+      await process.databases._users?.collection("users").updateOne({
+        _id: input.user_id,
+      }, {
+        $set: {
+          sessions: [],
+        },
+      });
+    }
+  },
+  revoke_role: async (input = {}) => {
+    const user = await process.databases._users?.collection("users").findOne({ _id: input?.user_id });
+    if (user && user.roles) {
+      await process.databases._users?.collection("users").updateOne({
+      	_id: input?.user_id
+      }, {
+        $pull: {
+          roles: 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 = {}) => {
+    return process.databases._users?.collection("users").updateOne({
+      _id: input?.user_id,
+    }, {
+      $set: {
+        password: input?.hashed_password,
+      },
+    });
+  },
+  user: async (input = {}) => {
+    if (input?.email_address) {
+      const user = await process.databases._users?.collection("users").findOne({ emailAddress: input.email_address });
+      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;
+  },
+  user_has_role: async (input = {}) => {
+    const user = await process.databases._users?.collection("users").findOne({ _id: input?.user_id });
+
+    if (user && user.roles) {
+      return user?.roles?.includes(input?.role);
+    }
+
+    return false;
+  },
+  user_with_login_token: async (input = {}) => {
+    const user = await process.databases._users?.collection("users").findOne({
+      "sessions.token": input?.token,
+    });
+
+    return user;
+  },
+  user_with_reset_token: async (input = {}) => {
+    const user = await process.databases._users?.collection("users").findOne({
+      "passwordResetTokens.token": input["passwordResetTokens.token"],
+    });
+    
+    return user;
+  },
+  user_with_verify_email_token: async (input = {}) => {
+    const user = await process.databases._users?.collection("users").findOne({
+      "verifyEmailTokens.token": input?.token,
+    });
+
+    return user;
+  },
+};
+
+export default accounts;