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

package/src/app/api/validate_input.js

@@ -0,0 +1,130 @@
+import get_value_from_object from './get_value_from_object.js';
+import input_validators from './input_validators.js';
+import is_array_path from './is_array_path.js';
+import types from '../../lib/types.js';
+
+export const handle_get_input_value = (
+  input = null,
+  path = '',
+  types_only_schema = false
+) => {
+  if (path && !types.is_string(path)) {
+    throw new Error('path must be passed as a string');
+  }
+
+  if (types_only_schema || (!types_only_schema && !types.is_object(input))) {
+    return input;
+  }
+
+  if (path.includes(".$.")) {
+    const [array_path] = path.split(".$.");
+    return get_value_from_object(input, array_path);
+  }
+
+  return get_value_from_object(input, path);
+};
+
+const get_array_path_key = (array_path = "") => {
+  if (!array_path) {
+    return '';
+  }
+
+  if (array_path && !types.is_string(array_path)) {
+    throw new Error('array_path must be a type of string');
+  }
+
+  const array_path_parts = array_path.split(".");
+
+  return array_path_parts.pop();
+};
+
+const add_validation_task = ({ queue, rules, input, path, types_only_schema }) => {
+  if (rules && rules.type === "object") {
+    queue = add_to_validation_queue(queue, rules.properties, input, path);
+  }
+
+  if (rules && rules.type === "array" && types.is_object(rules.element)) {
+    queue = add_to_validation_queue(queue, rules.element, input, `${path}.$`);
+  }
+
+  const path_to_value = is_array_path(path) ? get_array_path_key(path) : path;
+
+  return {
+    path,
+    rules,
+    input_value: handle_get_input_value(input, path_to_value, types_only_schema),
+  };
+};
+
+const add_to_validation_queue = (
+  queue = [],
+  schema = {},
+  input = {},
+  parent_path = ''
+) => {
+  // NOTE: If schema.type is present, we're forcing the schema for an array
+  // item that's not an object (see element rule in input_validators.js).
+
+  // const types_only_schema = !!schema.type; // if schema.type is present, this is true.
+  const types_only_schema = !!(schema.type && input_validators.types.includes(schema.type));
+
+  if (!types_only_schema) {
+  	const schema_definitions = Object.entries(schema || {});
+
+  	for (let i = 0; i < schema_definitions?.length; i += 1) {
+  		const [field, rules] = schema_definitions[i];
+      const validation_task = add_validation_task({
+        queue,
+        rules,
+        input,
+        path: field,
+        types_only_schema,
+      });
+
+      queue = [...queue, validation_task];
+  	}
+  }
+
+  if (types_only_schema) {
+    const validation_task = add_validation_task({
+      queue,
+      rules: schema,
+      input,
+      path: parent_path,
+      types_only_schema,
+    });
+
+    queue = [...queue, validation_task];
+  }
+
+  return queue;
+};
+
+const validate_input = async (input = {}, schema = {}, parent_path = '') => {
+	const validation_errors = [];
+	const queue = add_to_validation_queue([], schema, input, parent_path);
+
+	await Promise.all(queue.flatMap((validation_task) => {
+		return Object.entries(validation_task.rules || {}).flatMap(async ([rule_name, rule_value]) => {
+			const validator = input_validators.rules[rule_name];
+
+			if (validator && !validation_task.path.includes('.$.')) {
+				// NOTE: We pass validate_input as the final argument here so we can run
+				// validation on nested array and objects. This avoids creating a circular
+				// dependency error if we import validate_input into the input_validators file.
+				const result = await validator(rule_value, validation_task.input_value, validation_task.path, validate_input);
+
+				if (result && !result.valid) {
+					for (let i = 0; i < result.errors.length; i += 1) {
+						const error = result.errors[i];
+						validation_errors.push(error);
+					}
+				}
+			}
+		});
+	}));
+
+	return validation_errors;
+};
+
+export default validate_input;

package/src/app/api/validate_session.js

