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

package/src/app/register_app_options.js

@@ -0,0 +1,7 @@
+const register_app_options = (app_instance = {}, app_options = {}) => {
+	app_instance.databases = [];
+  app_instance.express = {};
+	app_instance.options = app_options;
+};
+
+export default register_app_options;

package/src/app/routes/register_route_from_function.js

@@ -0,0 +1,10 @@
+const register_route_from_function = (express_app = {}, route_path = '', route_handler = null) => {
+	express_app.get(
+		route_path,
+		async (req, res, next) => {
+			route_handler(req, res, next);
+		},
+	);
+};
+
+export default register_route_from_function;

package/src/app/routes/register_route_from_object.js

@@ -0,0 +1,34 @@
+import supported_http_methods from "./supported_http_methods.js";
+import types from "../../lib/types.js";
+
+const register_route_from_object = (express_app = {}, route_path = '', route_handler = {}) => {
+  const method = route_handler?.method?.toLowerCase();
+  const methods = route_handler?.methods?.map((method) => method?.toLowerCase());
+  const methods_for_route = (method ? [method] : methods)?.filter((method) => {
+  	return supported_http_methods.includes(method);
+  });
+  const middleware_for_route = types.is_array(route_handler?.middleware) ? route_handler?.middleware : [];
+
+  if (methods_for_route?.length === 0) {
+  	console.warn(`Cannot register route ${route_path}. All provided HTTP methods are invalid. Must be one of ${supported_http_methods?.join(', ')}.`);
+  	return;
+  }
+
+  if (!types.is_function(route_handler?.handler)) {
+  	console.warn(`Cannot register route ${route_path}. Handler must be a function.`);
+  	return;
+  }
+
+  for (let i = 0; i < methods_for_route?.length; i += 1) {
+  	const method_for_route = methods_for_route[i];
+  	express_app[method_for_route](
+  		route_path,
+  		...(middleware_for_route || []),
+  		async (req, res, next) => {
+  			route_handler.handler(req, res, next);
+  		},
+  	);
+  }
+};
+
+export default register_route_from_object;

package/src/app/routes/supported_http_methods.js

@@ -0,0 +1,9 @@
+const supported_http_methods = [
+  'get',
+  'delete',
+  'patch',
+  'post',
+  'put',
+];
+
+export default supported_http_methods;

package/src/app/settings/load.js

@@ -0,0 +1,33 @@
+import is_valid_json from "../../lib/is_valid_json.js";
+import parse_json from "../../lib/parse_json.js";
+
+const default_settings = {
+  config: {},
+  global: {},
+  public: {},
+  private: {},
+};
+
+const load = () => {
+  const has_settings = !!process.env.JOYSTICK_SETTINGS;
+  const settings = `${process.env.JOYSTICK_SETTINGS}`.replace(/\\/g, '');
+  const settings_are_valid = has_settings && is_valid_json(settings);
+
+  if (!has_settings) {
+    return default_settings;
+  }
+
+  if (!settings_are_valid) {
+    console.warn(
+      `Could not parse settings. Please verify that your settings.${process.env.NODE_ENV}.json file exports a valid JSON object.`
+    );
+
+    return default_settings;
+  }
+
+  const parsed_settings = parse_json(settings);
+
+  return parsed_settings || default_settings;
+};
+
+export default load;

package/src/app/ssr/index.js

