@quillsql/react 2.15.3 → 2.15.4

package/dist/esm/utils/tableProcessing.js

@@ -1,652 +0,0 @@
-import { convertPostgresColumn } from './columnProcessing';
-import { isStringType } from './columnType';
-import { MAX_PIVOT_UNIQUE_VALUES } from './constants';
-import { parseFetchResponse, quillFetch } from './dataFetcher';
-import { parseValueFromBigQueryDates } from './dataProcessing';
-import { parseQueryDateRangeByDatabaseType } from './dates';
-import { processFilterErrorList } from './errorProcessing';
-import { DEFAULT_PAGINATION } from './paginationProcessing';
-import { generatePivotWithSQL } from './pivotConstructor';
-import { generateCountQuery, generateDistinctQuery, generateMinMaxDateRangeQueries, processColumnReference, } 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 getUniqueValuesByQuery = async ({ columns, query, client, getToken, tenants, customFields, filters, dashboardName, eventTracking, }) => {
-    const stringNames = columns.map((column) => column.field);
-    const uniqueValues = {};
-    if (stringNames.length === 0) {
-        return {};
-    }
-    const distinctValueQuery = generateDistinctQuery(stringNames, query, client.databaseType || 'postgresql');
-    const distinctStrings = await fetchDistinctStrings(distinctValueQuery, client, getToken, tenants, eventTracking, customFields, filters, dashboardName);
-    if (!distinctStrings) {
-        return {};
-    }
-    for (const column of distinctStrings) {
-        uniqueValues[column.column] = column.values;
-    }
-    return uniqueValues;
-};
-export const getUniqueStringValuesByColumn = async ({ columns, tableName, client, getToken, tenants, customFields, withExceededColumns, query, dashboardName, eventTracking, }) => {
-    const convertedStringColumns = columns.filter((column) => {
-        return isStringType(column.fieldType);
-    });
-    const stringNames = convertedStringColumns.map((column) => processColumnReference(column.field, client.databaseType, undefined, true));
-    const { filteredColumns: smallStringColumns, exceededColumns } = stringNames.length > 0
-        ? await getCountsByColumns(convertedStringColumns, query || `Select ${stringNames.join(', ')} from ${tableName}`, client, getToken, tenants, customFields ?? [], eventTracking, dashboardName)
-        : { filteredColumns: [], exceededColumns: undefined };
-    const smallStringNames = smallStringColumns.map((column) => processColumnReference(column.field, client.databaseType, undefined, true));
-    const newUniqueValues = query || smallStringColumns.length > 0
-        ? await getUniqueValuesByQuery({
-            // returns null if data error
-            columns: smallStringColumns,
-            query: query || `Select ${smallStringNames.join(', ')} from ${tableName}`,
-            client,
-            getToken,
-            tenants,
-            customFields: customFields ?? [],
-            dashboardName,
-            eventTracking,
-        })
-        : null;
-    if (!newUniqueValues) {
-        return {};
-    }
-    if (withExceededColumns) {
-        exceededColumns?.forEach((column) => {
-            if (newUniqueValues) {
-                newUniqueValues[column.field] = ['EXCEEDS_LIMIT'];
-            }
-        });
-    }
-    return newUniqueValues;
-};
-export const getUniqueStringValuesByTable = async ({ tables, columns, client, getToken, tenants, dashboardName, customFields, withExceededColumns, queryTemplate, eventTracking, }) => {
-    const uniqueValues = {};
-    await Promise.all(tables.map(async (tableName) => {
-        const tableColumns = columns.filter((column) => {
-            return column.table === tableName;
-        });
-        const tableColumnString = tableColumns
-            .map((col) => `${col.table ? `${col.table}.` : ''}${col.field}`)
-            .join(', ');
-        const query = queryTemplate
-            ? queryTemplate.replace('*', tableColumnString)
-            : `SELECT ${tableColumnString} FROM ${tableName}`;
-        const newUniqueValues = await getUniqueStringValuesByColumn({
-            columns: tableColumns,
-            tableName,
-            client,
-            getToken,
-            tenants,
-            dashboardName,
-            customFields,
-            withExceededColumns,
-            query,
-            eventTracking,
-        });
-        uniqueValues[tableName] = newUniqueValues;
-    }));
-    return uniqueValues;
-};
-export const getRelevantInfoFromQuery = async ({ tables, columns, aliasedColumns, reportBuilderColumns, client, getToken, tenants, query, queryTemplate, customFields, dashboardName, eventTracking, }) => {
-    let dateRanges = {};
-    let uniqueStrings = null;
-    const columnUniqueValues = {};
-    let error = undefined;
-    try {
-        uniqueStrings = await getUniqueStringValuesByTable({
-            tables,
-            columns,
-            client,
-            getToken,
-            tenants,
-            dashboardName,
-            customFields,
-            withExceededColumns: true,
-            queryTemplate,
-            eventTracking,
-        });
-        reportBuilderColumns.forEach((column) => {
-            columnUniqueValues[column.alias || column.field] =
-                uniqueStrings?.[column.table || '']?.[column.field] ?? [];
-        });
-        const dateColumns = aliasedColumns.filter((column) => {
-            return column.fieldType === 'date';
-        });
-        if (dateColumns.length > 0) {
-            dateRanges = await getQueryDateRangeByColumns(dateColumns, query, client, getToken, tenants, eventTracking, customFields, dashboardName);
-            if (dateRanges === null) {
-                throw new Error("Couldn't fetch date ranges");
-            }
-        }
-    }
-    catch (e) {
-        eventTracking?.logError?.({
-            type: 'bug', // TODO: determine type
-            severity: 'high',
-            message: 'Error fetching pivot info',
-            errorMessage: e.message,
-            errorStack: e.stack,
-            errorData: {
-                caller: 'getRelevantInfoFromQuery',
-                function: 'getRelevantInfoFromQuery',
-            },
-        });
-        error = "Couldn't fetch pivot info";
-    }
-    return {
-        uniqueStrings: uniqueStrings ?? undefined,
-        columnUniqueValues: columnUniqueValues,
-        dateRanges: dateRanges ?? undefined,
-        error,
-    };
-};
-export const getCountsByColumns = async (columns, query, client, getToken, tenants, customFields, eventTracking, dashboardName) => {
-    const stringNames = columns.map((column) => column.field);
-    const countQuery = generateCountQuery(stringNames, query, client.databaseType || 'postgresql');
-    try {
-        const { data } = await quillFetch({
-            client,
-            task: 'query',
-            metadata: {
-                query: countQuery,
-                clientId: client.publicKey,
-                databaseType: client.databaseType,
-                customFieldsByTable: customFields,
-                useNewNodeSql: true,
-                dashboardName,
-                tenants,
-            },
-            urlParameters: `caller=getCounts&task=query`,
-            getToken,
-        });
-        if (data.errorMessage) {
-            return { filteredColumns: columns, exceededColumns: undefined };
-        }
-        const results = data.rows.map((columnInfo) => {
-            return {
-                field: columnInfo.field || columnInfo.FIELD, // Snowflake
-                count: columnInfo.count || columnInfo.COUNT, // Snowflake
-            };
-        });
-        const filteredColumns = columns.filter((column) => {
-            const columnInfo = results.find((result) => result.field === column.field);
-            return columnInfo.count <= MAX_PIVOT_UNIQUE_VALUES;
-        });
-        const exceededColumns = columns.filter((column) => {
-            const columnInfo = results.find((result) => result.field === column.field);
-            return columnInfo.count > MAX_PIVOT_UNIQUE_VALUES;
-        });
-        return { filteredColumns, exceededColumns };
-    }
-    catch (e) {
-        eventTracking?.logError?.({
-            type: 'bug', // TODO: determine type
-            severity: 'high',
-            message: 'Error fetching counts by columns',
-            errorMessage: e.message,
-            errorStack: e.stack,
-            errorData: {
-                caller: 'getCountsByColumns',
-                function: 'getCountsByColumns',
-            },
-        });
-        return { filteredColumns: columns, exceededColumns: undefined };
-    }
-};
-const fetchDistinctStrings = async (query, client, getToken, tenants, eventTracking, customFields, filters, dashboardName) => {
-    try {
-        const { data } = await quillFetch({
-            client,
-            task: 'query',
-            metadata: {
-                query,
-                clientId: client.publicKey,
-                databaseType: client.databaseType,
-                customFieldsByTable: customFields,
-                useNewNodeSql: true,
-                filters,
-                dateField: filters?.find((filter) => filter.filterType === 'date_range')?.dateField,
-                dashboardName,
-                tenants,
-            },
-            urlParameters: `caller=fetchDistinct&task=query`,
-            getToken,
-        });
-        if (data.errorMessage) {
-            return null;
-        }
-        const results = data.rows.map((columnInfo) => {
-            const column = columnInfo.field || columnInfo.FIELD;
-            if (!columnInfo.string_values) {
-                return { column, values: [] };
-            }
-            // This function is used in ReportBuilder and PivotModal to fetch distinct values. However, neither PivotModal or FilterModal
-            // are currently built to handle null values (FilterModal uses SQL IN, which doesn't handle null values). For now, filtering
-            // out null values.
-            // as of 1/15, we are getting mssql distinct values as a delimited string due to node-sql-parser limitations
-            const values = typeof columnInfo.string_values === 'string'
-                ? columnInfo.string_values
-                    .split(',')
-                    .reduce((result, value) => {
-                    if (value !== null && value !== undefined) {
-                        // TODO: handle null values rather than filtering out
-                        result.push(value);
-                    }
-                    return result;
-                }, [])
-                : columnInfo.string_values.reduce((result, value) => {
-                    if (value !== null && value !== undefined) {
-                        // TODO: handle null values rather than filtering out
-                        result.push(value);
-                    }
-                    return result;
-                }, []);
-            return { column, values };
-        });
-        return results;
-    }
-    catch (e) {
-        eventTracking?.logError?.({
-            type: 'bug', // TODO: determine type
-            severity: 'high',
-            message: 'Error fetching distinct strings',
-            errorMessage: e.message,
-            errorStack: e.stack,
-            errorData: {
-                caller: 'fetchDistinctStrings',
-                function: 'fetchDistinctStrings',
-            },
-        });
-        return null;
-    }
-};
-export const getQueryDateRangeByColumns = async (columns, query, client, getToken, tenants, eventTracking, customFields, dashboardName) => {
-    const columnNames = columns.map(
-    // @ts-ignore
-    (column) => column.field || column.name);
-    const distinctValueQuery = generateMinMaxDateRangeQueries(columnNames, query, client.databaseType || 'postgresql');
-    const dateRanges = await fetchQueryDateRanges(distinctValueQuery, client, getToken, tenants, eventTracking, customFields, dashboardName);
-    return dateRanges;
-};
-const fetchQueryDateRanges = async (query, client, getToken, tenants, eventTracking, customFields, dashboardName) => {
-    try {
-        const { data } = await quillFetch({
-            client,
-            task: 'query',
-            metadata: {
-                query,
-                clientId: client.publicKey,
-                databaseType: client.databaseType,
-                customFieldsByTable: customFields,
-                useNewNodeSql: true,
-                dashboardName,
-                tenants,
-            },
-            getToken,
-        });
-        if (data.errorMessage) {
-            return null;
-        }
-        const results = data.rows.reduce((acc, currentValue) => {
-            acc[currentValue.field] = {
-                dateRange: parseQueryDateRangeByDatabaseType(currentValue.min_range, currentValue.max_range, client.databaseType || 'postgresql'),
-            };
-            return acc;
-        }, {});
-        return results;
-    }
-    catch (e) {
-        eventTracking?.logError?.({
-            type: 'bug', // TODO: determine type
-            severity: 'high',
-            message: 'Error fetching query date ranges',
-            errorMessage: e.message,
-            errorStack: e.stack,
-            errorData: {
-                caller: 'fetchQueryDateRanges',
-                function: 'fetchQueryDateRanges',
-            },
-        });
-        return null;
-    }
-};
-// Unused?
-export const getPaginatedRows = async (client, getToken, eventTracking, tenants, dashboardName, query, reportId, processing, filters, customFields) => {
-    if (query) {
-        return await fetchResultsByQuery({
-            query,
-            client,
-            tenants,
-            processing,
-            customFields,
-            filters,
-            dashboardName,
-            getToken,
-            eventTracking,
-        });
-    }
-    else if (reportId) {
-        return await fetchResultsByReport({
-            reportId,
-            client,
-            tenants,
-            processing,
-            filters,
-            customFields,
-            getToken,
-            eventTracking,
-        });
-    }
-    return { rows: [], columns: [] };
-};
-export const fetchResultsByQuery = async ({ query, client, tenants, processing, customFields, filters, dateField, rowsOnly, rowCountOnly, filterMap, dashboardName, pivot, getPivotRowCount = true, comparisonQuery, getToken, eventTracking, }) => {
-    let rows = [];
-    let columns = [];
-    let error = undefined;
-    let rowCount = undefined;
-    let itemQuery = undefined;
-    let referencedTables = undefined;
-    try {
-        if (pivot) {
-            const pivotData = await generatePivotWithSQL({
-                pivot,
-                client,
-                pivotQuery: query,
-                comparisonPivotQuery: comparisonQuery,
-                additionalProcessing: processing,
-                getPivotRowCount,
-                getToken,
-            });
-            rows = pivotData.rows;
-            columns = pivotData.columns;
-            rowCount = pivotData.rowCount;
-            itemQuery = pivotData.comparisonPivotQuery
-                ? [pivotData.pivotQuery, pivotData.comparisonPivotQuery]
-                : [pivotData.pivotQuery];
-        }
-        else {
-            let parsedSuccessfully = true;
-            let parsingError = '';
-            if (!rowCountOnly) {
-                const { data: results } = await quillFetch({
-                    client,
-                    task: 'astify',
-                    metadata: {
-                        clientId: client.clientId,
-                        useNewNodeSql: true,
-                        query,
-                    },
-                    getToken,
-                });
-                if (!results || results.success == false) {
-                    parsedSuccessfully = false;
-                    parsingError = results.message;
-                }
-            }
-            const fetchResp = await quillFetch({
-                client,
-                task: 'query',
-                metadata: {
-                    query,
-                    filterMap,
-                    clientId: client.publicKey,
-                    databaseType: client?.databaseType,
-                    customFieldsByTable: customFields,
-                    additionalProcessing: processing,
-                    useNewNodeSql: true,
-                    filters: filters?.map((filter) => ({
-                        ...filter,
-                        options: undefined,
-                    })),
-                    dateField: dateField ?? undefined,
-                    rowsOnly,
-                    rowCountOnly,
-                    dashboardName,
-                    tenants,
-                },
-                getToken,
-            });
-            const resp = await parseFetchResponse(client, 'query', fetchResp, getToken);
-            // console.log('newdata', newdata);
-            if (resp && resp.errorMessage) {
-                throw new Error(resp.errorMessage);
-            }
-            if (resp.rowCount !== undefined) {
-                rowCount = resp.rowCount;
-            }
-            if (!resp.error && !parsedSuccessfully) {
-                await quillFetch({
-                    client,
-                    task: 'log-broken-query',
-                    metadata: {
-                        query,
-                        clientId: client.clientId,
-                        error: parsingError,
-                    },
-                    getToken,
-                });
-                throw new Error('Quill parsing error' +
-                    parsingError.replace(`Error parsing query`, ''));
-            }
-            columns = resp.fields.map((elem) => convertPostgresColumn(elem));
-            rows = resp.rows;
-            itemQuery = resp.itemQuery;
-            referencedTables = resp.referencedTables;
-            if (customFields) {
-                const tables = referencedTables ?? [];
-                tables.forEach((table) => {
-                    const _customFields = customFields?.[table] ?? [];
-                    columns.forEach((col) => {
-                        if (_customFields.some((field) => {
-                            return field.field === col.field;
-                        })) {
-                            col.inferFormat = true;
-                        }
-                    });
-                });
-            }
-        }
-    }
-    catch (e) {
-        eventTracking?.logError?.({
-            type: 'bug', // TODO: determine type
-            severity: 'high',
-            message: 'Error fetching results by query',
-            errorMessage: e.message,
-            errorStack: e.stack,
-            errorData: {
-                caller: 'fetchResultsByQuery',
-                function: 'fetchResultsByQuery',
-            },
-        });
-        rows = [];
-        columns = [];
-        error = e.message || e;
-    }
-    if (client.databaseType && client.databaseType.toLowerCase() === 'bigquery') {
-        parseValueFromBigQueryDates(rows, columns);
-    }
-    return { rows, columns, rowCount, error, itemQuery, referencedTables };
-};
-export const fetchResultsByReport = async ({ reportId, client, tenants, processing, filters, customFields, rowsOnly, rowCountOnly, abortSignal, pivot, pivotQuery, comparisonPivotQuery, getPivotRowCount = true, getToken, eventTracking, }) => {
-    if (pivot && pivotQuery) {
-        return fetchResultsByQuery({
-            query: pivotQuery,
-            comparisonQuery: comparisonPivotQuery,
-            client,
-            tenants,
-            processing,
-            customFields,
-            filters,
-            pivot,
-            getPivotRowCount,
-            getToken,
-            eventTracking,
-        });
-    }
-    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['selectedValue'];
-                delete newFilter['presetOptions'];
-            }
-            delete newFilter['options'];
-            return newFilter;
-        })
-        : [];
-    try {
-        const fetchResp = await quillFetch({
-            client,
-            task: 'item',
-            metadata: {
-                dashboardItemId: reportId,
-                filters: minimalFilters,
-                clientId: client?.publicKey,
-                databaseType: client?.databaseType,
-                additionalProcessing: updatedProcessing,
-                forcePagination: true,
-                customFields,
-                useNewNodeSql: true,
-                rowsOnly,
-                rowCountOnly,
-                tenants,
-            },
-            abortSignal,
-            getToken,
-        });
-        const resp = await parseFetchResponse(client, 'item', fetchResp, getToken);
-        if (resp.errorMessage) {
-            throw new Error(resp.errorMessage);
-        }
-        processFilterErrorList(resp);
-        if (resp.rowCount !== undefined) {
-            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') {
-            throw new Error(resp.errorMessage);
-        }
-    }
-    catch (e) {
-        if (e instanceof Error && e.name === 'AbortError') {
-            throw e;
-        }
-        eventTracking?.logError?.({
-            type: 'bug', // TODO: determine type
-            severity: 'high',
-            message: 'Error fetching results by report',
-            errorMessage: e.message,
-            errorStack: e.stack,
-            errorData: {
-                caller: 'fetchResultsByReport',
-                function: 'fetchResultsByReport',
-            },
-        });
-        rows = [];
-        columns = [];
-        rowCount = 0;
-        error = e.message;
-    }
-    if (client.databaseType && client.databaseType.toLowerCase() === 'bigquery') {
-        parseValueFromBigQueryDates(rows, columns);
-    }
-    return { rows, columns, rowCount, error };
-};
-export const fetchTableByAST = async (ast, client, getToken, tenants, eventTracking, dashboardName, processing, customFields, rowsOnly, rowCountOnly) => {
-    let rows = [];
-    let columns = [];
-    let rowCount;
-    let error;
-    let itemQuery;
-    let referencedTables;
-    try {
-        const fetchResp = await quillFetch({
-            client,
-            task: 'patterns',
-            metadata: {
-                clientId: client.publicKey,
-                ast,
-                customFields,
-                additionalProcessing: processing,
-                useUpdatedDataGathering: true,
-                useNewNodeSql: true,
-                rowsOnly,
-                rowCountOnly,
-                dashboardName,
-                tenants,
-            },
-            getToken,
-        });
-        const resp = await parseFetchResponse(client, 'patterns', fetchResp, getToken);
-        if (resp.errorMessage || resp.name === 'error') {
-            throw new Error(resp.errorMessage);
-        }
-        processFilterErrorList(resp);
-        if (resp.rowCount !== undefined) {
-            rowCount = resp.rowCount;
-        }
-        const gatheredRows = resp.rows && resp.rows.length ? resp.rows : [];
-        columns = resp.fields.map((elem) => convertPostgresColumn(elem));
-        rows = gatheredRows;
-        itemQuery = resp.itemQuery;
-        referencedTables = resp.referencedTables;
-        if (customFields) {
-            const tables = referencedTables ?? [];
-            tables.forEach((table) => {
-                const _customFields = customFields?.[table] ?? [];
-                columns.forEach((col) => {
-                    if (_customFields.some((field) => {
-                        return field.field === col.field;
-                    })) {
-                        col.inferFormat = true;
-                    }
-                });
-            });
-        }
-    }
-    catch (e) {
-        eventTracking?.logError?.({
-            type: 'bug', // TODO: determine type
-            severity: 'high',
-            message: 'Error fetching table by AST',
-            errorMessage: e.message,
-            errorStack: e.stack,
-            errorData: {
-                caller: 'fetchTableByAST',
-                function: 'fetchTableByAST',
-            },
-        });
-        rows = [];
-        columns = [];
-        rowCount = 0;
-        error = e.message;
-    }
-    if (client.databaseType && client.databaseType.toLowerCase() === 'bigquery') {
-        parseValueFromBigQueryDates(rows, columns);
-    }
-    return { rows, columns, rowCount, error, itemQuery, referencedTables };
-};

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

@@ -1,9 +0,0 @@
-export type TenantValue = {
-    label: string;
-    value: string | number;
-};
-export type Tenant = {
-    name: string;
-    tenantField: string;
-};
-//# sourceMappingURL=tenants.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"tenants.d.ts","sourceRoot":"","sources":["../../../src/utils/tenants.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC"}

package/dist/esm/utils/tenants.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,7 +0,0 @@
-export declare function capitalize(text: string): string;
-export declare function depluralize(text: string): string;
-export declare function matchCasing(text: string | undefined, template: string | undefined): 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

@@ -1 +0,0 @@
-{"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,WAAW,CACzB,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,MAAM,CAwER;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"}