@quillsql/react 2.12.37 → 2.12.38

package/dist/esm/utils/report.js

@@ -0,0 +1,186 @@
+import { getYAxisFields } from './columnProcessing';
+import { cleanDashboardItem } from './dashboard';
+import { getData } from './dataFetcher';
+import { parseValueFromBigQueryDates } from './dataProcessing';
+import { DataLoadError } from './error';
+import { processFilterErrorList } from './errorProcessing';
+import { internalLog } from './logging';
+import { mergeComparisonRange } from './merge';
+import { isValidPivot } from './pivotProcessing';
+import { quillFormat } from './valueFormatter';
+export const EMPTY_REPORT = {
+    id: '',
+    name: '',
+    dashboardName: '',
+    rows: [],
+    columns: [],
+    chartType: '',
+    dateField: null,
+    pivot: null,
+    xAxisLabel: '',
+    xAxisField: '',
+    xAxisFormat: 'string',
+    yAxisFields: [],
+    order: -1,
+    compareRows: [],
+    filtersApplied: [],
+    queryString: '',
+    rowCount: 0,
+};
+export async function fetchReport(reportId, client, useReportTask = true, filters = [], additionalProcessing, dateBucket, customFields) {
+    let reportInfo = undefined;
+    let errorMessage = undefined;
+    try {
+        // Remove extra fields on each filter so we don't confuse the backend.
+        const hostedBody = {
+            metadata: {
+                reportId,
+                dashboardItemId: reportId,
+                orgId: client.customerId || '*',
+                clientId: client.publicKey,
+                task: useReportTask ? 'report' : 'item',
+                databaseType: client.databaseType,
+                filters: filters,
+                customFields,
+                additionalProcessing,
+                useNewNodeSql: true,
+            },
+        };
+        const cloudBody = {
+            id: reportId,
+            filters: filters,
+            useNewNodeSql: true,
+        };
+        const resp = await getData(client, 'itempost', 'omit', hostedBody, cloudBody, 'POST', 'fetch-data');
+        processFilterErrorList(resp);
+        const dashboardItem = { ...resp, filtersApplied: filters };
+        if (resp.errorMessage) {
+            throw new DataLoadError(resp?.errorMessage, {
+                ...resp,
+                useReportTask,
+            });
+        }
+        if (client.databaseType &&
+            client.databaseType.toLowerCase() === 'bigquery') {
+            parseValueFromBigQueryDates(dashboardItem.rows, resp.fields);
+        }
+        if (dashboardItem.compareRows) {
+            if (client.databaseType &&
+                client.databaseType.toLowerCase() === 'bigquery') {
+                parseValueFromBigQueryDates(dashboardItem.compareRows, resp.fields);
+            }
+            mergeComparisonRange(dashboardItem);
+        }
+        reportInfo = await cleanDashboardItem(dashboardItem, filters, client, dateBucket);
+        if (additionalProcessing) {
+            reportInfo.pagination = additionalProcessing.page;
+            reportInfo.sort = additionalProcessing.sort;
+        }
+    }
+    catch (error) {
+        if (error instanceof DataLoadError) {
+            if (error.data.useReportTask) {
+                internalLog('USING ITEM AS BACKUP');
+                const { report, error } = await fetchReport(reportId, client, false, filters, additionalProcessing, dateBucket, customFields);
+                reportInfo = report;
+                errorMessage = error;
+            }
+            else {
+                if (!error.data.data) {
+                    errorMessage = 'Failed to fetch chart';
+                    reportInfo = EMPTY_REPORT;
+                }
+                else {
+                    reportInfo = {
+                        ...error.data.data,
+                        id: error.data.data._id,
+                        error: error.message,
+                        adminError: error.data.adminErrorMessage,
+                    };
+                    errorMessage = error.message;
+                }
+            }
+        }
+        else {
+            reportInfo = {
+                id: reportId,
+                rows: [],
+                columns: [],
+            };
+            errorMessage = error.message;
+        }
+    }
+    return { report: reportInfo, error: errorMessage };
+}
+export const formatRowsFromReport = (report) => {
+    if (!report.rows || !report.columns) {
+        return [];
+    }
+    return report.rows.map((row) => {
+        return report.columns.reduce((formattedRow, column) => {
+            // Apply the format function to each field in the row
+            const formattedValue = quillFormat({
+                value: row[column.field],
+                format: column.format,
+            });
+            formattedRow[column.field] = formattedValue;
+            return formattedRow;
+        }, {});
+    });
+};
+export function convertInternalReportToReport(report) {
+    try {
+        if (!report) {
+            return EMPTY_REPORT;
+        }
+        const formattedReport = {
+            ...report,
+        };
+        if (formattedReport.pivot && isValidPivot(formattedReport.pivot)) {
+            let columns = report.pivotColumns ?? report.columns;
+            let rows = report.pivotRows ?? report.rows;
+            if (report.chartType === 'table') {
+                columns =
+                    report.pivotColumns?.map((col, index) => {
+                        if (index === 0) {
+                            return {
+                                ...col,
+                                format: col.format || 'string',
+                            };
+                        }
+                        return {
+                            ...col,
+                            format: report.pivot?.valueFieldType || 'whole_number',
+                        };
+                    }) ?? report.columns;
+                rows = formatRowsFromReport({ rows, columns });
+            }
+            else if (report.chartType === 'metric') {
+                columns =
+                    report.pivotColumns?.map((col) => {
+                        return { ...col, format: report.xAxisFormat };
+                    }) ?? report.columns;
+                rows = formatRowsFromReport({ rows, columns });
+            }
+            return {
+                ...formattedReport,
+                rows: rows,
+                yAxisFields: getYAxisFields(report),
+                columns: columns,
+                rowCount: rows ? rows.length : 0,
+            };
+        }
+        let rows = report.rows;
+        if (report.chartType === 'metric' || report.chartType === 'table') {
+            rows = formatRowsFromReport(report);
+        }
+        return {
+            ...formattedReport,
+            rows: rows,
+            yAxisFields: getYAxisFields(report),
+        };
+    }
+    catch (error) {
+        return EMPTY_REPORT;
+    }
+}

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