@@ -0,0 +1,20 @@
+import run_session_query from "../databases/queries/sessions.js";
+
+const validate_session = async (req = null, res = null) => {
+  const csrf_token = req?.headers['x-joystick-csrf'];
+  const session = await run_session_query('get_session', {
+    session_id: req?.cookies?.joystick_session,
+  });
+
+  if (csrf_token === 'joystick_test') {
+    return true;
+  }
+
+  if (!session || session && session.csrf !== csrf_token) {
+    return false;
+  }
+  
+  return true;
+};
+
+export default validate_session;

package/src/app/api/validate_type.js

@@ -0,0 +1,24 @@
+import types from "../../lib/types.js";
+
+const validate_type = (type, value) => {
+  switch (type) {
+    case "any":
+      return types.is_any(value);
+    case "array":
+      return types.is_array(value);
+    case "boolean":
+      return types.is_boolean(value);
+    case "float":
+      return types.is_float(value);
+    case "integer":
+      return types.is_integer(value);
+    case "number":
+      return types.is_number(value);
+    case "object":
+      return types.is_object(value);
+    case "string":
+      return types.is_string(value);
+  }
+};
+
+export default validate_type;

package/src/app/browser/hmr_client.js

@@ -0,0 +1,196 @@
+let reconnect_interval = null;
+let reconnect_attempts = 0;
+
+const websocket_client = (options = {}, on_connect = null) => {
+  let client = new WebSocket(
+    `ws://localhost:${window.__joystick_hmr_port__}/_joystick/hmr?${new URLSearchParams(options.query).toString()}`
+  );
+
+  if (reconnect_interval) {
+    clearInterval(reconnect_interval);
+    reconnect_interval = null;
+  }
+
+  const connection = {
+    client,
+    send: (message = {}) => {
+      if (options.queryParams) {
+        message = { ...message, ...options.queryParams };
+      }
+
+      return client.send(JSON.stringify(message));
+    },
+  };
+
+  client.addEventListener("open", () => {
+    console.log(`[hmr] Listening for changes...`);
+    reconnect_attempts = 0;
+    if (on_connect) on_connect(connection);
+  });
+
+  client.addEventListener("message", (event) => {
+    if (event?.data && options.onMessage) {
+      options.onMessage(JSON.parse(event.data), connection);
+    }
+  });
+
+  client.addEventListener("close", () => {
+    console.log(`[hmr] Disconnected from server.`);
+
+    client = null;
+
+    if (options.autoReconnect && !reconnect_interval) {
+      reconnect_interval = setInterval(() => {
+        client = null;
+
+        // NOTE: 12 attempts === try to reconnect for up to 1 minute (12 * 5 seconds between each attempt).
+        if (reconnect_attempts < 12) {
+          websocket_client(options, on_connect);
+
+          console.log(
+            `[hmr] Attempting to reconnect (${reconnect_attempts + 1}/12)...`
+          );
+
+          reconnect_attempts += 1;
+        } else {
+          console.log(
+            `[hmr] Reconnection attempts exhausted. Server is unavailable.`
+          );
+          clearInterval(reconnect_interval);
+        }
+      }, 5000);
+    }
+  });
+
+  return connection;
+};
+
+const remount_standalone_page = async () => {
+	const page_component_file = await import_page_component();
+
+	window.joystick.mount(
+	  page_component_file,
+	  Object.assign({}, window.__joystick_ssr_props__),
+	  document.getElementById("app")
+	);
+};
+
+const import_page_component = async () => {
+	const page_component_file = await import(`${window.__joystick_page_url__}?v=${new Date().getTime()}`).catch((error) => {
+	  // NOTE: If this fails, the file was likely deleted or renamed. Trigger a full reload
+	  // so the developer is aware.
+	  location.reload();
+	});
+
+	return page_component_file?.default;
+};
+
+const import_layout_component = async () => {
+	const layout_component_file = await import(`${window.__joystick_layout_url__}?v=${new Date().getTime()}`).catch((error) => {
+	  // NOTE: If this fails, the file was likely deleted or renamed. Trigger a full reload
+	  // so the developer is aware.
+	  location.reload();
+	});
+
+	return layout_component_file?.default;
+};
+
+const remount_page_in_layout = async () => {
+	const layout_component_file = await import_layout_component();
+	const page_component_file = await import_page_component();
+
+	window.joystick.mount(
+	  layout_component_file,
+	  Object.assign({ page: page_component_file }, window.__joystick_ssr_props__),
+	  document.getElementById("app")
+	);
+};
+
+const update_index_css = (joystick_index_css) => {
+	const updated_css = document.createElement("link");
+
+	updated_css.setAttribute("rel", "stylesheet");
+	updated_css.setAttribute("href", `/_joystick/index.css`);
+
+	document.head.replaceChild(updated_css, joystick_index_css);
+};
+
+const update_index_client_js = (joystick_index_client_js = {}) => {
+  const updated_index_client_js = document.createElement("script");
+
+  updated_index_client_js.setAttribute("type", "text/javascript");
+  updated_index_client_js.setAttribute(
+    "src",
+    `/_joystick/index.client.js`
+  );
+
+  joystick_index_client_js.parentNode.replaceChild(updated_index_client_js, joystick_index_client_js);
+};
+
+const hmr_client = (() =>
+  websocket_client({
+    autoReconnect: true,
+    query: {
+      user_language: window?.__joystick_user__?.language || '',
+      browser_language: navigator?.language || '',
+      page_component_path: window.__joystick_page_url__?.replace('/_joystick/', ''),
+    },
+    onMessage: async (message = {}, websocket_client_connection = {}) => {
+      const is_build_error = message && message.type && message.type === "BUILD_ERROR";
+
+      if (is_build_error) {
+        return location.reload();
+      }
+
+      // NOTE: Set this to disable the auto mount code in layouts/pages when
+      // working in an HMR/development context.
+      window.__joystick_hmr_update__ = true;
+      window.__joystick_hmr_previous_tree__ = [...(window.joystick._internal.tree || [])];
+      window.__joystick_hmr_previous_websockets__ = [...(window.joystick._internal.websockets || [])];
+
+      const previous_window_position = Object.assign({}, { scrollTop: window.scrollY });
+
+      const is_file_change = message && message.type && message.type === "FILE_CHANGE";
+      const is_page_in_layout = !!window.__joystick_layout_url__ && !!window.__joystick_page_url__;
+      const joystick_index_css = document.head.querySelector('link[href="/_joystick/index.css"]');
+      const joystick_index_client_js = document.body.querySelector('script[src="/_joystick/index.client.js"]');
+
+      if (message?.index_html_changed) {
+        location.reload();
+      }
+
+      if (message?.i18n) {
+        window.__joystick_i18n__ = message?.i18n;
+      }
+
+      if (message?.settings) {
+        window.__joystick_settings__ = message?.settings;
+        window.joystick.settings = message?.settings;
+      }
+
+      if (joystick_index_client_js && message?.index_client_changed) {
+      	update_index_client_js(joystick_index_client_js);
+      }
+
+      if (joystick_index_css && message?.index_css_changed) {
+      	update_index_css(joystick_index_css);
+      }
+
+      if (is_file_change && is_page_in_layout) {
+        remount_page_in_layout(websocket_client_connection);
+      }
+
+      if (is_file_change && !is_page_in_layout) {
+        remount_standalone_page(websocket_client_connection);
+      }
+
+      // NOTE: Set scroll back to what it was before the HMR update.
+      window.scrollTo(0, previous_window_position.scrollTop);
+
+      if (websocket_client_connection.send) {
+        websocket_client_connection.send({ type: "HMR_UPDATE_COMPLETE" });
+      }
+    },
+  }))();
+
+export default hmr_client;