@@ -0,0 +1,133 @@
+import fs from 'fs';
+import { parseHTML } from 'linkedom';
+import os from 'os';
+import get_api_for_data_functions from "../api/get_api_for_data_functions.js";
+import get_browser_safe_request from "../../lib/get_browser_safe_request.js";
+import load_settings from '../settings/load.js';
+import set_base_attributes_in_html from "./set_base_attributes_in_html.js";
+import set_head_tags_in_html from "./set_head_tags_in_html.js";
+import path_exists from "../../lib/path_exists.js";
+import get_browser_safe_user from '../accounts/get_browser_safe_user.js';
+
+const { readFile } = fs.promises;
+const app_settings = load_settings();
+const is_development = process.env.NODE_ENV === 'development';
+
+// NOTE: Set a global document so we have access to a pseudo-DOM in @joystick.js/ui
+// when server-side rendering.
+const { document: linkedom_document } = parseHTML('<div></div>');
+
+const build_html_response_for_browser = (options = {}) => {
+	return options?.base_html
+		.replace('${css}', `<style type="text/css" js-css>${options?.css}</style>`)
+		.replace(`<div id="app"></div>`, `
+			<div id="app">${options?.html}</div>
+			<script>
+				window.joystick = {
+					settings: {
+						global: ${JSON.stringify(app_settings?.global)},
+						public: ${JSON.stringify(app_settings?.public)},
+					},
+				};
+
+        window.__joystick_platform__ = '${os.platform()}';
+        window.__joystick_data__ = '${Buffer.from(JSON.stringify(options?.data), 'utf8').toString('base64')}';
+       	window.__joystick_i18n__ = ${JSON.stringify(options?.translations)};
+        ${is_development ? `window.__joystick_hmr_port__ = ${parseInt(process.env.PORT, 10) + 1}` : ''}
+        window.__joystick_layout_url__ = ${options?.render_layout_path ? `"/_joystick/${options?.render_layout_path}"` : null};
+        window.__joystick_page_url__ = ${options?.render_component_path ? `"/_joystick/${options?.render_component_path}"` : null};
+       	window.__joystick_request__ = ${JSON.stringify(get_browser_safe_request(options?.req))};
+        window.__joystick_settings__ = ${JSON.stringify({
+          global: app_settings?.global,
+          public: app_settings?.public,
+        })};
+
+        window.__joystick_should_auto_mount__ = true;
+        window.__joystick_ssr_props__ = ${JSON.stringify(options?.props)};
+        window.__joystick_url__ = ${JSON.stringify(options?.url)};
+        window.__joystick_user__ = ${JSON.stringify(get_browser_safe_user(options?.req?.context?.user))};
+			</script>
+			<script type="module" src="/_joystick/utils/process.js"></script>
+      <script type="module" src="/_joystick/index.client.js"></script>
+      ${options?.render_component_path ? `<script type="module" src="/_joystick/${options?.render_component_path}"></script>` : ''}
+      ${options?.render_layout_path ? `<script type="module" src="/_joystick/${options?.render_layout_path}"></script>` : ''}
+      ${is_development ? `<script type="module" src="/_joystick/hmr/client.js"></script>` : ''}
+		`);
+};
+
+const build_html_response_for_email = (options = {}) => {
+  return options?.base_html
+  	.replace('${css}', `<style type="text/css">${options?.css}</style>`)
+    .replace("${subject}", options?.email_options?.subject)
+    .replace("${preheader}", options?.email_options?.preheader || "")
+    .replace('<div id="email"></div>', `<div id="email">${options?.html}</div>`);
+};
+
+const build_html_response = (options = {}) => {
+	return options?.is_email ? build_html_response_for_email(options) : build_html_response_for_browser(options);
+};
+
+const get_base_html_for_email = async (base_html_name = '') => {
+	if (await path_exists(`email/${base_html_name ? `base_${base_html_name}` : 'base'}.html`)) {
+		return readFile(`email/${base_html_name ? `base_${base_html_name}` : 'base'}.html`, 'utf-8');
+	}
+
+	console.warn(`Could not find email/${base_html_name ? `base_${base_html_name}` : 'base'}.html`);
+
+	return '';
+};
+
+const get_base_css_for_email = async (base_html_name = '') => {
+	if (await path_exists(`email/${base_html_name ? `base_${base_html_name}` : 'base'}.css`)) {
+		return readFile(`email/${base_html_name ? `base_${base_html_name}` : 'base'}.css`, 'utf-8');
+	}
+
+	console.warn(`Could not find email/${base_html_name ? `base_${base_html_name}` : 'base'}.css`);
+
+	return '';
+};
+
+const get_component_instance = (component_to_render = null, component_options = {}) => {
+	return component_to_render(component_options);
+};
+
+const ssr = async (ssr_options = {}) => {
+	const component_instance = get_component_instance(ssr_options?.component_to_render, ssr_options?.component_options);
+	const api = get_api_for_data_functions(ssr_options?.req, ssr_options?.api_schema);
+	const ssr_tree = [];
+	const ssr_render = await component_instance.render_for_ssr(api, ssr_options?.req, ssr_tree, {
+		linkedom_document,
+		is_email: ssr_options?.is_email
+	});
+	const email_base_css = ssr_options?.is_email ? await get_base_css_for_email(ssr_options?.email_options?.base_html_name) : null;
+	const email_base_html = ssr_options?.is_email ? await get_base_html_for_email(ssr_options?.email_options?.base_html_name) : null;
+
+	const html = build_html_response({
+		is_email: ssr_options?.is_email,
+		attributes: ssr_options?.attributes,
+		base_html: ssr_options?.is_email ? email_base_html : ssr_options?.base_html,
+		component_instance,
+		css: ssr_options?.is_email ? `
+			${email_base_css}
+			${ssr_render?.css}
+		` : ssr_render?.css,
+		data: ssr_render?.data,
+		email_options: ssr_options?.email_options,
+		head: ssr_options?.head,
+		html: ssr_render?.html,
+		props: ssr_options?.component_options?.props,
+		render_component_path: ssr_options?.render_component_path,
+		render_layout_path: ssr_options?.render_layout_path,
+		req: ssr_options?.req,
+		translations: ssr_options?.component_options?.translations,
+		url: ssr_options?.component_options?.url,
+	});
+
+
+	const html_with_head_tags = set_head_tags_in_html(html, ssr_options?.head, ssr_options?.req);
+	const html_with_base_attributes = set_base_attributes_in_html(html_with_head_tags, ssr_options?.attributes);
+
+	return html_with_base_attributes;
+};
+
+export default ssr;

