@quillsql/react 2.10.39 → 2.11.0

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

@@ -0,0 +1,210 @@
+"use strict";
+// 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
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTableNames = exports.isDateishColumnType = exports.isTextColumnType = exports.isNumericColumnType = exports.extractColumnish = exports.isNodeEmptyCollection = exports.isCasingFunction = exports.isFunction = exports.isExprList = exports.isBaseBinaryExpr = exports.isLogicalBinaryExpr = exports.isBinaryExpr = exports.isDrop = exports.isDelete = exports.isAlter = exports.isInsertOrReplace = exports.isUpdate = exports.isSelect = exports.isBigQuery = exports.isCreate = exports.isUse = void 0;
+/**
+ * Returns whether the AST is for a 'use' query.
+ */
+const isUse = (ast) => ast?.type === 'use';
+exports.isUse = isUse;
+/**
+ * Returns whether the AST is for a 'create' query.
+ */
+const isCreate = (ast) => ast?.type === 'create';
+exports.isCreate = isCreate;
+/**
+ * Returns whether the AST is a wrapper for a 'bigquery' query.
+ */
+const isBigQuery = (ast) => ast?.type === 'bigquery';
+exports.isBigQuery = isBigQuery;
+/**
+ * Returns whether the AST is for a 'select' query.
+ */
+const isSelect = (ast) => ast?.type === 'select';
+exports.isSelect = isSelect;
+/**
+ * Returns whether the AST is for a 'update' query.
+ */
+const isUpdate = (ast) => ast?.type === 'update';
+exports.isUpdate = isUpdate;
+/**
+ * Returns whether the AST is for a 'replace' or 'insert' query.
+ */
+const isInsertOrReplace = (ast) => ast?.type === 'replace' || ast?.type === 'insert';
+exports.isInsertOrReplace = isInsertOrReplace;
+/**
+ * Returns whether the AST is for a 'alter' query.
+ */
+const isAlter = (ast) => ast?.type === 'alter';
+exports.isAlter = isAlter;
+/**
+ * Returns whether the AST is for a 'delete' query.
+ */
+const isDelete = (ast) => ast?.type === 'delete';
+exports.isDelete = isDelete;
+/**
+ * Returns whether the AST is for a 'drop' query.
+ */
+const isDrop = (ast) => ast?.type === 'drop';
+exports.isDrop = isDrop;
+/**
+ * Returns whether the node is a binary expression.
+ */
+const isBinaryExpr = (node) => node?.type === 'binary_expr';
+exports.isBinaryExpr = isBinaryExpr;
+/**
+ * Returns whether the node is a logical binary expression (ie. AND/OR).
+ */
+const isLogicalBinaryExpr = (node) => {
+    if (!(0, exports.isBinaryExpr)(node))
+        return false;
+    return ['AND', 'OR'].includes(node.operator.toUpperCase());
+};
+exports.isLogicalBinaryExpr = isLogicalBinaryExpr;
+/**
+ * Returns whether the node is a base binary expression (ie. not AND/OR).
+ */
+const isBaseBinaryExpr = (node) => {
+    if (!(0, exports.isBinaryExpr)(node))
+        return false;
+    return !['AND', 'OR'].includes(node.operator.toUpperCase());
+};
+exports.isBaseBinaryExpr = isBaseBinaryExpr;
+/**
+ * Returns whether the node is an expression list.
+ */
+const isExprList = (node) => {
+    return node?.type === 'expr_list';
+};
+exports.isExprList = isExprList;
+/**
+ * Returns whether the node is a function.
+ */
+const isFunction = (node) => {
+    return node?.type === 'function';
+};
+exports.isFunction = isFunction;
+/**
+ * Returns whether the function is 'UPPER' or 'LOWER'.
+ */
+const isCasingFunction = (node) => {
+    if (!(0, exports.isFunction)(node))
+        return false;
+    if (typeof node.name !== 'string')
+        return false;
+    return ['LOWER', 'UPPER'].includes(node.name.toUpperCase());
+};
+exports.isCasingFunction = isCasingFunction;
+/**
+ * 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.
+ */
+const isNodeEmptyCollection = (node) => {
+    // Check if the node is a binary expression with IN/NOT-IN
+    if (!(0, exports.isBaseBinaryExpr)(node))
+        return false;
+    if (!['IN', 'NOT IN'].includes(node.operator))
+        return false;
+    // Check the length of the right-hand expression list
+    if (!(0, exports.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 (!(0, exports.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;
+};
+exports.isNodeEmptyCollection = isNodeEmptyCollection;
+/**
+ * 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
+ */
+const extractColumnish = (expr_value) => {
+    if (expr_value?.type === 'column_ref') {
+        return expr_value.column;
+    }
+    else if (expr_value?.type === 'double_quote_string') {
+        return expr_value.value;
+    }
+    return undefined;
+};
+exports.extractColumnish = extractColumnish;
+/**
+ * Returns whether the given columnType is a numeric type (ie. number-ish).
+ * @param columnType the type of the column
+ * @returns true or false
+ */
+const isNumericColumnType = (columnType) => {
+    if (!columnType)
+        return false;
+    return [
+        'number',
+        'numeric',
+        'smallint',
+        'int2',
+        'int4',
+        'int8',
+        'float2',
+        'float4',
+        'float8',
+        'float16',
+    ].includes(columnType);
+};
+exports.isNumericColumnType = isNumericColumnType;
+/**
+ * Returns whether the given columnType is a text type (ie. text-ish).
+ * @param columnType the type of the column
+ * @returns true or false
+ */
+const isTextColumnType = (columnType) => {
+    if (!columnType)
+        return false;
+    return [
+        'varchar',
+        'text',
+        // 'json', // TODO: handle json type
+        'bool',
+        'char',
+        'string',
+        'citext',
+    ].includes(columnType);
+};
+exports.isTextColumnType = isTextColumnType;
+/**
+ * Returns whether the given columnType is a date type (ie. date-ish).
+ * @param columnType the type of the column
+ * @returns true or false
+ */
+const isDateishColumnType = (columnType) => {
+    if (!columnType)
+        return false;
+    return ['date', 'datetime', 'timestamp', 'timestamptz'].includes(columnType);
+};
+exports.isDateishColumnType = isDateishColumnType;
+/**
+ * Returns a list of table objects from the AST.
+ */
+const getTableNames = (ast) => {
+    if (!(0, exports.isSelect)(ast))
+        return [];
+    return ast.from?.map((tbl) => tbl.table) ?? [];
+};
+exports.getTableNames = getTableNames;

package/dist/cjs/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/cjs/components/ReportBuilder/bigDateMap.d.ts.map

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