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

package/src/app/api/input_validators.js

@@ -0,0 +1,227 @@
+import types from '../../lib/types.js';
+import validate_type from "./validate_type.js";
+import is_array_path from "./is_array_path.js";
+
+const allowed_values = (rule_value, input_value, parent_path) => {
+  const isValid = rule_value.includes(input_value);
+
+  if (!isValid) {
+    return {
+      valid: false,
+      errors: [
+        `Field ${parent_path} only allows the following values: ${rule_value.join(
+          ", "
+        )}.`,
+      ],
+    };
+  }
+
+  return {
+    valid: true,
+    errors: [],
+  };
+};
+
+const max_length = (rule_value, input_value, parent_path) => {
+  const valid = types.is_array(input_value) && input_value?.length <= rule_value;
+
+  if (!valid) {
+    return {
+      valid: false,
+      errors: [
+        `Field ${parent_path} length must be less than or equal to ${rule_value}.`,
+      ],
+    };
+  }
+
+  return {
+    valid: true,
+    errors: [],
+  };
+};
+
+const min_length = (rule_value, input_value, parent_path) => {
+  const valid = types.is_array(input_value) && input_value?.length >= rule_value;
+
+  if (!valid) {
+    return {
+      valid: false,
+      errors: [
+        `Field ${parent_path} length must be greater than or equal to ${rule_value}.`,
+      ],
+    };
+  }
+
+  return {
+    valid: true,
+    errors: [],
+  };
+};
+
+const input_validators = {
+  types: [
+	  "any",
+	  "array",
+	  "boolean",
+	  "float",
+	  "integer",
+	  "number",
+	  "object",
+	  "string",
+	],
+  rules: {
+    allowed_values,
+    allowedValues: allowed_values,
+    element: async (rule_value, input_value, parent_path, validate_input) => {
+      // NOTE: Allow for element to be passed as a type string so you can do arrays of single
+      // primitive elements (e.g., ['a', 'b', 'c'] or [1, 2, 3]).
+
+      if (
+        input_value &&
+        (types.is_object(rule_value) || types.is_string(rule_value)) &&
+        types.is_array(input_value)
+      ) {
+        // NOTE: Usage of .flatMap may seem excessive here but it's required because we're
+        // doing recursive calls to validate_input of n depth. Each call returns
+        // an array which means on complex nested schemas, we get back arrays of arrays of
+        // error strings when really we just want one flat array for the full tree.
+        const element_errors = await Promise.all(
+          input_value.flatMap(async (element, element_index) => {
+            const errors = await validate_input(
+              element,
+              types.is_string(rule_value) ? { type: rule_value } : rule_value,
+              `${parent_path}.${element_index}`
+            );
+
+            return errors.flatMap((error) => error);
+          })
+        );
+
+        return {
+          valid: element_errors.length === 0,
+          errors: element_errors.flatMap((element_error) => element_error),
+        };
+      }
+
+      return {
+        valid: true,
+        errors: [],
+      };
+    },
+    fields: async (rule_value, input_value, parent_path, validate_input) => {
+      if (types.is_object(rule_value) && types.is_object(input_value)) {
+        const errors = await validate_input(input_value, rule_value, parent_path);
+
+        return {
+          valid: errors.length === 0,
+          errors: [...errors],
+        };
+      }
+
+      return {
+        valid: false,
+        errors: [
+          `Field ${parent_path} must be of type object.`,
+        ],
+      };
+    },
+    max: (rule_value, input_value, parent_path) => {
+      const valid = input_value <= rule_value;
+
+      if (!valid) {
+        return {
+          valid: false,
+          errors: [`Field ${parent_path} must be less than or equal to ${rule_value}.`],
+        };
+      }
+
+      return {
+        valid: true,
+        errors: [],
+      };
+    },
+    max_length,
+    maxLength: max_length,
+    min: (rule_value, input_value, parent_path) => {
+      const valid = input_value >= rule_value;
+
+      if (!valid) {
+        return {
+          valid: false,
+          errors: [
+            `Field ${parent_path} must be greater than or equal to ${rule_value}.`,
+          ],
+        };
+      }
+
+      return {
+        valid: true,
+        errors: [],
+      };
+    },
+    min_length,
+    minLength: min_length,
+    optional: (rule_value, input_value, parent_path) => {
+      const valid = rule_value === false ? !!input_value : true;
+
+      if (!valid) {
+        return {
+          valid: false,
+          errors: [`Field ${parent_path} is required.`],
+        };
+      }
+
+      return {
+        valid: true,
+        errors: [],
+      };
+    },
+    regex: (rule_value, input_value, parent_path) => {
+      const valid = new RegExp(rule_value).test(input_value);
+
+      if (!valid) {
+        return {
+          valid: false,
+          errors: [`Field ${parent_path} must conform to regex: ${rule_value}.`],
+        };
+      }
+
+      return {
+        valid: true,
+        errors: [],
+      };
+    },
+    required: (rule_value, input_value, parent_path) => {
+      const valid = rule_value === false ? true : !!input_value;
+
+      if (!valid) {
+        return {
+          valid: false,
+          errors: [`Field ${parent_path} is required.`],
+        };
+      }
+
+      return {
+        valid: true,
+        errors: [],
+      };
+    },
+    type: (rule_value, input_value, parent_path) => {
+      const valid = validate_type(rule_value, input_value);
+
+      if (input_value && !valid) {
+        return {
+          valid: false,
+          errors: [`Field ${parent_path} must be of type ${rule_value}.`],
+        };
+      }
+
+      return {
+        valid: true,
+        errors: [],
+      };
+    },
+  },
+};
+
+export default input_validators;

