@quillsql/react 2.12.37 → 2.12.39

package/dist/esm/utils/tableProcessing.js

@@ -0,0 +1,301 @@
+import { convertPostgresColumn } from './columnProcessing';
+import { MAX_PIVOT_UNIQUE_VALUES } from './constants';
+import { getData } from './dataFetcher';
+import { parseValueFromBigQueryDates } from './dataProcessing';
+import { parseDateByDatabaseType } from './dates';
+import { processFilterErrorList } from './errorProcessing';
+import { mergeComparisonRange } from './merge';
+import { DEFAULT_PAGINATION } from './paginationProcessing';
+import { generateCountQuery, generateDistinctQuery, generateMinMaxRangeQueries, } from './queryConstructor';
+export const hasColumnAlias = (columns, referencedColumns) => {
+    if (!referencedColumns) {
+        return true;
+    }
+    for (const column of columns) {
+        if (!referencedColumns.includes(column.field)) {
+            return true;
+        }
+    }
+    return false;
+};
+export const getUniqueValuesByColumns = async (columns, query, rows, client, customFields) => {
+    const stringNames = columns.map((column) => column.field);
+    const uniqueValues = {};
+    if (!client.databaseType ||
+        client.databaseType.toLowerCase() === 'bigquery') {
+        if (rows.length === 0) {
+            const hostedBody = {
+                metadata: {
+                    query: query,
+                    task: 'query',
+                    orgId: client.customerId || '*',
+                    clientId: client.publicKey,
+                    databaseType: client?.databaseType,
+                    customFieldsByTable: customFields,
+                    useNewNodeSql: true,
+                },
+            };
+            const cloudBody = { query };
+            const data = await getData(client, 'dashquery', 'same-origin', hostedBody, cloudBody);
+            if (!data || data.errorMessage) {
+                return null;
+            }
+            rows = data.rows;
+        }
+        for (const column of columns) {
+            const values = Array.from(
+            //@ts-ignore
+            new Set(rows.map((row) => row[column.name || column.field])));
+            // @ts-ignore
+            uniqueValues[column.name || column.field] = values.reduce((result, value) => {
+                result[value] = false;
+                return result;
+            }, {});
+        }
+    }
+    else {
+        const distinctValueQuery = generateDistinctQuery(stringNames, query, client.databaseType);
+        const distinctStrings = await fetchDistinctStrings(distinctValueQuery, client, customFields);
+        if (!distinctStrings) {
+            return {};
+        }
+        for (const column of distinctStrings) {
+            uniqueValues[column.column] = column.values;
+        }
+    }
+    return uniqueValues;
+};
+export const getCountsByColumns = async (columns, query, client, customFields) => {
+    const stringNames = columns.map((column) => column.field);
+    const countQuery = generateCountQuery(stringNames, query, client.databaseType);
+    try {
+        const hostedBody = {
+            metadata: {
+                query: countQuery,
+                task: 'query',
+                orgId: client.customerId || '*',
+                clientId: client.publicKey,
+                databaseType: client?.databaseType,
+                customFieldsByTable: customFields,
+                useNewNodeSql: true,
+            },
+        };
+        const cloudBody = { countQuery };
+        const data = await getData(client, 'dashquery', 'same-origin', hostedBody, cloudBody);
+        if (data.errorMessage) {
+            return columns;
+        }
+        const results = data.rows.map((columnInfo) => {
+            return { field: columnInfo.field, count: columnInfo.count };
+        });
+        const filteredColumns = columns.filter((column) => {
+            const columnInfo = results.find((result) => result.field === column.field);
+            return columnInfo.count <= MAX_PIVOT_UNIQUE_VALUES;
+        });
+        return filteredColumns;
+    }
+    catch (e) {
+        return columns;
+    }
+};
+const fetchDistinctStrings = async (query, client, customFields) => {
+    try {
+        const hostedBody = {
+            metadata: {
+                query,
+                task: 'query',
+                orgId: client.customerId || '*',
+                clientId: client.publicKey,
+                databaseType: client?.databaseType,
+                customFieldsByTable: customFields,
+                useNewNodeSql: true,
+            },
+        };
+        const cloudBody = { query };
+        const data = await getData(client, 'dashquery', 'same-origin', hostedBody, cloudBody);
+        if (data.errorMessage) {
+            return null;
+        }
+        const results = data.rows.map((columnInfo) => {
+            const column = columnInfo.field;
+            if (!columnInfo.string_values) {
+                return { column, values: {} };
+            }
+            const values = columnInfo.string_values.reduce((result, value) => {
+                result[value] = false;
+                return result;
+            }, {});
+            return { column, values };
+        });
+        return results;
+    }
+    catch (e) {
+        return null;
+    }
+};
+export const getDateRangeByColumns = async (columns, query, client, customFields) => {
+    const columnNames = columns.map(
+    // @ts-ignore
+    (column) => column.field || column.name);
+    const distinctValueQuery = generateMinMaxRangeQueries(columnNames, query, client.databaseType);
+    const dateRanges = await fetchDateRanges(distinctValueQuery, client, customFields);
+    return dateRanges;
+};
+const fetchDateRanges = async (query, client, customFields) => {
+    try {
+        const hostedBody = {
+            metadata: {
+                query,
+                task: 'query',
+                orgId: client.customerId || '*',
+                clientId: client.publicKey,
+                databaseType: client?.databaseType,
+                customFieldsByTable: customFields,
+                useNewNodeSql: true,
+            },
+        };
+        const cloudBody = { query };
+        const data = await getData(client, 'dashquery', 'same-origin', hostedBody, cloudBody);
+        if (data.errorMessage) {
+            return null;
+        }
+        const results = data.rows.reduce((acc, currentValue) => {
+            acc[currentValue.field] = {
+                dateRange: {
+                    start: parseDateByDatabaseType(currentValue.min_range, client.databaseType),
+                    end: parseDateByDatabaseType(currentValue.max_range, client.databaseType),
+                },
+            };
+            return acc;
+        }, {});
+        return results;
+    }
+    catch (e) {
+        return null;
+    }
+};
+export const getPaginatedRows = async (client, query, reportId, processing, filters, customFields) => {
+    if (query) {
+        return await fetchTableByQuery(query, client, processing, customFields);
+    }
+    else if (reportId) {
+        return await fetchTableByReport(reportId, client, processing, filters, customFields);
+    }
+    return { rows: [], columns: [] };
+};
+export const fetchTableByQuery = async (query, client, processing, customFields) => {
+    let rows = [];
+    let columns = [];
+    let error = undefined;
+    let rowCount = undefined;
+    let itemQuery = undefined;
+    try {
+        const hostedBody = {
+            metadata: {
+                query,
+                task: 'query',
+                orgId: client.customerId || '*',
+                clientId: client.publicKey,
+                databaseType: client?.databaseType,
+                getCustomFields: !client.customerId || client.customerId === '*' ? false : true,
+                customFieldsByTable: customFields,
+                additionalProcessing: processing,
+                useUpdatedDataGathering: processing ? true : false,
+                useNewNodeSql: true,
+            },
+        };
+        const cloudBody = { query };
+        const resp = await getData(client, 'dashquery', 'same-origin', hostedBody, cloudBody);
+        if (resp && resp.errorMessage) {
+            throw new Error(resp.errorMessage);
+        }
+        if (resp.rowCount) {
+            rowCount = resp.rowCount;
+        }
+        columns = resp.fields.map((elem) => convertPostgresColumn(elem));
+        rows = resp.rows;
+        itemQuery = resp.itemQuery;
+    }
+    catch (e) {
+        rows = [];
+        columns = [];
+        error = e.message;
+    }
+    if (client.databaseType && client.databaseType.toLowerCase() === 'bigquery') {
+        parseValueFromBigQueryDates(rows, columns);
+    }
+    return { rows, columns, rowCount, error, itemQuery };
+};
+export const fetchTableByReport = async (reportId, client, processing, filters, customFields) => {
+    const updatedProcessing = { ...processing };
+    let rows = [];
+    let columns = [];
+    let rowCount;
+    let error;
+    if (processing && processing.sort && !updatedProcessing.page) {
+        updatedProcessing.page = DEFAULT_PAGINATION;
+        updatedProcessing.page.page = 0;
+    }
+    const processedFilters = filters ? filters : [];
+    const minimalFilters = Object.values(processedFilters).length
+        ? Object.values(processedFilters).map((filter) => {
+            const newFilter = { ...filter };
+            if (newFilter.filterType === 'date_range') {
+                delete newFilter['field'];
+                delete newFilter['options'];
+                delete newFilter['selectedValue'];
+            }
+            return newFilter;
+        })
+        : [];
+    try {
+        const hostedBody = {
+            metadata: {
+                dashboardItemId: reportId,
+                orgId: client?.customerId || '*',
+                task: 'item',
+                filters: minimalFilters,
+                clientId: client?.publicKey,
+                databaseType: client?.databaseType,
+                additionalProcessing: updatedProcessing,
+                forcePagination: true,
+                customFields,
+                useNewNodeSql: true,
+            },
+        };
+        const cloudBody = {
+            id: reportId,
+            filters: [],
+            useNewNodeSql: true,
+        };
+        const resp = await getData(client, 'itempost', 'omit', hostedBody, cloudBody);
+        if (resp.errorMessage) {
+            throw new Error(resp.errorMessage);
+        }
+        processFilterErrorList(resp);
+        if (resp.rowCount) {
+            rowCount = resp.rowCount;
+        }
+        const gatheredRows = resp.rows && resp.rows.length ? resp.rows : [];
+        columns = resp.fields.map((elem) => convertPostgresColumn(elem));
+        rows = gatheredRows;
+        if (resp && resp.name !== 'error') {
+            if (resp.compareRows) {
+                mergeComparisonRange(resp);
+            }
+        }
+        else {
+            throw new Error(resp.errorMessage);
+        }
+    }
+    catch (e) {
+        rows = [];
+        columns = [];
+        rowCount = 0;
+        error = e.message;
+    }
+    if (client.databaseType && client.databaseType.toLowerCase() === 'bigquery') {
+        parseValueFromBigQueryDates(rows, columns);
+    }
+    return { rows, columns, rowCount, error };
+};

