@quillsql/react 2.12.37 → 2.12.39

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/utils/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,MAAM,CAAC;AACzC,eAAO,MAAM,uBAAuB,MAAM,CAAC"}

package/dist/esm/utils/constants.js

@@ -0,0 +1,2 @@
+export const MAX_COLUMN_ROWS_LIMIT = 500;
+export const MAX_PIVOT_UNIQUE_VALUES = 250;

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

@@ -0,0 +1,2 @@
+export declare function hashCode(obj: any): number;
+//# sourceMappingURL=crypto.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../../src/utils/crypto.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,UAShC"}

package/dist/esm/utils/crypto.js

@@ -0,0 +1,10 @@
+export function hashCode(obj) {
+    const serializedObj = JSON.stringify(obj);
+    let hashCode = 0;
+    for (let i = 0; i < serializedObj.length; i++) {
+        const char = serializedObj.charCodeAt(i);
+        hashCode = (hashCode << 5) - hashCode + char;
+        hashCode |= 0;
+    }
+    return hashCode;
+}

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

@@ -0,0 +1,6 @@
+export declare const downloadCSV: (data: {
+    rows: any[];
+    fields?: any[];
+    name?: string;
+}) => void;
+//# sourceMappingURL=csv.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"csv.d.ts","sourceRoot":"","sources":["../../../src/utils/csv.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW,SAAU;IAChC,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,SA2FA,CAAC"}

package/dist/esm/utils/csv.js

@@ -0,0 +1,78 @@
+import { quillFormat } from './valueFormatter';
+export const downloadCSV = (data) => {
+    const { rows, fields, name } = data;
+    // report.rows
+    if (rows && !rows.length) {
+        return;
+    }
+    // if table chart, use columns and valueFormatter
+    if (fields) {
+        const newRows = [];
+        for (let i = 0; i < rows.length; i++) {
+            const newRow = {};
+            Object.keys(rows[i]).forEach((field) => {
+                const fieldObj = fields.find((f) => f.field === field);
+                newRow[field] = quillFormat({
+                    value: rows[i][field],
+                    format: fieldObj?.format || 'text',
+                });
+            });
+            newRows.push(newRow);
+        }
+        const fieldsProcessed = fields?.map((col) => {
+            return {
+                label: col.field,
+                _id: col.field,
+                field: col.field,
+                format: 'percent',
+            };
+        });
+        const csvRows = [];
+        // Header row
+        csvRows.push(fields?.map((col) => col.label || col.field).join(','));
+        // Data rows
+        for (const row of newRows) {
+            const values = fieldsProcessed.map((field) => {
+                let value = JSON.stringify(row[field.label] ?? '');
+                if (value.includes('\\"')) {
+                    value = value.replaceAll('\\"', '""');
+                }
+                return value;
+            });
+            csvRows.push(values.join(','));
+        }
+        // Create CSV string and create a 'blob' with it
+        const csvString = csvRows.join('\r\n');
+        const csvBlob = new Blob([csvString], { type: 'text/csv' });
+        // Create a download link and click it
+        const downloadLink = document.createElement('a');
+        downloadLink.download = `${name}.csv`;
+        downloadLink.href = URL.createObjectURL(csvBlob);
+        downloadLink.style.display = 'none';
+        document.body.appendChild(downloadLink);
+        downloadLink.click();
+        document.body.removeChild(downloadLink);
+        return;
+    }
+    const json = rows; // JSON data passed as a prop
+    const fieldsProcessed = Object.keys(json[0]); // Assumes all objects have same keys
+    const csvRows = [];
+    // Header row
+    csvRows.push(fieldsProcessed.join(','));
+    // Data rows
+    for (const row of json) {
+        const values = fieldsProcessed.map((field) => JSON.stringify(row[field] || ''));
+        csvRows.push(values.join(','));
+    }
+    // Create CSV string and create a 'blob' with it
+    const csvString = csvRows.join('\r\n');
+    const csvBlob = new Blob([csvString], { type: 'text/csv' });
+    // Create a download link and click it
+    const downloadLink = document.createElement('a');
+    downloadLink.download = `${name}.csv`;
+    downloadLink.href = URL.createObjectURL(csvBlob);
+    downloadLink.style.display = 'none';
+    document.body.appendChild(downloadLink);
+    downloadLink.click();
+    document.body.removeChild(downloadLink);
+};

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

