@quillsql/react 2.15.2 → 2.15.4

package/dist/esm/utils/parserBigQuery.js

@@ -1,52 +0,0 @@
-// Functions use to parse BigQuery SQL
-export const isInTheLastIntervalBigQuery = (node) => {
-    const isOutsideOfDateTrunc = ['>=', '>'].includes(node.operator) &&
-        (node.left.type === 'column_ref' ||
-            (node.left.type === 'function' &&
-                node.left.name.toLowerCase() === 'timestamp')) &&
-        node.right.type === 'function' &&
-        node.right.name.toLowerCase() === 'timestamp_sub' &&
-        node.right.args.value[0].type === 'function' &&
-        node.right.args.value[1].type === 'interval' &&
-        ['current_timestamp'].includes(node.right.args.value[0].name.toLowerCase());
-    return isOutsideOfDateTrunc;
-};
-export const isAfterBigQuery = (node) => {
-    const isOutsideOfDateTrunc = ['>=', '>'].includes(node.operator) &&
-        (node.left.type === 'column_ref' ||
-            (node.left.type === 'function' &&
-                node.left.name.toLowerCase() === 'timestamp')) &&
-        ((node.right.type === 'function' &&
-            node.right.name.toLowerCase() === 'timestamp') ||
-            node.right.type === 'timestamp');
-    return isOutsideOfDateTrunc;
-};
-export const isBeforeBigQuery = (node) => {
-    const isOutsideOfDateTrunc = ['<=', '<'].includes(node.operator) &&
-        (node.left.type === 'column_ref' ||
-            (node.left.type === 'function' &&
-                node.left.name.toLowerCase() === 'timestamp')) &&
-        ((node.right.type === 'function' &&
-            node.right.name.toLowerCase() === 'timestamp') ||
-            node.right.type === 'timestamp');
-    return isOutsideOfDateTrunc;
-};
-export const isTheCurrentIntervalBigQuery = (node) => {
-    const isInsideOfDateTrunc = ['='].includes(node.operator) &&
-        node.left.type === 'function' &&
-        node.left.name &&
-        node.left.name.toLowerCase() === 'timestamp_trunc' &&
-        node.right.type === 'function' &&
-        node.right.name.toLowerCase() === 'timestamp_trunc' &&
-        node.right.args?.value[0]?.name?.toLowerCase() === 'current_timestamp';
-    return isInsideOfDateTrunc;
-};
-export const isEqualsBigQuery = (node) => {
-    const isEquals = ['='].includes(node.operator) &&
-        node.left.type === 'function' &&
-        node.left.name &&
-        node.left.name.toLowerCase() === 'timestamp_trunc' &&
-        node.right.name.toLowerCase() === 'timestamp_trunc' &&
-        node.right.args.value[0].type.toLowerCase() === 'timestamp';
-    return isEquals;
-};

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

@@ -1,3 +0,0 @@
-export declare const isInTheLastIntervalPostgres: (node: any) => boolean;
-export declare const isTheCurrentIntervalPostgres: (node: any) => boolean;
-//# sourceMappingURL=parserPostgres.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"parserPostgres.d.ts","sourceRoot":"","sources":["../../../src/utils/parserPostgres.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,GAAI,MAAM,GAAG,KAAG,OAyBvD,CAAC;AAEF,eAAO,MAAM,4BAA4B,GAAI,MAAM,GAAG,KAAG,OAiBxD,CAAC"}

package/dist/esm/utils/parserPostgres.js

