@quillsql/react 2.13.43 → 2.13.45

package/dist/esm/utils/tableProcessing.js

@@ -1,4 +1,3 @@
-import { deepCopy } from '../components/ReportBuilder/util';
 import { convertPostgresColumn, isStringType } from './columnProcessing';
 import { MAX_PIVOT_UNIQUE_VALUES, QUILL_QUERY_ENDPOINT, QUILL_SERVER, } from './constants';
 import { getData } from './dataFetcher';
@@ -19,61 +18,23 @@ export const hasColumnAlias = (columns, referencedColumns) => {
     }
     return false;
 };
-export const getUniqueValuesByColumns = async (columns, query, rows, client, tenants, customFields, filters, dashboardName) => {
+export const getUniqueValuesByQuery = async ({ columns, query, client, tenants, customFields, filters, dashboardName, }) => {
     const stringNames = columns.map((column) => column.field);
     const uniqueValues = {};
-    //TODO: this bigquery case is wack, we should be able to generate a distinct query for bigquery
-    if (!client.databaseType ||
-        client.databaseType.toLowerCase() === 'bigquery') {
-        if (rows.length === 0) {
-            const hostedBody = {
-                metadata: {
-                    query: query,
-                    task: 'query',
-                    clientId: client.publicKey,
-                    databaseType: client?.databaseType,
-                    customFieldsByTable: customFields,
-                    useNewNodeSql: true,
-                    dateField: filters?.find((filter) => filter.filterType === 'date_range')?.dateField,
-                    filters,
-                    dashboardName: dashboardName && tenants ? dashboardName : undefined,
-                    tenants: dashboardName && tenants ? tenants : undefined,
-                },
-            };
-            const cloudBody = { query };
-            const data = await getData(client, 'dashquery', 'same-origin', hostedBody, cloudBody);
-            if (!data || data.errorMessage) {
-                return null;
-            }
-            rows = data.rows;
-        }
-        for (const column of columns) {
-            const values = Array.from(new Set(rows
-                .map((row) => row[column.name || column.field])
-                .filter((value) => value !== null && value !== undefined)));
-            // @ts-ignore
-            uniqueValues[column.name || column.field] = values.reduce((result, value) => {
-                result[value] = false;
-                return result;
-            }, {});
-        }
+    if (stringNames.length === 0) {
+        return {};
     }
-    else {
-        if (stringNames.length === 0) {
-            return {};
-        }
-        const distinctValueQuery = generateDistinctQuery(stringNames, query, client.databaseType);
-        const distinctStrings = await fetchDistinctStrings(distinctValueQuery, client, tenants, customFields, filters, dashboardName);
-        if (!distinctStrings) {
-            return {};
-        }
-        for (const column of distinctStrings) {
-            uniqueValues[column.column] = column.values;
-        }
+    const distinctValueQuery = generateDistinctQuery(stringNames, query, client.databaseType || 'postgresql');
+    const distinctStrings = await fetchDistinctStrings(distinctValueQuery, client, tenants, customFields, filters, dashboardName);
+    if (!distinctStrings) {
+        return {};
+    }
+    for (const column of distinctStrings) {
+        uniqueValues[column.column] = column.values;
     }
     return uniqueValues;
 };
-export const getUniqueStringValues = async (columns, tableName, client, tenants, customFields, previousUniqueValues, withExceededColumns, query, dashboardName) => {
+export const getUniqueStringValuesByColumn = async ({ columns, tableName, client, tenants, customFields, withExceededColumns, query, dashboardName, }) => {
     const convertedStringColumns = columns.filter((column) => {
         return isStringType(column.fieldType);
     });
@@ -83,9 +44,15 @@ export const getUniqueStringValues = async (columns, tableName, client, tenants,
         : { filteredColumns: [], exceededColumns: undefined };
     const smallStringNames = smallStringColumns.map((column) => processColumnReference(column.field, client.databaseType, undefined, true));
     const newUniqueValues = query || smallStringColumns.length > 0
-        ? await getUniqueValuesByColumns(
-        // returns null if data error
-        smallStringColumns, query || `Select ${smallStringNames.join(', ')} from ${tableName}`, [], client, tenants, customFields ?? [], undefined, dashboardName)
+        ? await getUniqueValuesByQuery({
+            // returns null if data error
+            columns: smallStringColumns,
+            query: query || `Select ${smallStringNames.join(', ')} from ${tableName}`,
+            client,
+            tenants,
+            customFields: customFields ?? [],
+            dashboardName,
+        })
         : null;
     if (!newUniqueValues) {
         return {};
@@ -93,35 +60,59 @@ export const getUniqueStringValues = async (columns, tableName, client, tenants,
     if (withExceededColumns) {
         exceededColumns?.forEach((column) => {
             if (newUniqueValues) {
-                newUniqueValues[column.field] = { EXCEEDS_LIMIT: true };
+                newUniqueValues[column.field] = ['EXCEEDS_LIMIT'];
             }
         });
     }
-    if (previousUniqueValues) {
-        // This logic was used in ReportBuilder before this function was extracted
-        // Not sure if it still accurate, but didn't want to remove in case
-        const joinedUniqueValues = deepCopy(previousUniqueValues);
-        joinedUniqueValues[tableName] = newUniqueValues;
-        return joinedUniqueValues;
-    }
-    else {
-        return newUniqueValues;
-    }
+    return newUniqueValues;
+};
+export const getUniqueStringValuesByTable = async ({ tables, columns, client, tenants, dashboardName, customFields, withExceededColumns, queryTemplate, }) => {
+    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,
+            tenants,
+            dashboardName,
+            customFields,
+            withExceededColumns,
+            query,
+        });
+        uniqueValues[tableName] = newUniqueValues;
+    }));
+    return uniqueValues;
 };
-export const getRelevantInfoFromQuery = async (columns, client, tenants, query, customFields, dashboardName) => {
+export const getRelevantInfoFromQuery = async ({ tables, columns, aliasedColumns, reportBuilderColumns, client, tenants, query, queryTemplate, customFields, dashboardName, }) => {
     let dateRanges = {};
-    let uniqueStrings = {};
+    let uniqueStrings = null;
+    const columnUniqueValues = {};
     let error = undefined;
     try {
-        const convertedStringColumns = columns.filter((column) => {
-            return isStringType(column.fieldType);
+        uniqueStrings = await getUniqueStringValuesByTable({
+            tables,
+            columns,
+            client,
+            tenants,
+            dashboardName,
+            customFields,
+            withExceededColumns: true,
+            queryTemplate,
         });
-        const stringNames = convertedStringColumns.map((column) => column.field);
-        if (stringNames.length > 0) {
-            const { filteredColumns: smallStringColumns } = await getCountsByColumns(convertedStringColumns, query, client, tenants, customFields, dashboardName);
-            uniqueStrings = await getUniqueValuesByColumns(smallStringColumns, query, [], client, tenants, customFields, undefined, dashboardName);
-        }
-        const dateColumns = columns.filter((column) => {
+        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) {
@@ -136,6 +127,7 @@ export const getRelevantInfoFromQuery = async (columns, client, tenants, query,
     }
     return {
         uniqueStrings: uniqueStrings ?? undefined,
+        columnUniqueValues: columnUniqueValues,
         dateRanges: dateRanges ?? undefined,
         error,
     };
@@ -207,7 +199,7 @@ const fetchDistinctStrings = async (query, client, tenants, customFields, filter
         const results = data.rows.map((columnInfo) => {
             const column = columnInfo.field || columnInfo.FIELD;
             if (!columnInfo.string_values) {
-                return { column, 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
@@ -219,17 +211,17 @@ const fetchDistinctStrings = async (query, client, tenants, customFields, filter
                     .reduce((result, value) => {
                     if (value !== null && value !== undefined) {
                         // TODO: handle null values rather than filtering out
-                        result[value] = false;
+                        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[value] = false;
+                        result.push(value);
                     }
                     return result;
-                }, {});
+                }, []);
             return { column, values };
         });
         return results;
@@ -574,10 +566,3 @@ export const fetchTableByAST = async (ast, client, tenants, processing, customFi
     }
     return { rows, columns, rowCount, error, itemQuery, referencedTables };
 };
-export const convertUniqueValuesByColumnToUniqueValueStrings = (uniqueValuesByColumns) => {
-    return Object.keys(uniqueValuesByColumns).reduce((acc, column) => {
-        const uniqueValues = uniqueValuesByColumns[column] ?? [];
-        acc[column] = Object.keys(uniqueValues);
-        return acc;
-    }, {});
-};

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

@@ -0,0 +1,2 @@
+export declare const getScrollableParent: (element: HTMLElement | null) => HTMLElement | (Window & typeof globalThis);
+//# sourceMappingURL=ui.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ui.d.ts","sourceRoot":"","sources":["../../../src/utils/ui.ts"],"names":[],"mappings":"AACC,eAAO,MAAM,mBAAmB,YAAa,WAAW,GAAG,IAAI,+CAU/D,CAAC"}

package/dist/esm/utils/ui.js

@@ -0,0 +1,14 @@
+// Utility to find the nearest scrollable ancestor
+export const getScrollableParent = (element) => {
+    if (!element)
+        return document.body;
+    let parent = element.parentElement;
+    while (parent) {
+        const style = getComputedStyle(parent);
+        const isScrollable = /(auto|scroll)/.test(style.overflowY + style.overflowX);
+        if (isScrollable)
+            return parent;
+        parent = parent.parentElement;
+    }
+    return window;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillsql/react",
-  "version": "2.13.43",
+  "version": "2.13.45",
   "exports": {
     ".": {
       "import": "./dist/esm/index.js",