package/src/app/ssr/set_base_attributes_in_html.js

@@ -0,0 +1,43 @@
+import { parseHTML } from 'linkedom';
+import types from '../../lib/types.js';
+
+const add_attributes_to_dom = (dom = {}, attributes = {}) => {
+  const attribute_keys = Object.keys(attributes || {});
+  const attribute_keys_without_class_list = attribute_keys?.filter(
+    (key) => key !== "class"
+  );
+
+  if (types.is_array(attributes?.class?.list)) {
+    if (attributes?.class?.method === "replace") {
+      dom.setAttribute("class", attributes.class.list.join(" "));
+    } else {
+      for (let i = 0; i < attributes.class.list.length; i += 1) {
+      	const class_name = attributes.class.list[i];
+        dom.classList.add(class_name);
+      }
+    }
+  }
+
+  for (let i = 0; i < attribute_keys_without_class_list.length; i += 1) {
+  	const attribute = attribute_keys_without_class_list[i];
+    dom.setAttribute(attribute, attributes[attribute]);
+  }
+
+  return dom;
+};
+
+const set_base_attributes_in_html = (html = '', attributes = {}) => {
+  const { document } = parseHTML(html);
+
+  if (attributes?.html) {
+    add_attributes_to_dom(document.documentElement, attributes.html);
+  }
+
+  if (attributes?.body) {
+    add_attributes_to_dom(document.body, attributes.body);
+  }
+
+  return document.toString();
+};
+
+export default set_base_attributes_in_html;

package/src/app/ssr/set_head_tags_in_html.js