@@ -1,37 +0,0 @@
-export const isInTheLastIntervalPostgres = (node) => {
-    const isOutsideOfDateTrunc = ['>=', '>'].includes(node.operator) &&
-        node.left.type === 'column_ref' &&
-        node.right.type === 'binary_expr' &&
-        node.right.operator === '-' &&
-        node.right.left.type === 'function' &&
-        node.right.left.name.toLowerCase() === 'date_trunc' &&
-        node.right.left.args.value[0].type === 'single_quote_string' &&
-        node.right.left.args.value[1].type === 'function' &&
-        ['current_date', 'now'].includes(node.right.left.args.value[1].name.toLowerCase()) &&
-        node.right.right.type.toLowerCase() === 'interval' &&
-        node.right.right.expr.type === 'single_quote_string';
-    const noDateTrunc = ['>=', '>'].includes(node.operator) &&
-        node.left.type === 'column_ref' &&
-        node.right.type === 'binary_expr' &&
-        node.right.operator === '-' &&
-        node.right.left.type === 'function' &&
-        ['current_date', 'now'].includes(node.right.left.name.toLowerCase()) &&
-        node.right.right.type.toLowerCase() === 'interval' &&
-        node.right.right.expr.type === 'single_quote_string';
-    return isOutsideOfDateTrunc || noDateTrunc;
-};
-export const isTheCurrentIntervalPostgres = (node) => {
-    const isInsideOfDateTrunc = ['AND'].includes(node.operator) &&
-        (node.left.operator === '=' || node.left.type === 'double_quote_string') &&
-        node.right.operator === '=' &&
-        node.right.name &&
-        node.right.name.toLowerCase() === 'date_trunc' &&
-        node.args.value[0].type === 'single_quote_string' &&
-        node.args.value[1].type === 'binary_expr' &&
-        node.args.value[1].operator === '-' &&
-        node.args.value[1].left.type === 'function' &&
-        ['now', 'current_date'].includes(node.args.value[1].left.name.toLowerCase()) &&
-        node.args.value[1].right.type === 'interval' &&
-        node.args.value[1].right.expr.type === 'single_quote_string';
-    return isInsideOfDateTrunc;
-};

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

@@ -1,25 +0,0 @@
-import { QuillProviderClient } from '../models/Client';
-import { Pivot, PivotData } from '../models/Pivot';
-import { QuillReportInternal } from '../models/Report';
-import { AdditionalProcessing } from './tableProcessing';
-export declare function generatePivotWithSQL({ pivot, report, client, dateBucket, dateFilter, distinctStrings, dashboardName, tenants, additionalProcessing, pivotQuery, comparisonPivotQuery, getPivotRowCount, caller, getToken, }: {
-    pivot: Pivot;
-    report?: QuillReportInternal;
-    client: QuillProviderClient;
-    dateBucket?: string;
-    dateFilter?: any;
-    distinctStrings?: string[];
-    dashboardName?: string;
-    tenants?: {
-        tenantField: string;
-        tenantIds: (string | number)[];
-    }[] | (string | number)[];
-    additionalProcessing?: AdditionalProcessing;
-    pivotQuery?: string;
-    comparisonPivotQuery?: string;
-    getPivotRowCount?: boolean;
-    caller?: string;
-    getToken: () => Promise<string>;
-}): Promise<PivotData>;
-export declare function disambiguatedValueField(pivot: Pivot): string | undefined;
-//# sourceMappingURL=pivotConstructor.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"pivotConstructor.d.ts","sourceRoot":"","sources":["../../../src/utils/pivotConstructor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAYvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD,wBAAsB,oBAAoB,CAAC,EACzC,KAAK,EACL,MAAM,EACN,MAAM,EACN,UAAU,EACV,UAAU,EACV,eAAe,EACf,aAAa,EACb,OAAO,EACP,oBAAoB,EACpB,UAAU,EACV,oBAAoB,EACpB,gBAAuB,EACvB,MAAM,EACN,QAAQ,GACT,EAAE;IACD,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,MAAM,EAAE,mBAAmB,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,GAAG,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EACJ;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;KAAE,EAAE,GACzD,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IACxB,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CACjC,GAAG,OAAO,CAAC,SAAS,CAAC,CAuXrB;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,KAAK,sBAYnD"}

package/dist/esm/utils/pivotConstructor.js

