@quillsql/admin 1.5.2 → 1.6.1

package/dist/esm/public_components/SQLViewManager.js

@@ -6,9 +6,30 @@ import { EnvSelectPopover } from '../components';
 import { TableCell } from '../Admin';
 import CreateEditSqlView from '../forms/sql_views/CreateEditSqlView';
 import { addSqlView, editSQLView, deleteSQLView } from '../utils/dataEditor';
-import { getTableColumnsBySchema } from '../api/ConnectionClient';
-import { MemoizedButton, MemoizedDeleteButton, MemoizedSecondaryButton, } from '../components/UiComponents';
+import { getSqlViewData, getTableColumnsBySchema, } from '../api/ConnectionClient';
+import { LoadingSpinner, MemoizedButton, MemoizedDeleteButton, MemoizedModal, MemoizedSecondaryButton, } from '../components/UiComponents';
 import DatabaseMismatchCard from '../components/DatabaseMismatchCard';
+import TogglePrimitive from '../primitives/TogglePrimitive';
+import { SegmentedControl } from '../components/SegmentedControl';
+import SqlTextEditor from '../components/SqlTextEditor';
+import { Table } from '@quillsql/react';
+import { getSchemaInfo } from '../utils/schema';
+import { PromoteViewModal } from '../modals';
+export const getDuplicateColumns = (columns) => {
+    if (!columns) {
+        return [];
+    }
+    const columnCount = columns?.reduce((acc, curr) => {
+        if (acc[curr.field]) {
+            acc[curr.field] += 1;
+        }
+        else {
+            acc[curr.field] = 1;
+        }
+        return acc;
+    }, {});
+    return Object.keys(columnCount).filter((column) => columnCount[column] > 1);
+};
 export default function SQLViewManager({ containerStyle, }) {
     const [tables, setTables] = useState(undefined);
     const [modalIsOpen, setIsOpen] = useState(false);
@@ -24,14 +45,19 @@ export default function SQLViewManager({ containerStyle, }) {
     const [deleteModalIsOpen, setDeleteModalIsOpen] = useState(false);
     const [isPromoteViewModalOpen, setIsPromoteViewModalOpen] = useState(false);
     const [allTableData, setAllTableData] = useState([]);
+    const [referencedTablesMap, setReferencedTablesMap] = useState({});
     const [schemaIsLoading, setSchemaIsLoading] = useState(false);
+    const [customFieldInfo, setCustomFieldInfo] = useState(undefined);
+    const [provider, setProvider] = useState(null);
     const [initialSqlView, setInitialSqlView] = useState(undefined);
+    const [submittingView, setSubmittingView] = useState(false);
     const parentRef = useRef(null);
     const { state, dispatch } = useAdmin();
     const closeEditModal = () => {
         setEditModalIsOpen(false);
         setEditName('');
         setEditViewQuery('');
+        setCustomFieldInfo(undefined);
     };
     const clickTableCell = (table) => {
         setEditName(table.name);
@@ -42,9 +68,26 @@ export default function SQLViewManager({ containerStyle, }) {
             name: table.name,
             query: table.viewQuery,
         });
+        setCustomFieldInfo(table.customFieldInfo);
         setEditModalIsOpen(true);
     };
     const getTables = async () => {
+        const schemaData = await getSchemaInfo({
+            queryEndpoint: state.queryEndpoint,
+            queryHeaders: state.queryHeaders,
+            publicKey: state.client._id,
+            customerId: state.client.customerId,
+            gatherSchemaData: false,
+        }, 'svm');
+        setTables(schemaData);
+    };
+    const getSchemaTableDetails = async () => {
+        setSchemaIsLoading(true);
+        const response = await getTableColumnsBySchema(state.client._id, state.client.schemaNames, state.client.databaseType, state.queryEndpoint);
+        setAllTableData(response);
+        setSchemaIsLoading(false);
+    };
+    const getReferencedTablesMap = async () => {
         const response = await fetch(`${state.queryEndpoint}`, {
             method: 'POST',
             headers: {
@@ -55,7 +98,7 @@ export default function SQLViewManager({ containerStyle, }) {
                 metadata: {
                     clientId: state.client._id,
                     publicKey: state.client._id,
-                    task: 'schema',
+                    task: 'referenced-tables-map',
                     databaseType: state.client.databaseType,
                 },
             }),
@@ -64,74 +107,119 @@ export default function SQLViewManager({ containerStyle, }) {
             throw new Error('Failed to fetch tables data');
         }
         const data = await response.json();
-        setTables(data.data.tables);
-    };
-    const getSchemaTableDetails = async () => {
-        setSchemaIsLoading(true);
-        const response = await getTableColumnsBySchema(state.client._id, state.client.schemaNames, state.client.databaseType, state.queryEndpoint);
-        setAllTableData(response);
-        setSchemaIsLoading(false);
+        setReferencedTablesMap(data.data.referencedTablesMap);
     };
     useEffect(() => {
         let isSubscribed = true;
         if (isSubscribed && state.client) {
             getTables();
             getSchemaTableDetails();
+            getReferencedTablesMap();
         }
         return () => {
             isSubscribed = false;
         };
     }, [state.client]);
-    const handleClickFirstDelete = () => {
-        setTableToBeDeleted(editName);
-        setDeleteModalIsOpen(true);
-    };
-    const handleModalSubmit = async (submitRequest, query, name, id) => {
+    const handleModalSubmit = async (submitRequest, query, name, id, columns, customFieldInfo) => {
         try {
+            const prevTableName = tables?.find((table) => table._id === id)?.name;
+            const isPlural = referencedTablesMap &&
+                referencedTablesMap[prevTableName] &&
+                referencedTablesMap[prevTableName].length > 1
+                ? 's'
+                : '';
+            let trimmedName = name?.trim() || undefined;
+            let submitResponse;
             switch (submitRequest) {
                 case 'add':
-                    if (!name) {
-                        alert('No Name found');
+                    if (!trimmedName) {
+                        alert('No name found');
                         return;
                     }
-                    if (tables?.map((table) => table.name).includes(name)) {
+                    if (tables?.map((table) => table.name).includes(trimmedName)) {
                         alert('Name already exists');
                         return;
                     }
-                    if (!/^[a-z0-9_]+$/.test(name)) {
-                        alert('Name must be lowercase with no spaces');
+                    // determine if there are duplicate names if there are then alert the user
+                    let duplicateColumns = getDuplicateColumns(columns);
+                    if (duplicateColumns.length > 0) {
+                        alert(`Ambiguous column names found. Either use aliases or remove the column to make every column name unique: \n\n${duplicateColumns.join('\n')}`);
                         return;
                     }
-                    await addSqlView(name, query, state);
+                    if (!/^[a-z0-9_]+$/.test(trimmedName)) {
+                        alert('Names can only include lowercase letters, numbers, and underscores');
+                        return;
+                    }
+                    submitResponse = await addSqlView(trimmedName, query, customFieldInfo, state);
                     break;
                 case 'edit':
                     if (!id) {
                         return;
                     }
-                    if (!name) {
-                        alert('No id found');
+                    if (referencedTablesMap && referencedTablesMap[prevTableName]) {
+                        // This condition is for only query edits
+                        if (editQueryView) {
+                            const errorColumns = [];
+                            referencedTablesMap[prevTableName] = referencedTablesMap[prevTableName].forEach((table) => {
+                                table.referencedColumns.forEach((column) => {
+                                    if (!columns?.find((col) => {
+                                        return col.field === column;
+                                    })) {
+                                        errorColumns.push(`'${column}' referenced by ${table.dashboardName} - ${table.reportName}`);
+                                    }
+                                });
+                            });
+                            if (errorColumns.length > 0) {
+                                alert(`Edit Error\n\n${errorColumns.join('\n')} \n\nPlease modify your query to include these columns.`);
+                                return;
+                            }
+                        }
+                        else {
+                            const referencedTableInfo = referencedTablesMap[prevTableName].map((info) => {
+                                return `${info.dashboardName} - ${info.reportName}`;
+                            });
+                            alert(`Edit Error\n\n${referencedTableInfo.join('\n')} \n\nPlease delete those charts before renaming this table.`);
+                            return;
+                        }
+                    }
+                    if (!trimmedName) {
+                        alert('No name found');
                         return;
                     }
-                    if (!/^[a-z0-9_]+$/.test(name)) {
+                    if (!/^[a-z0-9_]+$/.test(trimmedName)) {
                         alert('Names can only include lowercase letters, numbers, and underscores');
                         return;
                     }
+                    // determine if there are duplicate names if there are then alert the user
+                    const duplicateColumns2 = getDuplicateColumns(columns);
+                    if (duplicateColumns2.length > 0) {
+                        alert(`Ambiguous column names found. Either use aliases or remove the column to make every column name unique: \n\n${duplicateColumns2.join('\n')}`);
+                        return;
+                    }
                     // check if the tableName is present excluding the table with the same id
                     if (tables
                         ?.filter((table) => table._id !== id)
                         .map((table) => table.name)
-                        .includes(name)) {
+                        .includes(trimmedName)) {
                         alert('Name already exists');
                         return;
                     }
-                    await editSQLView(name, query, id, state);
+                    submitResponse = await editSQLView(trimmedName, query, id, customFieldInfo, state);
                     break;
                 case 'delete':
                     if (!id) {
                         alert('No id found');
                         return;
                     }
-                    await deleteSQLView(id, state);
+                    // Determine if the table is referenced in other charts
+                    if (referencedTablesMap && referencedTablesMap[prevTableName]) {
+                        const referencedTableInfo = referencedTablesMap[prevTableName].map((info) => {
+                            return `${info.dashboardName} - ${info.reportName}`;
+                        });
+                        alert(`This table is referenced in the following dashboard${isPlural}/chart${isPlural}.\n\n${referencedTableInfo.join('\n')} \n\nPlease delete those charts before deleting this table.`);
+                        return;
+                    }
+                    submitResponse = await deleteSQLView(id, state);
                     break;
                 default:
                     setEditName('');
@@ -140,6 +228,10 @@ export default function SQLViewManager({ containerStyle, }) {
                     setEditModalIsOpen(true);
                     return;
             }
+            if (submitResponse.status !== 'success') {
+                alert(`There was an error processing your ${submitRequest} request.`);
+                return;
+            }
             await getTables();
             closeEditModal();
             setEditQueryView(false);
@@ -148,21 +240,13 @@ export default function SQLViewManager({ containerStyle, }) {
             console.error(e);
         }
     };
-    const handleEditAddView = async (request, query, name, id) => {
+    const handleEditAddView = async (request, query, name, id, columns) => {
         switch (request) {
             case 'edit':
-                if (!name) {
-                    alert('No name found');
-                    return;
-                }
-                if (!id) {
-                    alert('No id found');
-                    return;
-                }
-                await handleModalSubmit('edit', query, name, id);
+                await handleModalSubmit('edit', query, name, id, columns);
                 break;
             default:
-                await handleModalSubmit('final-edit', query);
+                await handleModalSubmit('final-edit', query, undefined, undefined, columns);
                 break;
         }
     };
@@ -195,7 +279,7 @@ export default function SQLViewManager({ containerStyle, }) {
                             borderLeftWidth: 0,
                             borderRightWidth: 0,
                             borderStyle: 'solid',
-                            borderColor: state.theme.borderColor,
+                            borderColor: state.theme?.borderColor,
                             paddingBottom: 20,
                             //   boxShadow: "0px 1px 4px 0px rgba(0, 0, 0, 0.07)",
                             //   paddingRight: '50px',
@@ -231,14 +315,31 @@ export default function SQLViewManager({ containerStyle, }) {
                                 paddingTop: 25,
                             }, children: tables && tables?.length
                                 ? tables.map((table) => (_jsx(TableCell, { table: table, clickTableCell: clickTableCell }, table._id)))
-                                : null }, 'edit-view-query')) : (_jsx(CreateEditSqlView, { containerStyle: {}, initialSqlView: initialSqlView, closeEditView: () => setEditQueryView(false), addEditView: (request, name, query, id) => {
-                                handleEditAddView(request, name, query, id);
-                            }, allTableData: allTableData, schemaIsLoading: schemaIsLoading })) }))] }), _jsx(EditAddViewModal, { viewName: editName, viewQuery: editViewQuery, viewId: editViewId, editModalIsOpen: editModalIsOpen, closeEditModal: closeEditModal, submit: handleModalSubmit, state: state, onEditViewClick: () => setEditQueryView(true) })] }));
+                                : null }, 'edit-view-query')) : (_jsx(CreateEditSqlView, { containerStyle: {}, initialSqlView: initialSqlView, closeEditView: () => setEditQueryView(false), addEditView: (request, name, query, id, columns) => {
+                                handleEditAddView(request, name, query, id, columns);
+                            }, setProvider: (provider) => { setProvider(provider); }, provider: provider, allTableData: allTableData, schemaIsLoading: schemaIsLoading })) }))] }), _jsx(PromoteViewModal, { clientId: state.client._id, client: state.client, clients: state.clients, isOpen: isPromoteViewModalOpen, setIsOpen: setIsPromoteViewModalOpen, ModalComponent: MemoizedModal, views: tables || [], parentRef: parentRef }), _jsx(EditAddViewModal, { viewName: editName, viewQuery: editViewQuery, viewId: editViewId, editModalIsOpen: editModalIsOpen, customFieldInfo: customFieldInfo, closeEditModal: closeEditModal, submit: async (submitRequest, query, name, id, columns, customFieldInfo) => {
+                    if (submitRequest !== 'delete') {
+                        setSubmittingView(true);
+                    }
+                    await handleModalSubmit(submitRequest, query, name, id, columns, customFieldInfo);
+                    setSubmittingView(false);
+                }, state: state, onEditViewClick: () => setEditQueryView(true), isLoading: submittingView })] }));
 }
