@quillsql/react 2.15.2 → 2.15.4

package/dist/cjs/components/ReportBuilder/util.js

@@ -1,842 +0,0 @@
-"use strict";
-// A collection of reusable, pure, utility functions for the Report Builder.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDateFilterInfo = exports.trimEndS = exports.deepCopy = exports.isExtractEquals = exports.isDateTruncEquals = exports.newUTCDate = exports.isColumnComparison = exports.isThePreviousInterval = exports.isEquals = exports.isTheCurrentInterval = exports.isBefore = exports.isAfter = exports.isInTheLastInterval = exports.isColumnDateish = exports.isColumnReferenceish = exports.isDateTrunc = exports.isNodeEmptyCollection = void 0;
-exports.isTopLevelBoolean = isTopLevelBoolean;
-exports.hasTopLevelOrBoolean = hasTopLevelOrBoolean;
-exports.generateColumnExpr = generateColumnExpr;
-exports.areObjectsEqualish = areObjectsEqualish;
-exports.formatDateComparisonNode = formatDateComparisonNode;
-exports.getInTheCurrentIntervalSentence = getInTheCurrentIntervalSentence;
-exports.getInTheLastIntervalSentence = getInTheLastIntervalSentence;
-exports.getInThePreviousIntervalSentence = getInThePreviousIntervalSentence;
-exports.getIsEqualsSentence = getIsEqualsSentence;
-exports.getIsAfterSentence = getIsAfterSentence;
-exports.getIsBeforeSentence = getIsBeforeSentence;
-exports.dateTruncSuffixToString = dateTruncSuffixToString;
-exports.extractSuffixToString = extractSuffixToString;
-exports.tryConvertDateEquality = tryConvertDateEquality;
-exports.showNodeAsRow = showNodeAsRow;
-exports.getPostgresBasicType = getPostgresBasicType;
-exports.removeNonSelectedTableReferences = removeNonSelectedTableReferences;
-exports.removeTableNameAlias = removeTableNameAlias;
-exports.allNumericNodesValidInTree = allNumericNodesValidInTree;
-exports.isIdColumn = isIdColumn;
-exports.getCustomSentence = getCustomSentence;
-const date_fns_1 = require("date-fns");
-const bigDateMap_1 = require("./bigDateMap");
-const textProcessing_1 = require("../../utils/textProcessing");
-const parserBigQuery_1 = require("../../utils/parserBigQuery");
-const parserPostgres_1 = require("../../utils/parserPostgres");
-const astFilterProcessing_1 = require("../../utils/astFilterProcessing");
-/**
- * A node that is "in" or "not in" where none of the variants are selected.
- */
-const isNodeEmptyCollection = (node) => {
-    return (['IN', 'NOT IN'].includes(node.operator) &&
-        node.right.type === 'expr_list' &&
-        node.right.value.length === 1 &&
-        node.right.value[0].type === 'function' &&
-        ['lower', 'upper'].includes(node.right.value[0].name.toLowerCase()) &&
-        node.right.value[0].args.type === 'expr_list' &&
-        node.right.value[0].args.value.length === 1 &&
-        node.right.value[0].args.value[0].value === '');
-};
-exports.isNodeEmptyCollection = isNodeEmptyCollection;
-function isTopLevelBoolean(node) {
-    // override normal logic for conditions added by users
-    if (node.isCondition !== undefined) {
-        return true;
-    }
-    if (!node.parentheses &&
-        node.type === 'binary_expr' &&
-        (node.operator === 'AND' || node.operator === 'OR')) {
-        return true;
-    }
-    return false;
-}
-function hasTopLevelOrBoolean(ast) {
-    if (ast.where && ast.where.operator === 'OR') {
-        return true;
-    }
-    return false;
-}
-// Returns whether the node is a date_trunc function.
-const isDateTrunc = (node) => {
-    try {
-        return node &&
-            node.type === 'function' &&
-            node.name === 'date_trunc' &&
-            node.args &&
-            node.args.type === 'expr_list' &&
-            node.args?.value.length === 2 &&
-            node.args?.value[0].type === 'single_quote_string' &&
-            // The right-side value can either be a double-quoted string literal or
-            // a cast to some sort of date-ish type. We handle these variants:
-            //  -> date_trunc('month', '2024-01-01'::DATE)
-            //  -> date_trunc('month', "2024-01-01")
-            //  -> date_trunc('month', TIMESTAMP '2024-01-01')
-            //  -> date_trunc('month', DATE '2024-01-01')
-            node.args?.value[1].type === 'cast'
-            ? node.args?.value[1].expr.type === 'single_quote_string'
-            : ['timestamp', 'date', 'column_ref', 'double_quote_string'].includes(node.args?.value[1].type);
-    }
-    catch (e) {
-        return false;
-    }
-};
-exports.isDateTrunc = isDateTrunc;
-// Returns whether the given node is a raw column reference.
-const isColumnReferenceish = (node) => {
-    return node && ['column_ref', 'double_quote_string'].includes(node.type);
-};
-exports.isColumnReferenceish = isColumnReferenceish;
-function generateColumnExpr(name) {
-    return {
-        type: 'expr',
-        expr: {
-            type: 'column_ref',
-            table: null,
-            column: name,
-        },
-        as: null,
-    };
-}
-// Returns whether this column node is either a date_trunc or extract
-// function which implies that it is some sort of date/timestamp type.
-// TODO: replace me with actual code that checks against dbtype.
-const isColumnDateish = (col) => {
-    return (col &&
-        col?.expr?.type === 'function' &&
-        ['date_trunc', 'extract'].includes(col?.expr?.name?.toLowerCase()));
-};
-exports.isColumnDateish = isColumnDateish;
-function areObjectsEqualish(left, right) {
-    if (left === null || right === null)
-        return false;
-    if (left === undefined || right === undefined)
-        return false;
-    if (typeof left !== 'object' || typeof right !== 'object')
-        return false;
-    for (const [key, value] of Object.entries(left)) {
-        if (typeof value === 'string') {
-            if (!right[key])
-                return false;
-            if (right[key].toLowerCase() !== value.toLowerCase())
-                return false;
-        }
-        else if (typeof value === 'object') {
-            if (!areObjectsEqualish(value, right[key]))
-                return false;
-        }
-        else if (!value) {
-            if (!right[key])
-                return false;
-        }
-        else {
-            console.error('unknown type: ', typeof value);
-        }
-    }
-    return true;
-}
-function formatDateComparisonNode(node) {
-    for (const [key, callback] of Object.entries(bigDateMap_1.DATE_DESCRIPTION_MAP)) {
-        const partialObject = JSON.parse(key);
-        if (areObjectsEqualish(partialObject, node)) {
-            return callback(node);
-        }
-    }
-    return null;
-}
-function getInTheCurrentIntervalSentence(node, databaseType) {
-    if (databaseType === 'BigQuery') {
-        const dateColumn = (0, textProcessing_1.snakeAndCamelCaseToTitleCase)(node.left.args.value[0].column);
-        const periodValue = node.left.args.value[1].column.toLowerCase();
-        return `${dateColumn} in the current ${periodValue}`;
-    }
-    return null;
-}
-const BIG_QUERY_DAY_TO_INTERVAL_MAP = {
-    '* 365 day': 'year',
-    '* 30 day': 'month',
-    '* 7 day': 'week',
-};
-function getInTheLastIntervalSentence(node, databaseType) {
-    if (databaseType === 'BigQuery') {
-        const dateColumn = (0, textProcessing_1.snakeAndCamelCaseToTitleCase)(node.left.column || node.left.args.value[0].columns || '');
-        const amount = node.right.args.value[1].expr.value;
-        let unit = node.right.args.value[1].unit.toLowerCase();
-        if (unit.includes('*')) {
-            unit = BIG_QUERY_DAY_TO_INTERVAL_MAP[unit];
-        }
-        return `${dateColumn} in the last ${amount} ${unit}${amount > 1 ? 's' : ''}`;
-    }
-    return null;
-}
-function getInThePreviousIntervalSentence(node, databaseType) {
-    if (databaseType === 'BigQuery') {
-        const dateColumn = (0, textProcessing_1.snakeAndCamelCaseToTitleCase)(node.left.args.value[0].column);
-        const periodValue = node.left.args.value[1].column.toLowerCase();
-        return `${dateColumn} in the previous ${periodValue}`;
-    }
-    return null;
-}
-function getIsEqualsSentence(node, databaseType) {
-    if (databaseType === 'BigQuery') {
-        const dateColumn = (0, textProcessing_1.snakeAndCamelCaseToTitleCase)(node.left.args.value[1].column);
-        const type = node.right.args.value[1].column.toLowerCase();
-        const value = node.right.args.value[0].value;
-        // using date-fns can I parse the date to short month year
-        const date = new Date(value);
-        if (type === 'year') {
-            return `${dateColumn} is in ${(0, date_fns_1.format)((0, date_fns_1.addMinutes)(date, date.getTimezoneOffset()), 'yyyy')}`;
-        }
-        else if (type === 'month') {
-            return `${dateColumn} is in ${(0, date_fns_1.format)((0, date_fns_1.addMinutes)(date, date.getTimezoneOffset()), 'MMM yyyy')}`;
-        }
-        else if (type === 'quarter') {
-            return `${dateColumn} is in ${(0, date_fns_1.format)((0, date_fns_1.addMinutes)(date, date.getTimezoneOffset()), 'QQQ yyyy')}`;
-        }
-        return `${dateColumn} is in the ${type} of ${value}`;
-    }
-    return null;
-}
-function getIsAfterSentence(node, databaseType) {
-    if (databaseType === 'BigQuery') {
-        const dateColumn = (0, textProcessing_1.snakeAndCamelCaseToTitleCase)(node.left?.column || node.left?.args?.value[0]?.columns || '');
-        const value = node.right?.value || node.right?.args?.value[0]?.value || '';
-        if (!dateColumn || !value) {
-            return null;
-        }
-        return `${dateColumn} is after ${value}`;
-    }
-    return null;
-}
-function getIsBeforeSentence(node, databaseType) {
-    if (databaseType === 'BigQuery') {
-        const dateColumn = (0, textProcessing_1.snakeAndCamelCaseToTitleCase)(node.left?.column || node.left?.args?.value[0]?.columns || '');
-        const value = node.right?.value || node.right?.args?.value[0]?.value || '';
-        if (!dateColumn || !value) {
-            return null;
-        }
-        return `${dateColumn} is before ${value}`;
-    }
-    return null;
-}
-// "created_at" >= date_trunc ('year', CURRENT_DATE) - INTERVAL '1 year'
-// or
-// "created_at" >= CURRENT_DATE - INTERVAL '1 year'
-// in the last year aka one interval from today
-const isInTheLastInterval = (node, databaseType) => {
-    if (databaseType && databaseType.toLowerCase() === 'bigquery') {
-        return (0, parserBigQuery_1.isInTheLastIntervalBigQuery)(node);
-    }
-    return (0, parserPostgres_1.isInTheLastIntervalPostgres)(node);
-};
-exports.isInTheLastInterval = isInTheLastInterval;
-const isAfter = (node, databaseType) => {
-    if (databaseType && databaseType.toLowerCase() === 'bigquery') {
-        return (0, parserBigQuery_1.isAfterBigQuery)(node);
-    }
-};
-exports.isAfter = isAfter;
-const isBefore = (node, databaseType) => {
-    if (databaseType && databaseType.toLowerCase() === 'bigquery') {
-        return (0, parserBigQuery_1.isBeforeBigQuery)(node);
-    }
-};
-exports.isBefore = isBefore;
-// "created_at" >= date_trunc ('year', CURRENT_DATE - INTERVAL '1 year')
-// this year
-const isTheCurrentInterval = (node, databaseType) => {
-    if (databaseType && databaseType.toLowerCase() === 'bigquery') {
-        return (0, parserBigQuery_1.isTheCurrentIntervalBigQuery)(node);
-    }
-    return (0, parserPostgres_1.isTheCurrentIntervalPostgres)(node);
-};
-exports.isTheCurrentInterval = isTheCurrentInterval;
-// "created_at" >= date_trunc ('year', CURRENT_DATE - INTERVAL '1 year')
-// this year
-const isEquals = (node, databaseType) => {
-    if (databaseType && databaseType.toLowerCase() === 'bigquery') {
-        return (0, parserBigQuery_1.isEqualsBigQuery)(node);
-    }
-    return false;
-};
-exports.isEquals = isEquals;
-const isThePreviousInterval = (node) => {
-    const isInsideOfDateTrunc = ['='].includes(node.operator) &&
-        node.left.name &&
-        node.left.name.toLowerCase() === 'timestamp_trunc' &&
-        node.left.type === 'function' &&
-        node.right.name &&
-        node.right.name.toLowerCase() === 'timestamp_trunc' &&
-        node.right.args.value[0]?.name?.toLowerCase() === 'timestamp_sub' &&
-        node.right.args.value[0].args.value[0].name.toLowerCase() ===
-            'current_timestamp';
-    return isInsideOfDateTrunc;
-};
-exports.isThePreviousInterval = isThePreviousInterval;
-/**
- * Returns whether this node is the root of a binary expression
- * where the left child is a string but really should be
- * interpreted as a column name.
- */
-const isColumnComparison = (node) => {
-    const ops = [
-        '>=',
-        '>',
-        '<=',
-        '<',
-        'AND',
-        'OR',
-        '!=',
-        '=',
-        'LIKE',
-        'NOT LIKE',
-        'IN',
-        'NOT IN',
-        'BETWEEN',
-        '-',
-        '+',
-        'IS NOT',
-        'IS',
-    ];
-    return (ops.includes(node.operator) &&
-        node.left &&
-        (node.left.type === 'column_ref' ||
-            node.left.type === 'double_quote_string' ||
-            (node.left.type === 'function' &&
-                ['lower', 'upper'].includes(node.left.name.toLowerCase()))));
-};
-exports.isColumnComparison = isColumnComparison;
-// Returns a new date object with timezone adjusted
-const newUTCDate = (dateString) => {
-    let date = new Date(dateString);
-    // If the date is invalid, try appending a 1 (eg. "April" => "April 1")
-    if (Number.isNaN(date.getDate())) {
-        date = new Date(`${dateString} 1`);
-    }
-    date.setMinutes(date.getMinutes() + date.getTimezoneOffset()); // TZ adjust
-    // Default to using the current year, unless explicitly overridden
-    const dateYear = date.getFullYear();
-    if (!dateString.includes(dateYear.toString())) {
-        date.setFullYear(new Date().getFullYear());
-    }
-    return date;
-};
-exports.newUTCDate = newUTCDate;
-const getPeriod = (node, databaseType) => {
-    if (databaseType === 'BigQuery') {
-        return node.left.args.value[1]?.column.toLowerCase();
-    }
-    else {
-        return node.left.args.value[0]?.value.toLowerCase();
-    }
-};
-/**
- * Takes the right side of a dateTruncEquals expression (ie. the suffix)
- * and returns a pretty string representation of what that value means.
- *
- * eg. date_trunc('year', TIMESTAMP '2023-01-01') would be "in 2023"
- * eg. date_trunc('month', TIMESTAMP '2023-01-01') would be "in Jan 2023"
- * eg. date_trunc('quarter', TIMESTAMP '2023-01-01') would be "in Q1 2023"
- */
-function dateTruncSuffixToString(node, databaseType) {
-    const period = getPeriod(node, databaseType);
-    const dateNode = node.right.value ? node.right : node.right.args.value[1];
-    const rawDateStr = dateNode.type === 'cast' ? dateNode.expr.value : dateNode.value;
-    const date = (0, exports.newUTCDate)(rawDateStr);
-    switch (period) {
-        case 'year':
-            return `in ${date.getFullYear()}`;
-        case 'quarter':
-            return `in Q${(0, date_fns_1.getQuarter)(date)} ${date.getFullYear()}`;
-        case 'month':
-            return `in ${date.toLocaleString('default', { month: 'short', year: 'numeric' })}`;
-        case 'week':
-            return `week of ${date.toDateString()}`;
-        case 'day':
-            return `on ${date.toDateString()}`;
-        case 'hour':
-            return `hour of ${date.toLocaleString()}`;
-        default:
-            return `${period} of ${date}`;
-    }
-}
-/**
- * Takes an extract binary expression and returns a string version
- * of what the AST means.
- *
- * eg. extract(YEAR FROM "created_at") = 2023 would be "in 2023"
- * eg. extract(MONTH FROM "created_at") = 1 would be "in January"
- * eg. TODO: add more variants as they come up
- */
-function extractSuffixToString(node) {
-    const period = node.left.args.field.toLowerCase();
-    const value = node.right.value;
-    switch (period) {
-        case 'year': {
-            return `is ${value}`;
-        }
-        case 'month': {
-            const date = new Date(2000, value - 1, 1);
-            date.setMinutes(date.getMinutes() + date.getTimezoneOffset()); // TZ adjust
-            return `in ${date.toLocaleString('default', { month: 'long' })}`;
-        }
-        default: {
-            return `${period} is ${value}`;
-        }
-    }
-}
-function tryConvertDateEquality(node, databaseType) {
-    if ((0, exports.isDateTruncEquals)(node)) {
-        const columnNode = node.left.args.value[1];
-        const columnName = columnNode.column ?? columnNode.value;
-        const cleanColumnName = (0, textProcessing_1.snakeAndCamelCaseToTitleCase)(columnName.replaceAll('_at', ''));
-        const prettyDateSuffix = dateTruncSuffixToString(node, databaseType);
-        return `${cleanColumnName} ${prettyDateSuffix}`;
-    }
-    else if ((0, exports.isExtractEquals)(node)) {
-        const columnNode = node.left.args.source;
-        const columnName = columnNode.column ?? columnNode.value;
-        const cleanColumnName = (0, textProcessing_1.snakeAndCamelCaseToTitleCase)(columnName.replaceAll('_at', ''));
-        const prettyDateSuffix = extractSuffixToString(node);
-        return `${cleanColumnName} ${prettyDateSuffix}`;
-    }
-    return undefined;
-}
-/**
- * Returns whether this node is an equality of a date column with a
- * date trunc.
- */
-const isDateTruncEquals = (node) => {
-    return (node.type === 'binary_expr' &&
-        node.operator === '=' &&
-        (0, exports.isDateTrunc)(node.left) &&
-        (node.right.type === 'single_quote_string' || // is a string literal
-            (node.right.type === 'cast' &&
-                node.right.expr.type === 'single_quote_string') || // or is string casted to non-string
-            (0, exports.isDateTrunc)(node.right)) // or is a date_trunc
-    );
-};
-exports.isDateTruncEquals = isDateTruncEquals;
-/**
- * Returns whether this node is an equality of a date column with extract.
- */
-const isExtractEquals = (node) => {
-    return (node.type === 'binary_expr' &&
-        node.operator === '=' &&
-        node.left.type === 'extract' &&
-        node.right.type === 'number');
-};
-exports.isExtractEquals = isExtractEquals;
-function showNodeAsRow(node, ast) {
-    // if the expression is something like status = "completed"
-    if (node.left.type === 'column_ref') {
-        return true;
-    }
-    if (!['AND', 'OR'].includes(node.operator)) {
-        return true;
-    }
-    if ((ast.left?.left?.left?.left || ast.right?.left?.left?.left) &&
-        node.left.left?.type === 'column_ref') {
-        return true;
-    }
-    return false;
-}
-function getPostgresBasicType(column) {
-    if (!column)
-        return undefined;
-    let format;
-    if (column.dataTypeID) {
-        switch (column.dataTypeID) {
-            case 16: // boolean
-                format = 'boolean';
-                break;
-            case 20: // int8
-            case 21: // int2
-            case 23: // int4
-            case 700: // float4
-            case 701: // float8
-            case 1700: // numeric
-                format = 'number';
-                break;
-            case 1082: // date
-            case 1083: // time
-            case 1184: // timestamptz
-            case 1114: // timestamp
-                format = 'date';
-                break;
-            case 1043: // varchar
-            default:
-                format = 'string';
-        }
-    }
-    return format;
-}
-const deepCopy = (obj) => JSON.parse(JSON.stringify(obj));
-exports.deepCopy = deepCopy;
-const trimEndS = (s) => (s.endsWith('s') ? s.slice(0, -1) : s);
-exports.trimEndS = trimEndS;
-const getDateColumnAndPath = (node) => {
-    // "created_at" <= ...
-    if (node.left && node.left.type === 'column_ref') {
-        return { dateColumn: node.left.column, dateColumnPath: 'left.column' };
-    }
-    // LOWER("created_at") <= ...
-    if (node.left &&
-        node.left.type === 'function' &&
-        ['lower', 'upper'].includes(node.left.name.toLowerCase()) &&
-        node.left.args.type == 'expr_list' &&
-        node.left.args.value.length === 1 &&
-        node.left.args.value[0].type === 'double_quote_string') {
-        return {
-            dateColumn: node.left.args.value[0].value,
-            dateColumnPath: 'left.args.value.0.value',
-        };
-    }
-    // LOWER("created_at") <= ...
-    if (node.left &&
-        node.left.type === 'function' &&
-        ['lower', 'upper'].includes(node.left.name.toLowerCase()) &&
-        node.left.args.type == 'expr_list' &&
-        node.left.args.value.length === 1 &&
-        node.left.args.value[0].type === 'column_ref') {
-        return {
-            dateColumn: node.left.args.value[0].column,
-            dateColumnPath: 'left.args.value.0.column',
-        };
-    }
-    // date_trunc('...', "...") = ...
-    if (node.left &&
-        node.left.type === 'function' &&
-        node.left.name.toLowerCase() === 'date_trunc' &&
-        node.left.args.type == 'expr_list' &&
-        node.left.args.value.length === 2 &&
-        node.left.args.value[1].type === 'column_ref') {
-        return {
-            dateColumn: node.left.args.value[1].column,
-            dateColumnPath: 'left.args.value.1.column',
-        };
-    }
-    // date_trunc('...', "...") = ...
-    if (node.left &&
-        node.left.type === 'function' &&
-        node.left.name.toLowerCase() === 'date_trunc' &&
-        node.left.args.type == 'expr_list' &&
-        node.left.args.value.length === 2 &&
-        node.left.args.value[1].type === 'double_quote_string') {
-        return {
-            dateColumn: node.left.args.value[1].value,
-            dateColumnPath: 'left.args.value.1.value',
-        };
-    }
-    // unknown
-    return { dateColumn: null, dateColumnPath: '' };
-};
-const parseIntervalNode = (node) => {
-    if (node.type !== 'interval')
-        return null;
-    if (node.unit && node.unit.length > 0) {
-        return {
-            intervalCount: parseInt(node.expr.value),
-            intervalType: node.unit,
-        };
-    }
-    const parts = node.expr.value.split(' ');
-    return {
-        intervalCount: parts.length > 1 ? parseInt(parts[0]) : 1,
-        intervalType: (0, exports.trimEndS)(parts.length > 1 ? parts[1] : 'year'),
-    };
-};
-// Parses the interval and path to the interval (used to change the interval)
-// from a node using one of many pre-defined patterns. Otherwise null.
-const getIntervalAndPath = (node) => {
-    if (node.right && node.right.right && node.right.right.type === 'interval') {
-        const interval = parseIntervalNode(node.right.right);
-        const { intervalCount, intervalType } = interval ?? {};
-        return {
-            intervalCount,
-            intervalType,
-            intervalPaths: ['right.right.expr.value'],
-        };
-    }
-    // date_trunc('...', "...") = date_trunc('...', ...)
-    if (node.left &&
-        node.left.type === 'function' &&
-        node.left.name.toLowerCase() === 'date_trunc' &&
-        node.left.args.type == 'expr_list' &&
-        node.left.args.value.length === 2 &&
-        node.right &&
-        node.right.type === 'function' &&
-        node.right.name.toLowerCase() === 'date_trunc' &&
-        node.right.args.type == 'expr_list' &&
-        node.right.args.value.length === 2) {
-        // date_trunc('day', "created_at") >= date_trunc('day', CURRENT_DATE - INTERVAL '90 days')
-        if (node.right &&
-            node.right.type === 'function' &&
-            node.right.name.toLowerCase() === 'date_trunc' &&
-            node.right.args.type == 'expr_list' &&
-            node.right.args.value.length === 2 &&
-            node.right.args.value[1].type === 'binary_expr' &&
-            node.right.args.value[1].right.type === 'interval') {
-            return parseIntervalNode(node.right.args.value[1].right);
-        }
-        const intervalType = node.right.args.value[0].value;
-        return {
-            intervalCount: null,
-            intervalType: (0, exports.trimEndS)(intervalType ?? 'year'),
-            intervalPaths: ['right.args.value.0.value', 'left.args.value.0.value'],
-        };
-    }
-    // "created_at" >= DATE_TRUNC('day', CURRENT_DATE - INTERVAL '90 days')
-    if (node.left &&
-        node.left.type === 'column_ref' &&
-        node.right &&
-        node.right.type === 'function' &&
-        node.right.name.toLowerCase() === 'date_trunc' &&
-        node.right.args.type == 'expr_list' &&
-        node.right.args.value.length === 2 &&
-        node.right.args.value[1].type === 'binary_expr' &&
-        node.right.args.value[1].right &&
-        node.right.args.value[1].right.type === 'interval') {
-        const interval = parseIntervalNode(node.right.node.right.args.value[1].right);
-        const { intervalCount, intervalType } = interval ?? {};
-        return {
-            intervalCount,
-            intervalType,
-            intervalPaths: ['right.args.value.0.value'],
-        };
-    }
-    // unknown
-    return { intervalCount: 1, intervalType: '', intervalPaths: [] };
-};
-const getDateFilterType = (node) => {
-    if ((0, exports.isDateTruncEquals)(node))
-        return 'equals';
-    if (node.operator === '>=' &&
-        node.left &&
-        node.left.type === 'column_ref' &&
-        node.right &&
-        node.right.type === 'binary_expr' &&
-        node.right.operator == '-' &&
-        node.right.right &&
-        node.right.right.type == 'interval') {
-        // ... >= ... - INTERVAL '...'
-        return 'in the last';
-    }
-    else if (node.operator === '=' &&
-        node.left?.type === 'function' &&
-        node.left?.name === 'date_trunc' &&
-        node.right?.type === 'function' &&
-        node.right?.name === 'date_trunc' &&
-        node.right.args.type === 'expr_list' &&
-        node.right.args.value.length === 2 &&
-        node.right.args.value[1].type === 'function' &&
-        ['current_date', 'now'].includes(node.right.args.value[1].name.toLowerCase())) {
-        // DATE_TRUNC('...', ...) = DATE_TRUNC('...', ...)
-        return 'in the current';
-    }
-    else {
-        // ... = DATE_TRUNC('...', ... - INTERVAL '...');
-        return 'in the previous';
-    }
-};
-const getDateFilterInfo = (node) => {
-    const { dateColumn, dateColumnPath } = getDateColumnAndPath(node);
-    const interval = getIntervalAndPath(node);
-    const { intervalCount, intervalType } = interval ?? {};
-    const intervalPaths = interval?.intervalPaths;
-    const dateFilterType = getDateFilterType(node);
-    return {
-        dateColumn,
-        dateColumnPath,
-        dateFilterType,
-        intervalCount,
-        intervalType,
-        intervalPaths,
-    };
-};
-exports.getDateFilterInfo = getDateFilterInfo;
-// NEED TO UPDATE FOR MORE POTENTIAL CASES
-function getNodeTable(node) {
-    if (node.table) {
-        return node.table;
-    }
-    if (node.args && node.args.value?.[0]?.table) {
-        return node.args.value[0].table;
-    }
-    return null;
-}
-// Recursively remove filters that don't apply to the given table
-function removeNonSelectedTableFilters(node, table, columns, uniqueValues) {
-    if (!node) {
-        return null;
-    }
-    if (node.left && node.left.type !== 'binary_expr') {
-        const referencedTable = getNodeTable(node.left);
-        const referencedColumn = (0, astFilterProcessing_1.getFieldFromExpression)(node.left);
-        if (!referencedColumn) {
-            return null;
-        }
-        if (uniqueValues &&
-            (node.operator === 'IN' ||
-                (node.operator === 'NOT IN' &&
-                    node.right?.type === 'expr_list' &&
-                    node.right.value))) {
-            node.right.value = node.right.value.filter((value) => {
-                const field = (0, astFilterProcessing_1.getFieldFromExpression)(value);
-                const check = field &&
-                    uniqueValues[referencedColumn] &&
-                    uniqueValues[referencedColumn].includes(field);
-                return check;
-            });
-            if (!node.right.value || !node.right.value.length) {
-                return null;
-            }
-        }
-        if ((referencedTable && referencedTable !== table) ||
-            !columns.includes(referencedColumn)) {
-            return null;
-        }
-        else {
-            if (node.left.value) {
-                node.left.column = node.left.value;
-            }
-            else if (node.left.args?.value?.[0]?.value) {
-                node.left.args.value[0].column = node.left.args.value[0].value;
-            }
-            return node;
-        }
-    }
-    node.left = removeNonSelectedTableFilters(node.left, table, columns, uniqueValues);
-    node.right = removeNonSelectedTableFilters(node.right, table, columns, uniqueValues);
-    if (node.left && node.right) {
-        return node;
-    }
-    else if (node.left) {
-        return node.left;
-    }
-    else if (node.right) {
-        return node.right;
-    }
-    else {
-        return null;
-    }
-}
-function removeNonSelectedTableOrderBys(orderby, table, columns) {
-    if (!orderby || !orderby.length) {
-        return null;
-    }
-    return orderby
-        .filter((node) => node.expr &&
-        node.expr.table === table &&
-        columns.includes(node.expr.column))
-        .map((node) => {
-        return { ...node, expr: { ...node.expr, table: null } };
-    });
-}
-function removeNonSelectedTableReferences(ast, table, columns, uniqueValues) {
-    ast.columns = ast.columns.filter((col) => {
-        return col.table === table || col.expr.table === table || !col.expr.table;
-    });
-    if (!ast.where)
-        return ast;
-    ast.where = removeNonSelectedTableFilters(ast.where, table, columns, uniqueValues);
-    ast.orderby = removeNonSelectedTableOrderBys(ast.orderby, table, columns);
-    return ast;
-}
-function recursiveRemoveTableReference(node, table, as) {
-    if (!node || typeof node !== 'object') {
-        return node;
-    }
-    if (node.length) {
-        return node.map((n) => recursiveRemoveTableReference(n, table, as));
-    }
-    if (node.table && node.as && node.table === table && node.as === as) {
-        node.as = null;
-    }
-    else if (node.table && node.table === as) {
-        node.table = table;
-    }
-    Object.keys(node).forEach((key) => {
-        if (typeof node[key] === 'object') {
-            node[key] = recursiveRemoveTableReference(node[key], table, as);
-        }
-    });
-    return node;
-}
-function removeTableNameAlias(ast, schema) {
-    if (!ast.from?.length || !ast.from) {
-        return ast;
-    }
-    const referencedTables = (0, exports.deepCopy)(ast.from);
-    // In the context of where this function is used, (ReportBuilder AI)
-    // ast.from should only contain one table (if not, it would have triggered a retry)
-    referencedTables.forEach((from) => {
-        let table = from.table;
-        if (!schema.find((s) => s.name === table)) {
-            // if the table isn't actually there, replace with a table that fits columns
-            const referencedColumns = ast.columns.map((col) => (0, astFilterProcessing_1.getFieldFromExpression)(col.expr) || (0, astFilterProcessing_1.getFieldFromExpression)(col));
-            const schemaTable = schema.find((s) => {
-                return referencedColumns.every((col) => s.columns.find((c) => c.field === col));
-            });
-            if (schemaTable) {
-                ast = recursiveRemoveTableReference(ast, schemaTable.name, table);
-                table = schemaTable.name;
-            }
-        }
-        const as = from.as;
-        if (as) {
-            ast = recursiveRemoveTableReference(ast, table, as);
-        }
-    });
-    return ast;
-}
-function allNumericNodesValidInTree(node) {
-    if (!node)
-        return true;
-    if (node.type === 'number') {
-        const value = parseFloat(node.value);
-        if (Number.isNaN(value)) {
-            return false;
-        }
-        else {
-            node.value = value;
-            return true;
-        }
-    }
-    const isLeftValid = allNumericNodesValidInTree(node.left);
-    const isRightValid = allNumericNodesValidInTree(node.right);
-    return isLeftValid && isRightValid;
-}
-function isIdColumn(columnName) {
-    return (columnName &&
-        (columnName.toLowerCase() === 'id' ||
-            columnName.toLowerCase().endsWith('_id') ||
-            columnName.endsWith('Id')));
-}
-// This function determines if a node is a custom node type.
-// This will parse out date filters and some numeric filters that are unique (between).
-function getCustomSentence(node, databaseType) {
-    if ((0, exports.isTheCurrentInterval)(node, databaseType)) {
-        return getInTheCurrentIntervalSentence(node, databaseType);
-    }
-    else if ((0, exports.isInTheLastInterval)(node, databaseType)) {
-        return getInTheLastIntervalSentence(node, databaseType);
-    }
-    else if ((0, exports.isAfter)(node, databaseType)) {
-        return getIsAfterSentence(node, databaseType);
-    }
-    else if ((0, exports.isBefore)(node, databaseType)) {
-        return getIsBeforeSentence(node, databaseType);
-    }
-    else if ((0, exports.isThePreviousInterval)(node)) {
-        return getInThePreviousIntervalSentence(node, databaseType);
-    }
-    else if ((0, exports.isEquals)(node, databaseType)) {
-        return getIsEqualsSentence(node, databaseType);
-    }
-    return null;
-}