@quillsql/react 2.15.3 → 2.15.4

package/dist/esm/utils/dashboard.js

@@ -1,414 +0,0 @@
-import { generatePivotTable, generatePivotTableYAxis, } from './pivotConstructor';
-import { snakeAndCamelCaseToTitleCase, snakeCaseToTitleCase, } from './textProcessing';
-import { quillFetch } from './dataFetcher';
-import { getDateBucketFromRange } from './dates';
-import { generatePivotWithSQL } from './pivotConstructor';
-import { getUniqueValuesByQuery } from './tableProcessing';
-import { convertFieldTypeToJSType, convertPostgresColumn, fieldTypeToDataTypeID, processColumnName, } from './columnProcessing';
-const defaultDashboardItem = {
-    id: '',
-    name: '',
-    dashboardName: '',
-    rows: [],
-    compareRows: [],
-    columns: [],
-    chartType: '',
-    pivot: null,
-    yAxisFields: [],
-    xAxisLabel: '',
-    xAxisField: '',
-    xAxisFormat: 'string',
-    order: -1,
-    filtersApplied: [],
-    queryString: '',
-    rowCount: 0,
-    columnInternal: [],
-};
-/**
- * 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, getToken, eventTracking, client, dateBucket, additionalProcessing, customFields, skipPivotFetch, tenants, }) {
-    if (!item)
-        return defaultDashboardItem;
-    if (!item.rows) {
-        return {
-            ...defaultDashboardItem,
-            id: item._id,
-            name: item.name,
-        };
-    }
-    const fields = item.fields || [];
-    const columnsWithCustomFields = [...(item.columns ?? [])];
-    if (item.includeCustomFields && item.rows?.length > 0) {
-        const tables = item.referencedTables ?? [];
-        tables.forEach((table) => {
-            const _customFields = customFields?.[table] ?? [];
-            _customFields.forEach((field) => {
-                const isJsonCustomField = !!field.refColumn;
-                if (item.rows[0][field.field] !== undefined &&
-                    !item.columns.some((col) => col.field === field.field)) {
-                    const result_field = fields.find((f) => f.name === field.field);
-                    const converted_field = convertPostgresColumn(result_field ?? {});
-                    columnsWithCustomFields.push({
-                        field: field.field,
-                        format: converted_field.format,
-                        label: snakeAndCamelCaseToTitleCase(field.field),
-                        fieldType: converted_field.fieldType,
-                        dataTypeID: converted_field.dataTypeID,
-                        jsType: converted_field.jsType,
-                        inferFormat: isJsonCustomField,
-                    });
-                }
-            });
-        });
-    }
-    const processedColumns = item.columns.map((col) => {
-        return { ...col, label: snakeAndCamelCaseToTitleCase(col.label) };
-    });
-    const columnInternal = (item.includeCustomFields ? columnsWithCustomFields : item.columns).map((col) => {
-        const field = item.fields?.find((f) => f.name === col.field);
-        const converted_field = convertPostgresColumn(field ?? {});
-        return {
-            fieldType: converted_field.fieldType,
-            dataTypeID: converted_field.dataTypeID,
-            jsType: converted_field.jsType,
-            ...col,
-            label: snakeAndCamelCaseToTitleCase(col.label),
-        };
-    });
-    let pivotTable;
-    let pivotError;
-    try {
-        pivotTable = await getPivotTable({
-            ...item,
-            pivot: item.pivot && !skipPivotFetch
-                ? {
-                    ...item.pivot,
-                    aggregations: item.pivot.aggregations ?? [
-                        {
-                            valueField: item.pivot.valueField,
-                            valueFieldType: item.pivot.valueFieldType,
-                            valueField2: item.pivot.valueField2,
-                            valueField2Type: item.pivot.valueField2Type,
-                            aggregationType: item.pivot.aggregationType,
-                        },
-                    ],
-                }
-                : undefined,
-        }, dashboardFilters, item.dashboardName, getToken, client, eventTracking, dateBucket, additionalProcessing, tenants, customFields);
-    }
-    catch (e) {
-        pivotTable = undefined;
-        eventTracking?.logError?.({
-            type: 'bug', // TODO: determine type
-            severity: 'high',
-            message: 'Error fetching pivot table',
-            errorMessage: e.message,
-            errorStack: e.stack,
-            errorData: {
-                caller: 'cleanDashboardItem',
-                function: 'cleanDashboardItem',
-            },
-        });
-        console.error('Error fetching pivot table', e);
-        pivotError = 'Error fetching pivot table';
-    }
-    // For each key on item that starts with "referenceLine_{field}", we want to
-    // add it to referenceLineYValues as [field]: [value, value] (we only support horizontal lines)
-    // Then for each number value in the referenceLines map, we also want to add [key]: [value, value]
-    const referenceLineYValues = [];
-    for (const key in item) {
-        if (key.startsWith('referenceLine_')) {
-            const field = key.slice(14);
-            if (!item[key] || !item[key][0])
-                continue;
-            const value = Object.values(item[key][0])[0];
-            referenceLineYValues.push({ label: field, query: [value, value] });
-        }
-    }
-    if (item.referenceLines) {
-        for (const referenceLine of item.referenceLines) {
-            if (Array.isArray(referenceLine.query)) {
-                referenceLineYValues.push({
-                    label: referenceLine.label,
-                    query: referenceLine.query,
-                });
-            }
-            else if (referenceLine.query === '') {
-                referenceLineYValues.push({
-                    label: referenceLine.label,
-                    query: (pivotTable?.rows ? pivotTable.rows : item.rows).map((row) => Number(row[referenceLine.label]) || 0),
-                });
-            }
-        }
-    }
-    return {
-        id: item._id ?? item.id,
-        name: item.name,
-        dashboardName: item.dashboardName,
-        // section: item.section,
-        rows: item.rows,
-        pivotRows: pivotTable ? pivotTable.rows : undefined,
-        pivotColumns: pivotTable ? pivotTable.columns : undefined,
-        compareRows: item.compareRows,
-        columns: processedColumns.map((column) => {
-            return {
-                field: column.field,
-                format: column.format,
-                label: column.label,
-                inferFormat: column.inferFormat,
-            };
-        }),
-        includeCustomFields: item.includeCustomFields,
-        columnInternal,
-        columnsWithCustomFields,
-        chartType: item.chartType,
-        dateField: item.dateField,
-        pivot: pivotError
-            ? undefined
-            : item.pivot
-                ? {
-                    ...item.pivot,
-                    aggregations: item.pivot.aggregations ?? [
-                        {
-                            valueField: item.pivot.valueField,
-                            valueFieldType: item.pivot.valueFieldType,
-                            valueField2: item.pivot.valueField2,
-                            valueField2Type: item.pivot.valueField2Type,
-                            aggregationType: item.pivot.aggregationType,
-                        },
-                    ],
-                    columnValues: item.distinctStrings,
-                }
-                : undefined,
-        yAxisFields: pivotTable
-            ? extractPivotedYAxis(pivotTable, item)
-            : item.yAxisFields,
-        xAxisLabel: item.xAxisLabel,
-        xAxisField: item.xAxisField,
-        xAxisFormat: item.xAxisFormat,
-        order: item.order,
-        filtersApplied: item.filtersApplied,
-        filterMap: item.filterMap,
-        flags: item.flags,
-        rowCount: item.rowCount ? parseInt(item.rowCount) : item.rows.length,
-        pivotRowCount: pivotTable ? pivotTable.rowCount : undefined,
-        template: item.template,
-        sort: item.sort,
-        itemQuery: item.itemQuery,
-        queryString: item.queryString,
-        pivotQuery: pivotTable?.pivotQuery,
-        comparisonPivotQuery: pivotTable?.comparisonPivotQuery,
-        referencedTables: item?.referencedTables || [],
-        referencedColumns: item?.referencedColumns || {},
-        error: item.error ?? pivotError,
-        referenceLineYValues: referenceLineYValues,
-        referenceLines: item.referenceLines,
-    };
-}
-/**
- * Extract and transform the data from itemInfo.
- */
-async function getPivotTable(report, dashboardFilters, dashboardName, getToken, client, eventTracking, dateBucketInitial, additionalProcessing, tenants, customFields) {
-    if (!report)
-        return undefined;
-    const dateFilter = Object.values(dashboardFilters ?? {}).find((filter) => filter.filterType === 'date_range' || filter.operator === '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 || report.rows.length === 0) {
-            const columns = [];
-            if (pivot.rowField) {
-                columns.push({
-                    field: pivot.rowField,
-                    label: snakeCaseToTitleCase(processColumnName(pivot.rowField)),
-                    format: pivot.rowFieldType || 'string',
-                    jsType: convertFieldTypeToJSType(pivot.rowFieldType || 'string'),
-                    fieldType: pivot.rowFieldType || 'string',
-                    dataTypeID: fieldTypeToDataTypeID(pivot.rowFieldType || 'string'),
-                });
-            }
-            for (const agg of pivot.aggregations ?? []) {
-                if (agg.valueField) {
-                    columns.push({
-                        field: agg.valueField,
-                        label: snakeCaseToTitleCase(processColumnName(agg.valueField)),
-                        //FIXME: valueFieldType is not always the same as the format
-                        format: agg.valueFieldType ??
-                            'whole_number',
-                        jsType: agg.valueFieldType ?? 'number',
-                        fieldType: agg.valueFieldType ?? 'number',
-                        dataTypeID: fieldTypeToDataTypeID(agg.valueFieldType ?? 'number'),
-                    });
-                }
-            }
-            return {
-                rows: [],
-                rowCount: 0,
-                pivotQuery: '',
-                columns: columns,
-            };
-        }
-        try {
-            let dateBucket = dateBucketInitial;
-            let filterDateRange = undefined;
-            if (dateFilter && dateFilter.startDate && dateFilter.endDate) {
-                filterDateRange = {
-                    start: dateFilter.startDate,
-                    end: dateFilter.endDate,
-                };
-            }
-            else if (report.dateRange) {
-                filterDateRange = report.dateRange;
-            }
-            if (!dateBucket && filterDateRange) {
-                dateBucket = getDateBucketFromRange(filterDateRange);
-            }
-            if (pivot.columnField && !report.distinctStrings) {
-                const columnFieldColumn = (report.columnsWithCustomFields ?? report.columns).find((col) => col.field === pivot.columnField);
-                if (!columnFieldColumn) {
-                    console.error('could not find pivot column field on report', pivot.columnField);
-                }
-                const unique = await getUniqueValuesByQuery({
-                    columns: [columnFieldColumn],
-                    query: report.queryString,
-                    client,
-                    getToken,
-                    dashboardName: dashboardName,
-                    tenants,
-                    customFields: customFields ?? {},
-                    eventTracking,
-                });
-                report.distinctStrings = unique?.[pivot.columnField] ?? [];
-            }
-            if (pivot.columnField && !report.distinctStrings) {
-                const columnFieldColumn = (report.columnsWithCustomFields ?? report.columns).find((col) => col.field === pivot.columnField);
-                if (!columnFieldColumn) {
-                    console.error('could not find pivot column field on report', pivot.columnField);
-                }
-                const unique = await getUniqueValuesByQuery({
-                    columns: [columnFieldColumn],
-                    query: report.queryString,
-                    client,
-                    getToken,
-                    dashboardName: dashboardName,
-                    tenants,
-                    customFields: customFields ?? {},
-                    eventTracking,
-                });
-                report.distinctStrings = unique?.[pivot.columnField] ?? [];
-            }
-            const pivotTable = await generatePivotWithSQL({
-                pivot,
-                report,
-                client,
-                dateBucket,
-                dateFilter,
-                distinctStrings: report.distinctStrings,
-                dashboardName,
-                tenants,
-                additionalProcessing,
-                getToken,
-            });
-            return pivotTable;
-        }
-        catch (e) {
-            eventTracking?.logError?.({
-                type: 'bug', // TODO: determine type
-                severity: 'high',
-                message: 'Error fetching pivot table',
-                errorMessage: e.message,
-                errorStack: e.stack,
-                errorData: {
-                    caller: 'getPivotTable',
-                    function: 'getPivotTable',
-                },
-            });
-            console.error('Error fetching pivot table', e);
-            throw e;
-        }
-    }
-    return pivot && data.rows
-        ? generatePivotTable({
-            pivot,
-            report,
-            client,
-            uniqueValues: report.distinctStrings,
-            dashboardName,
-            tenants,
-            dateFilter,
-            additionalProcessing,
-            getToken,
-            eventTracking,
-        })
-        : 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;
-    return yAxisFields && yAxisFields.length > 0
-        ? generatePivotTableYAxis(pivot, pivotTable.columns, yAxisFields[0])
-        : 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, getToken, tenants, flags) {
-    const { data: resp } = await quillFetch({
-        client,
-        task: 'dashboard',
-        metadata: {
-            name: dashboardName,
-            clientId: client.publicKey,
-            databaseType: client.databaseType,
-            useNewNodeSql: true,
-            tenants,
-            flags,
-        },
-        getToken,
-    });
-    return {
-        ...resp,
-        createdAt: resp.createdAt && new Date(resp.createdAt),
-        dateFilter: resp.dateFilter
-            ? {
-                ...resp.dateFilter,
-                presetOptions: resp.dateFilter.presetOptions?.map((preset) => ({
-                    ...preset,
-                    loopStart: preset.loopStart
-                        ? new Date(preset.loopStart)
-                        : undefined,
-                    loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : undefined,
-                })),
-                defaultPresetRanges: resp.dateFilter.defaultPresetRanges?.map((preset) => ({
-                    ...preset,
-                    loopStart: preset.loopStart
-                        ? new Date(preset.loopStart)
-                        : undefined,
-                    loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : undefined,
-                })),
-            }
-            : undefined,
-    };
-}

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