@@ -1,296 +0,0 @@
-import { getDateString } from '../internals/ReportBuilder/PivotModal';
-import { isStringType, processColumnName } from './columnProcessing';
-import { MAX_PIVOT_UNIQUE_VALUES } from './constants';
-import { quillFetch } from './dataFetcher';
-import { parseValueFromBigQueryDates } from './dataProcessing';
-import { getComparisonInterval } from './dates';
-import { mergeComparisonPivotColumns, mergeComparisonPivotRows } from './merge';
-import { additionalProcessingOnPivotQuery, generatePivotQuery, generateRowCountQuery, } from './queryConstructor';
-import { matchCasing, snakeCaseToTitleCase } from './textProcessing';
-export async function generatePivotWithSQL({ pivot, report, client, dateBucket, dateFilter, distinctStrings, dashboardName, tenants, additionalProcessing, pivotQuery, comparisonPivotQuery, getPivotRowCount = true, caller, getToken, }) {
-    let sqlQuery = pivotQuery;
-    let comparisonPivotSql = comparisonPivotQuery;
-    const databaseType = client.databaseType || 'postgresql';
-    if (!pivotQuery &&
-        pivot.columnField &&
-        !pivot.columnValues &&
-        !distinctStrings) {
-        if (!report?.rows) {
-            throw new Error('No distinct strings provided for column field');
-        }
-        else {
-            distinctStrings = Array.from(new Set(report.rows
-                .map((row) => row[pivot.columnField])
-                .filter((value) => value !== null && value !== undefined)));
-        }
-    }
-    if (!pivot.aggregations?.length && pivot.aggregationType) {
-        pivot.aggregations = [
-            {
-                aggregationType: pivot.aggregationType,
-                valueField: pivot.valueField,
-                valueFieldType: pivot.valueFieldType,
-                valueField2: pivot.valueField2,
-                valueField2Type: pivot.valueField2Type,
-            },
-        ];
-    }
-    let comparisonInterval = undefined;
-    if (dateFilter && dateFilter.comparisonRange) {
-        comparisonInterval = getComparisonInterval({
-            startDate: dateFilter.comparisonRange.startDate,
-            endDate: dateFilter.comparisonRange.endDate,
-        }, dateBucket);
-    }
-    if (pivot.rowField && !pivot.rowFieldType) {
-        const rowColumn = report?.columns.find((column) => column.field === pivot.rowField);
-        pivot.rowFieldType = rowColumn?.format || 'string';
-    }
-    const filteredDistinctStrings = distinctStrings?.filter((value) => value !== null && value !== undefined && value !== '');
-    const pivotColumnFields = filteredDistinctStrings?.slice(0, MAX_PIVOT_UNIQUE_VALUES);
-    if (!pivotQuery && report) {
-        if (!report.itemQuery) {
-            throw Error('No item query found in report');
-        }
-        const itemQuery = report.itemQuery[0];
-        const comparisonQuery = report.itemQuery[1];
-        if (!itemQuery) {
-            throw Error('No item query found in report');
-        }
-        sqlQuery =
-            pivotQuery ??
-                generatePivotQuery(pivot, itemQuery, databaseType, pivotColumnFields, dateBucket);
-        comparisonPivotSql = comparisonQuery
-            ? generatePivotQuery(pivot, comparisonQuery, databaseType, pivotColumnFields, dateBucket)
-            : '';
-    }
-    if (!sqlQuery) {
-        throw 'Error generating pivot query';
-    }
-    const paginatedSqlQuery = additionalProcessingOnPivotQuery(pivot, sqlQuery, additionalProcessing, client.databaseType);
-    const paginatedComparisonQuery = comparisonPivotSql
-        ? additionalProcessingOnPivotQuery(pivot, comparisonPivotSql, additionalProcessing, client.databaseType)
-        : '';
-    const preQueries = [paginatedSqlQuery];
-    getPivotRowCount =
-        getPivotRowCount &&
-            (report?.chartType === 'table' || caller === 'ReportBuilder');
-    if (getPivotRowCount) {
-        const pivotRowCountQuery = generateRowCountQuery(sqlQuery, client.databaseType);
-        preQueries.push(pivotRowCountQuery);
-    }
-    if (paginatedComparisonQuery) {
-        preQueries.push(paginatedComparisonQuery);
-    }
-    const { data: resp } = await quillFetch({
-        client,
-        task: 'query',
-        metadata: {
-            preQueries,
-            clientId: client.publicKey,
-            databaseType: databaseType,
-            runQueryConfig: {
-                overridePost: true,
-                convertDatatypes: true,
-            },
-            useNewNodeSql: true,
-            dashboardName,
-            tenants,
-        },
-        urlParameters: `caller=generatePivot&task=query`,
-        credentials: 'same-origin',
-        getToken,
-    });
-    if (resp.success === false) {
-        throw resp.errorMessage;
-    }
-    const queryResponseRows = resp?.queryResults?.[0]?.rows || [];
-    const queryResponseFields = resp?.queryResults?.[0]?.fields || [];
-    const queryComparisonResponseRows = (getPivotRowCount
-        ? resp?.queryResults?.[2]?.rows
-        : resp?.queryResults?.[1]?.rows) || [];
-    const queryComparisonResponseFields = (getPivotRowCount
-        ? resp?.queryResults?.[2]?.fields
-        : resp?.queryResults?.[1]?.fields) || [];
-    parseValueFromBigQueryDates(queryResponseRows, queryResponseFields);
-    parseValueFromBigQueryDates(queryComparisonResponseRows, queryComparisonResponseFields);
-    const responseRows = mergeComparisonPivotRows({
-        pivot,
-        rows: queryResponseRows,
-        compRows: queryComparisonResponseRows,
-        databaseType,
-        dateBucket,
-        comparisonInterval,
-        columnFieldValues: pivotColumnFields,
-    });
-    const responseFields = mergeComparisonPivotColumns({
-        pivot,
-        rows: queryResponseFields,
-        compRows: queryComparisonResponseFields,
-    });
-    const rows = pivot.rowField
-        ? responseRows.map((row) => !row[pivot.rowField] ? { ...row, [pivot.rowField]: '-' } : row)
-        : responseRows;
-    if (pivot.columnField && client.databaseType?.toLowerCase() === 'bigquery') {
-        rows.forEach((row) => {
-            Object.keys(row).forEach((key) => {
-                const processedKey = processColumnName(key);
-                if (processedKey !== key) {
-                    row[processedKey] = row[key];
-                    delete row[key];
-                }
-            });
-        });
-    }
-    const columns = responseFields
-        ?.map((field) => ({
-        field: processColumnName(field.name),
-        label: snakeCaseToTitleCase(processColumnName(field.name.replace('comparison_', 'comparison '))),
-        format: field.name === pivot.rowField
-            ? 'string'
-            : // This scary equation is calculating which aggregation a column is associated with.
-                // Eg you have 7 columns and 2 aggregations, you can assume column 0 is the row field, 1-3 is aggregation 0, and 4-6 is aggregation 1.
-                // pivot.aggregations?.[
-                //     Math.floor(
-                //       (index - 1) /
-                //         Math.floor(
-                //           (responseFields.length - 1) /
-                //             (pivot.aggregations?.length ?? 1),
-                //         ),
-                //     )
-                //   ]?.aggregationType === 'percentage'
-                pivot.aggregations?.find((agg) => agg.valueField === field.name ||
-                    `${agg.valueField}_percentage` === field.name ||
-                    (!agg.valueField &&
-                        agg.aggregationType === 'percentage' &&
-                        field.name.endsWith('percentage')))?.aggregationType === 'percentage'
-                    ? 'percent'
-                    : 'whole_number',
-        fieldType: field.fieldType,
-        jsType: field.jsType,
-        dataTypeID: field.dataTypeID,
-    }))
-        .filter((field, index) => field.field !== 'comparison_' + pivot.rowField || index === 0)
-        .sort((a, b) => {
-        if (a.field === pivot.rowField) {
-            return -1;
-        }
-        if (b.field === pivot.rowField) {
-            return 1;
-        }
-        return 0;
-    });
-    if (pivot.rowField && !isStringType(pivot.rowFieldType || '')) {
-        rows.forEach((row) => {
-            row.__quillRawDate =
-                typeof row[pivot.rowField || ''] === 'object' // BigQuery
-                    ? row[pivot.rowField || ''].value
-                    : row[pivot.rowField || ''];
-            let value = typeof row[pivot.rowField || ''] === 'object' // BigQuery
-                ? row[pivot.rowField || ''].value
-                : row[pivot.rowField || ''];
-            if (dateBucket === 'week' &&
-                dateFilter?.startDate &&
-                dateFilter?.endDate) {
-                const rowDate = new Date(value);
-                // check if row value is within dateFilter, else push it to within the date filter
-                if (rowDate < dateFilter.startDate) {
-                    value = dateFilter.startDate.toISOString();
-                }
-                else if (rowDate > dateFilter.endDate) {
-                    value = dateFilter.endDate.toISOString();
-                }
-            }
-            const dateString = getDateString(value, dateFilter?.startDate && dateFilter?.endDate
-                ? { start: dateFilter.startDate, end: dateFilter.endDate }
-                : undefined, dateBucket, databaseType);
-            row[pivot.rowField || ''] = dateString;
-        });
-        // add a row for each date in the range that doesn't have a value
-        if (pivot.rowField &&
-            pivot.rowFieldType &&
-            !isStringType(pivot.rowFieldType) &&
-            dateFilter?.startDate &&
-            dateFilter?.endDate) {
-            const dateSet = new Set(rows.map((row) => row[pivot.rowField || '']));
-            // create a loop that will go through each formatted date and add a row if it doesn't exist going to the current date
-            for (let date = dateFilter.startDate; date <= dateFilter.endDate; date = new Date(date.getTime() + 24 * 60 * 60 * 1000)) {
-                const formattedDate = getDateString(date.toISOString(), { start: dateFilter.startDate, end: dateFilter.endDate }, dateBucket, databaseType);
-                if (!dateSet.has(formattedDate)) {
-                    const newRow = {};
-                    newRow[pivot.rowField] = formattedDate;
-                    newRow.__quillRawDate = date.toISOString();
-                    rows.push(newRow);
-                    dateSet.add(formattedDate);
-                }
-            }
-        }
-        // sort the rows by date
-        if (!pivot.sort) {
-            rows.sort((a, b) => {
-                if (a.__quillRawDate < b.__quillRawDate) {
-                    return -1;
-                }
-                if (a.__quillRawDate > b.__quillRawDate) {
-                    return 1;
-                }
-                return 0;
-            });
-        }
-        // remove the raw date field
-        // rows.forEach((row: any) => {
-        //   delete row.__quillRawDate;
-        // });
-    }
-    // should be doing this in the query
-    // if (pivot.sort) {
-    //   rows.sort((a: any, b: any) => {
-    //     if (pivot.sortDirection === 'ASC') {
-    //       return compareValues(a, b, pivot.sortField || '');
-    //     } else {
-    //       return compareValues(b, a, pivot.sortField || '');
-    //     }
-    //   });
-    // }
-    // for the case of count agg on no value field
-    columns?.forEach((column, index) => {
-        if (column.label &&
-            ['null', 'undefined'].includes(column.label.toLowerCase()) &&
-            !pivot.columnField &&
-            !pivot.aggregations?.[index]?.valueField &&
-            pivot.aggregations?.[index]?.aggregationType === 'count') {
-            column.label = 'Count';
-        }
-    });
-    // If a numeric column field is not present add it with a value of 0
-    const numericColumns = columns?.filter((column) => column.format === 'whole_number' || column.format === 'percentage');
-    rows.forEach((row) => {
-        numericColumns?.forEach((column) => {
-            row[column.field] = row[column.field] ?? 0;
-        });
-    });
-    return {
-        rows: rows,
-        columns: columns ?? [],
-        rowCount: getPivotRowCount
-            ? (Number(resp?.queryResults?.[1]?.rows?.[0]?.['row_count']) ??
-                rows.length)
-            : 0,
-        pivotQuery: sqlQuery,
-        comparisonPivotQuery: comparisonPivotSql,
-    };
-}
-export function disambiguatedValueField(pivot) {
-    if (pivot.aggregations && pivot.aggregations.length > 0) {
-        if (!pivot.aggregations[0]?.valueField && !pivot.valueField) {
-            return undefined; // avoid returning empty string
-        }
-        if (pivot.aggregations.length === 1) {
-            return pivot.aggregations[0]?.valueField ?? pivot.valueField;
-        }
-        else {
-            return `${pivot.aggregations[0].valueField}_${matchCasing(pivot.aggregations[0].aggregationType, pivot.aggregations[0].valueField)}`;
-        }
-    }
-    return pivot.valueField ? pivot.valueField : undefined; // avoid returning empty string
-}

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