-function EditAddViewModal({ viewName, viewQuery, viewId, editModalIsOpen, closeEditModal, submit, state, onEditViewClick = () => { }, }) {
+function EditAddViewModal({ viewName, viewQuery, viewId, editModalIsOpen, customFieldInfo, closeEditModal, submit, state, onEditViewClick = () => { }, isLoading, }) {
     const [name, setName] = useState(viewName);
     const [query, setQuery] = useState(viewQuery);
     const [id, setId] = useState(viewId);
+    const [useCustomField, setUseCustomField] = useState(customFieldInfo ? true : false);
+    const [customFieldType, setCustomFieldType] = useState(customFieldInfo ? customFieldInfo.type : 'eav');
+    const [customFieldQuery, setCustomFieldQuery] = useState(customFieldInfo ? customFieldInfo.query : '');
+    const [runQueryButtonLoading, setRunQueryButtonLoading] = useState(false);
+    const [tableData, setTableData] = useState(undefined);
+    const [errorInfo, setErrorInfo] = useState({ show: false, message: '' });
+    useEffect(() => {
+        setCustomFieldQuery(customFieldInfo?.query || '');
+        setCustomFieldType(customFieldInfo?.type || 'eav');
+        setUseCustomField(customFieldInfo ? true : false);
+    }, [customFieldInfo]);
     useEffect(() => {
         setName(viewName);
     }, [viewName]);
@@ -248,7 +349,15 @@ function EditAddViewModal({ viewName, viewQuery, viewId, editModalIsOpen, closeE
     useEffect(() => {
         setId(viewId);
     }, [viewId]);
-    return (_jsx(ModalPrimitive, { isOpen: editModalIsOpen, close: closeEditModal, children: _jsxs("div", { className: "flex flex-col p-[6px]", children: [_jsxs("div", { style: {
+    return (_jsx(ModalPrimitive, { isOpen: editModalIsOpen, close: () => {
+            setUseCustomField(false);
+            setCustomFieldType('eav');
+            setCustomFieldQuery('');
+            setTableData(undefined);
+            setErrorInfo({ show: false, message: '' });
+            setName('');
+            closeEditModal();
+        }, children: _jsxs("div", { style: { height: '100%', overflow: 'scroll', width: '100%' }, children: [_jsxs("div", { style: {
                         display: 'flex',
                         flexDirection: 'row',
                         alignItems: 'center',
@@ -281,7 +390,6 @@ function EditAddViewModal({ viewName, viewQuery, viewId, editModalIsOpen, closeE
                         fontWeight: 'medium',
                         height: '120px',
                         boxShadow: '0 1px 2px 0 rgba(0,0,0,.05)',
-                        width: '500px',
                         background: 'linear-gradient(white 50%, transparent)',
                         color: state.theme?.primaryTextColor,
                         borderWidth: '1px',
@@ -315,7 +423,81 @@ function EditAddViewModal({ viewName, viewQuery, viewId, editModalIsOpen, closeE
                             } }), viewName && (_jsx("div", { style: { position: 'absolute', bottom: '10px', right: '10px' }, children: _jsx(MemoizedSecondaryButton, { label: 'Edit Query   ↗', onClick: () => {
                                     closeEditModal();
                                     onEditViewClick();
-                                } }) }))] }), _jsxs("div", { style: {
+                                } }) }))] }), _jsx("br", {}), ['65d65b57cdd8ae70a5648d9c', '665610862cf7a3000be66453'].includes(state.client._id) &&
+                    state.client.databaseType === 'PostgreSQL' && (_jsxs(_Fragment, { children: [_jsx("h3", { style: {
+                                fontWeight: '600',
+                                fontSize: '14px',
+                                marginBottom: '6px',
+                                color: '#212121',
+                            }, children: "Custom fields" }), _jsx(TogglePrimitive, { value: useCustomField, onClick: () => {
+                                setUseCustomField((useCustomField) => !useCustomField);
+                            } }), _jsx("br", {}), useCustomField && (_jsxs(_Fragment, { children: [_jsx("h3", { style: {
+                                        fontWeight: '600',
+                                        fontSize: '14px',
+                                        marginBottom: '6px',
+                                        marginTop: '20px',
+                                        color: '#212121',
+                                    }, children: "Custom field type" }), _jsx(SegmentedControl, { theme: state.theme, value: customFieldType, onChange: (e) => {
+                                        setCustomFieldType(e);
+                                    }, left: 'EAV', right: 'JSON' }), _jsx("br", {}), _jsx("h3", { style: {
+                                        fontWeight: '600',
+                                        fontSize: '14px',
+                                        marginBottom: '6px',
+                                        color: '#212121',
+                                    }, children: "Custom field query" }), _jsx("h3", { style: {
+                                        fontWeight: '400',
+                                        fontSize: '14px',
+                                        marginBottom: '20px',
+                                        color: '#212121',
+                                    }, children: customFieldType === 'eav'
+                                        ? `A table of custom fields. It must have these columns: ref_table, ref_id, field, value, type, ${state.client.customerFieldName.replaceAll('"', '')}.`
+                                        : `A table of custom fields. It must have these columns: ref_table, ref_column, field, ${state.client.customerFieldName.replaceAll('"', '')}.` }), _jsx(SqlTextEditor, { value: customFieldQuery, setValue: (e) => {
+                                        setCustomFieldQuery(e);
+                                    }, setEditorMounted: () => { }, containerStyle: {
+                                        width: 800,
+                                    }, previousProvider: null, height: '150px', schema: [] }), _jsx("br", {}), _jsx(MemoizedButton, { label: 'Run query', onClick: async () => {
+                                        if (/limit\s+\d+\s*;?\s*$/i.test(customFieldQuery)) {
+                                            setErrorInfo({
+                                                show: true,
+                                                message: 'Error: Please remove the limit at the end of your query.',
+                                            });
+                                            return;
+                                        }
+                                        setErrorInfo({ show: false, message: '' });
+                                        setRunQueryButtonLoading(true);
+                                        const getSqlResults = await getSqlViewData(state.client._id, customFieldQuery, state.client.databaseType, state.queryEndpoint);
+                                        if (!getSqlResults.success) {
+                                            setErrorInfo({
+                                                show: true,
+                                                message: getSqlResults.error,
+                                            });
+                                        }
+                                        else {
+                                            setErrorInfo({ show: false, message: '' });
+                                            setTableData(getSqlResults);
+                                        }
+                                        setRunQueryButtonLoading(false);
+                                    } }), _jsx("br", {}), runQueryButtonLoading && (_jsx("div", { style: {
+                                        height: '250px',
+                                        width: '100%',
+                                        display: 'flex',
+                                        justifyContent: 'center',
+                                        alignItems: 'center',
+                                    }, children: _jsx(LoadingSpinner, {}) })), !errorInfo.show && tableData && !runQueryButtonLoading && (_jsx(Table, { rows: tableData.rows, columns: tableData.fields, containerStyle: {
+                                        height: '250px',
+                                        maxWidth: '800px',
+                                        paddingTop: '20px',
+                                    }, hideCSVDownloadButton: true })), errorInfo.show && (_jsx("div", { style: {
+                                        fontSize: 15,
+                                        fontWeight: '400',
+                                        paddingTop: '20px',
+                                    }, children: _jsx("div", { style: {
+                                            padding: 30,
+                                            background: 'rgba(0,0,0,0.02)',
+                                            display: 'inline-block',
+                                            flex: 0,
+                                            borderRadius: 6,
+                                        }, children: errorInfo.message }) }))] }))] })), _jsxs("div", { style: {
                         display: 'flex',
                         flexDirection: 'row',
                         alignItems: 'center',
@@ -327,6 +509,47 @@ function EditAddViewModal({ viewName, viewQuery, viewId, editModalIsOpen, closeE
                                     alert('Please enter a name');
                                     return;
                                 }
-                                submit(viewName ? 'edit' : 'add', query, name, id);
-                            }, label: viewName ? 'Save changes' : 'Create view' })] })] }) }));
+                                if (useCustomField) {
+                                    const fields = tableData?.fields.map((field) => field.field);
+                                    const missingFields = [];
+                                    if (!fields) {
+                                        alert('Custom field query is missing required columns');
+                                        return;
+                                    }
+                                    if (customFieldType === 'eav') {
+                                        // make sure the tableData has the required columns
+                                        [
+                                            'ref_table',
+                                            'ref_id',
+                                            'field',
+                                            'value',
+                                            'type',
+                                            state.client.customerFieldName.replaceAll('"', ''),
+                                        ].forEach((requiredField) => {
+                                            if (!fields.includes(requiredField)) {
+                                                missingFields.push(requiredField);
+                                            }
+                                        });
+                                    }
+                                    else {
+                                        [
+                                            'ref_table',
+                                            'field',
+                                            'ref_column',
+                                            state.client.customerFieldName.replaceAll('"', ''),
+                                        ].forEach((requiredField) => {
+                                            if (!fields.includes(requiredField)) {
+                                                missingFields.push(requiredField);
+                                            }
+                                        });
+                                    }
+                                    if (missingFields.length > 0) {
+                                        alert(`Custom field query is missing required columns: ${missingFields.join(', ')}`);
+                                        return;
+                                    }
+                                }
+                                submit(viewName ? 'edit' : 'add', query, name, id, undefined, useCustomField
+                                    ? { type: customFieldType, query: customFieldQuery }
+                                    : undefined);
+                            }, label: viewName ? 'Save changes' : 'Create view', isLoading: isLoading })] })] }) }));
 }

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