@@ -1,13 +0,0 @@
-import { QuillProviderClient } from '../models/Client';
-import { QuillFetchOptions, QuillResults } from '../models/Data';
-export declare const quillFetch: ({ client, task, method, metadata, abortSignal, credentials, urlParameters, getToken, }: QuillFetchOptions) => Promise<QuillResults>;
-export declare const parseFetchResponse: (client: QuillProviderClient, task: string, response: QuillResults, getToken: () => Promise<string>) => Promise<any>;
-/**
- * @deprecated Use quillFetch instead. If post fetch parsing is required, use parseFetchResponse.
- */
-export declare function getData(client: QuillProviderClient, cloudQueryEndpoint: string, noCred: RequestCredentials, hostedRequestBody: any, cloudRequestBody: any, method: string | undefined, getToken: () => Promise<string>, queryParam?: string, abortSignal?: AbortSignal): Promise<any>;
-export declare function fetchSqlQuery(ast: any, client: QuillProviderClient, getToken: () => Promise<string>, formData?: any): Promise<{
-    query: string;
-    error?: string;
-}>;
-//# sourceMappingURL=dataFetcher.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"dataFetcher.d.ts","sourceRoot":"","sources":["../../../src/utils/dataFetcher.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AA6EjE,eAAO,MAAM,UAAU,GAAU,wFAS9B,iBAAiB,KAAG,OAAO,CAAC,YAAY,CAsD1C,CAAC;AAIF,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,mBAAmB,EAC3B,MAAM,MAAM,EACZ,UAAU,YAAY,EACtB,UAAU,MAAM,OAAO,CAAC,MAAM,CAAC,iBA0EhC,CAAC;AAEF;;GAEG;AACH,wBAAsB,OAAO,CAC3B,MAAM,EAAE,mBAAmB,EAC3B,kBAAkB,EAAE,MAAM,EAC1B,MAAM,EAAE,kBAAkB,EAC1B,iBAAiB,EAAE,GAAG,EACtB,gBAAgB,EAAE,GAAG,EACrB,MAAM,oBAAS,EACf,QAAQ,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,EAC/B,UAAU,CAAC,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,WAAW,gBAgL1B;AA+CD,wBAAsB,aAAa,CACjC,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,EAC/B,QAAQ,CAAC,EAAE,GAAG,GACb,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAiB5C"}