package/dist/esm/utils/textProcessing.d.ts

@@ -0,0 +1,6 @@
+export declare function capitalize(text: string): string;
+export declare function depluralize(text: string): string;
+export declare function snakeCaseToTitleCase(str: string): string;
+export declare function snakeAndCamelCaseToTitleCase(str: string): string;
+export declare function removeDoubleQuotes(str: string): string;
+//# sourceMappingURL=textProcessing.d.ts.map

package/dist/esm/utils/textProcessing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/textProcessing.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQhD;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,UAa/C;AAED,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,MAAM,UAiBvD;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,UAK7C"}

package/dist/esm/utils/textProcessing.js

@@ -0,0 +1,49 @@
+export function capitalize(text) {
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}
+export function depluralize(text) {
+    if (text.endsWith('ies')) {
+        return text.slice(0, -3) + 'y';
+    }
+    if (text.endsWith('s')) {
+        return text.slice(0, -1);
+    }
+    return text;
+}
+export function snakeCaseToTitleCase(str) {
+    if (!str) {
+        return str;
+    }
+    return str
+        .toString()
+        .split(/_| /)
+        .map((word) => word === 'id'
+        ? 'ID'
+        : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join(' ');
+}
+export function snakeAndCamelCaseToTitleCase(str) {
+    if (!str) {
+        return str;
+    }
+    if (str.includes('_')) {
+        return str
+            .split(/_| /)
+            .map((word) => (word === 'id' ? 'ID' : capitalize(word)))
+            .join(' ');
+    }
+    else {
+        const text = str.replace(/([a-z])([A-Z])/g, '$1 $2');
+        const newText = text
+            .split(' ')
+            .map((word) => (word === 'Id' || word === 'id' ? 'ID' : capitalize(word)))
+            .join(' ');
+        return newText;
+    }
+}
+export function removeDoubleQuotes(str) {
+    if (!str) {
+        return str;
+    }
+    return str.replace(/"/g, '');
+}

package/dist/esm/utils/validation.d.ts

@@ -0,0 +1,9 @@
+import { ChartBuilderData } from '../ChartBuilder';
+export declare const validateReport: (formData: ChartBuilderData, dashboardData: {
+    filters?: any[];
+    dateFilter?: any;
+}, defaultDateFilter: {
+    table?: string;
+    field?: string;
+}, allTables: any[]) => any[];
+//# sourceMappingURL=validation.d.ts.map

package/dist/esm/utils/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/utils/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnD,eAAO,MAAM,cAAc,aACf,gBAAgB,iBACX;IAAE,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAAC,UAAU,CAAC,EAAE,GAAG,CAAA;CAAE,qBACjC;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,aAC1C,GAAG,EAAE,UA4BjB,CAAC"}

package/dist/esm/utils/validation.js

@@ -0,0 +1,20 @@
+export const validateReport = (formData, dashboardData, defaultDateFilter, allTables) => {
+    const issues = [];
+    const filters = dashboardData.filters || [];
+    const dateFilter = dashboardData.dateFilter;
+    if (dateFilter && dateFilter.comparison && formData.chartType === 'pie') {
+        issues.push(`"${formData.dashboardName}" is a date comparison dashboard that only supports line and column charts.`);
+    }
+    if (dateFilter &&
+        ((!defaultDateFilter.table && !defaultDateFilter.field) ||
+            (!formData.dateField.field && !formData.dateField.table))) {
+        issues.push(`Delete the date filter "${formData.dashboardName}" or add to another dashboard.`);
+    }
+    filters.forEach((filter) => {
+        const table = allTables.find((elem) => elem === filter.table);
+        if (!table) {
+            issues.push(`Delete the "${filter.label}" filter on "${formData.dashboardName}" or add to another dashboard.`);
+        }
+    });
+    return issues;
+};

package/dist/esm/utils/valueFormatter.d.ts

@@ -0,0 +1,29 @@
+import { type AxisFormat } from '../Dashboard';
+export type Field = {
+    _id: string;
+    label: string;
+    field: string;
+    format: AxisFormat;
+};
+type Props = {
+    value: any;
+    field: string | undefined | null;
+    fields: Field[];
+};
+export declare const DATE_FORMAT_TYPES: string[];
+export declare const NUMBER_FORMAT_TYPES: string[];
+/**
+ * Pretty-prints the given values to their nice-looking string form.
+ */
+export declare const valueFormatter: ({ value, field, fields }: Props) => string;
+export declare const quillFormat: ({ value, format, }: {
+    value: any;
+    format: string;
+}) => string;
+export declare const compareValues: (a: {
+    [key: string]: any;
+}, b: {
+    [key: string]: any;
+}, column: string) => number;
+export {};
+//# sourceMappingURL=valueFormatter.d.ts.map

package/dist/esm/utils/valueFormatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFormatter.d.ts","sourceRoot":"","sources":["../../../src/utils/valueFormatter.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,MAAM,KAAK,GAAG;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,UAAU,CAAC;CACpB,CAAC;AAEF,KAAK,KAAK,GAAG;IACX,KAAK,EAAE,GAAG,CAAC;IACX,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACjC,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,iBAAiB,UAQ7B,CAAC;AAEF,eAAO,MAAM,mBAAmB,UAM/B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,6BAA8B,KAAK,KAAG,MA0ChE,CAAC;AAEF,eAAO,MAAM,WAAW;WAIf,GAAG;YACF,MAAM;MACZ,MA2CH,CAAC;AAoNF,eAAO,MAAM,aAAa;;;;WAGhB,MAAM,KACb,MAkDF,CAAC"}