@@ -0,0 +1,13 @@
+import { QuillReportInternal } from '../models/Report';
+/**
+ * Returns a cleaned version of the dashboard item we store in state. We clean
+ * the dashboard item so that we aren't exposing unnecessary details to the
+ * client and also so that we can give the developer using our items a stable
+ * interface to build amazing dashboards on top of.
+ * @param item
+ */
+export declare function cleanDashboardItem(item: {
+    [key: string]: any;
+} | undefined, dashboardFilters: any, client?: any, dateBucket?: string): Promise<QuillReportInternal>;
+export declare function getDashboard(dashboardName: string, client: any): Promise<any>;
+//# sourceMappingURL=dashboard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dashboard.d.ts","sourceRoot":"","sources":["../../../src/utils/dashboard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AA+BpE;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,GAAG,SAAS,EACxC,gBAAgB,EAAE,GAAG,EACrB,MAAM,CAAC,EAAE,GAAG,EACZ,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,mBAAmB,CAAC,CAyC9B;AAgHD,wBAAsB,YAAY,CAChC,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,GAAG,GACV,OAAO,CAAC,GAAG,CAAC,CA2Bd"}

package/dist/esm/utils/dashboard.js

@@ -0,0 +1,171 @@
+import { generatePivotTable, generatePivotTableYAxis, } from '../internals/ReportBuilder/PivotModal';
+import { snakeAndCamelCaseToTitleCase } from './textProcessing';
+import { getData } from './dataFetcher';
+import { getDateBucketFromRange } from './dates';
+import { generatePivotWithSQL } from './pivotConstructor';
+const defaultDashboardItem = {
+    id: '',
+    name: '',
+    dashboardName: '',
+    rows: [],
+    compareRows: [],
+    columns: [],
+    chartType: '',
+    dateField: null,
+    pivot: null,
+    yAxisFields: [],
+    xAxisLabel: '',
+    xAxisField: '',
+    xAxisFormat: 'string',
+    order: -1,
+    filtersApplied: {},
+    queryString: '',
+    rowCount: 0,
+};
+/**
+ * Returns a cleaned version of the dashboard item we store in state. We clean
+ * the dashboard item so that we aren't exposing unnecessary details to the
+ * client and also so that we can give the developer using our items a stable
+ * interface to build amazing dashboards on top of.
+ * @param item
+ */
+export async function cleanDashboardItem(item, dashboardFilters, client, dateBucket) {
+    if (!item)
+        return defaultDashboardItem;
+    if (!item.rows)
+        return {
+            ...defaultDashboardItem,
+            id: item._id,
+            name: item.name,
+        };
+    const pivotTable = await getPivotTable(item, dashboardFilters, client, dateBucket);
+    return {
+        id: item._id,
+        name: item.name,
+        dashboardName: item.dashboardName,
+        rows: item.rows,
+        pivotRows: pivotTable ? pivotTable.rows : undefined,
+        pivotColumns: pivotTable ? pivotTable.columns : undefined,
+        compareRows: item.compareRows,
+        columns: item.columns.map((col) => {
+            return { ...col, label: snakeAndCamelCaseToTitleCase(col.label) };
+        }),
+        chartType: item.chartType,
+        dateField: item.dateField,
+        pivot: item.pivot,
+        yAxisFields: pivotTable
+            ? extractPivotedYAxis(pivotTable, item)
+            : item.yAxisFields,
+        xAxisLabel: item.xAxisLabel,
+        xAxisField: item.xAxisField,
+        xAxisFormat: item.xAxisFormat,
+        order: item.order,
+        filtersApplied: item.filtersApplied,
+        rowCount: parseInt(item.rowCount),
+        sort: item.sort,
+        itemQuery: item.itemQuery,
+        queryString: item.queryString,
+    };
+}
+/**
+ * Extract and transform the data from itemInfo.
+ */
+async function getPivotTable(report, dashboardFilters, client, dateBucketInitial) {
+    if (!report)
+        return undefined;
+    const dateFilter = Object.values(dashboardFilters ?? {}).find((filter) => filter.filterType === 'date_range' || filter.opterator === 'BETWEEN');
+    if (dateFilter?.operator === 'BETWEEN') {
+        dateFilter.startDate = dateFilter.value[0];
+        dateFilter.endDate = dateFilter.value[1];
+    }
+    const pivot = report?.pivot;
+    const data = report || {};
+    if (pivot && client) {
+        if (report.rowCount === 0) {
+            return { rows: [], columns: [] };
+        }
+        try {
+            let dateBucket = dateBucketInitial;
+            let filterDateRange = undefined;
+            if (dateFilter) {
+                filterDateRange = {
+                    start: dateFilter.startDate,
+                    end: dateFilter.endDate,
+                };
+            }
+            else if (report.dateRange) {
+                filterDateRange = report.dateRange;
+            }
+            if (!dateBucket && filterDateRange) {
+                dateBucket = getDateBucketFromRange(filterDateRange);
+            }
+            const pivotTable = await generatePivotWithSQL(pivot, report, client, dateBucket, dateFilter, report.distinctStrings);
+            if (pivotTable) {
+                return pivotTable;
+            }
+            throw new Error('Error generating pivot table');
+        }
+        catch (e) {
+            throw new Error('Failed to fetch chart');
+        }
+    }
+    return pivot && data.rows
+        ? generatePivotTable(pivot, JSON.parse(JSON.stringify(data.rows)), // deep copy
+        dateFilter?.startDate && dateFilter?.endDate
+            ? { start: dateFilter.startDate, end: dateFilter.endDate }
+            : undefined, Boolean(dateFilter?.comparisonRange?.startDate), -1, dateFilter?.comparisonRange?.startDate &&
+            dateFilter?.comparisonRange?.endDate
+            ? {
+                start: dateFilter.comparisonRange.startDate,
+                end: dateFilter.comparisonRange.endDate,
+            }
+            : undefined)
+        : undefined;
+}
+/**
+ * Extracts the yAxis from the pivot table, if one exists.
+ */
+function extractPivotedYAxis(pivotTable, itemInfo, config = undefined) {
+    if (!pivotTable)
+        return itemInfo?.yAxisFields ?? [];
+    const pivot = itemInfo?.pivot || config?.pivot;
+    if (!pivot.columnField && !pivot.rowField)
+        return itemInfo?.yAxisFields ?? [];
+    const yAxisFields = config ? config.yAxisFields : itemInfo?.yAxisFields;
+    const pivotTableYAxis = yAxisFields
+        ? generatePivotTableYAxis(pivot, pivotTable.columns, yAxisFields[0])
+        : null;
+    const fields = pivotTableYAxis
+        ? pivotTableYAxis
+        : config
+            ? config.yAxisFields
+            : itemInfo.yAxisFields;
+    if (fields.length == 1) {
+        const sampleField = fields[0];
+        fields[fields.length] = {
+            ...sampleField,
+            field: `comparison_${sampleField.field}`,
+            label: `comparison ${sampleField.label}`,
+        };
+    }
+    return fields;
+}
+export async function getDashboard(dashboardName, client) {
+    const searchParams = new URLSearchParams({
+        publicKey: client.publicKey,
+        orgId: client.customerId,
+        name: dashboardName,
+    }).toString();
+    const hostedBody = {
+        metadata: {
+            name: dashboardName,
+            task: 'config',
+            clientId: client.publicKey,
+            orgId: client.customerId || '*',
+            databaseType: client.databaseType,
+            useNewNodeSql: true,
+        },
+    };
+    const resp = await getData(client, `dashconfig?${searchParams}`, 'omit', hostedBody, null, 'GET');
+    return resp;
+}

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