package/src/app/api/is_array_path.js

@@ -0,0 +1,6 @@
+const is_array_path = (path = '') => {
+  return new RegExp(/\.[0-9]+\.?/g).test(path);
+};
+
+export default is_array_path;
+

package/src/app/api/push/health.js

@@ -0,0 +1,17 @@
+import fs from 'fs';
+
+const { readFile } = fs.promises;
+
+const health = async (req = {}, res = {}) => {
+  const instance_token = await readFile("/root/push/instance_token.txt", "utf-8");
+
+  if (req?.headers["x-instance-token"] === instance_token?.replace("\n", "")) {
+    return res.status(200).send("ok");
+  }
+
+  return res
+    .status(403)
+    .send("Sorry, you must pass a valid instance token to access this endpoint.");
+};
+
+export default health;

package/src/app/api/register_getters.js

@@ -0,0 +1,57 @@
+import format_api_error from "./format_api_error.js";
+import get from "./get.js";
+import get_api_context from "./get_api_context.js";
+import get_api_url_component from "./get_api_url_component.js";
+import handle_api_error from "./handle_api_error.js";
+import is_valid_json from "../../lib/is_valid_json.js";
+import types from "../../lib/types.js";
+import validate_session from "./validate_session.js";
+
+const register_getters = (express_app = {}, getter_definitions = [], api_context = {}, api_schema_options = {}) => {
+	for (let i = 0; i < getter_definitions?.length; i += 1) {
+		const [getter_name, getter_definition] = getter_definitions[i];
+		express_app.get(
+			`/api/_getters/${get_api_url_component(getter_name)}`,
+      ...(types.is_array(getter_definition?.middleware) ? getter_definition?.middleware : []),
+      async (req = {}, res = {}) => {
+      	if (process.databases?._sessions) {
+	        const is_valid_session = await validate_session(req, res);
+
+	        if (!is_valid_session) {
+				    return res.status(403).send(
+				      JSON.stringify({
+				        errors: [format_api_error(new Error('Unauthorized request.'))],
+				      })
+				    );
+	        }
+      	}
+
+        const context = await get_api_context(req, res, api_context);
+        
+        const decoded_input = decodeURIComponent(req?.query?.input);
+        const input = is_valid_json(decoded_input) ? JSON.parse(decoded_input) : null;
+
+        const decoded_output = decodeURIComponent(req?.query?.output);
+        const output = is_valid_json(decoded_output) ? JSON.parse(decoded_output) : null;
+
+				get({
+					get_name: getter_name,
+					get_options: {
+						input,
+						output,
+					},
+					getter_definition,
+					request_context: context,
+					api_schema_options,
+				}).then((response) => {
+          return res.status(200).send(JSON.stringify(response));
+        }).catch((error) => {
+        	handle_api_error(`api.getters.${getter_name}`, error, res);
+        });
+      },
+		);
+	}
+};
+
+export default register_getters;
+	

