@isoftdata/utility-dashboard-backend 2.0.1 → 2.1.0

package/chart-helper.js

@@ -1,268 +0,0 @@
-const { formatterTemplates } = require('./formatter-templates.json')
-const toSnakeCase = require('to-snake-case')
-const mysqlDataTypes = require('mysql/lib/protocol/constants/types')
-const klona = require('klona')
-const styleTableRow = require('./style-templates.js')
-
-const mysqlToGoogleChartsDataTypeMap = mysqlDataType => {
-	switch (mysqlDataType) {
-		case 'VAR_STRING':
-		case 'STRING':
-		case 'ENUM':
-		case 'VARCHAR':
-			return 'string'
-		case 'DECIMAL':
-		case 'NEWDECIMAL':
-		case 'BIT':
-		case 'TINY':
-		case 'SHORT':
-		case 'LONG':
-		case 'FLOAT':
-		case 'DOUBLE':
-		case 'LONGLONG':
-		case 'INT24':
-		case 'YEAR':
-			return 'number'
-		case 'TIMESTAMP':
-		case 'DATETIME':
-		case 'TIMESTAMP2':
-		case 'DATETIME2':
-			return 'datetime'
-		case 'DATE':
-		case 'NEWDATE':
-			return 'date'
-		case 'TIME':
-		case 'TIME2':
-			return 'timeofday'
-		default:
-			return 'string'
-	}
-}
-
-const makeDataTableCol = (key, fields, role = null) => {
-	return {
-		id: toSnakeCase(key).toLowerCase(),
-		label: key,
-		type: mysqlToGoogleChartsDataTypeMap(fields[key]),
-		role,
-	}
-}
-
-module.exports = {
-	queryWithFields: (connection, query) => { // the only function here that talks to the server at all
-		return new Promise((resolve, reject) => {
-			connection.query(query, (err, results, fields) => {
-				if (err) {
-					console.error('Error running query for dashboard chart', err)
-					reject(err)
-				} else {
-					resolve({
-						results,
-						fields: fields.reduce((sum, field) => {
-							return {
-								...sum,
-								[field.name]: mysqlDataTypes[field.type] || field.type,
-							}
-						}, {}),
-					})
-				}
-			})
-		})
-	},
-	getMultiSeriesData: ({ data: queryResult, seriesOptions, formatting, fields }) => {
-		const { groupXAxisBy, series, value, tooltip } = seriesOptions
-		//Get an array of all of the keys for the series
-		const allOfTheKeysInTheSeries = new Set(queryResult.map(row => row[series]))
-
-		let objectOfAllKeysWithNullValues = {}
-		for (const key of allOfTheKeysInTheSeries) {
-			objectOfAllKeysWithNullValues[key] = null
-			//add in a spot for the tooltips for each column to go
-			if (tooltip) {
-				objectOfAllKeysWithNullValues[`${tooltip} ${key}`] = null
-			}
-		}
-
-		let grouped = {}
-
-		//create objects for each thing they're grouping by
-		// console.time(`create objects for each thing they're grouping by`)
-		for (const row of queryResult) {
-			//if we don't yet have a prop for what we're grouping by, then we need to initialize an object of all null values for it
-			if (!grouped[row[groupXAxisBy]]) {
-				grouped[row[groupXAxisBy]] = klona(objectOfAllKeysWithNullValues) //give nulls for all values by default
-			}
-
-			grouped[row[groupXAxisBy]][row[series]] = row[value]
-			// add the tooltips for each series in each row
-			if (tooltip) {
-				grouped[row[groupXAxisBy]][`${tooltip} ${row[series]}`] = row[tooltip]
-			}
-		}
-		// console.timeEnd(`create objects for each thing they're grouping by`)
-
-		//The mysql field types need to map to our output data
-		let seriesFields = { [groupXAxisBy]: fields[groupXAxisBy] }
-		let seriesFormatting = {}
-		for (const key of allOfTheKeysInTheSeries) {
-			seriesFields[key] = fields[value]
-			//add tooltips here, so a tooltip column is created for every series column
-			if (tooltip) {
-				seriesFields[`${tooltip} ${key}`] = fields[tooltip]
-			}
-			//If there is any formatting applied to the value, we need to apply it to all of the other keys
-			if (formatting && value in formatting) {
-				seriesFormatting[key] = formatting[value]
-			}
-		}
-
-		//turn it back to an array and make sure the grouping column is first as required by a pie chart(at least)
-		// console.time(`group it back together`)
-		let multiSeriesData = []
-		for (const key in grouped) {
-			multiSeriesData.push({
-				[groupXAxisBy]: key,
-				...grouped[key],
-			})
-		}
-		// console.timeEnd(`group it back together`)
-		// console.log(`${multiSeriesData.length} rows with ${Object.keys(multiSeriesData[0]).length} props each.`)
-		return {
-			data: multiSeriesData,
-			formatting: {
-				...formatting,
-				...seriesFormatting,
-			},
-			fields: seriesFields,
-		}
-	},
-	makeNegativeNumbericValuesZero: resultSet => {
-		const numberCols = Object.keys(resultSet[0]).filter(key => typeof resultSet[0][key] === 'number')
-
-		return resultSet.map(row => {
-			numberCols.forEach(col => {
-				if (row[col] < 0) {
-					row[col] = 0
-				}
-			})
-
-			return row
-		})
-	},
-	coerceNullColumn: (columnProp, data, destinationType) => {
-		const hasNullValue = data.find(row => row[columnProp] === null)
-
-		if (hasNullValue) {
-			const rowWithValidValue = data.find(row => row[columnProp] !== null)
-			let nullReplacement = ''
-
-			if ((destinationType && destinationType === 'number') || (rowWithValidValue && typeof rowWithValidValue[columnProp] === 'number')) {
-				nullReplacement = 0
-			}
-
-			return data.map(row => {
-				return {
-					...row,
-					[columnProp]: row[columnProp] ?? nullReplacement,
-				}
-			})
-		} else {
-			return data
-		}
-	},
-	handleFormattingTemplates: formatting => {
-		if (formatting && typeof formatting === 'object') {
-			for (const key in formatting) {
-				if (typeof formatting[key].format === 'string') {
-					if (formatting[key].format in formatterTemplates) {
-						formatting[key].format = formatterTemplates[formatting[key].format]
-					} else {
-						formatting[key].format = {}
-					}
-				}
-			}
-		}
-
-		return formatting
-	},
-	getDataTableFormat: (data, fields, multiSeries) => {
-		let cols = []
-		// domain column for multiseries charts
-		if (multiSeries) {
-			cols = [ makeDataTableCol(multiSeries.groupXAxisBy, fields) ]
-		}
-		// All other columns (including domain for non multiseries charts)
-		for (const key in fields) {
-			if (!multiSeries || key !== multiSeries.groupXAxisBy) {
-				if (multiSeries && multiSeries.tooltip && key.includes(multiSeries.tooltip)) {
-					// If it's a tooltip, set the column's role exlicitly
-					cols.push(makeDataTableCol(key, fields, 'tooltip'))
-				} else {
-					// Otherwise, role is implicitly assigned
-					cols.push(makeDataTableCol(key, fields))
-				}
-			}
-		}
-
-		const rows = data.map(row => {
-			let items = []
-
-			for (const column in row) {
-				items.push({ v: row[column] })
-			}
-
-			return {
-				c: items,
-			}
-		})
-
-		return { cols, rows }
-	},
-	/**
-	 * Replace all null values with the previous non-null value, and optionally make data cumulative
-	 * @param {Object} dataTable - the data table
-	 * @param {Boolean} cumulative - whether to make the data cumulative, or fill remove holes in the data. Defaults to true.
-	 * @returns
-	 */
-	makeDataCumulative: (dataTable, cumulative = true) => {
-		dataTable.rows.forEach((row, rowIndex) => {
-			if (rowIndex > 0) {
-				row.c.forEach((col, colIndex) => {
-					if (colIndex > 0 && col.v == null) {
-						col.v = Number(dataTable.rows[rowIndex - 1].c[colIndex].v)
-					} else if (cumulative && colIndex > 0) {
-						col.v = Number(col.v) + Number(dataTable.rows[rowIndex - 1].c[colIndex].v)
-					}
-				})
-			}
-		})
-		return dataTable
-	},
-	getRactiveTableDataFormat: (rows, fields, formatting, styleTemplate = {}) => {
-		const columns = Object.keys(fields).map(field => {
-			// right align currency values
-			if (formatting?.[field]?.type === 'NumberFormat' && formatting?.[field].format.prefix === '$') {
-				return {
-					property: `${field}.value`,
-					name: field,
-					class: 'text-right border-top-0',
-				}
-			}
-			return {
-				property: `${field}.value`,
-				name: field,
-				class: 'border-top-0',
-			}
-		})
-		if (styleTemplate) {
-			rows = rows.map(row => {
-				return styleTableRow(row, styleTemplate)
-			})
-		}
-		return {
-			columns,
-			rows,
-			sortedRows: [],
-		}
-	},
-}

