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

package/src/app/api/accounts/recover_password.js

@@ -0,0 +1,16 @@
+import accounts from "../../accounts/index.js";
+import handle_api_error from "../handle_api_error.js";
+
+const recover_password = async (req = {}, res = {}) => {
+  try {
+    await accounts.recover_password({
+      email_address: req?.body?.emailAddress || req?.body?.email_address,
+    });
+
+    res.status(200).send(JSON.stringify({}));
+  } catch(error) {
+    handle_api_error('accounts.recover_password', error, res);
+  }
+};
+
+export default recover_password;

package/src/app/api/accounts/reset_password.js

@@ -0,0 +1,24 @@
+import accounts from "../../accounts/index.js";
+import default_user_output_fields from "../../accounts/default_user_output_fields.js";
+import handle_api_error from "../handle_api_error.js";
+
+const reset_password = async (req = {}, res = {}) => {
+	try {
+		const reset = await accounts.reset_password({
+		  token: req?.body?.token,
+		  password: req?.body?.password,
+		  output: req?.body?.output || default_user_output_fields,
+		});
+
+		accounts._set_account_cookie(res, {
+		  token: reset?.token,
+		  token_expires_at: reset?.token_expires_at,
+		});
+
+		res.status(200).send(JSON.stringify(reset?.user || {}));
+  } catch(error) {
+    handle_api_error('accounts.reset_password', error, res);
+  }
+};
+
+export default reset_password;

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

@@ -0,0 +1,49 @@
+import accounts from "../../accounts/index.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";
+
+const signup = async (req = {}, res = {}) => {
+	try {
+		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 = await accounts.signup({
+		  email_address: req?.body?.emailAddress || req?.body?.email_address,
+		  password: req?.body?.password,
+		  metadata: req?.body?.metadata,
+		  output: req?.body?.output || default_user_output_fields,
+		});
+
+		if (process.env.NODE_ENV !== 'test') {
+		  accounts._set_account_cookie(res, {
+		    token: signup?.token,
+		    token_expires_at: signup?.token_expires_at,
+		  });
+		}
+
+		const response = {
+		  ...(signup?.user || {}),
+		};
+
+		if (process.env.NODE_ENV === 'test') {
+		  response.joystick_token = signup?.token;
+		  response.joystick_login_token_expires_at = signup?.token_expires_at;
+		}
+
+		res.status(200).send(JSON.stringify(response));
+	} catch(error) {
+		handle_api_error('accounts.signup', error, res);
+	}
+};
+
+export default signup;

package/src/app/api/accounts/user.js

@@ -0,0 +1,21 @@
+import default_user_output_fields from "../../accounts/default_user_output_fields.js";
+import get_output from "../get_output.js";
+import has_login_token_expired from "../../accounts/has_login_token_expired.js";
+
+const user = (req = {}, res = {}) => {
+  const login_token_has_expired = has_login_token_expired(
+    res,
+    req?.cookies?.joystick_login_token,
+    req?.cookies?.joystick_login_token_expires_at
+  );
+
+  const status = !login_token_has_expired ? 200 : 401;
+  const user = get_output(
+    req?.context?.user,
+    req?.body?.output || default_user_output_fields
+  );
+
+  return res.status(status).send(JSON.stringify({ status, user }));
+};
+
+export default user;

package/src/app/api/accounts/verify_email.js

@@ -0,0 +1,11 @@
+import accounts from "../../accounts/index.js";
+
+const verify_email = async (req = {}, res = {}) => {
+  await accounts.verify_email({
+    token: req?.query?.token,
+  });
+
+  res.redirect("/");
+};
+
+export default verify_email;

package/src/app/api/format_api_error.js

@@ -0,0 +1,10 @@
+const format_api_error = (exception = {}, location = "", status = 0) => {
+  return {
+    status,
+    error: exception,
+    message: exception?.message || exception,
+    location,
+  };
+};
+
+export default format_api_error;