package/src/app/api/register_setters.js

@@ -0,0 +1,55 @@
+import format_api_error from "./format_api_error.js";
+import get_api_context from "./get_api_context.js";
+import get_api_url_component from "./get_api_url_component.js";
+import handle_api_error from "./handle_api_error.js";
+import set from "./set.js";
+import types from "../../lib/types.js";
+import validate_session from "./validate_session.js";
+
+const register_setters = (express_app = {}, setter_definitions = [], api_context = {}, api_schema_options = {}) => {
+	for (let i = 0; i < setter_definitions?.length; i += 1) {
+		const [setter_name, setter_definition] = setter_definitions[i];
+		express_app.post(
+			`/api/_setters/${get_api_url_component(setter_name)}`,
+      ...(types.is_array(setter_definition?.middleware) ? setter_definition?.middleware : []),
+      async (req = {}, res = {}) => {
+      	if (process.databases?._sessions) {
+	        const is_valid_session = await validate_session(req, res);
+
+	        if (!is_valid_session) {
+				    return res.status(403).send(
+				      JSON.stringify({
+				        errors: [format_api_error(new Error('Unauthorized request.'))],
+				      })
+				    );
+	        }
+      	}
+
+        const context = await get_api_context(req, res, api_context);
+
+        // NOTE: No need for URL decoding or JSON integrity check like getters as these are passed
+        // via the body, not query parameters.
+        const input = req?.body?.input || null;
+        const output = req?.body?.output || null;
+
+				set({
+					set_name: setter_name,
+					set_options: {
+						input,
+						output,
+					},
+					setter_definition,
+					request_context: context,
+					api_schema_options,
+				}).then((response) => {
+          return res.status(200).send(JSON.stringify(response));
+        }).catch((error) => {
+        	handle_api_error(`api.setters.${setter_name}`, error, res);
+        });
+      },
+		);
+	}
+};
+
+export default register_setters;
+	

package/src/app/api/sanitize_api_response.js

@@ -0,0 +1,35 @@
+import escape_html from "../../lib/escape_html.js";
+import types from '../../lib/types.js';
+
+const sanitized_api_response = (data = null) => {
+  let sanitized_data = data;
+
+  if (
+    !types.is_string(sanitized_data) &&
+    !types.is_object(sanitized_data) &&
+    !types.is_array(sanitized_data)
+  ) {
+    return sanitized_data;
+  }
+
+  if (types.is_string(sanitized_data)) {
+    sanitized_data = (escape_html(sanitized_data))?.trim();
+  }
+
+  if (types.is_object(sanitized_data) && !types.is_array(sanitized_data)) {
+    sanitized_data = Object.entries(sanitized_data || {})?.reduce((result = {}, [key, value]) => {
+      result[key] = sanitized_api_response(value);
+      return result;
+    }, {});
+  }
+
+  if (types.is_array(sanitized_data)) {
+    sanitized_data = sanitized_data.map((array_item = null) => {
+      return sanitized_api_response(array_item);
+    });
+  }
+  
+  return sanitized_data;
+};
+
+export default sanitized_api_response;

package/src/app/api/set.js