package/empty dashboard schema.sql

@@ -1,65 +0,0 @@
-/*
-SQLyog Ultimate v13.1.7 (64 bit)
-MySQL - 5.7.15-log : Database - itrackpro
-*********************************************************************
-*/
-
-/*!40101 SET NAMES utf8 */;
-
-/*!40101 SET SQL_MODE=''*/;
-
-/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
-/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
-/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
-/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
-/*Table structure for table `dashboard_chart` */
-
-DROP TABLE IF EXISTS `dashboard_chart`;
-
-CREATE TABLE `dashboard_chart` (
-  `chart_id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
-  `name` VARCHAR(64) NOT NULL COMMENT 'Internal name.',
-  `title` VARCHAR(64) NOT NULL COMMENT 'Title shown to user.',
-  `supertype` ENUM('google','table','embed') NOT NULL DEFAULT 'google' COMMENT 'Designates how the chart needs to be loaded and displayed.',
-  `json` TEXT NOT NULL COMMENT 'JSON options for charts.',
-  `show_chart` BIT(1) NOT NULL DEFAULT b'1' COMMENT 'Whether to show the chart in the charts list in the configuration screen.',
-  PRIMARY KEY (`chart_id`)
-) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;
-
-/*Table structure for table `dashboard_report` */
-
-DROP TABLE IF EXISTS `dashboard_report`;
-
-CREATE TABLE `dashboard_report` (
-  `dashboard_report_id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
-  `report_name` VARCHAR(64) NOT NULL COMMENT 'Used internally in the program. Snake case.',
-  `report_title` VARCHAR(64) NOT NULL COMMENT 'Shown to the user.',
-  `json` TEXT NOT NULL COMMENT 'Parameters for the report. Array of objects.',
-  `share_type` ENUM('user','group','store','everyone') NOT NULL DEFAULT 'everyone' COMMENT 'The type of id to use for sharing',
-  `share_id` INT(11) DEFAULT NULL COMMENT 'User/Group/Store Id',
-  `owner_id` INT(10) DEFAULT NULL COMMENT 'ID of the user who created the report. Used to control edit permissions on the client.',
-  PRIMARY KEY (`dashboard_report_id`)
-) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;
-
-/*Table structure for table `dashboard_report_chart` */
-
-DROP TABLE IF EXISTS `dashboard_report_chart`;
-
-CREATE TABLE `dashboard_report_chart` (
-  `report_chart_id` INT(11) NOT NULL AUTO_INCREMENT,
-  `dashboard_report_id` INT(10) UNSIGNED NOT NULL,
-  `chart_id` INT(10) UNSIGNED NOT NULL,
-  `rank` TINYINT(3) UNSIGNED NOT NULL DEFAULT '1' COMMENT 'Order to display this chart in this report.',
-  `json_override` TEXT COMMENT 'Json - report-specific overrides for chart options.',
-  PRIMARY KEY (`report_chart_id`),
-  UNIQUE KEY `UC_Report_Chart` (`dashboard_report_id`,`chart_id`),
-  KEY `maptochart` (`chart_id`),
-  KEY `reporttomap` (`dashboard_report_id`),
-  CONSTRAINT `maptochart` FOREIGN KEY (`chart_id`) REFERENCES `dashboard_chart` (`chart_id`) ON DELETE CASCADE ON UPDATE CASCADE,
-  CONSTRAINT `reporttomap` FOREIGN KEY (`dashboard_report_id`) REFERENCES `dashboard_report` (`dashboard_report_id`) ON DELETE CASCADE ON UPDATE CASCADE
-) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;
-
-/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
-/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
-/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
-/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