@@ -1,33 +0,0 @@
-import { AxisFormat } from '../Dashboard';
-import { ColumnInternal } from '../models/Columns';
-import { Pivot, PivotData } from '../models/Pivot';
-import { QuillReportInternal } from '../models/Report';
-import { UniqueValuesByColumn } from '../models/Tables';
-export declare function isValidPivot(pivot: Pivot): {
-    valid: boolean;
-    reason: string;
-};
-export declare function getPossiblePivotFieldOptions(columns: ColumnInternal[], uniqueValues: UniqueValuesByColumn): {
-    rowFields: string[];
-    columnFields: string[];
-    valueFields: string[];
-};
-export declare function cleanPivot(pivot: Pivot, possibleColumns: {
-    rowFields: any;
-    columnFields: any;
-    valueFields: any;
-}): Pivot;
-export declare const isPivotPossible: (fields: any, pivot: Pivot) => boolean;
-export declare const pivotFormData: (pivot: Pivot, columns: ColumnInternal[], report?: QuillReportInternal, formChartType?: string, pivotData?: PivotData) => {
-    pivot: Pivot;
-    chartType: string;
-    xAxisField: string | undefined;
-    xAxisFormat: AxisFormat;
-    xAxisLabel: string | undefined;
-    yAxisFields: {
-        field: string;
-        label: string;
-        format: AxisFormat;
-    }[];
-};
-//# sourceMappingURL=pivotProcessing.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"pivotProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/pivotProcessing.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAWxD,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CA6C7E;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,cAAc,EAAE,EACzB,YAAY,EAAE,oBAAoB;;;;EAqDnC;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,eAAe,EAAE;IACf,SAAS,EAAE,GAAG,CAAC;IACf,YAAY,EAAE,GAAG,CAAC;IAClB,WAAW,EAAE,GAAG,CAAC;CAClB,GACA,KAAK,CAsCP;AAED,eAAO,MAAM,eAAe,GAAI,QAAQ,GAAG,EAAE,OAAO,KAAK,YA8BxD,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,OAAO,KAAK,EACZ,SAAS,cAAc,EAAE,EACzB,SAAS,mBAAmB,EAC5B,gBAAgB,MAAM,EACtB,YAAY,SAAS;;;;;;;;;;;CAuDtB,CAAC"}