@@ -0,0 +1,119 @@
+import format_api_error from "./format_api_error.js";
+import get_output from "./get_output.js";
+import get_sanitized_context from "../../lib/get_sanitized_context.js";
+import sanitize_api_response from "./sanitize_api_response.js";
+import track_function_call from "../../test/track_function_call.js";
+import types from "../../lib/types.js";
+import validate_input from "./validate_input.js";
+
+const run_setter = async (
+  set_name = '',
+  setter_definition = {},
+  input = {},
+  output = {},
+  context = {},
+  api_schema_options = {}
+) => {
+  const should_disable_sanitization = setter_definition?.sanitize === false;
+  const should_sanitize_output = (setter_definition?.sanitize || api_schema_options?.sanitize) === true;
+
+  track_function_call(`node.api.setters.${set_name}`, [
+    input,
+    get_sanitized_context(context),
+  ]);
+
+  const data = (await setter_definition?.set(input, context));
+  const response = output ? get_output(data, output) : data;
+  
+  return !should_disable_sanitization && should_sanitize_output ? sanitize_api_response(
+    response
+  ) : response;
+};
+
+const run_authorization = async (setter_name = '', setter_definition = {}, input = {}, context = {}) => {
+  track_function_call(`node.api.setters.${setter_name}.authorized`, [
+    input,
+    get_sanitized_context(context),
+  ]);
+
+  const authorization = await setter_definition?.authorized(input, context);
+
+  if (typeof authorization === 'boolean') {
+    return authorization;
+  }
+
+  if (types.is_object(authorization) && !types.is_array(authorization) && !types.is_undefined(authorization?.authorized)) {
+    return authorization?.authorized ? true : authorization?.message;
+  }
+};
+
+const handle_log_validation_errors = (validation_errors = [], setter_name = '') => {
+	console.log(
+	  `Input validation for setter "${setter_name}" failed with the following errors:\n`
+	);
+
+	for (let i = 0; i < validation_errors?.length; i += 1) {
+	  const validation_error = validation_errors[i];
+	  console.log(`${i + 1}. ${validation_error}`);
+	}
+};
+
+const run_validation = (set_request_input = {}, setter_definition_input = {}) => {
+	return validate_input(set_request_input, setter_definition_input);
+};
+
+const set = async ({
+	set_name,
+	set_options, // NOTE: skip, input, output.
+	setter_definition,
+	request_context,
+	api_schema_options,
+}) => {
+	const should_run_validation = setter_definition?.input && Object.keys(setter_definition?.input)?.length > 0;
+	const should_run_authorization = types.is_function(setter_definition?.authorized);
+
+	if (should_run_validation) {
+		const validation_errors = await run_validation(set_options?.input, setter_definition?.input);
+		
+		if (validation_errors?.length > 0) {
+			handle_log_validation_errors(validation_errors, set_name);
+
+		  return Promise.reject({
+	      errors: validation_errors.map((error) => {
+	        return format_api_error(new Error(error), `setters.${set_name}.input`, 401);
+	      }),
+	    });
+		}
+	}
+
+	if (should_run_authorization) {
+		const authorized = await run_authorization(set_name, setter_definition, set_options?.input, request_context);
+
+		if (!authorized || types.is_string(authorized)) {
+      return Promise.reject({
+        errors: [
+          format_api_error(
+            new Error(typeof authorized === 'string' ? authorized : `Not authorized to access ${set_name}.`),
+            `setters.${set_name}.authorized`,
+            403
+          ),
+        ],
+      });
+		}
+	}
+
+	if (types.is_function(setter_definition?.set)) {
+		const response = await run_setter(
+		  set_name,
+		  setter_definition,
+		  set_options?.input,
+		  set_options?.output,
+		  request_context,
+		  api_schema_options,
+		);
+
+		return Promise.resolve(response);
+	}
+};
+
+export default set;

package/src/app/api/test/accounts/delete.js

@@ -0,0 +1,8 @@
+import accounts_query from "../../../databases/queries/accounts.js";
+
+const test_accounts_delete = async (req = {}, res = {}) => {
+  await accounts_query('delete_user', { user_id: req?.body?.user_id });
+  res.status(200).send({ data: {} });
+};
+
+export default test_accounts_delete;

package/src/app/api/test/accounts/signup.js