package/src/app/browser/process_polyfill.js

@@ -0,0 +1,11 @@
+import process from "process/browser";
+
+window.process = process;
+
+const env = {
+  NODE_ENV: "${NODE_ENV}",
+};
+
+if (window.process) {
+  window.process.env = env;
+}

package/src/app/cron_jobs/register.js

@@ -0,0 +1,29 @@
+import cron from 'node-cron';
+import types from "../../lib/types.js";
+
+const register = (cron_jobs = {}) => {
+  if (types.is_object(cron_jobs)) {
+    const cron_job_definitions = Object.entries(cron_jobs || {});
+    for (let i = 0; i < cron_job_definitions.length; i += 1) {
+      const [cron_job_name, cron_job_options] = cron_job_definitions[i];
+      if (cron_job_options?.schedule && cron_job_options?.run && types.is_function(cron_job_options?.run)
+      ) {
+        process.cron = {
+          ...(process.queues || {}),
+          [cron_job_name]: cron.schedule(cron_job_options?.schedule, () => {
+            if (
+              (cron_job_options?.logAtRunTime && types.is_string(cron_job_options?.logAtRunTime)) ||
+              (cron_job_options?.log_at_run_time && types.is_string(cron_job_options?.log_at_run_time))
+            ) {
+              console.log(cron_job_options.logAtRunTime || cron_job_options?.log_at_run_time);
+            }
+
+            cron_job_options.run();
+          }),
+        };
+      }
+    }
+  }
+};
+
+export default register;