@@ -0,0 +1,2 @@
+export declare function processJoinASTWithDuplicateColumns(duplicateColumnsNames: string[], tableNames: string[], schema: any, ast: any): any;
+//# sourceMappingURL=astProcessing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"astProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/astProcessing.ts"],"names":[],"mappings":"AAAA,wBAAgB,kCAAkC,CAChD,qBAAqB,EAAE,MAAM,EAAE,EAC/B,UAAU,EAAE,MAAM,EAAE,EACpB,MAAM,EAAE,GAAG,EACX,GAAG,EAAE,GAAG,OAsCT"}

package/dist/esm/utils/astProcessing.js

@@ -0,0 +1,37 @@
+export function processJoinASTWithDuplicateColumns(duplicateColumnsNames, tableNames, schema, ast) {
+    const columns = [];
+    schema.forEach((table) => {
+        if (tableNames.includes(table.tableName)) {
+            table.columns.forEach((column) => {
+                let tableName = table.tableName;
+                if (table.tableName.includes('.')) {
+                    tableName = table.tableName.split('.')[1] || table.tableName;
+                }
+                if (duplicateColumnsNames.includes(column.columnName)) {
+                    columns.push({
+                        type: 'expr',
+                        as: `${tableName}_${column.columnName}`,
+                        expr: {
+                            type: 'column_ref',
+                            table: tableName,
+                            column: column.columnName,
+                        },
+                    });
+                }
+                else {
+                    columns.push({
+                        type: 'expr',
+                        as: null,
+                        expr: {
+                            type: 'column_ref',
+                            table: tableName,
+                            column: column.columnName,
+                        },
+                    });
+                }
+            });
+        }
+    });
+    ast.columns = columns;
+    return ast;
+}