@@ -0,0 +1,3 @@
+export declare function getData(client: any, cloudQueryEndpoint: string, noCred: RequestCredentials, hostedRequestBody: any, cloudRequestBody: any, method?: string, queryParam?: string): Promise<any>;
+export declare function getDataFromCloud(client: any, cloudQueryEndpoint: string, cloudRequestBody: any, method?: string): Promise<any>;
+//# sourceMappingURL=dataFetcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dataFetcher.d.ts","sourceRoot":"","sources":["../../../src/utils/dataFetcher.tsx"],"names":[],"mappings":"AA2EA,wBAAsB,OAAO,CAC3B,MAAM,EAAE,GAAG,EACX,kBAAkB,EAAE,MAAM,EAC1B,MAAM,EAAE,kBAAkB,EAC1B,iBAAiB,EAAE,GAAG,EACtB,gBAAgB,EAAE,GAAG,EACrB,MAAM,SAAS,EACf,UAAU,CAAC,EAAE,MAAM,gBA6IpB;AAED,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,GAAG,EACX,kBAAkB,EAAE,MAAM,EAC1B,gBAAgB,EAAE,GAAG,EACrB,MAAM,SAAS,gBAgChB"}

package/dist/esm/utils/dataFetcher.js

@@ -0,0 +1,205 @@
+function fetchQuillData(responseData) {
+    if (!responseData) {
+        return null;
+    }
+    if (responseData.data && responseData.data?.data) {
+        return responseData.data;
+    }
+    else if (responseData.data) {
+        return responseData;
+    }
+    return null;
+}
+function parseData(rows, queryType) {
+    if (!rows || rows.length === 0)
+        return [];
+    switch (queryType) {
+        case 'dateRange':
+            return {
+                start: new Date(rows[0]?.min_date),
+                end: new Date(rows[0]?.max_date),
+            };
+        case 'rowCount':
+            return parseInt(rows[0]?.row_count);
+        case 'distinctStrings':
+            return rows.map((row) => {
+                return row['column_field'];
+            });
+        default:
+            return rows;
+    }
+}
+async function testSqlViewState(hostedRequestBody, client, referencedTables) {
+    let errorMessage = null;
+    await Promise.all(referencedTables.map(async (table) => {
+        if (!table) {
+            return;
+        }
+        const hostedBody = {
+            metadata: {
+                tables: [table],
+                task: 'test-view',
+                clientId: hostedRequestBody.metadata.clientId,
+            },
+        };
+        const cloudBody = { ...hostedBody };
+        const resp = await getData(client, 'test-view', 'same-origin', hostedBody, cloudBody);
+        if (resp.success === false) {
+            const brokenBody = {
+                metadata: {
+                    table: table,
+                    task: 'set-broken-view',
+                    clientId: hostedRequestBody.metadata.clientId,
+                },
+            };
+            getData(client, 'test-view', 'same-origin', brokenBody, cloudBody);
+            errorMessage = `SQL View Error: '${table}' is out of sync with datasource.`;
+        }
+    }));
+    return errorMessage;
+}
+// this function gets the data either from the self hosted endpoint or
+// our cloud server
+export async function getData(client, cloudQueryEndpoint, noCred, hostedRequestBody, cloudRequestBody, method = 'POST', queryParam) {
+    if (!client) {
+        return null;
+    }
+    try {
+        if (client.queryEndpoint) {
+            // self hosted
+            const processedParam = queryParam ? `?${queryParam}` : '';
+            const resp = await fetch(`${client.queryEndpoint}${processedParam}`, {
+                method: 'POST',
+                headers: {
+                    ...client.queryHeaders,
+                    'Content-Type': 'application/json',
+                },
+                credentials: client.withCredentials ? 'include' : noCred,
+                body: JSON.stringify(hostedRequestBody),
+            });
+            const responseJson = await resp.json();
+            if (responseJson.status === 'error' &&
+                ['query', 'patterns', 'item'].includes(hostedRequestBody.metadata.task)) {
+                const brokenReport = { ...responseJson };
+                let errorPrefix = 'Error: ';
+                let errorMessage = 'Failed to fetch chart';
+                if (hostedRequestBody.metadata.task === 'query' ||
+                    hostedRequestBody.metadata.task === 'patterns') {
+                    errorPrefix = 'SQL Error: ';
+                    errorMessage = errorPrefix + responseJson.error;
+                }
+                let adminErrorMessage = undefined;
+                const processedData = fetchQuillData(brokenReport);
+                if (processedData &&
+                    processedData.data &&
+                    processedData.data.referencedTables) {
+                    adminErrorMessage = await testSqlViewState(hostedRequestBody, client, processedData.data.referencedTables);
+                }
+                return {
+                    success: false,
+                    errorMessage,
+                    adminErrorMessage,
+                    data: brokenReport.data,
+                };
+            }
+            if (responseJson.error) {
+                return {
+                    success: false,
+                    errorMessage: responseJson.error,
+                };
+            }
+            let result;
+            if (hostedRequestBody &&
+                hostedRequestBody.metadata &&
+                (hostedRequestBody.metadata.task === 'report' ||
+                    hostedRequestBody.metadata.useUpdatedDataGathering)) {
+                if (responseJson.data?.data) {
+                    result = {
+                        fields: responseJson?.data.queries?.queryResults[0]?.fields,
+                        ...responseJson.data.data,
+                    };
+                    responseJson.data.data?.queryOrder?.forEach((queryKey, index) => {
+                        result[queryKey] = parseData(responseJson.queries.queryResults[index].rows, queryKey);
+                    });
+                }
+                else {
+                    result = {
+                        fields: responseJson?.queries?.queryResults[0]?.fields,
+                        ...responseJson.data,
+                    };
+                    responseJson.data.queryOrder.forEach((queryKey, index) => {
+                        result[queryKey] = parseData(responseJson.queries.queryResults[index].rows, queryKey);
+                    });
+                }
+            }
+            else {
+                if (responseJson.data?.data) {
+                    result = {
+                        fields: responseJson?.data.queries?.queryResults[0]?.fields,
+                        ...responseJson.data.data,
+                        rows: responseJson?.data.queries?.queryResults[0]?.rows,
+                        compareRows: responseJson?.data.queries?.queryResults[1]?.rows,
+                    };
+                }
+                else {
+                    result = {
+                        fields: responseJson?.queries?.queryResults[0]?.fields,
+                        ...responseJson.data,
+                        rows: responseJson?.queries?.queryResults[0]?.rows,
+                        compareRows: responseJson?.queries?.queryResults[1]?.rows,
+                    };
+                }
+            }
+            if (responseJson.data.columns &&
+                responseJson.data.fields &&
+                responseJson.data.columns.length != responseJson.data.fields) {
+                // Remove all columns that don't appear in fields, overtime this should never be the case
+                const columns = responseJson.data.columns.filter((columns) => responseJson.data.fields.find((field) => field.name === columns.field));
+                result = {
+                    ...result,
+                    columns,
+                };
+            }
+            return result;
+        }
+        else {
+            // cloud
+            return await getDataFromCloud(client, cloudQueryEndpoint, cloudRequestBody, method);
+        }
+    }
+    catch (e) {
+        console.error('Failed to parse JSON:', e);
+        return null;
+    }
+}
+export async function getDataFromCloud(client, cloudQueryEndpoint, cloudRequestBody, method = 'POST') {
+    const environment = client?.environment;
+    const host = (typeof process !== 'undefined' && process?.env?.QUILL_SERVER_HOST) ||
+        'https://quill-344421.uc.r.appspot.com';
+    const url = `${host}/${cloudQueryEndpoint}`;
+    const resp = await fetch(url, {
+        method,
+        headers: {
+            Authorization: 'Bearer ',
+            ...(environment ? { environment } : {}), // Remember to provide the actual token
+            'Content-Type': 'application/json',
+            environment: environment || undefined,
+        },
+        body: method === 'POST'
+            ? JSON.stringify({
+                ...cloudRequestBody,
+                ...{
+                    publicKey: client?.publicKey,
+                    orgId: client?.customerId,
+                },
+            })
+            : null,
+    });
+    try {
+        return await resp.json();
+    }
+    catch (e) {
+        console.error('Failed to parse JSON:', e);
+        return null;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { QuillReportInternal } from '../models/Report';
+export declare enum Calculation {
+    PointToPointPercentageChange = "POINT_TO_POINT_PERCENTAGE_CHANGE",
+    SimplePercentageChange = "SIMPLE_PERCENTAGE_CHANGE",
+    Sum = "SUM"
+}
+export declare const getSimplePercentageChange: (data: QuillReportInternal) => number | undefined;
+export declare const getPointToPointPercentageChange: (data: QuillReportInternal) => number | undefined;
+export declare const getSumOfFields: (data: QuillReportInternal, comparison: boolean) => number;
+export declare function parseValueFromBigQueryDates(rows: any[], columns: any[]): void;
+//# sourceMappingURL=dataProcessing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dataProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/dataProcessing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAQvD,oBAAY,WAAW;IACrB,4BAA4B,qCAAqC;IACjE,sBAAsB,6BAA6B;IACnD,GAAG,QAAQ;CACZ;AAyBD,eAAO,MAAM,yBAAyB,SAAU,mBAAmB,uBAsClE,CAAC;AAEF,eAAO,MAAM,+BAA+B,SAAU,mBAAmB,uBAkFxE,CAAC;AAEF,eAAO,MAAM,cAAc,SACnB,mBAAmB,cACb,OAAO,WAoBpB,CAAC;AAGF,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,QAkBtE"}