package/src/app/databases/database_type_map.js

@@ -0,0 +1,6 @@
+const database_type_map = {
+	mongodb: 'nosql',
+	postgresql: 'sql',
+};
+
+export default database_type_map;

package/src/app/databases/get_target_database_connection.js

@@ -0,0 +1,25 @@
+import load_settings from "../settings/load.js";
+
+const get_target_database_connection = (database_type = 'users') => {
+  const settings = load_settings();
+  const databases = settings?.config?.databases || [];
+  const target_database_index = databases.findIndex((database) => !!database[database_type]);
+  const target_database_in_settings = databases[target_database_index];
+  
+  if (!target_database_in_settings) {
+    return null;
+  }
+  
+  const has_multiple_of_provider = (databases?.filter((database) => database?.provider === target_database_in_settings?.provider))?.length > 1;
+  const database_port = (parseInt(process.env.PORT, 10) + 10) + target_database_index;
+  
+  return {
+    database_type,
+    provider: target_database_in_settings?.provider,
+    connection: !has_multiple_of_provider ?
+      process.databases[target_database_in_settings?.provider] :
+      process.databases[target_database_in_settings?.provider][target_database_in_settings?.name || `${target_database_in_settings?.provider}_${database_port}`],
+  };
+};
+
+export default get_target_database_connection;

package/{dist/app/databases/mongodb/availableQueryParameters.js → src/app/databases/mongodb/available_query_parameters.js}