package/formatter-templates.json

@@ -1,15 +0,0 @@
-{
-	"formatterTemplates": {
-		"CURRENCY": {
-			"prefix": "$",
-			"fractionDigits": 2,
-			"groupingSymbol": ","
-		},
-		"MEDIUMDATE": {
-			"format": "medium"
-		},
-		"LONGDATE": {
-			"format": "long"
-		}
-	}
-}

package/index.js

@@ -1,284 +0,0 @@
-const db = require('@isoftdata/utility-db')
-const {
-	getMultiSeriesData,
-	makeNegativeNumbericValuesZero,
-	coerceNullColumn,
-	handleFormattingTemplates,
-	getDataTableFormat,
-	queryWithFields,
-	makeDataCumulative,
-	getRactiveTableDataFormat: getRactiveTableDataFormat } = require('./chart-helper.js')
-const { datesFromRange } = require('@isoftdata/utility-date-time')
-const { formatterTemplates } = require('./formatter-templates.json')
-const formatDate = require('date-fns/format')
-const camelcase = require('camelcase')
-const mysql = require('mysql')
-const deepmerge = require('deepmerge')
-const handleChartTypeSpecificQuirks = (chartType, resultSet) => {
-	if (resultSet.length) {
-		switch (chartType) {
-			case 'PieChart':
-				//PieCharts error if you have negative numbers, so we'll just set those to 0
-				resultSet = makeNegativeNumbericValuesZero(resultSet)
-				break
-			case 'TreeMap':
-				//tree charts need the 2nd columns to be not null
-				resultSet = coerceNullColumn(Object.keys(resultSet[0])[1], resultSet)
-				if (resultSet.length === 1) {
-					resultSet[0].id = 'No Data'
-				}
-				break
-			default:
-				//all charts need the first column to be not null
-				resultSet = coerceNullColumn(Object.keys(resultSet[0])[0], resultSet)
-		}
-	}
-
-	return resultSet
-}
-
-const loadChartData = async(mysqlConnection, { query: queryObject, formatting, chartWrapper, multiSeries, table, supertype, cumulative, ...theRest }) => { // needs database connection
-	if (!chartWrapper) {
-		chartWrapper = {
-			chartType: supertype,
-			options: {
-				height: 450, width: 800,
-			},
-		}
-	}
-
-	// There are area charts in the wild that need to be cumulative but aren't specifically flagged as such,
-	// So make area charts cumulative unless they're explicitly set not to be
-	cumulative = cumulative || (chartWrapper?.chartType === 'AreaChart' && cumulative !== false)
-
-	let dataTable = {}, processedFormatting = {}
-	try {
-		const dataTableAndProcessedFormatting = await loadDataTableAndProcessedFormatting(mysqlConnection, { query: queryObject, multiSeries, formatting, chartType: chartWrapper?.chartType, cumulative, table })
-		dataTable = dataTableAndProcessedFormatting.dataTable
-		processedFormatting = dataTableAndProcessedFormatting.processedFormatting
-	} catch (err) {
-		console.error('Error loading dataTable / processedFormatting')
-		throw err
-	}
-
-	if (chartWrapper?.chartType === 'Table') {
-		return {
-			...theRest,
-			supertype,
-			chartWrapper,
-			table: { ...table, ...dataTable }, // combine the data and any table setting overrides
-			formatting: processedFormatting,
-		}
-	}
-	return {
-		...theRest,
-		cumulative,
-		supertype,
-		chartWrapper: {
-			...chartWrapper,
-			dataTable,
-		},
-		formatting: processedFormatting,
-	}
-}
-/*
-*	Returns only the data needed to render out the chart. If chartType is 'Table', it will return it in the format consumed by the ractive table component.
-*	Otherwise, it will return data in the google chart Datatable object literal format.
-*	multiSeries, formatting properties should be deconstructed from the chart object, chartType should be deconstructed from the chart's chartWrapper property
-*/
-const loadDataTableAndProcessedFormatting = async(mysqlConnection, { query: queryObject, multiSeries, formatting, chartType, cumulative, table }) => {
-	let { results: queryResultSet, fields } = (queryObject && queryObject.sql) ? await queryWithFields(mysqlConnection, queryObject) : { fields: [], results: [] }
-	let data = handleChartTypeSpecificQuirks(chartType, queryResultSet)
-
-	if (multiSeries) {
-		({ data, formatting, fields } = getMultiSeriesData({
-			data,
-			seriesOptions: multiSeries,
-			formatting,
-			fields,
-		}))
-	}
-
-	const processedFormatting = handleFormattingTemplates(formatting)
-
-	if (chartType?.toLowerCase() === 'table') {
-		return { dataTable: getRactiveTableDataFormat(data, fields, processedFormatting, table?.style), processedFormatting }
-	}
-
-	let dataTable = getDataTableFormat(data, fields, multiSeries) //per the Google Charts docs, the DataTable object literal format is the most performant, so we'll turn it into that format before returning
-
-	// Stacked area charts will have holes / jagged lines if there are nulls in the middle of a column,
-	// so always do this for those, even if we don't need it to be cumulative.
-	if (cumulative || chartType === 'AreaChart') {
-		dataTable = makeDataCumulative(dataTable, cumulative)
-	}
-
-	return { dataTable, processedFormatting }
-}
-
-const loadDataTable = async(mysqlConnection, { query: queryObject, multiSeries, formatting, chartType }) => {
-	const { dataTable } = await loadDataTableAndProcessedFormatting(mysqlConnection, { query: queryObject, multiSeries, formatting, chartType })
-	return dataTable
-}
-const loadOptionList = async(mysqlConnection, optionListQuery, optionList = []) => {
-	return [
-		...optionList,
-		// ...(optionListQuery && await query(mysqlConnection, optionListQuery)) || [],
-		...(optionListQuery && await db.query(mysqlConnection, optionListQuery)) || [],
-
-	]
-}
-
-const loadOutputParameterValues = async(mysqlConnection, { definitionList = [], selectionList = [], forClient = false, session = {} }) => {
-	let parameterValues = []
-
-	// If definitionList is not an Array, there are no parameters, so just return []
-	if (!(definitionList instanceof Array)) {
-		return []
-	}
-
-	for (const definition of definitionList) {
-		const matchingParameterSelection = selectionList.find(param => param.name === definition.name)
-
-		let parameter = {
-			name: definition.name,
-			type: definition.type,
-			title: definition.title || definition.name,
-			default: definition.default,
-			value: (matchingParameterSelection && matchingParameterSelection.value) || definition.default,
-			queryValues: {},
-		}
-
-		if (definition.type === 'dateRange') {
-			parameter.dates = matchingParameterSelection?.dates || { to: null, from: null }
-			parameter.value = parameter.value || 'Last 30 Days'
-			if (parameter.value !== 'Custom') {
-				parameter.dates = datesFromRange(parameter.value)
-			}
-			if (!forClient) {
-				parameter.queryValues = {
-					[`${parameter.name}_start_date`]: parameter.dates.from,
-					[`${parameter.name}_end_date`]: parameter.dates.to,
-				}
-			}
-		} else if (definition.type === 'selection') {
-			parameter.optionList = await loadOptionList(mysqlConnection, definition.optionListQuery, definition.optionList) // queries db
-			// Make sure the value they gave us is in the option list, otherwise take the first one, to prevent putting invalid values in the query
-			if (!parameter.optionList.map(option => option.id).includes(parameter.value)) {
-				console.log('Invalid parameter value supplied', parameter.value)
-				parameter.value = parameter.optionList?.[0]?.id
-			}
-
-			const option = parameter.optionList.find(option => option.id === parameter.value)
-
-			if (!forClient) {
-				parameter.queryValues = {
-					[parameter.name]: option.rawSql ? mysql.raw(parameter.value) : parameter.value,
-				}
-			}
-		} else if (definition.type === 'date') {
-			parameter.value = parameter.value || formatDate(new Date(), 'yyyy-MM-dd')
-			if (!forClient) {
-				parameter.queryValues = {
-					[parameter.name]: parameter.value,
-				}
-			}
-		} else if (definition.type === 'session') {
-			// I think 'name' is the internal name of the parameter, and we should be able to expect that to be the name of the session variable
-			// Or we could have a separate value for the name of the session variable
-			// Might need to make this more complicated to handle nested variables
-			parameter.value = session[camelcase(definition.name)]
-			if (!forClient) {
-				parameter.queryValues = {
-					[parameter.name]: parameter.value,
-				}
-			}
-		}
-
-		parameterValues.push(parameter)
-	}
-
-	return parameterValues
-}
-
-/**
- *
- * @param {string} query - unparameterized query, with ${placeholders} for parameters
- * @param {Array<Object>} parameterValues - Parameter values to be plugged into the query
- * @returns {{sql: string, values: Array}}
- */
-const parameterizeQuery = (query, parameterValues) => {
-	// Don't parameterize a lack of a query
-	if (!query) {
-		return {
-			sql: '',
-			values: [],
-		}
-	}
-	const queryParameterValues = parameterValues.reduce((acc, val) => {
-		return val.queryValues ? {
-			...acc,
-			...val.queryValues,
-		} : acc
-	}, {})
-
-	//match on a token that starts with ${ and ends with a closing }.
-	//Then include a capture group to get the inner part of that to use as a key
-	const regexp = /\${([^}]+)}/g
-
-	const queryParameterKeys = [ ...query.matchAll(regexp) ].map(([ fullToken, insideToken ]) => insideToken.trim())
-	//if they put a token in the query that isn't one of the defined parameters of the report, just return null?
-	const queryParameters = queryParameterKeys.map(key => queryParameterValues[key] || null)
-
-	return {
-		sql: query.replace(regexp, '?'),
-		values: queryParameters,
-	}
-}
-
-module.exports = {
-	formatReportMetadata: async(mysqlConnection, { report, chartsInReport, session = {} }) => {
-		try {
-			const parameterValues = await loadOutputParameterValues(mysqlConnection, { definitionList: report.parameters, forClient: true, session })
-
-			return {
-				dashboardReportId: report.dashboardReportId,
-				name: report.reportName,
-				title: report.reportTitle,
-				charts: chartsInReport,
-				parameterValues,
-				ownerId: report.ownerId,
-				autoRefreshInterval: report.autoRefreshInterval,
-			}
-		} catch (err) {
-			console.error(err)
-			throw err
-		}
-	},
-	formatChartDataForReport: async(mysqlConnection, { reportParameters, chart, reportChart, parameterSelectionList, session = {} }) => {
-		try {
-			const parameterValues = await loadOutputParameterValues(mysqlConnection, { definitionList: reportParameters, selectionList: parameterSelectionList, session })
-			if (reportChart?.jsonOverride?.chartWrapper?.dataTable) {
-				const { dataTable, ...chartWrapper } = reportChart.jsonOverride.chartWrapper
-				reportChart.jsonOverride.chartWrapper = chartWrapper
-			}
-			const combinedChart = deepmerge(chart, reportChart.jsonOverride ?? {})
-			return await loadChartData(mysqlConnection, {
-				...combinedChart,
-				rank: reportChart.rank,
-				reportChartId: reportChart.reportChartId,
-				query: parameterizeQuery(chart.query, parameterValues),
-			})
-		} catch (err) {
-			console.error(err)
-			throw err
-		}
-	},
-	loadOutputParameterValues,
-	loadDataTable,
-	loadDataTableAndProcessedFormatting,
-	parameterizeQuery,
-	handleFormattingTemplates,
-	formatterTemplates,
-	// TODO: function that diffs the default chart options with the ones being saved, and returns the difference to be saved as overrides
-}