@quillsql/react 2.12.37 → 2.12.38

package/dist/esm/components/ReportBuilder/ast.js

@@ -0,0 +1,230 @@
+// Type definitions for node-sql-parser 1.0
+// Project: https://github.com/taozhi8833998/node-sql-parser#readme
+// Definitions by: taozhi8833998 <https://github.com/taozhi8833998>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.4
+import { recursiveSearchByKey } from '../../utils/astProcessing';
+/**
+ * Returns whether the AST is for a 'use' query.
+ */
+export const isUse = (ast) => ast?.type === 'use';
+/**
+ * Returns whether the AST is for a 'create' query.
+ */
+export const isCreate = (ast) => ast?.type === 'create';
+/**
+ * Returns whether the AST is a wrapper for a 'bigquery' query.
+ */
+export const isBigQuery = (ast) => ast?.type === 'bigquery';
+/**
+ * Returns whether the AST is for a 'select' query.
+ */
+export const isSelect = (ast) => ast?.type === 'select';
+/**
+ * Returns whether the AST is for a 'update' query.
+ */
+export const isUpdate = (ast) => ast?.type === 'update';
+/**
+ * Returns whether the AST is for a 'replace' or 'insert' query.
+ */
+export const isInsertOrReplace = (ast) => ast?.type === 'replace' || ast?.type === 'insert';
+/**
+ * Returns whether the AST is for a 'alter' query.
+ */
+export const isAlter = (ast) => ast?.type === 'alter';
+/**
+ * Returns whether the AST is for a 'delete' query.
+ */
+export const isDelete = (ast) => ast?.type === 'delete';
+/**
+ * Returns whether the AST is for a 'drop' query.
+ */
+export const isDrop = (ast) => ast?.type === 'drop';
+/**
+ * Returns whether the node is a binary expression.
+ */
+export const isBinaryExpr = (node) => node?.type === 'binary_expr';
+/**
+ * Returns whether the node is a logical binary expression (ie. AND/OR).
+ */
+export const isLogicalBinaryExpr = (node) => {
+    if (!isBinaryExpr(node))
+        return false;
+    return ['AND', 'OR'].includes(node.operator.toUpperCase());
+};
+/**
+ * Returns whether the node is a base binary expression (ie. not AND/OR).
+ */
+export const isBaseBinaryExpr = (node) => {
+    if (!isBinaryExpr(node))
+        return false;
+    return !['AND', 'OR'].includes(node.operator.toUpperCase());
+};
+/**
+ * Returns whether the node is an expression list.
+ */
+export const isExprList = (node) => {
+    return node?.type === 'expr_list';
+};
+/**
+ * Returns whether the node is a function.
+ */
+export const isFunction = (node) => {
+    return node?.type === 'function';
+};
+/**
+ * Returns whether the function is 'UPPER' or 'LOWER'.
+ */
+export const isCasingFunction = (node) => {
+    if (!isFunction(node))
+        return false;
+    if (typeof node.name !== 'string')
+        return false;
+    return ['LOWER', 'UPPER'].includes(node.name.toUpperCase());
+};
+/**
+ * Returns whether the given node is an empty collection.
+ *
+ * A empty collection is any binary operator node with either "IN" or "NOT IN"
+ * operator where none of the variants are selected.
+ */
+export const isNodeEmptyCollection = (node) => {
+    // Check if the node is a binary expression with IN/NOT-IN
+    if (!isBaseBinaryExpr(node))
+        return false;
+    if (!['IN', 'NOT IN'].includes(node.operator))
+        return false;
+    // Check the length of the right-hand expression list
+    if (!isExprList(node.right))
+        return false;
+    if (node.right.value.length === 0)
+        return true;
+    if (node.right.value.length > 1)
+        return false;
+    // Edge-case: There could be one element in the list but if that element
+    // is an empty string, we treat the list as also being empty.
+    const firstExprValue = node.right.value[0];
+    if (!isCasingFunction(firstExprValue))
+        return false;
+    if (firstExprValue.args.value.length !== 1)
+        return false;
+    const casingFuncChild = firstExprValue.args.value[0];
+    if (casingFuncChild.value !== '')
+        return false;
+    return true;
+};
+export function getColumnName(ast) {
+    let columnObj = recursiveSearchByKey(ast.expr, 'column');
+    if (columnObj) {
+        return extractColumnish(columnObj);
+    }
+    columnObj = recursiveSearchByKey(ast.expr, 'args');
+    if (columnObj) {
+        if (Array.isArray(columnObj.value)) {
+            columnObj.value.forEach((arg) => {
+                if (arg.type === 'double_quote_string' || arg.type === 'column_ref') {
+                    return extractColumnish(arg);
+                }
+            });
+        }
+        else {
+            return extractColumnish(columnObj);
+        }
+    }
+    return undefined;
+}
+/**
+ * Extracts the column-like part from a ColumnRef node or a Value node
+ * that is typed as double_quote_string.
+ * @param expr_value either a ColumnRef or a double_quote_string Value
+ * @returns column as a string or undefined
+ */
+export const extractColumnish = (expr_value) => {
+    if (typeof expr_value === 'string')
+        return expr_value;
+    //@ts-ignore
+    if (expr_value.expr && !expr_value.type) {
+        //@ts-ignore
+        return expr_value.expr.value;
+    }
+    else if (expr_value?.type === 'column_ref') {
+        return (expr_value.column?.expr?.value ??
+            expr_value.column);
+    }
+    return expr_value.value;
+};
+/**
+ * Returns whether the given columnType is a numeric type (ie. number-ish).
+ * @param columnType the type of the column
+ * @returns true or false
+ */
+export const isNumericColumnType = (columnType) => {
+    if (!columnType)
+        return false;
+    return [
+        'number',
+        'numeric',
+        'smallint',
+        'int2',
+        'int4',
+        'int8',
+        'float2',
+        'float4',
+        'float8',
+        'float16',
+    ].includes(columnType);
+};
+/**
+ * Returns whether the given columnType is a numeric bool.
+ * @param columnType the type of the column
+ * @returns true or false
+ */
+export const isBoolColumnType = (columnType) => {
+    if (!columnType)
+        return false;
+    return ['bool', 'boolean'].includes(columnType);
+};
+/**
+ * Returns whether the given columnType is a text type (ie. text-ish).
+ * @param columnType the type of the column
+ * @returns true or false
+ */
+export const isTextColumnType = (columnType) => {
+    if (!columnType)
+        return false;
+    return [
+        'varchar',
+        'text',
+        // 'json', // TODO: handle json type
+        // 'bool',
+        'char',
+        'string',
+        'citext',
+    ].includes(columnType);
+};
+/**
+ * Returns whether the given columnType is a date type (ie. date-ish).
+ * @param columnType the type of the column
+ * @returns true or false
+ */
+export const isDateishColumnType = (columnType) => {
+    if (!columnType)
+        return false;
+    return ['date', 'datetime', 'timestamp', 'timestamptz'].includes(columnType);
+};
+/**
+ * Returns a list of table objects from the AST.
+ */
+export const getTableNames = (ast) => {
+    if (!isSelect(ast))
+        return [];
+    return ast.from?.map((tbl) => tbl.table) ?? [];
+};
+/**
+ * Returns a list of table objects from the AST.
+ */
+export const getTableAliases = (ast) => {
+    if (!isSelect(ast))
+        return [];
+    return ast.from?.map((tbl) => tbl.as) ?? [];
+};

package/dist/esm/components/ReportBuilder/bigDateMap.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A big map of partial objects and a callback to convert each to a string.
+ */
+export declare const DATE_DESCRIPTION_MAP: {
+    [x: string]: (node: any) => string;
+};
+//# sourceMappingURL=bigDateMap.d.ts.map

package/dist/esm/components/ReportBuilder/bigDateMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigDateMap.d.ts","sourceRoot":"","sources":["../../../../src/components/ReportBuilder/bigDateMap.ts"],"names":[],"mappings":"AAaA;;GAEG;AACH,eAAO,MAAM,oBAAoB;wBAoCnB,GAAG;CAmpBhB,CAAC"}