@isoftdata/utility-dashboard-backend 2.0.1 → 2.1.0

package/README.md

@@ -17,16 +17,16 @@ This function returns data in the format expected for the `loadReportMetadata` f
 #### Function signature
 
 ```js
-async formatReportMetadata(mysqlConnection, { report, chartsInReport })
+async formatReportMetadata(mysqlConnection, { report, chartsInReport, session })
 ```
 
 #### Example Usage (From Pro Web `server/chart-loader.js`)
 
 ```js
-async function loadReportMetadata({ dashboardReportId, chartId }) {
+async function loadReportMetadata({ dashboardReportId, chartId, session }) {
 	const report = await db.dashboardReport.loadById({ dashboardReportId }) // gets a report by its id
 	const chartsInReport = await db.dashboardChart.loadByReport({ dashboardReportId, chartId }) // gets all charts for a specified report, or if `chartId` is specified, only gets that chart for that report.
-	return await formatReportMetadata(db.pool, { report, chartsInReport })
+	return await formatReportMetadata(db.pool, { report, chartsInReport, session })
 }
 ```
 
@@ -93,6 +93,16 @@ Example:
 ]
 ```
 
+#### session
+Session object from the Auth Module
+
+#### site (optional)
+The 'type' of site for the product this is used in. Determines the MySQL table to query for site selection parameters, and used to calculate `siteIdColumn` if that is not specified.
+#### siteIdColumn (optional)
+The name of the column that stores the site id in the site table. Defaults to `${site}id`.
+#### siteNameColumn (optional)
+The store name column.
+
 ### formatChartDataForReport
 
 This function returns data in the format expected for the `loadChartDataForReport` function on the dashboard client component, including applying any report-specific chart options overrides and running the chart's query.
@@ -100,18 +110,18 @@ This function returns data in the format expected for the `loadChartDataForRepor
 #### Function signature
 
 ```js
-async formatChartDataForReport(mysqlConnection, { reportParameters, chart, reportChart, parameterSelectionList })
+async formatChartDataForReport(mysqlConnection, { reportParameters, chart, reportChart, parameterSelectionList, session })
 ```
 
 #### Example usage: (from Pro Web `server/chart-loader.js`)
 
 ```js
-async function loadChartDataForReport ({ dashboardReportId, chartId, parameterSelectionList }) {
+async function loadChartDataForReport ({ dashboardReportId, chartId, parameterSelectionList, session }) {
 	const report = await db.dashboardReport.loadById({ dashboardReportId }) // get the report object
 	const chart = await db.dashboardChart.loadById({ chartId }) // get the chart object
 	const reportChart = await db.dashboardReportChart.loadByReportAndChartId({ chartId, dashboardReportId }) // get the report chart for the rank/overrides
 	try {
-		const chartData = await formatChartDataForReport(db.pool, { reportParameters: report.parameters, chart, reportChart, parameterSelectionList })
+		const chartData = await formatChartDataForReport(db.pool, { reportParameters: report.parameters, chart, reportChart, parameterSelectionList, session })
 		return chartData
 	} catch (err) {
 		console.error(err)
@@ -132,6 +142,9 @@ The id of a chart row in `wa_dashboard_chart`.
 #### parameterSelectionList
 The array of selected parameters sent from the client dashboard.
 
+#### session
+Session object from the Auth Module
+
 ### loadOutputParameterValues
 
 This function outputs the report's parameter values in the format expected by the dashboard client and backend. When sending to the client, including `forClient: true` will not include the properties only needed by the backend.

package/dist/chart-helper.d.ts

@@ -0,0 +1,32 @@
+import { Connection, OkPacket, ResultSetHeader, RowDataPacket } from "mysql";
+import { Formatting, GoogleDataTable, MultiSeriesOptions, ProcessedFormatting, Table } from "./types/chart";
+export type QueryFieldsObject = Record<string, string>;
+declare function queryWithFields(connection: Connection, query: {
+    sql: string;
+    values: unknown[];
+}): Promise<{
+    results: RowDataPacket[] | RowDataPacket[][] | OkPacket | OkPacket[] | ResultSetHeader;
+    fields: QueryFieldsObject;
+}>;
+interface getMultiSeriesDataInput {
+    data: RowDataPacket[];
+    seriesOptions: MultiSeriesOptions;
+    formatting?: Formatting;
+    fields: QueryFieldsObject;
+}
+declare function getMultiSeriesData({ data: queryResult, seriesOptions, formatting, fields }: getMultiSeriesDataInput): {
+    data: RowDataPacket[];
+    formatting: Formatting;
+    fields: Record<string, string>;
+};
+declare function makeNegativeNumbericValuesZero(resultSet: RowDataPacket[]): RowDataPacket[];
+declare function coerceNullColumn(columnProp: string, data: RowDataPacket[], destinationType?: unknown): RowDataPacket[];
+declare function handleFormattingTemplates(formatting?: Formatting): ProcessedFormatting;
+declare function getDataTableFormat(data: RowDataPacket[], fields: {
+    [key: string]: string;
+}, multiSeries?: MultiSeriesOptions): GoogleDataTable;
+declare function makeDataCumulative(dataTable: GoogleDataTable, cumulative?: boolean): GoogleDataTable;
+declare function getRactiveTableDataFormat(rows: RowDataPacket[], fields: {
+    [key: string]: string;
+}, formatting: ProcessedFormatting, styleTemplates?: {}): Table;
+export { queryWithFields, getMultiSeriesData, makeNegativeNumbericValuesZero, makeNegativeNumbericValuesZero as makeNegativeNumericValuesZero, coerceNullColumn, handleFormattingTemplates, getDataTableFormat, makeDataCumulative, getRactiveTableDataFormat, };

package/dist/chart-helper.js

@@ -0,0 +1,240 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRactiveTableDataFormat = exports.makeDataCumulative = exports.getDataTableFormat = exports.handleFormattingTemplates = exports.coerceNullColumn = exports.makeNegativeNumericValuesZero = exports.makeNegativeNumbericValuesZero = exports.getMultiSeriesData = exports.queryWithFields = void 0;
+const formatting_templates_1 = __importDefault(require("./formatting-templates"));
+const toSnakeCase = require('to-snake-case');
+const mysqlDataTypes = require('mysql/lib/protocol/constants/types');
+const style_templates_1 = __importDefault(require("./style-templates"));
+function 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';
+    }
+}
+function makeDataTableCol(key, fields, role = null) {
+    return {
+        id: toSnakeCase(key).toLowerCase(),
+        label: key,
+        type: mysqlToGoogleChartsDataTypeMap(fields[key]),
+        role,
+    };
+}
+function queryWithFields(connection, query) {
+    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,
+                        };
+                    }, {}) ?? {},
+                });
+            }
+        });
+    });
+}
+exports.queryWithFields = queryWithFields;
+function getMultiSeriesData({ data: queryResult, seriesOptions, formatting, fields }) {
+    const { groupXAxisBy, series, value, tooltip } = seriesOptions;
+    const allOfTheKeysInTheSeries = new Set(queryResult.map(row => row[series]));
+    const objectOfAllKeysWithNullValues = {};
+    for (const key of allOfTheKeysInTheSeries) {
+        objectOfAllKeysWithNullValues[key] = null;
+        if (tooltip) {
+            objectOfAllKeysWithNullValues[`${tooltip} ${key}`] = null;
+        }
+    }
+    const grouped = {};
+    for (const row of queryResult) {
+        if (!grouped[row[groupXAxisBy]]) {
+            grouped[row[groupXAxisBy]] = { ...objectOfAllKeysWithNullValues };
+        }
+        grouped[row[groupXAxisBy]][row[series]] = row[value];
+        if (tooltip) {
+            grouped[row[groupXAxisBy]][`${tooltip} ${row[series]}`] = row[tooltip];
+        }
+    }
+    const seriesFields = { [groupXAxisBy]: fields[groupXAxisBy] };
+    const seriesFormatting = {};
+    for (const key of allOfTheKeysInTheSeries) {
+        seriesFields[key] = fields[value];
+        if (tooltip) {
+            seriesFields[`${tooltip} ${key}`] = fields[tooltip];
+        }
+        if (formatting && value in formatting) {
+            seriesFormatting[key] = formatting[value];
+        }
+    }
+    const multiSeriesData = [];
+    for (const key in grouped) {
+        multiSeriesData.push({
+            [groupXAxisBy]: key,
+            ...grouped[key],
+        });
+    }
+    return {
+        data: multiSeriesData,
+        formatting: {
+            ...formatting,
+            ...seriesFormatting,
+        },
+        fields: seriesFields,
+    };
+}
+exports.getMultiSeriesData = getMultiSeriesData;
+function 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;
+    });
+}
+exports.makeNegativeNumbericValuesZero = makeNegativeNumbericValuesZero;
+exports.makeNegativeNumericValuesZero = makeNegativeNumbericValuesZero;
+function 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;
+    }
+}
+exports.coerceNullColumn = coerceNullColumn;
+function handleFormattingTemplates(formatting) {
+    const formattingOutput = {};
+    if (formatting && typeof formatting === 'object') {
+        for (const key in formatting) {
+            formattingOutput[key] = { type: formatting[key].type, format: null };
+            if (typeof formatting[key].format === 'string') {
+                if (formatting[key].format in formatting_templates_1.default) {
+                    formattingOutput[key].format = formatting_templates_1.default[formatting[key].format];
+                }
+            }
+        }
+    }
+    return formattingOutput;
+}
+exports.handleFormattingTemplates = handleFormattingTemplates;
+function getDataTableFormat(data, fields, multiSeries) {
+    let cols = [];
+    if (multiSeries) {
+        cols = [makeDataTableCol(multiSeries.groupXAxisBy, fields)];
+    }
+    for (const key in fields) {
+        if (!multiSeries || key !== multiSeries.groupXAxisBy) {
+            if (multiSeries?.tooltip && key.includes(multiSeries.tooltip)) {
+                cols.push(makeDataTableCol(key, fields, 'tooltip'));
+            }
+            else {
+                cols.push(makeDataTableCol(key, fields));
+            }
+        }
+    }
+    const rows = data.map(row => {
+        const items = [];
+        for (const column in row) {
+            items.push({ v: row[column] });
+        }
+        return {
+            c: items,
+        };
+    });
+    return { cols, rows };
+}
+exports.getDataTableFormat = getDataTableFormat;
+function 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;
+}
+exports.makeDataCumulative = makeDataCumulative;
+function getRactiveTableDataFormat(rows, fields, formatting, styleTemplates = {}) {
+    const columns = Object.keys(fields).map(field => {
+        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 (styleTemplates) {
+        rows = rows.map(row => {
+            return (0, style_templates_1.default)(row, styleTemplates);
+        });
+    }
+    return {
+        columns,
+        rows,
+    };
+}
+exports.getRactiveTableDataFormat = getRactiveTableDataFormat;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-helper.js","sourceRoot":"","sources":["../src/chart-helper.ts"],"names":[],"mappings":"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"}

package/dist/formatting-templates.d.ts

@@ -0,0 +1,3 @@
+import { FormattingTemplates } from "./types/chart";
+declare const formattingTemplates: FormattingTemplates;
+export default formattingTemplates;

package/dist/formatting-templates.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const formattingTemplates = {
+    "CURRENCY": {
+        "prefix": "$",
+        "fractionDigits": 2,
+        "groupingSymbol": ",",
+    },
+    "MEDIUMDATE": {
+        "format": "medium",
+    },
+    "LONGDATE": {
+        "format": "long",
+    },
+};
+exports.default = formattingTemplates;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybWF0dGluZy10ZW1wbGF0ZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZm9ybWF0dGluZy10ZW1wbGF0ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFFQSxNQUFNLG1CQUFtQixHQUF3QjtJQUNoRCxVQUFVLEVBQUU7UUFDWCxRQUFRLEVBQUUsR0FBRztRQUNiLGdCQUFnQixFQUFFLENBQUM7UUFDbkIsZ0JBQWdCLEVBQUUsR0FBRztLQUNyQjtJQUNELFlBQVksRUFBRTtRQUNiLFFBQVEsRUFBRSxRQUFRO0tBQ2xCO0lBQ0QsVUFBVSxFQUFFO1FBQ1gsUUFBUSxFQUFFLE1BQU07S0FDaEI7Q0FDRCxDQUFBO0FBQ0Qsa0JBQWUsbUJBQW1CLENBQUEifQ==

package/dist/index.d.ts

@@ -0,0 +1,73 @@
+import { handleFormattingTemplates } from './chart-helper.js';
+import * as formatterTemplates from './formatting-templates';
+import { DashboardReportParameter } from './types/parameter';
+import { Session, SiteType } from './types/session';
+import { MultiSeriesOptions, Formatting, Chart, Table, GoogleDataTable, ProcessedFormatting } from './types/chart';
+import { Connection } from 'mysql';
+import { Report, ReportInput } from './types/report';
+type LoadDataTableAndProcessedFormattingOptions = {
+    query: {
+        sql: string;
+        values: unknown[];
+    };
+    multiSeries?: MultiSeriesOptions;
+    formatting?: Formatting;
+    chartType: string;
+    cumulative?: boolean;
+    table?: Table;
+};
+declare function loadDataTableAndProcessedFormatting(mysqlConnection: Connection, { query: queryObject, multiSeries, formatting, chartType, cumulative, table }: LoadDataTableAndProcessedFormattingOptions): Promise<{
+    dataTable: GoogleDataTable | Table;
+    processedFormatting: ProcessedFormatting;
+}>;
+type loadDataTableOptions = {
+    query: {
+        sql: string;
+        values: unknown[];
+    };
+    multiSeries: MultiSeriesOptions;
+    formatting: Formatting;
+    chartType: string;
+};
+declare function loadDataTable(mysqlConnection: Connection, { query: queryObject, multiSeries, formatting, chartType }: loadDataTableOptions): Promise<GoogleDataTable>;
+type loadOutputParameterValuesOptions = {
+    definitionList: DashboardReportParameter[];
+    selectionList?: Array<Partial<DashboardReportParameter> & Pick<DashboardReportParameter, 'name'>>;
+    forClient?: boolean;
+    session: Session;
+    site?: SiteType;
+    siteIdColumn?: string;
+    siteNameColumn?: string;
+};
+declare function loadOutputParameterValues(mysqlConnection: Connection, { definitionList, selectionList, forClient, session, site, siteIdColumn, siteNameColumn }: loadOutputParameterValuesOptions): Promise<DashboardReportParameter[]>;
+declare const parameterizeQuery: (queryString: string, parameterValues: DashboardReportParameter[]) => {
+    sql: string;
+    values: unknown[];
+};
+type FormatReportMetadataOptions = {
+    report: ReportInput;
+    chartsInReport: Chart[];
+    session: Session;
+    site: SiteType;
+    siteIdColumn?: string;
+    siteNameColumn?: string;
+};
+declare function formatReportMetadata(mysqlConnection: Connection, { report, chartsInReport, session, site, siteIdColumn, siteNameColumn }: FormatReportMetadataOptions): Promise<Report>;
+type FormatChartDataForReportOptions = {
+    reportParameters: DashboardReportParameter[];
+    chart: Chart;
+    reportChart: {
+        chartId: number;
+        dashboardReportId: number;
+        jsonOverride: Partial<Chart>;
+        rank: number;
+        reportChartId: number;
+    };
+    parameterSelectionList: DashboardReportParameter[];
+    session: Session;
+    site: SiteType;
+    siteIdColumn?: string;
+    siteNameColumn?: string;
+};
+declare function formatChartDataForReport(mysqlConnection: Connection, { reportParameters, chart, reportChart, parameterSelectionList, session, site, siteIdColumn, siteNameColumn }: FormatChartDataForReportOptions): Promise<Omit<Chart, 'query'>>;
+export { formatReportMetadata, formatChartDataForReport, loadOutputParameterValues, loadDataTable, loadDataTableAndProcessedFormatting, parameterizeQuery, handleFormattingTemplates, formatterTemplates, };