package/dist/esm/utils/astProcessing.uspec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=astProcessing.uspec.d.ts.map

package/dist/esm/utils/astProcessing.uspec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"astProcessing.uspec.d.ts","sourceRoot":"","sources":["../../../src/utils/astProcessing.uspec.ts"],"names":[],"mappings":""}

package/dist/esm/utils/astProcessing.uspec.js

@@ -0,0 +1,24 @@
+import { processJoinASTWithDuplicateColumns } from "./astProcessing";
+describe('astProcessing', () => {
+    describe('processJoinASTWithDuplicateColumns', () => {
+        it('should return a new ast object with unambiguous columns', () => {
+            const dummyAst = { where: 'dummy where' };
+            const tableNames = ['table1', 'table2'];
+            const duplicateColumns = ['amount'];
+            const schema = [
+                {
+                    tableName: 'table1',
+                    columns: [{ columnName: 'amount' }, { columnName: 'name' }],
+                },
+                {
+                    tableName: 'table2',
+                    columns: [{ columnName: 'amount' }, { columnName: 'other_name' }],
+                },
+            ];
+            const resultAst = processJoinASTWithDuplicateColumns(duplicateColumns, tableNames, schema, dummyAst);
+            expect(resultAst.columns.length).toEqual(4);
+            expect(resultAst.columns[0].as).toEqual('table1_amount');
+            expect(resultAst.columns[1].as).toEqual(null);
+        });
+    });
+});

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