@@ -0,0 +1,104 @@
+import html_parser from 'node-html-parser';
+import types from '../../lib/types.js';
+
+const set_head_tags_in_html = (html_string = '', head = null, req = {}) => {
+  const html = html_parser.parse(html_string);
+  const head_tag = html.querySelector('head');
+
+  if (req?.context?.session) {
+    const meta_tag_wrapper = html_parser.parse(`<meta />`);
+    const tag = meta_tag_wrapper.querySelector('meta');
+
+    tag.setAttribute('name', 'csrf');
+    tag.setAttribute('content', req?.context?.session?.csrf);
+
+    head_tag.appendChild(tag);
+  }
+
+  if (!head) {
+    return html.toString();
+  }
+
+  if (head.title) {
+    const existing_title = head_tag.querySelector('title');
+    
+    if (existing_title) {
+      const new_title = html_parser.parse(`<title>${head.title}</title>`);
+      head_tag.exchangeChild(existing_title, new_title);
+    }
+  
+    if (!existing_title) {
+      head_tag.insertAdjacentHTML('afterbegin', `<title>${head.title}</title>`);
+    }
+  }
+
+  if (head.tags && head.tags.meta && types.is_array(head.tags.meta) && head.tags.meta.length > 0) {
+    for (let i = 0; i < head?.tags?.meta?.length; i += 1) {
+    	const meta_tag = head.tags.meta[i];
+
+      const existing_tag = head_tag.querySelector(`meta[name="${meta_tag.name}"]`);
+      const new_tag = html_parser.parse(`<meta />`);
+
+      const meta_tag_entries = Object.entries(meta_tag || {});
+
+      for (let i = 0; i < meta_tag_entries?.length; i += 1) {
+      	const [attribute_name, attribute_value] = meta_tag_entries[i];
+      	new_tag.querySelector('meta').setAttribute(attribute_name, attribute_value);
+      }
+
+      if (existing_tag) {
+        head_tag.exchangeChild(existing_tag, new_tag);
+      }
+  
+      if (!existing_tag) {
+        head_tag.appendChild(new_tag);
+      }
+    }
+  }
+  
+  if (head.tags && head.tags.link && types.is_array(head.tags.link) && head.tags.link.length > 0) {
+    for (let i = 0; i < head?.tags?.link?.length; i += 1) {
+    	const link_tag = head?.tags?.link[i];
+    	const new_tag = html_parser.parse(`<link />`);
+
+      const link_tag_entries = Object.entries(link_tag || {});
+  
+  		for (let i = 0; i < link_tag_entries?.length; i += 1) {
+  			const [attribute_name, attribute_value] = link_tag_entries[i];
+        new_tag.querySelector('link').setAttribute(attribute_name, attribute_value);
+  		}
+
+      head_tag.appendChild(new_tag);
+    }
+  }
+  
+  if (head.tags && head.tags.script && Array.isArray(head.tags.script) && head.tags.script.length > 0) {
+    for (let i = 0; i < head?.tags?.script?.length; i += 1) {
+    	const script_tag = head.tags.script[i];
+    	const new_tag = html_parser.parse(`<script></script>`);
+
+      const script_tag_entries = Object.entries(script_tag || {});
+
+      for (let i = 0; i < script_tag_entries?.length; i += 1) {
+        const [attribute_name, attribute_value] = script_tag_entries[i];
+        new_tag.querySelector('script').setAttribute(attribute_name, attribute_value);
+      }
+  
+      head_tag.appendChild(new_tag);
+    }
+  }
+  
+  if (head.jsonld) {
+    const new_tag = html_parser.parse(`<script></script>`);
+    const tag = new_tag.querySelector('script');
+  
+    tag.setAttribute('type', 'application/ld+json');
+    tag.set_content(JSON.stringify(head.jsonld, null, 2));
+
+    head_tag.appendChild(new_tag);
+  }
+  
+  return html.toString();
+};
+
+export default set_head_tags_in_html;

package/src/app/start_express.js

@@ -0,0 +1,50 @@
+import express from "express";
+import https from "https";
+import built_in_middleware from "./middleware/built_in.js";
+import get_joystick_build_path from "../lib/get_joystick_build_path.js";
+import get_ssl_certificates from "./get_ssl_certificates.js";
+import types from "../lib/types.js";
+
+const start_express = (on_after_start_server = null, app_instance = {}) => {
+  const config = joystick?.settings?.config || {};
+  const joystick_build_path = get_joystick_build_path();
+  const ssl = get_ssl_certificates(app_instance?.options?.ssl);
+  const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 2600;
+
+  // NOTE: Reassign process.env in case we fell back to default port.
+  process.env.PORT = port;
+
+  const express_app = express();
+  const server = ssl ? https.createServer(ssl, express_app).listen(port) : express_app.listen(port);
+
+  built_in_middleware({
+    app_instance,
+    csp_config: app_instance?.options?.csp,
+  	express_app,
+  	joystick_build_path,
+    middleware_config: config?.middleware,
+    port,
+  });
+
+  if (app_instance?.options?.middleware && types.is_array(app_instance?.options?.middleware)) {
+  	for (let i = 0; i < app_instance?.options?.middleware?.length; i += 1) {
+  		const middleware_to_run = app_instance?.options?.middleware[i];
+  		express_app.use(middleware_to_run);
+  	}
+  }
+
+  const instance = {
+    port,
+    app: express_app,
+    server,
+  };
+
+  if (types.is_function(on_after_start_server)) {
+    on_after_start_server(instance, app_instance);
+  }
+
+  return instance;
+};
+
+export default start_express;
+

