@quillsql/react 2.15.2 → 2.15.4

package/dist/cjs/utils/astProcessing.js

@@ -1,616 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchASTFromQuillReport = exports.fetchAndProcessASTFromPrompt = exports.createSelectStarFromAst = exports.createBasicSelectASTFromColumns = exports.getAllPossibleColumns = exports.isSubquery = void 0;
-exports.getSelectFromAST = getSelectFromAST;
-exports.processStarColumn = processStarColumn;
-exports.recursiveSearchByKey = recursiveSearchByKey;
-exports.recursiveSearchByKeys = recursiveSearchByKeys;
-exports.createTableNameToTableAliasMap = createTableNameToTableAliasMap;
-exports.getColumnsByTableName = getColumnsByTableName;
-exports.processApostrophe = processApostrophe;
-exports.recursiveSearchByKeysFindAllOccurances = recursiveSearchByKeysFindAllOccurances;
-exports.getColumnAndTableInfo = getColumnAndTableInfo;
-exports.getColumnsByTableFromASTAndSchema = getColumnsByTableFromASTAndSchema;
-exports.getTablesHelper = getTablesHelper;
-const ast_1 = require("../components/ReportBuilder/ast");
-const convert_1 = require("../components/ReportBuilder/convert");
-const util_1 = require("../components/ReportBuilder/util");
-const astFilterProcessing_1 = require("./astFilterProcessing");
-const dataFetcher_1 = require("./dataFetcher");
-const tableProcessing_1 = require("./tableProcessing");
-function getSelectFromAST(ast) {
-    if (Array.isArray(ast)) {
-        return ast[0];
-    }
-    else if (ast.select) {
-        return ast.select;
-    }
-    else {
-        return ast;
-    }
-}
-function processStarColumn(ast, columns) {
-    if (ast.columns === '*') {
-        ast.columns = columns.map((column) => {
-            return {
-                type: 'expr',
-                expr: {
-                    type: 'column_ref',
-                    table: null,
-                    column: column.field,
-                },
-                as: null,
-            };
-        });
-    }
-    return ast;
-}
-// a useful function to search for a specific keywork and return the value
-function recursiveSearchByKey(node, searchKey) {
-    let result = undefined;
-    if (!node || typeof node !== 'object') {
-        return undefined;
-    }
-    if (node[searchKey]) {
-        return node[searchKey];
-    }
-    const keys = Object.keys(node);
-    for (const key of keys) {
-        result = recursiveSearchByKey(node[key], searchKey);
-        if (result) {
-            return result;
-        }
-    }
-    return result;
-}
-// If the object has all the requested keys, return the object
-function recursiveSearchByKeys(node, searchKeys) {
-    let result = undefined;
-    if (!node || typeof node !== 'object') {
-        return undefined;
-    }
-    const nodeKeys = Object.keys(node);
-    if (searchKeys.every((key) => nodeKeys.includes(key))) {
-        return node;
-    }
-    for (const key of nodeKeys) {
-        result = recursiveSearchByKeys(node[key], searchKeys);
-        if (result) {
-            return result;
-        }
-    }
-    return result;
-}
-function createTableNameToTableAliasMap(ast) {
-    const tableNameToTableAliasMap = {};
-    if (ast.from) {
-        for (const table of ast.from) {
-            const tableObject = recursiveSearchByKeys(table, ['table', 'as']);
-            if (tableObject.as) {
-                tableNameToTableAliasMap[tableObject.as] = tableObject.table;
-            }
-            else {
-                tableNameToTableAliasMap[tableObject.table] = tableObject.table;
-            }
-        }
-    }
-    if (ast.with) {
-        for (const withStmt of ast.with) {
-            const astFrom = withStmt.stmt.from ?? withStmt.stmt.ast.from;
-            if (astFrom) {
-                for (const table of astFrom) {
-                    const tableObject = recursiveSearchByKeys(table, ['table', 'as']);
-                    if (tableObject.as) {
-                        tableNameToTableAliasMap[tableObject.as] = tableObject.table;
-                    }
-                    else {
-                        tableNameToTableAliasMap[tableObject.table] = tableObject.table;
-                    }
-                }
-            }
-        }
-    }
-    return tableNameToTableAliasMap;
-}
-function getColumnsByTableName(ast, tableName) {
-    const tableNameToTableAliasMap = createTableNameToTableAliasMap(ast);
-    const columns = [];
-    ast.columns.forEach((col) => {
-        const columnInfo = recursiveSearchByKeys(col, ['table', 'column']);
-        if (columnInfo.table === tableName ||
-            columnInfo.table === tableNameToTableAliasMap[tableName]) {
-            columns.push({ field: columnInfo.column });
-        }
-    });
-    return { columns, name: tableName };
-}
-function processApostrophe(node, searchKeys) {
-    if (!node || typeof node !== 'object') {
-        return;
-    }
-    const nodeKeys = Object.keys(node);
-    if (searchKeys.every((key) => nodeKeys.includes(key))) {
-        if (node.type === 'single_quote_string') {
-            node.value = node.value.replace("''", "'").replace("\\'", "'");
-        }
-    }
-    for (const key of nodeKeys) {
-        processApostrophe(node[key], searchKeys);
-    }
-    return;
-}
-function recursiveSearchByKeysFindAllOccurances(node, searchKeys, results) {
-    if (!node || typeof node !== 'object') {
-        return;
-    }
-    const nodeKeys = Object.keys(node);
-    if (searchKeys.every((key) => nodeKeys.includes(key))) {
-        return results.push(node);
-    }
-    for (const key of nodeKeys) {
-        recursiveSearchByKeysFindAllOccurances(node[key], searchKeys, results);
-    }
-    return results;
-}
-function getColumnAndTableInfo(tableAliasMap, column, schemaInfo) {
-    let columnsInfo = recursiveSearchByKeys(column, ['table', 'column']);
-    if (!columnsInfo) {
-        const quoteStringColumn = recursiveSearchByKeys(column, ['type', 'value']);
-        columnsInfo = { table: null, column: quoteStringColumn.value };
-    }
-    let columnName = columnsInfo.column;
-    if (columnsInfo.column &&
-        columnsInfo.column.expr &&
-        typeof columnsInfo.column !== 'string') {
-        columnName = columnsInfo.column.expr.value;
-    }
-    let tableName = '';
-    if (columnsInfo.table) {
-        tableName = tableAliasMap[columnsInfo.table];
-    }
-    else {
-        // If there is no column name search through the schemaInfo to find an accurate table name
-        const tableNames = Object.values(tableAliasMap);
-        for (const table of tableNames) {
-            const tableInfo = schemaInfo.find((tableInfo) => tableInfo.name === table);
-            if (!tableInfo)
-                continue;
-            const columnNames = tableInfo.columns.map((column) => column.field);
-            if (columnNames.includes(columnName)) {
-                tableName = table;
-                break;
-            }
-        }
-    }
-    return { tableName, columnName };
-}
-function getColumnsByTableFromASTAndSchema(ast, tables, tableAliasMap, skipStar = false) {
-    if (!ast || !ast.columns) {
-        return {};
-    }
-    const referencedColumns = {};
-    if (!skipStar &&
-        (ast?.columns === '*' || ast?.columns?.[0]?.expr?.column === '*')) {
-        // Be sure to select everything from stars
-        const tableList = ast.from.map((table) => recursiveSearchByKey(table, 'table'));
-        tableList.forEach((table) => {
-            const tableInfo = tables.find((tableInfo) => tableInfo.name === table);
-            if (tableInfo) {
-                if (!referencedColumns[table]) {
-                    referencedColumns[table] = [];
-                }
-                referencedColumns[table] = tableInfo.columns.map((column) => column.field);
-            }
-        });
-    }
-    else {
-        // look through all the columns
-        ast.columns.forEach((column) => {
-            const result = getColumnAndTableInfo(tableAliasMap, column, tables);
-            if (!result || !result.tableName)
-                return;
-            if (!referencedColumns[result.tableName]) {
-                referencedColumns[result.tableName] = [];
-            }
-            // @ts-ignore
-            referencedColumns[result.tableName].push(result.columnName);
-        });
-    }
-    // Look through every join reference
-    if (ast.from) {
-        const allColumnReferncesInFrom = recursiveSearchByKeysFindAllOccurances(ast.from, ['column', 'table'], []);
-        allColumnReferncesInFrom.forEach((column) => {
-            const result = getColumnAndTableInfo(tableAliasMap, column, tables);
-            if (!result || !result.tableName)
-                return;
-            if (!referencedColumns[result.tableName]) {
-                referencedColumns[result.tableName] = [];
-            }
-            // @ts-ignore
-            referencedColumns[result.tableName].push(result.columnName);
-        });
-    }
-    // Look through the where's
-    if (ast.where) {
-        let allColumnReferncesInWhere = recursiveSearchByKeysFindAllOccurances(ast.where, ['column', 'table'], []);
-        allColumnReferncesInWhere.forEach((column) => {
-            const result = getColumnAndTableInfo(tableAliasMap, column, tables);
-            if (!result || !result.tableName || !result.columnName)
-                return;
-            if (!referencedColumns[result.tableName]) {
-                referencedColumns[result.tableName] = [];
-            }
-            // @ts-ignore
-            referencedColumns[result.tableName].push(result.columnName);
-        });
-        // NEED TO SEARCH FOR ALL DOUBLE QUOTE STRINGS AS WELL
-        allColumnReferncesInWhere = recursiveSearchByKeysFindAllOccurances(ast.where, ['type', 'value'], []);
-        allColumnReferncesInWhere.forEach((column) => {
-            if (column.type === 'double_quote_string') {
-                let tableName = '';
-                const tableNames = Object.values(tableAliasMap);
-                for (const table of tableNames) {
-                    const tableInfo = tables.find((tableInfo) => tableInfo.name === table);
-                    if (!tableInfo)
-                        continue;
-                    const columnNames = tableInfo.columns.map((column) => column.field);
-                    if (columnNames.includes(column.value)) {
-                        tableName = table;
-                        break;
-                    }
-                }
-                if (tableName === '') {
-                    return;
-                }
-                if (!referencedColumns[tableName]) {
-                    referencedColumns[tableName] = [];
-                }
-                // @ts-ignore
-                referencedColumns[tableName].push(column.value);
-            }
-        });
-    }
-    // Look through the orderby's
-    if (ast.orderby) {
-        const allColumnReferencesInOrderBy = ast.orderby.map((orderby) => ({
-            field: (0, astFilterProcessing_1.getFieldFromExpression)(orderby.expr ?? orderby),
-            table: orderby.expr?.table,
-        }));
-        allColumnReferencesInOrderBy.forEach((column) => {
-            const table = column.table || ast.from?.length === 1 ? ast.from[0].table : '';
-            if (!table) {
-                return;
-            }
-            if (!referencedColumns[table]) {
-                referencedColumns[table] = [];
-            }
-            referencedColumns[table].push(column.field);
-        });
-    }
-    for (const table in referencedColumns) {
-        referencedColumns[table] = Array.from(new Set(referencedColumns[table]));
-    }
-    return referencedColumns;
-}
-const isSubquery = (node) => {
-    if (!node)
-        return false;
-    if (node.ast)
-        return true;
-    if (node.left && (0, exports.isSubquery)(node.left))
-        return true;
-    if (node.right && (0, exports.isSubquery)(node.right))
-        return true;
-    if (node.value && Array.isArray(node.value)) {
-        for (const value of node.value) {
-            if ((0, exports.isSubquery)(value))
-                return true;
-        }
-    }
-    return false;
-};
-exports.isSubquery = isSubquery;
-const getAllPossibleColumns = (baseAst, schema) => {
-    if (!baseAst || !baseAst.from) {
-        return schema.flatMap((table) => table.columns.map((c) => ({
-            ...c,
-            table: table.displayName,
-        })));
-    }
-    // TODO: support infinitely nested FROM table lookups.
-    // This currently only supports top-level table names in the FROM section
-    // of queries (eg. FROM "table_name", not "FROM (SELECT * FROM other) AS table_name")
-    const tableNamesInQuery = baseAst.from.map((tbl) => tbl.table);
-    return schema
-        .filter((t) => tableNamesInQuery.includes(t.displayName))
-        .flatMap((table) => table.columns
-        .map((c) => ({
-        ...c,
-        table: table.displayName,
-    }))
-        .sort((a, b) => {
-        const aIsId = a.field.toLowerCase() === 'id' ||
-            a.field.toLowerCase().endsWith('_id') ||
-            a.field.endsWith('Id');
-        const bIsId = b.field.toLowerCase() === 'id' ||
-            b.field.toLowerCase().endsWith('_id') ||
-            b.field.endsWith('Id');
-        if (aIsId && !bIsId)
-            return 1;
-        if (bIsId && !aIsId)
-            return -1;
-        return 0;
-    }));
-};
-exports.getAllPossibleColumns = getAllPossibleColumns;
-const createBasicSelectASTFromColumns = (columns, tableName) => {
-    return {
-        type: 'select',
-        options: null,
-        distinct: null,
-        columns: columns.map((column) => ({
-            expr: {
-                type: 'column_ref',
-                table: tableName,
-                column: column.field,
-            },
-            as: null,
-        })),
-        from: [{ db: null, table: tableName, as: null }],
-        where: null,
-        groupby: null,
-        having: null,
-        orderby: null,
-        limit: null,
-    };
-};
-exports.createBasicSelectASTFromColumns = createBasicSelectASTFromColumns;
-const createSelectStarFromAst = (ast) => {
-    return {
-        ...ast,
-        columns: [
-            {
-                expr: {
-                    type: 'column_ref',
-                    table: null,
-                    column: '*',
-                },
-                as: null,
-            },
-        ],
-    };
-};
-exports.createSelectStarFromAst = createSelectStarFromAst;
-const fetchAndProcessASTFromPrompt = async ({ aiPrompt, schema, client, prevPivot, currentQuery, prevTable, dashboardName, tenants, getToken, eventTracking, }) => {
-    let res, data, ast, newAst, pivot;
-    let numRetries = 0;
-    let whereAST;
-    const MAX_RETRIES = 3;
-    if (aiPrompt.trim().length > 500) {
-        throw new Error('Error: Prompt must be less than 500 characters');
-    }
-    try {
-        let isTableJoin = !ast || !ast.from || ast.from.length !== 1;
-        while (isTableJoin || (0, exports.isSubquery)(ast?.where)) {
-            if (numRetries === MAX_RETRIES)
-                break;
-            if (!currentQuery || (ast && (isTableJoin || (0, exports.isSubquery)(ast?.where)))) {
-                res = await (0, dataFetcher_1.quillFetch)({
-                    client,
-                    task: 'magic',
-                    metadata: {
-                        initialQuestion: aiPrompt,
-                    },
-                    getToken,
-                });
-            }
-            else {
-                res = await (0, dataFetcher_1.quillFetch)({
-                    client,
-                    task: 'magic-edit',
-                    metadata: {
-                        sqlQuery: currentQuery,
-                        initialQuestion: aiPrompt,
-                    },
-                    getToken,
-                });
-            }
-            data = res.data;
-            ast = data?.ast?.length ? data?.ast[0] : data?.ast;
-            // TODO: Debug invalid table joins in handleAsk
-            isTableJoin =
-                ast?.type !== 'bigquery' &&
-                    (!ast || !ast.from || ast.from.length !== 1);
-            numRetries += 1;
-        }
-        if (numRetries === MAX_RETRIES) {
-            console.error('[Error]: Max retries exceeded.');
-            console.info(`%c[Prompt]: ${aiPrompt}`, 'color: dimgray');
-            throw new Error("Error: Couldn't process your request, please re-word your prompt.");
-        }
-        ast = ast.length ? ast[0] : ast;
-        newAst = (0, convert_1.convertBigQuery)(ast);
-        newAst = (0, util_1.removeTableNameAlias)(newAst, schema);
-        newAst = (0, convert_1.convertWildcardColumns)(newAst, schema); // must go before groupby
-        ({ ast: newAst, pivot } = (0, convert_1.convertGroupBy)(newAst, schema, prevPivot, prevTable));
-        newAst = (0, convert_1.convertOrderBy)(newAst, schema);
-        newAst = (0, convert_1.convertStringComparison)(newAst, client.databaseType || 'postgresql');
-        newAst = (0, convert_1.convertRemoveSimpleParentheses)(newAst);
-        const table = (0, ast_1.getTableNames)(newAst)[0];
-        if (!table) {
-            throw new Error('Table or table alias not found');
-        }
-        const processedName = table || '';
-        const tableInfo = schema.find((t) => t.name === processedName);
-        if (!tableInfo) {
-            throw new Error('Table info not found');
-        }
-        const uniqueValues = await (0, tableProcessing_1.getUniqueStringValuesByColumn)({
-            columns: tableInfo.columns,
-            tableName: processedName,
-            client,
-            getToken,
-            eventTracking,
-            tenants,
-            dashboardName,
-        });
-        newAst = (0, convert_1.convertUnaryToBinary)(newAst);
-        newAst = (0, util_1.removeNonSelectedTableReferences)(newAst, processedName, tableInfo.columns.map((col) => col.field), uniqueValues);
-        if (pivot) {
-            newAst = (0, util_1.deepCopy)({ ...newAst, orderby: null, limit: null });
-        }
-        whereAST = (0, util_1.deepCopy)(newAst.where);
-        const _columns = schema.find((_table) => {
-            return _table.name === table;
-        })?.columns;
-        // parse the whereAst first
-        const filterTree = (0, astFilterProcessing_1.astToFilterTree)(whereAST, client.databaseType?.toLowerCase() || 'postgresql', _columns);
-        const cleanAst = filterTree
-            ? (0, astFilterProcessing_1.filterTreeToAst)(filterTree, client.databaseType?.toLowerCase() || 'postgresql')
-            : null;
-        whereAST = cleanAst;
-    }
-    catch (e) {
-        console.log(e);
-        eventTracking?.logError?.({
-            type: 'bug', // TODO: determine type
-            severity: 'high',
-            message: 'Error fetching and processing AST from prompt',
-            errorMessage: e.message,
-            errorStack: e.stack,
-            errorData: {
-                caller: 'fetchAndProcessASTFromPrompt',
-                function: 'fetchAndProcessASTFromPrompt',
-            },
-        });
-        if (e instanceof Error) {
-            return {
-                ast: null,
-                pivot: null,
-                whereAST: null,
-                error: "Error: Couldn't process your request, please re-word your prompt.",
-            };
-        }
-    }
-    return { ast: newAst, pivot, whereAST };
-};
-exports.fetchAndProcessASTFromPrompt = fetchAndProcessASTFromPrompt;
-const fetchASTFromQuillReport = async (report, client, schema, getToken, eventTracking) => {
-    let newAst;
-    let groupByPivot = null;
-    let schemaInfo = [];
-    try {
-        if (!report) {
-            throw new Error('Report not found');
-        }
-        const { data: resp } = await (0, dataFetcher_1.quillFetch)({
-            client,
-            task: 'astify',
-            metadata: {
-                clientId: client.clientId,
-                useNewNodeSql: true,
-                query: report.queryString,
-            },
-            getToken,
-        });
-        if (resp.success === false) {
-            throw new Error("Couldn't process report query.");
-        }
-        const ast = getSelectFromAST(resp.ast);
-        let convertedAst = processStarColumn(ast, report.columns);
-        convertedAst = (0, convert_1.convertWildcardColumns)(convertedAst, schema); // must go before groupby
-        convertedAst = (0, convert_1.convertBigQuery)(convertedAst);
-        schemaInfo = schema;
-        processApostrophe(convertedAst, ['type', 'value']);
-        convertedAst = (0, convert_1.convertBigQuery)(convertedAst);
-        ({ ast: newAst, pivot: groupByPivot } = (0, convert_1.convertGroupBy)(convertedAst, schemaInfo, report.pivot ? report.pivot : undefined));
-        newAst = convertedAst;
-    }
-    catch (e) {
-        console.log(e);
-        eventTracking?.logError?.({
-            type: 'bug', // TODO: determine type
-            severity: 'high',
-            message: 'Error fetching AST from report',
-            errorMessage: e.message,
-            errorStack: e.stack,
-            errorData: {
-                caller: 'fetchASTFromQuillReport',
-                function: 'fetchASTFromQuillReport',
-            },
-        });
-        if (e instanceof Error) {
-            return {
-                error: e.message,
-                ast: null,
-                pivot: null,
-            };
-        }
-    }
-    return { ast: newAst, pivot: groupByPivot, schema: schemaInfo };
-};
-exports.fetchASTFromQuillReport = fetchASTFromQuillReport;
-const POSTGRES_DATE_TYPES = [
-    'timestamp',
-    'date',
-    'timestamptz',
-    'time',
-    'timetz',
-];
-function getTablesHelper(ast, allTables, skipStar) {
-    const tableAliasMap = createTableNameToTableAliasMap(ast);
-    const tablesInQuery = Object.values(tableAliasMap);
-    // Remove all aliased tables (with statements and subqueries)
-    const onlyReferenceTables = allTables
-        .filter((table) => tablesInQuery.includes(table.displayName))
-        .map((table) => table.displayName);
-    // Get non with statement column references
-    let referencedColumns = getColumnsByTableFromASTAndSchema(ast, allTables, tableAliasMap, skipStar);
-    referencedColumns = Object.keys(referencedColumns)
-        .filter((table) => onlyReferenceTables.includes(table))
-        .reduce((obj, key) => {
-        obj[key] = referencedColumns[key];
-        return obj;
-    }, {});
-    // With statement column references
-    if (ast.with) {
-        for (const withStmt of ast.with) {
-            const astFrom = withStmt.stmt.from ?? withStmt.stmt.ast.from;
-            if (astFrom) {
-                const withReferencedColumns = getColumnsByTableFromASTAndSchema(withStmt.stmt.ast ?? withStmt.stmt, allTables, tableAliasMap, skipStar);
-                // @ts-ignore
-                Object.keys(withReferencedColumns).forEach((tableName) => {
-                    if (referencedColumns[tableName]) {
-                        // @ts-ignore
-                        referencedColumns[tableName].push(...(withReferencedColumns[tableName] || []));
-                    }
-                    else {
-                        // @ts-ignore
-                        referencedColumns[tableName] = withReferencedColumns[tableName];
-                    }
-                });
-            }
-        }
-    }
-    // Make all the column strings unique
-    for (const table in referencedColumns) {
-        referencedColumns[table] = Array.from(new Set(referencedColumns[table]));
-    }
-    const referencedTablesAndColumns = onlyReferenceTables.map((tableName) => {
-        return {
-            name: tableName,
-            columns: referencedColumns[tableName]?.map((column) => {
-                return { field: column };
-            }) || [],
-        };
-    });
-    const dateFields = allTables
-        .filter((table) => onlyReferenceTables.includes(table.displayName))
-        .map((table) => {
-        return {
-            name: table.displayName,
-            columns: table.columns.filter((column) => POSTGRES_DATE_TYPES.includes(column.fieldType)),
-        };
-    });
-    return { referencedTablesAndColumns, dateFields };
-}

package/dist/cjs/utils/axisFormatter.d.ts

@@ -1,19 +0,0 @@
-import { AxisFormat } from '../Dashboard';
-type Field = {
-    field: string;
-    format: AxisFormat;
-};
-type Props = {
-    value: string | number | boolean | undefined | null;
-    field: string | undefined | null;
-    fields: Field[];
-};
-/**
- * Pretty-prints the given values to their nice-looking string form.
- *
- * The axis formatter will print a shorter version of the valueFormatter, which
- * fits nicely along the X or Y axes.
- */
-export declare const axisFormatter: ({ value, field, fields }: Props) => string;
-export {};
-//# sourceMappingURL=axisFormatter.d.ts.map

package/dist/cjs/utils/axisFormatter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"axisFormatter.d.ts","sourceRoot":"","sources":["../../../src/utils/axisFormatter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,KAAK,KAAK,GAAG;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,UAAU,CAAC;CACpB,CAAC;AAEF,KAAK,KAAK,GAAG;IACX,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,IAAI,CAAC;IACpD,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACjC,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,0BAA0B,KAAK,KAAG,MA4C/D,CAAC"}