@@ -0,0 +1,50 @@
+import accounts_query from "../../../databases/queries/accounts.js";
+import default_user_output_fields from "../../../accounts/default_user_output_fields.js";
+import format_api_error from "../../format_api_error.js";
+import handle_api_error from "../../handle_api_error.js";
+import validate_input from "../../validate_input.js";
+import signup from "../../../accounts/signup.js";
+
+const test_accounts_signup = async (req = {}, res = {}) => {
+	try {
+		// NOTE: Assume accounts created in tests are ephemeral on a per-run basis.
+		// When signing up, automatically delete an existing user to avoid fragile
+		// tests and conflicts between runs.
+		const existing_user_with_email = await accounts_query('user', { email_address: req?.body?.emailAddress || req?.body?.email_address });
+		const existing_user_with_username = await accounts_query('user', { username: req?.body?.username });
+		const existing_user = existing_user_with_email || existing_user_with_username;
+
+		if (existing_user) {
+		  await accounts_query('delete_user', { user_id: existing_user?._id || existing_user?.user_id });
+		}
+
+		const metadata_schema = process.joystick?.app_options?.accounts?.signup?.metadata;
+		const metadata_errors = metadata_schema ? await validate_input(req?.body?.metadata, metadata_schema) : [];
+
+		if (metadata_errors?.length > 0) {
+			return handle_api_error('accounts.signup', {
+	      errors: metadata_errors.map((error) => {
+	        return format_api_error(new Error(error), `accounts.signup.metadata`, 401);
+	      }),
+	    }, res);
+		}
+
+		const signup_response = await signup({
+		  email_address: req?.body?.emailAddress || req?.body?.email_address,
+		  username: req?.body?.username,
+		  password: req?.body?.password,
+		  metadata: req?.body?.metadata,
+		  output: req?.body?.output || default_user_output_fields,
+		});
+
+		res.status(200).send(JSON.stringify({
+		  ...(signup_response?.user || {}),
+		  joystick_login_token: signup_response?.token,
+		  joystick_login_token_expires_at: signup_response?.token_expires_at,
+		}));
+	} catch(error) {
+		handle_api_error('test.accounts.signup', error, res);
+	}
+};
+
+export default test_accounts_signup;

package/src/app/api/test/bootstrap.js

@@ -0,0 +1,39 @@
+import dynamic_import from "../../../lib/dynamic_import.js";
+import get_api_for_data_functions from "../get_api_for_data_functions.js";
+import get_browser_safe_request from "../../../lib/get_browser_safe_request.js";
+import get_platform_safe_path from "../../../lib/get_platform_safe_path.js";
+import get_translations from "../../../lib/get_translations.js";
+import load_settings from "../../settings/load.js";
+
+const test_bootstrap = async (req = {}, res = {}, app_instance = {}) => {
+  const joystick_build_path = `${process.cwd()}/.joystick/build/`;
+  const component_to_render = req?.query?.path_to_component ?
+  	await dynamic_import(
+      get_platform_safe_path(`${joystick_build_path}/${req?.query?.path_to_component}?v=${new Date().getTime()}`)
+    ) :
+  	null;
+
+  if (component_to_render) {
+    const component_instance = component_to_render();
+    const api_for_data_functions = get_api_for_data_functions(req, app_instance?.options?.api);
+    const browser_safe_request = get_browser_safe_request(req);
+    const data = await component_instance.fetch_data(api_for_data_functions, browser_safe_request, {}, component_instance);
+
+    return res.status(200).send({
+      data: {
+        [component_instance?.id]: data,
+      },
+      req: browser_safe_request,
+      settings: load_settings(),
+      translations: await get_translations({
+	    	joystick_build_path,
+	    	render_component_path: req?.query?.path_to_component,
+	    	req,
+	    }),
+    });
+  }
+
+  res.status(200).send({ data: {}, translations: {} });
+};
+
+export default test_bootstrap;

package/src/app/api/test/process.js

@@ -0,0 +1,7 @@
+const test_process = (req = {}, res = {}) => {
+  res.status(200).send({
+    test: process?.test || {},
+  });
+};
+
+export default test_process;

package/src/app/api/test/queues.js

@@ -0,0 +1,25 @@
+const test_queues = async (req = {}, res = {}, app_instance = {}) => {
+	const queue = process?.queues[req?.body?.queue];
+	const job = app_instance?.options?.queues[req?.body?.queue]?.jobs[req?.body?.job];
+
+	if (!queue) {
+	  return res.status(404).send({ status: 404, error: `Queue ${req?.body?.queue} not found.` });
+	}
+
+	if (!job) {
+	  return res.status(400).send({
+	  	status: 400,
+	  	error: `Couldn't find a job called ${req?.body?.job} for the ${req?.body?.queue} queue.`
+	 	});
+	}
+
+	await queue.handle_next_job({
+	  _id: 'joystick_test',
+	  job: req?.body?.job,
+	  payload: req?.body?.payload,
+	});
+
+	res.status(200).send({ status: 200, data: {} });
+};
+
+export default test_queues;