package/src/app/start_node_as_cluster.js

@@ -0,0 +1,30 @@
+import cluster from "cluster";
+import os from "os";
+
+const start_node_as_cluster = (callback = null) => {
+  const cpus = os.cpus().length;
+
+  if (cluster.isPrimary) {
+    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 default start_node_as_cluster;

package/src/app/uploaders/local_upload_progress_middleware.js

@@ -0,0 +1,24 @@
+import emit_websocket_event from "../websockets/emit_event.js";
+import float_to_decimal_place from '../../lib/float_to_decimal_place.js';
+
+const local_upload_progress_middleware = (providers = 1, req = {}, res = {}, next) => {
+  let progress = 0;
+  const file_size = parseInt(req.headers["content-length"], 10);
+
+  req.on("data", (chunk) => {
+    if (chunk.length > 0) {
+      progress += chunk.length;
+      const percentage = float_to_decimal_place((progress / (file_size * providers)) * 100);
+      emit_websocket_event(
+        `uploaders_${req?.headers["x-joystick-upload-id"]}`,
+        "progress",
+        { provider: "local", progress: percentage }
+      );
+    }
+  });
+
+  next();
+};
+
+export default local_upload_progress_middleware;
+

package/src/app/uploaders/register.js

@@ -0,0 +1,169 @@
+import multer from 'multer';
+import get_browser_safe_request from '../../lib/get_browser_safe_request.js'
+import handle_api_error from '../api/handle_api_error.js';
+import is_valid_json from '../../lib/is_valid_json.js';
+import local_upload_progress_middleware from './local_upload_progress_middleware.js';
+import run_upload from './run_upload.js';
+import string_to_slug from "../../lib/string_to_slug.js";
+import track_function_call from '../../test/track_function_call.js';
+import types from '../../lib/types.js';
+import validate_uploader_options from './validate_options.js';
+import validate_uploads from './validate_uploads.js';
+
+const upload_files = async (upload_options = {}) => {
+  const upload_size = parseInt(upload_options?.req?.headers["content-length"], 10);
+  const providers = upload_options?.uploader_options?.providers?.includes("local")
+    // NOTE: If an explicit local upload is defined, we DO NOT want to account for
+  	// the transfer from the client to the server. That progress has already been
+  	// tracked via the local_upload_progress_middleware.
+    ? upload_options?.uploader_options?.providers.length
+    // NOTE: If there IS NOT a local upload, we want to account for the transfer
+    // from the client to the server.
+    : upload_options?.uploader_options?.providers?.length + 1;
+  const total_upload_size_all_providers = upload_size * providers;
+
+  return run_upload({
+    // NOTE: This accounts for the file being uploaded to the server which should factor in to
+    // the current upload progress. More important for big files or multiple files.
+    existing_upload_progress: upload_size,
+    total_upload_size_all_providers,
+    uploads: upload_options?.validated_uploads,
+    input: upload_options?.upload_input,
+    req: upload_options?.req,
+  });
+};
+
+const handle_on_after_upload = async (uploader_name = '', on_after_upload = null, on_after_upload_options = {}) => {
+  // NOTE: IF this throws an error, abort upload.
+  await on_after_upload({
+    input: on_after_upload_options?.input,
+    req: on_after_upload_options?.req,
+    uploads: on_after_upload_options?.uploads,
+  });
+
+  track_function_call(`node.uploaders.${uploader_name}.on_after_upload`, [{
+    input: on_after_upload_options?.input,
+    req: get_browser_safe_request(on_after_upload_options?.req),
+    uploads: on_after_upload_options?.uploads,
+  }]);
+};
+
+const handle_on_before_upload = async (uploader_name = '', on_before_upload = null, on_before_upload_options = {}) => {
+  // NOTE: IF this throws an error, abort upload.
+  await on_before_upload({
+    input: on_before_upload_options?.input,
+    req: on_before_upload_options?.req,
+    uploads: on_before_upload_options?.uploads,
+  });
+
+  track_function_call(`node.uploaders.${uploader_name}.on_before_upload`, [{
+    input: on_before_upload_options?.input,
+    req: get_browser_safe_request(on_before_upload_options?.req),
+    uploads: on_before_upload_options?.uploads,
+  }]);
+};
+
+const get_uploader_input = (input = '') => {
+	return input && is_valid_json(input) && JSON.parse(input);
+};
+
+const handle_upload = async (uploader_name = '', uploader_options = {}, req = {}, res = {}) => {
+	try {
+		const uploader_input = get_uploader_input(req?.headers['x-joystick-upload-input']);
+
+		const validated_uploads = await validate_uploads({
+			files: req?.files,
+			uploader_input,
+			uploader_name,
+			uploader_options
+	  });
+
+		if (validated_uploads?.errors) {
+			return handle_api_error(`uploaders.${uploader_name}`, validated_uploads, res);
+		}
+
+	  if (types.is_function(uploader_options?.onBeforeUpload) || types.is_function(uploader_options?.on_before_upload)) {
+	  	await handle_on_before_upload(uploader_name, uploader_options?.onBeforeUpload || uploader_options?.on_before_upload, {
+	      input: uploader_input,
+	      req,
+	      uploads: validated_uploads,
+	    });
+	  }
+
+	  const uploaded_files = await upload_files({
+	  	validated_uploads,
+	  	uploader_input,
+	  	uploader_options,
+	  	req,
+	  });
+
+	  if (types.is_function(uploader_options?.onAfterUpload) || types.is_function(uploader_options?.on_after_upload)) {
+	  	await handle_on_after_upload(uploader_name, uploader_options?.onAfterUpload || uploader_options?.on_after_upload, {
+	      input: uploader_input,
+	      req,
+	      uploads: uploaded_files,
+	    });
+	  }
+
+	  return res.status(200).send(JSON.stringify({ uploads: uploaded_files }));
+	} catch (error) {
+		handle_api_error(`uploaders.${uploader_name}`, error, res);
+	}
+};
+
+const register_uploader_route = (uploader_name = '', uploader_options = {}, app_instance = {}) => {
+	const formatted_uploader_name = string_to_slug(uploader_name);
+	const max_upload_size = uploader_options?.maxSizeInMegabytes || uploader_options?.max_size_in_megabytes;
+	const uploader = multer({ limits: { fileSize: `${max_upload_size || 10}MB` } });
+	// NOTE: Max of 10 files at a time to avoid flooding the server.
+	const multer_middleware = uploader.array('files', 10);
+	const providers = uploader_options?.providers?.includes('local') ?
+		uploader_options?.providers?.length :
+		uploader_options?.providers?.length + 1;
+
+	app_instance.express.app.post(
+		`/api/_uploaders/${formatted_uploader_name}`,
+		(req, res, next) => local_upload_progress_middleware(providers, req, res, next),
+		// NOTE: Sigh. No other way to hook into the error handling for Multer.
+		(req, res, next) => multer_middleware(req, res, (multer_error) => {
+			if (multer_error) {
+				let error = multer_error;
+
+				if (multer_error?.message === 'File too large') {
+					error = new Error(`Max file size is ${max_upload_size}MB.`);
+				}
+
+				handle_api_error(`uploader.${uploader_name}`, error, res);
+			} else {
+				next();
+			}
+		}),
+		(req = {}, res = {}) => handle_upload(uploader_name, uploader_options, req, res),
+	);
+};
+
+const warn_uploader_options_errors = (uploader_options_errors = []) => {
+	if (uploader_options_errors?.length > 0) {
+		for (let i = 0; i < uploader_options_errors?.length; i += 1) {
+			const uploader_options_error = uploader_options_errors[i];
+			console.error(uploader_options_error);
+		}
+	}
+};
+
+const register = (user_uploader_definitions = {}, app_instance = {}) => {
+  const uploader_definitions = Object.entries(user_uploader_definitions);
+
+  for (let i = 0; i < uploader_definitions?.length; i += 1) {
+  	const [uploader_name, uploader_options] = uploader_definitions[i];
+  	const uploader_options_errors = validate_uploader_options(uploader_options);
+
+  	warn_uploader_options_errors(uploader_options_errors);
+
+  	if (uploader_options_errors?.length === 0) {
+  		register_uploader_route(uploader_name, uploader_options, app_instance);
+  	}
+  }
+};
+
+export default register;