@quillsql/react 2.12.37 → 2.12.39

package/dist/esm/utils/getDomain.js

@@ -0,0 +1,52 @@
+/**
+ * Calculates the adjusted domain for numeric values in the specified fields of the given data.
+ * @param data - The data containing numeric fields.
+ * @param  fields - The fields to consider for domain calculation.
+ * @returns - An array representing the adjusted domain [min, max].
+ */
+export default function getDomain(data, fields) {
+    const fieldsArray = fields.map((elem) => elem.field);
+    const numericValues = [];
+    data.forEach((item) => {
+        fieldsArray.forEach((field) => {
+            let value = item[field];
+            // Try to cast the value to a number
+            const numericValue = parseFloat(value);
+            if (!isNaN(numericValue)) {
+                value = numericValue;
+            }
+            if (typeof value === 'number') {
+                numericValues.push(value);
+            }
+        });
+    });
+    const [minValue, maxValue] = numericValues.reduce(([min, max], value) => [Math.min(min, value), Math.max(max, value)], [Infinity, -Infinity]);
+    if (minValue === 0 && maxValue === 0) {
+        return [0, 1];
+    }
+    if (minValue === Infinity && maxValue === -Infinity) {
+        return [0, 1];
+    }
+    return fuzzyRound(Math.min(minValue, 0), maxValue);
+}
+// Rounds the range to 4 equally-spaced increments of nice,round numbers.
+function fuzzyRound(min, max) {
+    const range = parseFloat((max - min).toPrecision(1));
+    const increment = Math.ceil(range / 4);
+    let newMin = min;
+    // if (min % increment !== 0) {
+    //   newMin = min - (min % increment);
+    // }
+    if (Number.isNaN(newMin)) {
+        newMin = 0;
+    }
+    let newMax = min + increment * 4;
+    if (max % increment !== 0) {
+        const adjMax = max + (increment - (max % increment));
+        newMax = parseFloat(adjMax.toPrecision(2));
+    }
+    if (Number.isNaN(newMax)) {
+        newMax = 0;
+    }
+    return [newMin ?? 0, newMax ?? 0];
+}

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

@@ -0,0 +1,2 @@
+export declare function internalLog(message: string, ...optionalParams: any[]): void;
+//# sourceMappingURL=logging.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../../src/utils/logging.ts"],"names":[],"mappings":"AACA,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,GAAG,EAAE,QAKpE"}

package/dist/esm/utils/logging.js

