@quillsql/react 2.10.39 → 2.11.0

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

@@ -0,0 +1,648 @@
+"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.getPostgresBasicType = exports.showNodeAsRow = exports.isExtractEquals = exports.isDateTruncEquals = exports.tryConvertDateEquality = exports.extractSuffixToString = exports.dateTruncSuffixToString = exports.newUTCDate = exports.isColumnComparison = exports.isTheCurrentIntervalBigQuery = exports.isThePreviousInterval = exports.isTheCurrentInterval = exports.isInTheLastIntervalBigQuery = exports.isInTheLastInterval = exports.getInThePreviousIntervalSentence = exports.getInTheLastIntervalSentence = exports.getInTheCurrentIntervalSentence = exports.formatDateComparisonNode = exports.areObjectsEqualish = exports.isColumnDateish = exports.generateColumnExpr = exports.isColumnReferenceish = exports.isDateTrunc = exports.hasTopLevelOrBoolean = exports.isTopLevelBoolean = exports.isNodeEmptyCollection = void 0;
+const date_fns_1 = require("date-fns");
+const bigDateMap_1 = require("./bigDateMap");
+/**
+ * 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;
+}
+exports.isTopLevelBoolean = isTopLevelBoolean;
+function hasTopLevelOrBoolean(ast) {
+    if (ast.where && ast.where.operator === 'OR') {
+        return true;
+    }
+    return false;
+}
+exports.hasTopLevelOrBoolean = hasTopLevelOrBoolean;
+// 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.
+// TODO: This is a helpful function, let's use it!
+// eslint-disable-next-line no-unused-vars
+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,
+    };
+}
+exports.generateColumnExpr = generateColumnExpr;
+// 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;
+}
+exports.areObjectsEqualish = areObjectsEqualish;
+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;
+}
+exports.formatDateComparisonNode = formatDateComparisonNode;
+function getInTheCurrentIntervalSentence(node, databaseType) {
+    if (databaseType === 'BigQuery') {
+        const dateColumn = node.left.args.value[0].column;
+        const periodValue = node.left.args.value[1].column.toLowerCase();
+        return `${dateColumn} in the current ${periodValue}`;
+    }
+    return null;
+}
+exports.getInTheCurrentIntervalSentence = getInTheCurrentIntervalSentence;
+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 = node.left.column;
+        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;
+}
+exports.getInTheLastIntervalSentence = getInTheLastIntervalSentence;
+function getInThePreviousIntervalSentence(node, databaseType) {
+    if (databaseType === 'BigQuery') {
+        const dateColumn = node.left.args.value[0].column;
+        const periodValue = node.left.args.value[1].column.toLowerCase();
+        return `${dateColumn} in the previous ${periodValue}`;
+    }
+    return null;
+}
+exports.getInThePreviousIntervalSentence = getInThePreviousIntervalSentence;
+// "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.toLowerCase() === 'bigquery') {
+        return (0, exports.isInTheLastIntervalBigQuery)(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;
+};
+exports.isInTheLastInterval = isInTheLastInterval;
+// created_at >= DATE_SUB(CURRENT_DATE(), INTERVAL 1 MONTH)
+// in the last month aka one interval from today
+const isInTheLastIntervalBigQuery = (node) => {
+    const isOutsideOfDateTrunc = ['>=', '>'].includes(node.operator) &&
+        node.left.type === 'column_ref' &&
+        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;
+};
+exports.isInTheLastIntervalBigQuery = isInTheLastIntervalBigQuery;
+// "created_at" >= date_trunc ('year', CURRENT_DATE - INTERVAL '1 year')
+// this year
+const isTheCurrentInterval = (node, databaseType) => {
+    if (databaseType.toLowerCase() === 'bigquery') {
+        return (0, exports.isTheCurrentIntervalBigQuery)(node);
+    }
+    const isInsideOfDateTrunc = ['AND'].includes(node.operator) &&
+        (node.left.operator === '=' || node.left.type === 'double_quote_string') &&
+        node.right.operator === '=' &&
+        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;
+};
+exports.isTheCurrentInterval = isTheCurrentInterval;
+const isThePreviousInterval = (node, databaseType) => {
+    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;
+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;
+};
+exports.isTheCurrentIntervalBigQuery = isTheCurrentIntervalBigQuery;
+/**
+ * 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();
+    }
+};
+const getRawDateStr = (node, databaseType) => {
+    if (databaseType === 'BigQuery') {
+        return node.right.value;
+    }
+    else {
+        const dateNode = node.right.value ? node.right : node.right.args.value[1];
+        return dateNode.type === 'cast' ? dateNode.expr.value : dateNode.value;
+    }
+};
+/**
+ * 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}`;
+    }
+}
+exports.dateTruncSuffixToString = dateTruncSuffixToString;
+/**
+ * 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}`;
+        }
+    }
+}
+exports.extractSuffixToString = extractSuffixToString;
+function tryConvertDateEquality(node, databaseType) {
+    if ((0, exports.isDateTruncEquals)(node)) {
+        const columnNode = node.left.args.value[1];
+        const columnName = columnNode.column ?? columnNode.value;
+        const cleanColumnName = 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 = columnName.replaceAll('_at', '');
+        const prettyDateSuffix = extractSuffixToString(node);
+        return `${cleanColumnName} ${prettyDateSuffix}`;
+    }
+    return undefined;
+}
+exports.tryConvertDateEquality = tryConvertDateEquality;
+/**
+ * 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;
+}
+exports.showNodeAsRow = showNodeAsRow;
+function getPostgresBasicType(column) {
+    if (!column)
+        return undefined;
+    let format;
+    if (column.dataTypeID) {
+        switch (column.dataTypeID) {
+            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;
+}
+exports.getPostgresBasicType = getPostgresBasicType;
+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;

package/dist/cjs/components/UiComponents.d.ts

@@ -27,6 +27,8 @@ export interface TableComponentProps {
     downloadCSV?: () => void;
     LoadingComponent?: () => JSX.Element;
     DownloadCSVButtonComponent?: (props: ButtonComponentProps) => JSX.Element;
+    rowsPerPage?: number;
+    emptyStateLabel?: string;
 }
 export interface TextInputComponentProps {
     onChange: (e: any) => void;
@@ -73,12 +75,12 @@ export declare const MemoizedSecondaryButton: ({ label, onClick }: {
     label: any;
     onClick: any;
 }) => import("react/jsx-runtime").JSX.Element;
-export declare const MemoizedSelect: ({ value, onChange, options, disabled, label, }: {
+export declare const MemoizedSelect: ({ value, onChange, options, disabled, style, }: {
     value: any;
     onChange: any;
     options: any;
     disabled?: boolean | undefined;
-    label: any;
+    style?: {} | undefined;
 }) => import("react/jsx-runtime").JSX.Element;
 export declare const MemoizedHeader: ({ children }: {
     children: any;
@@ -86,6 +88,17 @@ export declare const MemoizedHeader: ({ children }: {
 export declare const MemoizedLabel: ({ children }: {
     children: any;
 }) => import("react/jsx-runtime").JSX.Element;
+export declare const MemoizedCheckbox: ({ checked, onChange, style, ...props }: {
+    [x: string]: any;
+    checked: any;
+    onChange: any;
+    style?: {} | undefined;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const MemoizedTabs: ({ defaultValue, options, onValueChange }: {
+    defaultValue: any;
+    options: any;
+    onValueChange: any;
+}) => import("react/jsx-runtime").JSX.Element;
 export declare const MemoizedText: ({ children }: {
     children: any;
 }) => import("react/jsx-runtime").JSX.Element;