package/dist/esm/utils/pivotProcessing.js

@@ -1,177 +0,0 @@
-import { isIdColumn } from '../components/ReportBuilder/util';
-import { isDateField } from '../internals/ReportBuilder/PivotModal';
-import { isBoolType, isDateType, isNumberType, isStringType, } from './columnProcessing';
-import { MAX_PIVOT_UNIQUE_VALUES } from './constants';
-import { disambiguatedValueField } from './pivotConstructor';
-import { NUMBER_FORMAT_TYPES } from './valueFormatter';
-export function isValidPivot(pivot) {
-    if (!pivot.rowField &&
-        !pivot.aggregations?.[0]?.valueField &&
-        pivot.aggregations?.[0]?.aggregationType !== 'count') {
-        return {
-            valid: false,
-            reason: 'Row field cannot be empty without a value field when aggregation is not "count"',
-        };
-    }
-    else if (!pivot.rowField && pivot.columnField) {
-        return {
-            valid: false,
-            reason: 'Row field cannot be empty when column field is present',
-        };
-    }
-    else if (pivot.aggregations?.some((a) => a.aggregationType !== 'count' &&
-        a.aggregationType !== 'percentage' &&
-        !a.valueField)) {
-        return {
-            valid: false,
-            reason: 'Value field cannot be empty when aggregation is not "count" or "percentage"',
-        };
-    }
-    else if (pivot.aggregations?.some((a) => a.aggregationType === 'percentage' &&
-        !a.valueField &&
-        (!pivot.rowField || pivot.columnField))) {
-        return {
-            valid: false,
-            reason: 'Empty percentage field only supported for pivot tables with a row field and no column field',
-        };
-    }
-    return { valid: true, reason: '' };
-}
-export function getPossiblePivotFieldOptions(columns, uniqueValues) {
-    const rowFields = [];
-    const columnFields = [];
-    const valueFields = [];
-    for (const column of columns) {
-        // row fields can be dates or strings
-        if (isDateType(column.fieldType)) {
-            rowFields.push(column.field);
-        }
-        // include ID fields as rowField pivot option
-        // if (isIdColumn(column.field)) { // TODO: this will cause problems elsewhere that are only expecting string or date: look into it
-        //   rowFields.push(column.field);
-        // }
-        // column fields can be strings
-        if (isStringType(column.fieldType)) {
-            const possibleValues = uniqueValues?.[column.field] ?? [];
-            const isNullValuesOnly = !possibleValues ||
-                (Object.keys(possibleValues).length === 1 &&
-                    Object.keys(possibleValues)[0] === 'null');
-            if (!isNullValuesOnly &&
-                possibleValues.length <= MAX_PIVOT_UNIQUE_VALUES &&
-                !(Object.keys(possibleValues).length === 1 &&
-                    possibleValues[0] === 'EXCEEDS_LIMIT')) {
-                columnFields.push(column.field);
-            }
-            if (!isNullValuesOnly // Used to limit rowFields with max unique values, no more
-            ) {
-                rowFields.push(column.field);
-            }
-        }
-        // value fields can be numbers or bools
-        if (isNumberType(column.fieldType) || isBoolType(column.fieldType)) {
-            if (!isIdColumn(column.field)) {
-                valueFields.push(column.field);
-            }
-        }
-    }
-    return {
-        rowFields,
-        columnFields,
-        valueFields,
-    };
-}
-export function cleanPivot(pivot, possibleColumns) {
-    // Swap row field and column field if the AI put a date field as the column field
-    if (pivot.columnField &&
-        !possibleColumns.columnFields.includes(pivot.columnField)) {
-        if (possibleColumns.rowFields.includes(pivot.columnField)) {
-            const rowField = pivot.rowField;
-            pivot.rowField = pivot.columnField;
-            pivot.columnField = possibleColumns.columnFields.includes(rowField)
-                ? rowField
-                : undefined;
-        }
-    }
-    if (pivot.rowField && !possibleColumns.rowFields.includes(pivot.rowField)) {
-        pivot.rowField = undefined;
-    }
-    if (!pivot.valueField ||
-        !possibleColumns.valueFields.includes(pivot.valueField)) {
-        pivot.valueField = '';
-    }
-    if (pivot.columnField &&
-        !possibleColumns.columnFields.includes(pivot.columnField)) {
-        pivot.columnField = undefined;
-    }
-    if (pivot.aggregationType) {
-        pivot.aggregations = [
-            {
-                valueField: pivot.valueField,
-                aggregationType: pivot.aggregationType,
-            },
-        ];
-    }
-    return pivot;
-}
-export const isPivotPossible = (fields, pivot) => {
-    let validPivot = true;
-    if (pivot.rowField &&
-        !fields.find((field) => field.name === pivot.rowField || field.field === pivot.rowField)) {
-        validPivot = false;
-    }
-    if (pivot.valueField &&
-        !fields.find((field) => field.name === pivot.valueField || field.field === pivot.valueField)) {
-        validPivot = false;
-    }
-    if (pivot.columnField &&
-        !fields.find((field) => field.name === pivot.columnField || field.field === pivot.columnField)) {
-        validPivot = false;
-    }
-    return validPivot;
-};
-export const pivotFormData = (pivot, columns, report, formChartType, pivotData) => {
-    const yAxisField = pivot.columnField ?? disambiguatedValueField(pivot) ?? '';
-    const yAxisLabel = report?.yAxisFields && report?.yAxisFields?.length > 0
-        ? (report.yAxisFields[0]?.label ?? '')
-        : (disambiguatedValueField(pivot) ?? '');
-    // date labels for pivots should be treated like strings since they are
-    const yAxisIsDate = pivot.columnField
-        ? isDateField(pivot.columnFieldType ?? '')
-        : false;
-    const chartType = formChartType ?? (pivot.rowField ? 'column' : 'metric');
-    const rowColumn = (pivotData?.columns ?? columns).find((col) => col.field === pivot.rowField);
-    const xAxisField = pivot.rowField &&
-        !(['metric', 'gauge'].includes(chartType) &&
-            !NUMBER_FORMAT_TYPES.includes(rowColumn?.format ?? ''))
-        ? pivot.rowField
-        : disambiguatedValueField(pivot);
-    const result = {
-        pivot,
-        chartType: chartType,
-        xAxisField,
-        xAxisFormat: chartType === 'gauge'
-            ? 'percent'
-            : chartType === 'metric'
-                ? 'whole_number'
-                : isDateType(pivot.rowFieldType ?? '')
-                    ? 'string'
-                    : isNumberType(pivot.rowFieldType ?? '')
-                        ? 'whole_number'
-                        : isNumberType(disambiguatedValueField(pivot) ?? '')
-                            ? 'whole_number'
-                            : 'string',
-        xAxisLabel: report?.xAxisLabel || pivot.rowField,
-        yAxisFields: [
-            {
-                field: yAxisField,
-                label: yAxisLabel,
-                format: yAxisIsDate
-                    ? 'string'
-                    : report?.yAxisFields && report?.yAxisFields?.length > 0
-                        ? (report?.yAxisFields[0]?.format ?? 'whole_number')
-                        : (report?.columns.find((col) => col.field === disambiguatedValueField(pivot))?.format ?? 'whole_number'),
-            },
-        ],
-    };
-    return result;
-};

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