@@ -1,4 +1,4 @@
-var availableQueryParameters_default = [
+const available_query_parameters = [
   "replicaSet",
   "tls",
   "ssl",
@@ -37,6 +37,5 @@ var availableQueryParameters_default = [
   "retryWrites",
   "uuidRepresentation"
 ];
-export {
-  availableQueryParameters_default as default
-};
+
+export default available_query_parameters;

package/src/app/databases/mongodb/build_connection_string.js

@@ -0,0 +1,30 @@
+import build_query_parameters from "./build_query_parameters.js";
+import serialize_query_parameters from "../../../lib/serialize_query_parameters.js";
+
+const build_connection_string = (connection = {}) => {
+  let connection_string = "mongodb://";
+
+  if (connection && (connection.username || connection.password)) {
+    connection_string = `${connection_string}${connection.username || connection.password ? `${connection.username || ""}${!!connection.username && !!connection.password ? ':' : ''}${connection.password || ""}@` : ''}`;
+  }
+
+  if (connection && connection.hosts && Array.isArray(connection.hosts)) {
+    connection_string = `${connection_string}${connection.hosts
+      .map((host) => `${host.hostname}:${host.port}`)
+      .join(",")}`;
+  }
+
+  if (connection && connection.database) {
+    connection_string = `${connection_string}/${connection.database}`;
+  }
+
+  const query_parameters = build_query_parameters(connection);
+
+  if (Object.keys(query_parameters || {})?.length > 0 ) {
+    connection_string = `${connection_string}?${serialize_query_parameters(query_parameters)}`;
+  }
+
+  return connection_string;
+};
+
+export default build_connection_string;

package/src/app/databases/mongodb/build_query_parameters.js

@@ -0,0 +1,17 @@
+import available_query_parameters from "./available_query_parameters.js";
+
+const build_query_parameters = (connection = {}) => {
+  const query_parameters = {};
+
+  for (let i = 0; i < available_query_parameters.length; i += 1) {
+    const available_parameter = available_query_parameters[i];
+
+    if (connection && connection[available_parameter]) {
+      query_parameters[available_parameter] = connection[available_parameter];
+    }
+  }
+
+  return query_parameters;
+};
+
+export default build_query_parameters;

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

@@ -0,0 +1,42 @@
+import chalk from "chalk";
+import fs from 'fs';
+import { MongoClient } from "mongodb";
+import mongo_uri from "mongo-uri-tool";
+import build_connection_string from "./build_connection_string.js";
+
+const connect_mongodb = async (database_settings = {}, database_port = 2610) => {
+  try {
+    const connection = database_settings?.connection || {
+      hosts: [
+        { hostname: "127.0.0.1", port: database_port },
+      ],
+      database: "app",
+      replicaSet: `joystick_${database_port}`,
+    };
+
+    const connection_string = build_connection_string(connection);
+    const parsed_uri = mongo_uri.parseUri(connection_string);
+
+    const connection_options = {
+      ssl: !['development', 'test'].includes(process.env.NODE_ENV),
+      ...(database_settings?.options || {})
+    };
+
+    if (database_settings?.options?.ca) {
+      connection_options.ca = fs.readFileSync(database_settings?.options?.ca);
+    }
+
+    const client = await MongoClient.connect(connection_string, connection_options);
+    const db = client.db(parsed_uri.db);
+
+    return Promise.resolve(db);
+  } catch (exception) {
+    console.warn(
+      chalk.yellowBright(
+        `\nFailed to connect to MongoDB. Please double-check connection settings and try again.\n\nError from MongoDB:\n\n${chalk.redBright(exception?.message)}`
+      ),
+    );
+  }
+};
+
+export default connect_mongodb;

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

@@ -0,0 +1,35 @@
+import types from "../../../lib/types.js";
+
+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 process.databases._sessions?.collection('sessions').createIndex('sessions', { _id: 1 });
+	  await process.databases._sessions?.collection('sessions').createIndex('sessions', { createdAt: 1 }, { expireAfterSeconds: 3600 });
+	},
+	users: async () => {
+	  // Users
+	  await process.databases._users?.collection('users').createIndex({ _id: 1 });
+	  await process.databases._users?.collection('users').createIndex({ emailAddress: 1 });
+	  await process.databases._users?.collection('users').createIndex({ username: 1 });
+	  await process.databases._users?.collection('users').createIndex({ 'sessions.token': 1 });
+	  await process.databases._users?.collection('users').createIndex({ 'passwordResetTokens.token': 1 });
+	  await process.databases._users?.collection('users').createIndex({ 'passwordResetTokens.token': 1, _id: 1 });
+	  await process.databases._users?.collection('users').createIndex({ roles: 1 });
+	  await process.databases._users?.collection('users').createIndex({ roles: 1, _id: 1 });
+	  await process.databases._users?.collection('roles').createIndex({ role: 1 });
+	  await process.databases._users?.collection('roles').createIndex({ role: 1, userId: 1 });
+	},
+};
+
+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/accounts/create_accounts_metadata_table_columns.js

@@ -0,0 +1,18 @@
+import escape from 'pg-escape';
+
+const create_accounts_metadata_table_columns = async (users_database = '', sqlized_metadata = {}) => {
+  if (users_database === 'postgresql') {
+    const columns = Object.keys(sqlized_metadata || {});
+    
+    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 default create_accounts_metadata_table_columns;