@@ -0,0 +1,6 @@
+export declare const getCustomFieldInfo: (client: any, caller?: string) => Promise<any[]>;
+export declare const getSchemaInfoWithCustomFields: (client: any, caller?: string) => Promise<{
+    schemaData: any;
+    customFieldsByTable: any[];
+}>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/utils/schema.ts"],"names":[],"mappings":"AAkDA,eAAO,MAAM,kBAAkB,WAAkB,GAAG,oCA+EnD,CAAC;AAEF,eAAO,MAAM,6BAA6B,WAChC,GAAG;;;EA6CZ,CAAC"}

package/dist/esm/utils/schema.js

@@ -0,0 +1,153 @@
+const triggerSoftUpdate = async (client, tables) => {
+    const { queryEndpoint, queryHeaders, publicKey } = client;
+    tables.forEach(async (table) => {
+        if (table.isSelectStar) {
+            fetch(`${queryEndpoint}?update-view`, {
+                method: 'POST',
+                headers: {
+                    ...queryHeaders,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    metadata: {
+                        preQueries: [table.viewQuery.replace(/;/, '')],
+                        clientId: publicKey,
+                        publicKey: publicKey,
+                        task: 'update-view',
+                        name: table.name,
+                        id: table._id,
+                        runQueryConfig: { getColumns: true },
+                    },
+                }),
+            });
+        }
+    });
+};
+const parseResponse = (results) => {
+    if (results.data?.data) {
+        if (results.data.data.queries &&
+            results.data.data.queries.queryResults.length > 0) {
+            return results.data.data.queries.queryResults;
+        }
+        else {
+            return results.data.data.tables;
+        }
+    }
+    else {
+        if (results.queries &&
+            results.queries.queryResults &&
+            results.queries.queryResults.length > 0) {
+            return results.queries.queryResults;
+        }
+        else {
+            return results.data.tables;
+        }
+    }
+};
+export const getCustomFieldInfo = async (client, caller = 'se') => {
+    let customFieldsByTableUnique = [];
+    try {
+        const { queryEndpoint, queryHeaders, publicKey, databaseType, customerId } = client;
+        if (databaseType.toLowerCase() !== 'postgresql' ||
+            !['65d65b57cdd8ae70a5648d9c', '665610862cf7a3000be66453'].includes(publicKey)) {
+            throw new Error('CUSTOM FIELDS IS ONLY ALLOWED FOR POSTGRESQL DATABASES');
+        }
+        const response = await fetch(`${queryEndpoint}?cfr-${caller}`, {
+            method: 'POST',
+            headers: {
+                ...queryHeaders,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                metadata: {
+                    clientId: publicKey,
+                    publicKey,
+                    task: 'custom-field-records',
+                    databaseType: databaseType,
+                    orgId: customerId,
+                },
+            }),
+        });
+        const result = await response.json();
+        const extractedData = parseResponse(result);
+        const customFieldsByTable = [];
+        extractedData.forEach((table) => {
+            if (!table.rows) {
+                return;
+            }
+            table.rows.forEach((row) => {
+                customFieldsByTable.push({
+                    view_name: table.name,
+                    ref_table: row.ref_table,
+                    field: row.field,
+                    ref_column: row.ref_column,
+                    type: row.type,
+                });
+            });
+        });
+        // make sure the are no duplicate records in extractedData
+        const customFieldsByTableSet = new Set();
+        customFieldsByTableUnique = customFieldsByTable.filter((item) => {
+            if (customFieldsByTableSet.has(item.view_name +
+                item.ref_table +
+                item.field +
+                item.ref_column +
+                item.type)) {
+                return false;
+            }
+            customFieldsByTableSet.add(item.view_name +
+                item.ref_table +
+                item.field +
+                item.ref_column +
+                item.type);
+            return true;
+        });
+    }
+    catch (e) {
+        return customFieldsByTableUnique;
+    }
+    return customFieldsByTableUnique;
+};
+export const getSchemaInfoWithCustomFields = async (client, caller = 'se') => {
+    const { queryEndpoint, queryHeaders, publicKey, customerId } = client;
+    let customFieldsByTableUnique = [];
+    let getCustomFields = true;
+    if (!customerId || customerId !== '*') {
+        try {
+            customFieldsByTableUnique = await getCustomFieldInfo(client, caller);
+        }
+        catch (e) {
+            getCustomFields = false;
+        }
+    }
+    const response = await fetch(`${queryEndpoint}?schema-${caller}`, {
+        method: 'POST',
+        headers: {
+            ...queryHeaders,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            metadata: {
+                clientId: publicKey,
+                publicKey: publicKey,
+                task: 'schema',
+                removeCustomerField: true,
+                getCustomFields: !client.customerId ||
+                    client.customerId === '*' ||
+                    (customFieldsByTableUnique.length === 0 && !getCustomFields)
+                    ? false
+                    : true,
+                orgId: client.customerId || '*',
+                customFieldsByTable: customFieldsByTableUnique,
+                gatherSchemaData: '665610862cf7a3000be66453' === publicKey ? true : false,
+            },
+        }),
+    });
+    const result = await response.json();
+    const parsedData = parseResponse(result);
+    triggerSoftUpdate(client, parsedData);
+    return {
+        schemaData: parsedData,
+        customFieldsByTable: customFieldsByTableUnique,
+    };
+};

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