package/src/app/api/get.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_getter = async (
+  get_name = '',
+  getter_definition = {},
+  input = null,
+  output = null,
+  context = {},
+  api_schema_options = {}
+) => {
+  const should_disable_sanitization = getter_definition?.sanitize === false;
+  const should_sanitize_output = (getter_definition?.sanitize || api_schema_options?.sanitize) === true;
+
+  track_function_call(`node.api.getters.${get_name}`, [
+    input,
+    get_sanitized_context(context),
+  ]);
+
+  const data = (await getter_definition?.get(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 (getter_name = '', getter_definition = {}, input = {}, context = {}) => {
+  track_function_call(`node.api.getters.${getter_name}.authorized`, [
+    input,
+    get_sanitized_context(context),
+  ]);
+
+  const authorization = await getter_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 = [], getter_name = '') => {
+	console.log(
+	  `Input validation for getter "${getter_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 = (get_request_input = {}, getter_definition_input = {}) => {
+	return validate_input(get_request_input, getter_definition_input);
+};
+
+const get = async ({
+	get_name,
+	get_options, // NOTE: skip, input, output.
+	getter_definition,
+	request_context,
+	api_schema_options,
+}) => {
+	const should_run_validation = getter_definition?.input && Object.keys(getter_definition?.input)?.length > 0;
+	const should_run_authorization = types.is_function(getter_definition?.authorized);
+
+	if (should_run_validation) {
+		const validation_errors = await run_validation(get_options?.input, getter_definition?.input);
+
+		if (validation_errors?.length > 0) {
+			handle_log_validation_errors(validation_errors, get_name);
+
+		  return Promise.reject({
+	      errors: validation_errors.map((error) => {
+	        return format_api_error(new Error(error), `getters.${get_name}.input`, 400);
+	      }),
+	    });
+		}
+	}
+
+	if (should_run_authorization) {
+		const authorized = await run_authorization(get_name, getter_definition, get_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 ${get_name}.`),
+            `getters.${get_name}.authorized`,
+            403
+          ),
+        ],
+      });
+		}
+	}
+
+	if (types.is_function(getter_definition?.get)) {
+		const response = await run_getter(
+		  get_name,
+		  getter_definition,
+		  get_options?.input,
+		  get_options?.output,
+		  request_context,
+		  api_schema_options,
+		);
+
+		return Promise.resolve(response);
+	}
+};
+
+export default get;

package/src/app/api/get_api_context.js

@@ -0,0 +1,27 @@
+const get_api_context = (req = {}, res = {}, api_context = null) => {
+  // NOTE: api_context is the optional *global* context defined in the API
+  // schema at /api/index.js in an app.
+  return new Promise(async (resolve) => {
+    if (typeof api_context === "function") {
+      const compiled_api_context = await api_context(req, res);
+
+      return resolve({
+        ...compiled_api_context,
+        ...(req?.context || {}),
+        req,
+        res,
+        ...(process.databases || {}),
+      });
+    }
+
+    return resolve({
+      ...api_context,
+      ...(req?.context || {}),
+      req,
+      res,
+      ...(process.databases || {}),
+    });
+  });
+};
+
+export default get_api_context;

package/src/app/api/get_api_for_data_functions.js

@@ -0,0 +1,37 @@
+import fetch from 'node-fetch';
+import get from "./get.js";
+import set from "./set.js";
+
+const get_api_for_data_functions = (req = {}, api_schema = {}) => {
+	return {
+		fetch,
+		get: (get_name = '', get_options = {}) => {
+			if (get_options?.skip) {
+				return null;
+			}
+
+			return get({
+				get_name,
+				get_options, // NOTE: skip, input, output
+				getter_definition: api_schema?.getters[get_name],
+				request_context: req?.context,
+				api_schema_options: api_schema?.options,
+			});
+		},
+		set: (set_name = '', set_options = {}) => {
+			if (set_options?.skip) {
+				return null;
+			}
+
+			return set({
+				set_name,
+				set_options, // NOTE: skip, input, output
+				setter_definition: api_schema?.setters[set_name],
+				request_context: req?.context,
+				api_schema_options: api_schema?.options,
+			});
+		},
+	}
+};
+
+export default get_api_for_data_functions;

package/src/app/api/get_api_url_component.js

@@ -0,0 +1,5 @@
+const get_api_url_component = (string = '') => {
+  return string.toLowerCase().replace(/\ /g, "-");
+};
+
+export default get_api_url_component;

package/src/app/api/get_output.js