@@ -0,0 +1,7 @@
+/* eslint-disable no-undef */
+export function internalLog(message, ...optionalParams) {
+    if (process.env.QUILL_ENV === 'development') {
+        const completeMessage = `Quill: ${message}: ${optionalParams.join('\n')}`;
+        console.log(completeMessage);
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare function mergeComparisonRange(resp: any): void;
+//# sourceMappingURL=merge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../../src/utils/merge.ts"],"names":[],"mappings":"AAAA,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,GAAG,QAI7C"}

package/dist/esm/utils/merge.js

@@ -0,0 +1,18 @@
+export function mergeComparisonRange(resp) {
+    if (resp.chartType === 'table')
+        return;
+    mergeForwards(resp);
+    // mergeBackwards(resp); // uncomment to switch back and forth
+}
+function mergeForwards(resp) {
+    const compRows = resp.compareRows;
+    let j = 0;
+    for (let i = 0; i < resp.rows.length; i++) {
+        if (j < compRows.length) {
+            for (const [key, value] of Object.entries(compRows[j])) {
+                resp.rows[i][`comparison_${key}`] = value;
+            }
+        }
+        j++;
+    }
+}

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

@@ -0,0 +1,21 @@
+import { Monaco } from '@monaco-editor/react';
+import { Range } from 'monaco-editor';
+interface CompletionItem {
+    label: string;
+    kind: number;
+    insertText: string;
+    insertTextRules: number;
+    range: Range;
+    detail?: string;
+}
+export declare const QUILL_LANGUAGE: any;
+export declare function generateSuggestionsBySchema(schema: any[], monaco: Monaco, range: Range, databaseType: string): CompletionItem[];
+export declare function generateSuggestionsByDatasource(monaco: Monaco, range: Range, databaseType: string): {
+    label: string;
+    kind: import("monaco-editor").languages.CompletionItemKind;
+    insertText: string;
+    insertTextRules: import("monaco-editor").languages.CompletionItemInsertTextRule;
+    range: Range;
+}[];
+export {};
+//# sourceMappingURL=monacoConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"monacoConfig.d.ts","sourceRoot":"","sources":["../../../src/utils/monacoConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAGtC,UAAU,cAAc;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,cAAc,EAAE,GAmJ5B,CAAC;AAyJF,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,GAAG,EAAE,EACb,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,MAAM,GACnB,cAAc,EAAE,CA2BlB;AAED,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,MAAM;;;;;;IAoBrB"}

package/dist/esm/utils/monacoConfig.js

@@ -0,0 +1,319 @@
+import { processColumnReference } from './queryConstructor';
+export const QUILL_LANGUAGE = {
+    monarchTokensProvider: {
+        defaultToken: '',
+        tokenPostfix: '.pgsql',
+        keywords: [
+            'SELECT',
+            'select',
+            'FROM',
+            'fromt',
+            'WHERE',
+            'where',
+            'IF',
+            'if',
+            'THEN',
+            'then',
+            'ELSE',
+            'ELSIF',
+            'CASE',
+            'case',
+            'WHEN',
+            'when',
+            'NULL',
+            'null',
+            'TRUE',
+            'true',
+            'FALSE',
+            'false',
+            'AS',
+            'as',
+            'LEFT',
+            'left',
+            'INNER',
+            'inner',
+            'JOIN',
+            'join',
+        ],
+        operators: [
+            '=',
+            '<',
+            '>',
+            '<=',
+            '>=',
+            '<>',
+            '!=',
+            '!',
+            '&&',
+            '||',
+            '++',
+            '--',
+            '+',
+            '-',
+            '*',
+            '/',
+            '%',
+            '<<',
+            '>>',
+            '&',
+            '|',
+            '^',
+            '~',
+            '::',
+        ],
+        symbols: '[=><!~?:&|+\\-*\\/\\^%]+',
+        tokenizer: {
+            root: [
+                [
+                    /[a-zA-Z_$][\w$]*/,
+                    {
+                        cases: {
+                            '@keywords': 'keyword',
+                            '@default': 'identifier',
+                        },
+                    },
+                ],
+                { include: '@whitespace' },
+                ['[{}()\\[\\]]', '@brackets'],
+                ['[<>](?!@symbols)', '@brackets'],
+                [
+                    '@symbols',
+                    {
+                        cases: {
+                            '@operators': 'operator',
+                            '@default': '',
+                        },
+                    },
+                ],
+                ['\\d*\\.\\d+([eE][\\-+]?\\d+)?', 'number.float'],
+                ['\\d+', 'number'],
+                ['[;,.]', 'delimiter'],
+                ["'([^'\\\\]|\\\\.)*$", 'string.invalid'],
+                ["'", 'string', '@string'],
+            ],
+            whitespace: [
+                ['[ \\t\\r\\n]+', ''],
+                ['--.*$', 'comment'],
+                ['\\/\\*', 'comment', '@comment'],
+            ],
+            comment: [
+                ['[^\\/*]+', 'comment'],
+                ['\\*\\/', 'comment', '@pop'],
+                ['[\\/*]', 'comment'],
+            ],
+            string: [
+                ["[^\\\\']+", 'string'],
+                ['\\\\.', 'string.escape'],
+                ["'", 'string', '@pop'],
+                ['"[^\\\\"]*"', 'string'],
+                ['"', 'string', '@dblString'],
+            ],
+            dblString: [
+                ['[^\\\\"]+', 'string'],
+                ['\\\\.', 'string.escape'],
+                ['"', 'string', '@pop'],
+            ],
+        },
+    },
+    languageConfiguration: {
+        comments: {
+            lineComment: '--',
+            blockComment: ['/*', '*/'],
+        },
+        brackets: [
+            ['{', '}'],
+            ['[', ']'],
+            ['(', ')'],
+        ],
+        autoClosingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: "'", close: "'" },
+        ],
+        surroundingPairs: [
+            { open: '{', close: '}' },
+            { open: '[', close: ']' },
+            { open: '(', close: ')' },
+            { open: '"', close: '"' },
+            { open: "'", close: "'" },
+        ],
+    },
+};
+const GENERIC_DATASOURCE_SUGGESTIONS = (monaco, range) => {
+    return [
+        {
+            label: 'SELECT',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'SELECT',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'FROM',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'FROM',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'JOIN',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'JOIN',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'LEFT JOIN',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'LEFT JOIN',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'INNER JOIN',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'INNER JOIN',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'MAX',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'MAX',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'MIN',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'MIN',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'ON',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'ON',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'WHERE',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'WHERE',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'LIMIT',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'LIMIT',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'GROUP BY',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'GROUP BY',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'ORDER BY',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'ORDER BY',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+    ];
+};
+const POSTGRES_DATASOURCE_SUGGESTIONS = (monaco, range) => {
+    return [
+        {
+            label: 'EXTRACT',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'EXTRACT',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'TO_TIMESTAMP',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'TO_TIMESTAMP',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'CURRENT_DATE',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'CURRENT_DATE',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'CURRENT_TIMESTAMP',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'CURRENT_TIMESTAMP',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+    ];
+};
+const BIGQUERY_DATASOURCE_SUGGESTIONS = (monaco, range) => {
+    return [
+        {
+            label: 'TO_TIMESTAMP',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'TO_TIMESTAMP',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+    ];
+};
+export function generateSuggestionsBySchema(schema, monaco, range, databaseType) {
+    const suggestions = [];
+    schema.forEach((table) => {
+        const curSuggestion = {
+            label: table.name,
+            kind: monaco.languages.CompletionItemKind.Field,
+            insertText: `${processColumnReference(table.name, databaseType).replaceAll('`', '')}`,
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        };
+        suggestions.push(curSuggestion);
+        table.columns.forEach((column) => {
+            const insertText = `${processColumnReference(column.name, databaseType).replaceAll('`', '')}`;
+            const curSuggestion = {
+                label: column.name,
+                kind: monaco.languages.CompletionItemKind.Field,
+                insertText,
+                detail: table.name,
+                insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                range,
+            };
+            suggestions.push(curSuggestion);
+        });
+    }, []);
+    return suggestions;
+}
+export function generateSuggestionsByDatasource(monaco, range, databaseType) {
+    if (!databaseType) {
+        return GENERIC_DATASOURCE_SUGGESTIONS(monaco, range);
+    }
+    switch (databaseType.toLowerCase()) {
+        case 'snowflake':
+        case 'postgresql':
+            return [
+                ...POSTGRES_DATASOURCE_SUGGESTIONS(monaco, range),
+                ...GENERIC_DATASOURCE_SUGGESTIONS(monaco, range),
+            ];
+        case 'bigquery':
+            return [
+                ...BIGQUERY_DATASOURCE_SUGGESTIONS(monaco, range),
+                ...GENERIC_DATASOURCE_SUGGESTIONS(monaco, range),
+            ];
+        default:
+            return GENERIC_DATASOURCE_SUGGESTIONS(monaco, range);
+    }
+}

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

@@ -0,0 +1,5 @@
+import { Pagination } from '../models/Pagination';
+export declare const DEFAULT_PAGINATION: Pagination;
+export declare function shouldFetchMore(pagination: Pagination, page: number, maxPage: number): boolean;
+export declare function shouldSortInMemory(pagination: Pagination, rowCount?: number, isPivot?: boolean): boolean;
+//# sourceMappingURL=paginationProcessing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paginationProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/paginationProcessing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElD,eAAO,MAAM,kBAAkB,EAAE,UAIhC,CAAC;AAEF,wBAAgB,eAAe,CAC7B,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,WAehB;AAED,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,EACtB,QAAQ,CAAC,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,OAAO,WASlB"}

package/dist/esm/utils/paginationProcessing.js

@@ -0,0 +1,25 @@
+export const DEFAULT_PAGINATION = {
+    page: 0,
+    rowsPerPage: 20,
+    rowsPerRequest: 500,
+};
+export function shouldFetchMore(pagination, page, maxPage) {
+    if (!pagination) {
+        return false;
+    }
+    const indexAdjustedPage = page;
+    const pageInterval = Math.floor((indexAdjustedPage * pagination.rowsPerPage) / pagination.rowsPerRequest);
+    const indexAdjustedPreviousPage = maxPage;
+    const previousPageInterval = Math.floor((indexAdjustedPreviousPage * pagination.rowsPerPage) /
+        pagination.rowsPerRequest);
+    return pageInterval > previousPageInterval;
+}
+export function shouldSortInMemory(pagination, rowCount, isPivot) {
+    if (isPivot) {
+        return true;
+    }
+    if (!rowCount || rowCount < pagination.rowsPerRequest) {
+        return true;
+    }
+    return false;
+}

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

@@ -0,0 +1,6 @@
+export declare const isInTheLastIntervalBigQuery: (node: any) => boolean;
+export declare const isAfterBigQuery: (node: any) => boolean;
+export declare const isBeforeBigQuery: (node: any) => boolean;
+export declare const isTheCurrentIntervalBigQuery: (node: any) => boolean;
+export declare const isEqualsBigQuery: (node: any) => any;
+//# sourceMappingURL=parserBigQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parserBigQuery.d.ts","sourceRoot":"","sources":["../../../src/utils/parserBigQuery.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,2BAA2B,SAAU,GAAG,YAYpD,CAAC;AAEF,eAAO,MAAM,eAAe,SAAU,GAAG,YAUxC,CAAC;AAEF,eAAO,MAAM,gBAAgB,SAAU,GAAG,YAUzC,CAAC;AAEF,eAAO,MAAM,4BAA4B,SAAU,GAAG,KAAG,OAUxD,CAAC;AAEF,eAAO,MAAM,gBAAgB,SAAU,GAAG,QASzC,CAAC"}

package/dist/esm/utils/parserBigQuery.js

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

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

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

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

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

package/dist/esm/utils/parserPostgres.js

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

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

@@ -0,0 +1,7 @@
+import { Pivot } from '../internals/ReportBuilder/PivotModal';
+import { QuillReportInternal } from '../models/Report';
+export declare function generatePivotWithSQL(pivot: Pivot, report: QuillReportInternal, client: any, dateBucket?: string, dateFilter?: any, distinctStrings?: any): Promise<{
+    rows: any;
+    columns: any;
+} | undefined>;
+//# sourceMappingURL=pivotConstructor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pivotConstructor.d.ts","sourceRoot":"","sources":["../../../src/utils/pivotConstructor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAiB,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAOvD,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,mBAAmB,EAC3B,MAAM,EAAE,GAAG,EACX,UAAU,CAAC,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,GAAG,EAChB,eAAe,CAAC,EAAE,GAAG;;;eAyLtB"}