@@ -0,0 +1,17 @@
+import { CSSProperties } from 'react';
+export type StyleInput = string | CSSProperties | undefined;
+export type StyleProps = {
+    className: string;
+} | {
+    style: CSSProperties;
+} | NonNullable<unknown>;
+/**
+ * Converts the given styles to a props object that can be passed directly into
+ * a jsx/tsx component. Converts to className if styles is a string, otherwise
+ * treats it as CSSProperties.
+ *
+ * Example:
+ * <div {...styleToProps(containerStyle)}>...</div>
+ */
+export declare function styleToProps(styles: StyleInput): StyleProps;
+//# sourceMappingURL=styles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../src/utils/styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAEtC,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,aAAa,GAAG,SAAS,CAAC;AAC5D,MAAM,MAAM,UAAU,GAClB;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GACrB;IAAE,KAAK,EAAE,aAAa,CAAA;CAAE,GACxB,WAAW,CAAC,OAAO,CAAC,CAAC;AAEzB;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAO3D"}

package/dist/esm/utils/styles.js

@@ -0,0 +1,16 @@
+/**
+ * Converts the given styles to a props object that can be passed directly into
+ * a jsx/tsx component. Converts to className if styles is a string, otherwise
+ * treats it as CSSProperties.
+ *
+ * Example:
+ * <div {...styleToProps(containerStyle)}>...</div>
+ */
+export function styleToProps(styles) {
+    if (!styles)
+        return {};
+    if (typeof styles === 'string') {
+        return { className: styles };
+    }
+    return { style: styles };
+}

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