@@ -0,0 +1,3 @@
+export declare function convertFieldTypeToJSType(fieldType: string): string;
+export declare function processColumnReference(column: string, databaseType: string): string;
+//# sourceMappingURL=columnProcessing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"columnProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/columnProcessing.ts"],"names":[],"mappings":"AAAA,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAsBlE;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,UAa1E"}

package/dist/esm/utils/columnProcessing.js

@@ -0,0 +1,37 @@
+export function convertFieldTypeToJSType(fieldType) {
+    switch (fieldType) {
+        case 'bool':
+            return 'bool';
+        case 'int8':
+        case 'int2':
+        case 'int4':
+        case 'float4':
+        case 'float8':
+        case 'numeric':
+            return 'number';
+        case 'date':
+        case 'time':
+        case 'timestamptz':
+        case 'timestamp':
+            return 'date';
+        case 'interval':
+        case 'varchar':
+        case 'text':
+        default:
+            return 'string';
+    }
+}
+export function processColumnReference(column, databaseType) {
+    if (['postgresql', 'snowflake'].includes(databaseType.toLowerCase())) {
+        const columnParts = column.split('.');
+        if (columnParts.length > 1) {
+            return `"${columnParts[0]}"."${columnParts[1]}"`;
+        }
+        return `"${column}"`;
+    }
+    const columnParts = column.split('.');
+    if (columnParts.length > 1) {
+        return `\`${columnParts[0]}\`.\`${columnParts[1]}\``;
+    }
+    return `\`${column}\``;
+}

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