@@ -1,15 +0,0 @@
-import { Pivot } from '../models/Pivot';
-import { AdditionalProcessing } from './tableProcessing';
-export declare function processSingleQuotes(value: string, databaseType: string): string;
-export declare function processAggType(aggType: string, hasColumnField?: boolean): string;
-export declare function processColumnReference(column: string, databaseType: string, fallbackOnNull?: string, isColumnFieldAlias?: boolean, isValueFieldAlias?: boolean): string;
-export declare function replaceSpacesWithUnderscores(column: string): string;
-export declare function processDateTrunc(dateBucket: string, rowField: string, databaseType: string, comparisonInterval?: string): string;
-export declare function processValueField(aggType: string, databaseType: string, valueField: string): string;
-export declare function generateCountQuery(fields: string[], query: string, databaseType: string): string;
-export declare function generateDistinctQuery(stringFields: string[], query: string, databaseType: string): string;
-export declare function generateMinMaxDateRangeQueries(columnFields: string[], query: string, databaseType: string): string;
-export declare function generatePivotQuery(pivot: Pivot, itemQuery: string, databaseType: string, distinctStrings?: string[], dateBucket?: string): string | undefined;
-export declare function additionalProcessingOnPivotQuery(pivot: Pivot, query?: string, additionalProcessing?: AdditionalProcessing, databaseType?: string): string | undefined;
-export declare function generateRowCountQuery(query?: string, databaseType?: string): string | undefined;
-//# sourceMappingURL=queryConstructor.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"queryConstructor.d.ts","sourceRoot":"","sources":["../../../src/utils/queryConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAIxC,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,UAStE;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,UAAQ,UAGrE;AAMD,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,cAAc,CAAC,EAAE,MAAM,EAEvB,kBAAkB,CAAC,EAAE,OAAO,EAC5B,iBAAiB,CAAC,EAAE,OAAO,UAqH5B;AAED,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,MAAM,UAE1D;AAmBD,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,kBAAkB,CAAC,EAAE,MAAM,UAiC5B;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,UAYnB;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EAAE,EAChB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,UAsBrB;AAED,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,MAAM,EAAE,EACtB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,UAmBrB;AA6GD,wBAAgB,8BAA8B,CAC5C,YAAY,EAAE,MAAM,EAAE,EACtB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,UAkBrB;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,eAAe,CAAC,EAAE,MAAM,EAAE,EAC1B,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,GAAG,SAAS,CAkBpB;AA43BD,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,KAAK,EACZ,KAAK,CAAC,EAAE,MAAM,EACd,oBAAoB,CAAC,EAAE,oBAAoB,EAC3C,YAAY,SAAe,sBA2E5B;AAED,wBAAgB,qBAAqB,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,sBAqB1E"}