@@ -0,0 +1,45 @@
+import { Column, ColumnInternal } from '../models/Columns';
+import { Pagination } from '../models/Pagination';
+export interface AdditionalProcessing {
+    sort?: {
+        field: string;
+        direction: string;
+    };
+    page?: Pagination;
+    last?: any;
+}
+export declare const hasColumnAlias: (columns: Column[], referencedColumns: string[]) => boolean;
+export declare const getUniqueValuesByColumns: (columns: Column[], query: string, rows: any, client: any, customFields: any[]) => Promise<{
+    [column: string]: {
+        [value: string]: boolean;
+    };
+} | null>;
+export declare const getCountsByColumns: (columns: Column[], query: string, client: any, customFields: any[]) => Promise<Column[]>;
+export declare const getDateRangeByColumns: (columns: Column[], query: string, client: any, customFields: any[]) => Promise<{
+    [column: string]: {
+        dateRange: {
+            start: Date;
+            end: Date;
+        };
+    };
+} | null>;
+export declare const getPaginatedRows: (client: any, query?: string, reportId?: string, processing?: AdditionalProcessing, filters?: any, customFields?: any) => Promise<{
+    columns: Column[];
+    rows: any[];
+    rowCount?: number;
+    error?: string;
+}>;
+export declare const fetchTableByQuery: (query: string, client: any, processing?: AdditionalProcessing, customFields?: any) => Promise<{
+    columns: ColumnInternal[];
+    rows: any[];
+    rowCount?: number | undefined;
+    error?: string | undefined;
+    itemQuery?: string[] | undefined;
+}>;
+export declare const fetchTableByReport: (reportId: string, client: any, processing?: AdditionalProcessing, filters?: any, customFields?: any) => Promise<{
+    columns: Column[];
+    rows: any[];
+    rowCount?: number | undefined;
+    error?: string | undefined;
+}>;
+//# sourceMappingURL=tableProcessing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tableProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/tableProcessing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAclD,MAAM,WAAW,oBAAoB;IACnC,IAAI,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5C,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED,eAAO,MAAM,cAAc,YAChB,MAAM,EAAE,qBACE,MAAM,EAAE,KAC1B,OAUF,CAAC;AAEF,eAAO,MAAM,wBAAwB,YAC1B,MAAM,EAAE,SACV,MAAM,QACP,GAAG,UACD,GAAG,gBACG,GAAG,EAAE;;;;SAkEpB,CAAC;AAEF,eAAO,MAAM,kBAAkB,YACpB,MAAM,EAAE,SACV,MAAM,UACL,GAAG,gBACG,GAAG,EAAE,KAClB,QAAQ,MAAM,EAAE,CA2ClB,CAAC;AAkDF,eAAO,MAAM,qBAAqB,YACvB,MAAM,EAAE,SACV,MAAM,UACL,GAAG,gBACG,GAAG,EAAE;;mBAEY;YAAE,KAAK,EAAE,IAAI,CAAC;YAAC,GAAG,EAAE,IAAI,CAAA;SAAE;;SAiB1D,CAAC;AA2DF,eAAO,MAAM,gBAAgB,WACnB,GAAG,UACH,MAAM,aACH,MAAM,eACJ,oBAAoB,YACvB,GAAG,iBACE,GAAG,KACjB,QAAQ;IACT,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAaA,CAAC;AAEF,eAAO,MAAM,iBAAiB,UACrB,MAAM,UACL,GAAG,eACE,oBAAoB,iBAClB,GAAG;aAET,cAAc,EAAE;UACnB,GAAG,EAAE;;;;EAqDZ,CAAC;AAEF,eAAO,MAAM,kBAAkB,aACnB,MAAM,UACR,GAAG,eACE,oBAAoB,YACvB,GAAG,iBACE,GAAG;aAET,MAAM,EAAE;UACX,GAAG,EAAE;;;EAgFZ,CAAC"}