@@ -0,0 +1,116 @@
+import types from "../../lib/types.js";
+
+const filter_output = (object = {}, fields = []) => {
+	const entries_for_object_to_filter = Object.entries(object || {});
+
+	for (let i = 0; i < entries_for_object_to_filter?.length; i += 1) {
+		const [key, value] = entries_for_object_to_filter[i];
+    const key_in_fields = fields.find((field) => field.key === key);
+
+    if (!key_in_fields) {
+      delete object[key];
+    }
+
+    if (key_in_fields && types.is_object(value) && key_in_fields.children.length === 0) {
+      return value;
+    }
+
+    if (key_in_fields && types.is_object(value) && key_in_fields.children.length > 0) {
+      filter_output(value, key_in_fields.children);
+    }
+
+    if (
+      key_in_fields &&
+      types.is_array(value) &&
+      key_in_fields.children &&
+      key_in_fields.children.length > 0
+    ) {
+      for (let i = 0; i < value?.length; i += 1) {
+        const value_element = value[i];
+        if (value_element && types.is_object(value_element)) {
+          filter_output(value_element, key_in_fields.children);
+        }
+      }
+    }
+	}
+
+  return object;
+};
+
+const get_path_part_arrays = (paths = []) => {
+  return paths.map((path) => {
+    return path.split(".");
+  });
+};
+
+const get_head_tail = (path_part_array = []) => {
+  const [head, ...tail] = path_part_array;
+  return {
+    head,
+    tail,
+  };
+};
+
+const get_head_tail_for_paths = (path_part_arrays = []) => {
+  return path_part_arrays.map((path_part_array) => {
+    return get_head_tail(path_part_array);
+  });
+};
+
+const add_to_map = (map = [], head_tail_for_paths = []) => {
+  for (let i = 0; i < head_tail_for_paths?.length; i += 1) {
+    const head_tail_for_path = head_tail_for_paths[i];
+    
+    const existing_map_entry = map.find(
+      (map_entry) => map_entry.key === head_tail_for_path.head
+    );
+
+    if (!existing_map_entry) {
+      const head_tail_for_children =
+        head_tail_for_path.tail && head_tail_for_path.tail.length > 0
+          ? get_head_tail(head_tail_for_path.tail)
+          : null;
+
+      map.push({
+        key: head_tail_for_path.head,
+        children: head_tail_for_children
+          ? add_to_map([], [head_tail_for_children])
+          : [], // The NEXT thing to nest and the parent.
+      });
+    }
+
+    if (existing_map_entry) {
+      const head_tail_for_children =
+        head_tail_for_path.tail && head_tail_for_path.tail.length > 0
+          ? get_head_tail(head_tail_for_path.tail)
+          : null;
+
+      existing_map_entry.children = [
+        ...(head_tail_for_children
+          ? add_to_map(existing_map_entry.children, [head_tail_for_children])
+          : []),
+      ];
+    }
+  }
+
+  return map;
+};
+
+const get_output = (output = {}, output_fields = []) => {
+  const map = [];
+  const path_part_arrays = get_path_part_arrays(output_fields);
+  const head_tail_for_paths = get_head_tail_for_paths(path_part_arrays);
+
+  add_to_map(map, head_tail_for_paths);
+
+  if (types.is_array(output)) {
+    return output.map((element) => {
+      return filter_output(element, map);
+    });
+  }
+
+  return filter_output(output, map);
+};
+
+export default get_output;
+

package/src/app/api/get_value_from_object.js

@@ -0,0 +1,8 @@
+const get_value_from_object = (object, path = '') => {
+  if (!path) return object;
+  if (!object) return undefined;
+  const properties = path.split(".");
+  return get_value_from_object(object[properties.shift()], properties.join("."));
+};
+
+export default get_value_from_object;

package/src/app/api/handle_api_error.js

@@ -0,0 +1,28 @@
+import format_api_error from "./format_api_error.js";
+import types from "../../lib/types.js";
+
+const handle_api_error = (location = '', error = '', res = {}) => {
+	// NOTE: This is an internal Joystick error that we control. Should be
+	// in the shape of { errors: [] } pre-formatted.
+	if (types.is_object(error) && !(error instanceof Error)) {
+    return res.status((error?.errors && error?.errors[0]?.status) || 500).send(
+      JSON.stringify(error)
+    );
+	}
+
+	if (error instanceof Error) {
+		return res.status(500).send(
+      JSON.stringify({
+      	errors: [format_api_error(error, location, 500)]
+      })
+    );
+	}
+
+	return res.status(500).send(
+    JSON.stringify({
+    	errors: [format_api_error(new Error(error), location, 500)]
+    })
+  );
+};
+
+export default handle_api_error;