@@ -1,4 +1,4 @@
-export declare const editSQLView: (editName: string, editViewQuery: string, editViewId: string, state: any) => Promise<any>;
-export declare const addSqlView: (name: string, editViewQuery: string, state: any) => Promise<any>;
+export declare const editSQLView: (editName: string, editViewQuery: string, editViewId: string, customFieldInfo: any, state: any) => Promise<any>;
+export declare const addSqlView: (name: string, editViewQuery: string, customFieldInfo: any, state: any) => Promise<any>;
 export declare const deleteSQLView: (id: string, state: any) => Promise<any>;
 //# sourceMappingURL=dataEditor.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dataEditor.d.ts","sourceRoot":"","sources":["../../../src/utils/dataEditor.tsx"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,aACZ,MAAM,iBACD,MAAM,cACT,MAAM,SACX,GAAG,iBAsDX,CAAC;AAEF,eAAO,MAAM,UAAU,SACf,MAAM,iBACG,MAAM,SACd,GAAG,iBA+CX,CAAC;AAEF,eAAO,MAAM,aAAa,OAAc,MAAM,SAAS,GAAG,iBAmCzD,CAAC"}
+{"version":3,"file":"dataEditor.d.ts","sourceRoot":"","sources":["../../../src/utils/dataEditor.tsx"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,aACZ,MAAM,iBACD,MAAM,cACT,MAAM,mBACD,GAAG,SACb,GAAG,iBAuDX,CAAC;AAEF,eAAO,MAAM,UAAU,SACf,MAAM,iBACG,MAAM,mBACJ,GAAG,SACb,GAAG,iBAgDX,CAAC;AAEF,eAAO,MAAM,aAAa,OAAc,MAAM,SAAS,GAAG,iBAmCzD,CAAC"}

package/dist/esm/utils/dataEditor.js

@@ -1,5 +1,5 @@
 import { QUILL_SERVER } from './constants';
-export const editSQLView = async (editName, editViewQuery, editViewId, state) => {
+export const editSQLView = async (editName, editViewQuery, editViewId, customFieldInfo, state) => {
     if (!editName.length) {
         alert('Please enter a table name.');
         return;
@@ -24,6 +24,7 @@ export const editSQLView = async (editName, editViewQuery, editViewId, state) =>
                 metadata: {
                     preQueries: [editViewQuery.replace(/;/, '')],
                     name: editName,
+                    customFieldInfo: customFieldInfo,
                     task: 'view',
                     id: editViewId,
                     clientId: state.client._id,
@@ -52,7 +53,7 @@ export const editSQLView = async (editName, editViewQuery, editViewId, state) =>
     }
     return await response.json();
 };
-export const addSqlView = async (name, editViewQuery, state) => {
+export const addSqlView = async (name, editViewQuery, customFieldInfo, state) => {
     if (!name.length) {
         alert('Please enter a table name.');
         return;
@@ -72,6 +73,7 @@ export const addSqlView = async (name, editViewQuery, state) => {
             body: JSON.stringify({
                 metadata: {
                     preQueries: [editViewQuery.replace(/;/, '')],
+                    customFieldInfo: customFieldInfo,
                     name: name,
                     task: 'view',
                     clientId: state.client._id,

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

@@ -29,7 +29,6 @@ interface SnowflakeConnection extends DatabaseConnection {
     port: string;
 }
 interface BigQueryConnection extends DatabaseConnection {
-    companyTag: string;
     jsonString: string;
 }
 export type ConnectionType = DatabaseConnection | PostgresConnection | MySQLConnection | SnowflakeConnection | BigQueryConnection;