@quillsql/admin 1.6.0 → 1.6.2

package/dist/esm/api/ConnectionClient.js

@@ -1,178 +1,162 @@
 import { QUILL_SERVER } from '../utils/constants';
-import { wrapInQuotes } from '../utils/textProcessing';
-export async function testConnectionString(connectionString, databaseType, clientId) {
-    const localURL = `${QUILL_SERVER}/sdk/test-connection`;
-    const response = await fetch(localURL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-            connectionString,
-            clientId,
-            databaseType,
-            task: 'test-connection',
-        }),
-    });
-    const results = await response.json();
-    return results;
+import { quillFetch } from '../utils/dataFetcher';
+export async function testConnectionString(queryEndpoint, connectionString, databaseType, getToken, clientId) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
+    try {
+        if (!clientId) {
+            // If no clientId, likely during onboarding, can't use actual sdk
+            const response = await fetch(`${QUILL_SERVER}/sdk/test-connection`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    connectionString,
+                    databaseType,
+                }),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            const results = await response.json();
+            return results;
+        }
+        else {
+            const { data } = await quillFetch({
+                client: {
+                    queryEndpoint,
+                    clientId: clientId,
+                    withCredentials: false,
+                },
+                task: 'test-connection',
+                metadata: {
+                    connectionString,
+                    databaseType,
+                },
+                getToken,
+                abortSignal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            return data;
+        }
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        if (error.name === 'AbortError') {
+            return { success: false, error: 'Connection timed out after 10 seconds' };
+        }
+        throw error;
+    }
 }
-export async function getSchemaTableInfo(clientId, schema, databaseType) {
-    const localURL = `${QUILL_SERVER}/sdk/schema-info`;
-    const response = await fetch(localURL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
+export async function getTablesBySchema(queryEndpoint, clientId, schema, getToken) {
+    const results = await quillFetch({
+        client: {
+            queryEndpoint,
+            clientId,
+            withCredentials: false,
         },
-        body: JSON.stringify({
+        task: 'tables-by-schema',
+        metadata: {
             clientId,
             schema,
-            databaseType,
-            task: 'schema-info',
-        }),
-    });
-    const results = await response.json();
-    return results;
-}
-export async function getTablesBySchema(clientId, schema) {
-    const localURL = `${QUILL_SERVER}/sdk/tables-by-schema`;
-    const response = await fetch(localURL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
         },
-        body: JSON.stringify({
-            clientId,
-            schemaNames: [schema],
-            task: 'tables-by-schema',
-        }),
+        getToken,
     });
-    const results = await response.json();
-    return results.tables;
+    if (results.status === 'success') {
+        return results.data.tables;
+    }
+    else {
+        throw new Error(results.error);
+    }
 }
-export async function getTableInfo(clientId, schema, table) {
-    const localURL = `${QUILL_SERVER}/sdk/table-info`;
-    const response = await fetch(localURL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
+export async function setSchemaNames(queryEndpoint, clientId, schemaNames, getToken) {
+    await quillFetch({
+        client: {
+            queryEndpoint,
             clientId,
-            schema,
-            table,
-            task: 'table-info',
-        }),
-    });
-    const results = await response.json();
-    return results;
-}
-export async function getOrgInfo(clientId, schema, table, orgIdColumn, orgColumn) {
-    const localURL = `${QUILL_SERVER}/sdk/org-info`;
-    const response = await fetch(localURL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
+            withCredentials: false,
         },
-        body: JSON.stringify({
+        task: 'set-schemas',
+        metadata: {
             clientId,
-            schema,
-            table,
-            orgColumn,
-            orgIdColumn,
-            task: 'org-info',
-        }),
+            schemaNames,
+        },
+        getToken,
     });
-    const results = await response.json();
-    return results.orgStrings;
 }
-export async function getFKInfo(clientId, schema, table, primaryKey) {
-    const localURL = `${QUILL_SERVER}/sdk/fk-info`;
-    const response = await fetch(localURL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
+// Unused?
+export async function getTableInfo(queryEndpoint, clientId, schema, table, getToken) {
+    const results = await quillFetch({
+        client: {
+            queryEndpoint,
+            clientId,
+            withCredentials: false,
         },
-        body: JSON.stringify({
+        task: 'table-info',
+        metadata: {
             clientId,
             schema,
             table,
-            primaryKey,
-            task: 'fk-info',
-        }),
+        },
+        getToken,
     });
-    const results = await response.json();
-    const potentialBestFK = results.foreignKeysString.reduce((acc, fk) => {
-        if (fk.startsWith(table.slice(0, -1))) {
-            acc.push(fk);
-        }
-        return acc;
-    }, []);
-    if (potentialBestFK.length > 0) {
-        return potentialBestFK;
+    if (results.status === 'success') {
+        return results.data.columns;
+    }
+    else {
+        throw new Error(results.error);
     }
-    return results.foreignKeysString;
 }
-export async function getTableSchema(clientId, tables, schemaName) {
-    const localURL = `${QUILL_SERVER}/sdk/table-schemas`;
-    const response = await fetch(localURL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
+export async function getTableColumnsBySchema(queryEndpoint, clientId, getToken, schemas) {
+    const results = await quillFetch({
+        client: {
+            queryEndpoint,
             clientId,
-            tables,
-            schemaName,
-            task: 'table-schemas',
-        }),
-    });
-    const results = await response.json();
-    return results;
-}
-export async function getTableColumnsBySchema(clientId, schemaNames, databaseType, queryEndpoint) {
-    const localURL = queryEndpoint ?? `${QUILL_SERVER}/table-info-by-schema`;
-    const response = await fetch(localURL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
+            withCredentials: false,
         },
-        body: JSON.stringify({
+        task: 'table-info-by-schema',
+        metadata: {
             clientId,
-            schemaNames,
-            task: 'table-schemas',
-            metadata: {
-                task: 'table-schemas',
-                preQueries: ['temp'],
-                clientId,
-                runQueryConfig: {
-                    overridePost: true,
-                    convertDatatypes: true,
-                    getTables: true,
-                    schema: schemaNames[0],
-                    schemaNames: schemaNames,
-                },
-                databaseType: databaseType,
-            },
-        }),
+            schemas,
+        },
+        getToken,
     });
-    const results = await response.json();
-    return queryEndpoint ? results.data.queryResults : results;
+    if (results.status === 'error') {
+        throw new Error(results.error);
+    }
+    const formattedResults = results.data.columnsByTable.map((table) => {
+        return {
+            tableName: table.tableName,
+            displayName: table.displayName,
+            columns: table.columns.map((column) => {
+                return {
+                    columnName: column.columnName,
+                    displayName: column.displayName,
+                    fieldType: column.fieldType,
+                    dataTypeId: column.dataTypeId,
+                    field: column.columnName,
+                };
+            }),
+        };
+    });
+    return { columnsByTable: formattedResults, schema: results.data.schema };
 }
-export async function getSQLViews(tableSchemas, customerNameField) {
-    const localURL = `${QUILL_SERVER}/sqlviewai`;
-    const response = await fetch(localURL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
+// Unused?
+export async function getVirtualTables(queryEndpoint, tableSchemas, customerNameField, clientId, getToken) {
+    const { data: results } = await quillFetch({
+        client: {
+            queryEndpoint,
+            clientId,
+            withCredentials: false,
         },
-        body: JSON.stringify({
+        task: 'sqlviewai',
+        metadata: {
             tableSchemas,
             customerNameField,
-            task: 'sqlviewai',
-        }),
+            clientId,
+        },
+        getToken,
     });
-    const results = await response.json();
     if (results.notSureWhatThisIs.length === 0) {
         return [];
     }
@@ -181,31 +165,57 @@ export async function getSQLViews(tableSchemas, customerNameField) {
     }
     return results.notSureWhatThisIs.sqlQueries;
 }
-export async function getSqlViewData(clientId, query, databaseType, queryEndpoint) {
-    const url = queryEndpoint ?? `${QUILL_SERVER}/sdk/query-view`;
-    const response = await fetch(url, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-            clientId,
-            query,
+export async function getVirtualTableData(clientId, query, databaseType, queryEndpoint, getToken) {
+    let queryAst = undefined;
+    try {
+        const { data } = await quillFetch({
+            client: {
+                queryEndpoint,
+                clientId,
+                withCredentials: false,
+            },
+            task: 'astify',
             metadata: {
-                task: 'query-view',
-                preQueries: [query],
                 clientId,
-                runQueryConfig: {
-                    overridePost: true,
-                    convertDatatypes: true,
-                    limitThousand: true,
-                },
-                databaseType: databaseType,
+                query,
+                useNewNodeSql: true,
+            },
+            getToken,
+        });
+        queryAst = data;
+        if (queryAst.success === false) {
+            return {
+                success: false,
+                error: queryAst.message,
+            };
+        }
+    }
+    catch (e) {
+        return {
+            success: false,
+            error: 'Invalid SQL Query',
+        };
+    }
+    const limitRegex = /limit\s+\d+/i;
+    const results = await quillFetch({
+        client: {
+            queryEndpoint,
+            clientId,
+            withCredentials: false,
+        },
+        task: 'query-view',
+        metadata: {
+            preQueries: [query],
+            clientId,
+            runQueryConfig: {
+                overridePost: true,
+                convertDatatypes: true,
+                limitThousand: !limitRegex.test(query),
             },
-            task: 'query-view',
-        }),
+            databaseType: databaseType,
+        },
+        getToken,
     });
-    const results = await response.json();
     if (results.status === 'error') {
         return { ...results, success: false };
     }
@@ -222,74 +232,142 @@ export async function getSqlViewData(clientId, query, databaseType, queryEndpoin
             };
         }
     }
+    if (databaseType.toLowerCase() === 'clickhouse') {
+        const dateFields = results.data.queryResults[0].fields.filter((field) => {
+            return (field.fieldType.toLowerCase() === 'date' // date32, which gets classified as date, does not work with dateTrunc operations that we use
+            );
+        });
+        if (dateFields.length > 0) {
+            return {
+                error: `Error Invalid Column ${dateFields[0].name}. Clickhouse Date types not supported. Use CAST(${dateFields[0].name} AS DateTime) to convert DATE fields to DateTime.`,
+                success: false,
+            };
+        }
+        const binaryFields = results.data.queryResults[0].fields.filter((field) => {
+            return (field.fieldType.toLowerCase() === 'bytea'
+            // It seems unlikely a customerID would be bytea
+            // && field.name !== customerId
+            );
+        });
+        if (binaryFields.length > 0) {
+            return {
+                error: `Error Invalid Column ${binaryFields[0].name}. Clickhouse Binary types not supported. Use CAST(${binaryFields[0].name} AS Text) to convert Binary fields to a supported type.`,
+                success: false,
+            };
+        }
+        const enumFields = results.data.queryResults[0].fields.filter((field) => {
+            return (field.fieldType.toLowerCase() === 'pg_enum' ||
+                field.fieldType.toLowerCase() === 'anyenum'
+            // It seems unlikely a customerID would be an enum
+            // && field.name !== customerId
+            );
+        });
+        if (enumFields.length > 0) {
+            return {
+                error: `Error Invalid Column ${enumFields[0].name}. Clickhouse ENUM types not supported. Use CAST(${enumFields[0].name} AS Text) to convert ENUM fields to a supported type.`,
+                success: false,
+            };
+        }
+    }
     return queryEndpoint
         ? {
             ...results.data.queryResults[0],
+            ...queryAst,
             success: results.status === 'success' ? true : false,
         }
-        : results;
+        : { ...results, ...queryAst };
 }
-export async function getQueryFromAI(aiPrompt, columnsByTable) {
-    const localURL = `${QUILL_SERVER}/sdk/sql-generator`;
-    const response = await fetch(localURL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
+// Unused?
+export async function getAST(query, clientId, queryEndpoint, getToken) {
+    const { data } = await quillFetch({
+        client: {
+            queryEndpoint,
+            clientId,
+            withCredentials: false,
+        },
+        task: 'astify',
+        metadata: {
+            clientId,
+            query,
+            useNewNodeSql: true,
+        },
+        getToken,
+    });
+    return data;
+}
+// Unused?
+export async function getQueryFromAI(aiPrompt, columnsByTable, queryEndpoint, clientId, getToken) {
+    const { data: results } = await quillFetch({
+        client: {
+            queryEndpoint,
+            clientId,
+            withCredentials: false,
         },
-        body: JSON.stringify({
+        task: 'sql-generator',
+        metadata: {
             initialQuestion: aiPrompt,
             tableSchemas: columnsByTable,
-            task: 'sql-generator',
-        }),
+            clientId,
+        },
+        getToken,
     });
-    const results = await response.json();
-    return results.message;
+    return results?.message || '';
 }
-export async function getQueryFromAiWithConnection(aiPrompt, clientId, schemaNames) {
-    const localURL = `${QUILL_SERVER}/ai-from-client-schema`;
-    const response = await fetch(localURL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
+export async function getQueryFromAiWithConnection(queryEndpoint, aiPrompt, clientId, getToken, schemaNames) {
+    if (aiPrompt.trim().length > 500) {
+        return '';
+    }
+    const { data: results } = await quillFetch({
+        client: {
+            queryEndpoint,
+            clientId,
+            withCredentials: false,
         },
-        body: JSON.stringify({
+        task: 'ai-from-client-schema',
+        metadata: {
             prompt: aiPrompt,
             clientId,
             schemaNames,
-            task: 'sql-generator',
-        }),
+        },
+        getToken,
     });
-    const results = await response.json();
-    return results.message;
+    return results?.message || '';
 }
-export async function createSQLView(connectionType, allSchemaInfo, columnsByTable, viewInfo, client, domainName, tableData, currentTableNames, override = false, clientId) {
+export async function createVirtualTable(viewInfo, client, tableData, currentTableNames, clientId, ownerTenantFields, queryEndpoint, queryHeaders, getToken) {
     let queryName = viewInfo.name;
-    let validQuery = false;
-    let localURL = `${QUILL_SERVER}/astify`;
-    const astResponse = await fetch(localURL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
+    const { data: queryAstRaw } = await quillFetch({
+        client: {
+            queryEndpoint,
+            clientId,
+            withCredentials: false,
         },
-        body: JSON.stringify({ query: viewInfo.query }),
-    });
-    tableData?.fields.forEach((column) => {
-        if (column.name ===
-            allSchemaInfo.selectedFields.foreignKey.replaceAll('"', '')) {
-            validQuery = true;
-        }
+        task: 'astify',
+        metadata: {
+            query: viewInfo.query,
+            clientId,
+            useNewNodeSql: true,
+        },
+        getToken,
     });
-    const queryAstRaw = await astResponse.json();
-    const queryAst = queryAstRaw.ast[0] ? queryAstRaw.ast[0] : queryAstRaw.ast;
-    queryName = queryAst.from.map((ast) => ast.table).join('_');
-    if (!override && !validQuery) {
+    const missingField = ownerTenantFields.find((field) => tableData &&
+        !tableData.fields.find((col) => col.name === field?.replaceAll('"', '')));
+    const failingTenant = client.allTenantTypes.find((tenant) => tenant.tenantField === missingField);
+    if (failingTenant) {
+        return {
+            success: false,
+            failingTenant,
+        };
+    }
+    if (!queryAstRaw || queryAstRaw.success === false) {
         return {
             success: false,
-            throwModal: true,
-            message: `No foreign key (${allSchemaInfo.selectedFields.foreignKey}) detected in the view. If this is a utility table override this error but if it isn’t you should rework your query.`,
+            error: queryAstRaw.message,
         };
     }
-    // append the next smallest number to the SQL View so the new view can be created
+    const queryAst = queryAstRaw.ast[0] ? queryAstRaw.ast[0] : queryAstRaw.ast;
+    queryName =
+        viewInfo.name ?? queryAst.from.map((ast) => ast.table).join('_');
+    // append the next smallest number to the Virtual Table so the new view can be created
     if (currentTableNames.includes(queryName)) {
         let nextSmallestNumber = 1;
         while (currentTableNames.includes(`${queryName}${nextSmallestNumber}`)) {
@@ -297,91 +375,21 @@ export async function createSQLView(connectionType, allSchemaInfo, columnsByTabl
         }
         queryName = queryName + nextSmallestNumber;
     }
-    const columns = columnsByTable.find((table) => table.tableName ===
-        `${allSchemaInfo.selectedFields.schema}.${allSchemaInfo.selectedFields.table}`).columns;
-    const customerFieldType = columns.find((column) => column.columnName === allSchemaInfo.selectedFields.organizationIdField).fieldType;
-    const fuzzyType = customerFieldType === 'string' ||
-        customerFieldType === 'uuid' ||
-        customerFieldType === 'text' ||
-        customerFieldType === 'varchar' ||
-        customerFieldType === 'object'
-        ? 'text'
-        : 'number';
-    localURL = `${QUILL_SERVER}/sdk/create-environment`;
-    const wrapQuotes = connectionType.type.toLocaleLowerCase() === 'postgresql' ||
-        connectionType.type.toLocaleLowerCase() === 'snowflake';
-    const payload = {
-        customerFieldName: wrapInQuotes(allSchemaInfo.selectedFields.foreignKey, wrapQuotes),
-        customerTableName: `${wrapInQuotes(allSchemaInfo.selectedFields.schema, wrapQuotes)}.${wrapInQuotes(allSchemaInfo.selectedFields.table, wrapQuotes)}`,
-        customerTableFieldName: wrapInQuotes(allSchemaInfo.selectedFields.organizationIdField, wrapQuotes),
-        adminCustomerId: allSchemaInfo.selectedFields.defaultOrg?.id,
-        customerTableTitleFieldName: wrapInQuotes(allSchemaInfo.selectedFields.customerNameField, wrapQuotes),
-        customerView: allSchemaInfo.selectedFields.customerView,
-        columns: tableData?.fields,
-        task: 'create-environment',
-        viewQuery: viewInfo.query,
-        customerFieldType: fuzzyType,
-        name: queryName,
-        client,
-        domainName,
-        schemaName: allSchemaInfo.selectedFields.schema,
-        schemaNames: [wrapInQuotes(allSchemaInfo.selectedFields.schema)],
-        clientId,
-    };
-    const response = await fetch(localURL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
+    const results = await quillFetch({
+        client: {
+            queryEndpoint,
+            clientId,
+            withCredentials: false,
         },
-        body: JSON.stringify(payload),
-    });
-    const results = await response.json();
-    return { ...results, success: true };
-}
-export async function processCustomerOrgViewQuery(query, schema, clientId) {
-    let localURL = `${QUILL_SERVER}/astify`;
-    const astResponse = await fetch(localURL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
+        task: 'create-virtual-table',
+        metadata: {
+            columns: tableData?.fields,
+            queryString: viewInfo.query,
+            name: queryName,
+            clientId,
+            ownerTenantFields,
         },
-        body: JSON.stringify({ query }),
+        getToken,
     });
-    const ast = await astResponse.json();
-    let fkInfo = [];
-    // make sure ast.ast.columns only has to values
-    let hasId = false;
-    let hasName = false;
-    if (ast.ast.columns && ast.ast.columns.length === 2) {
-        ast.ast.columns.forEach((column) => {
-            const columnName = column.as || column.expr.column;
-            if (columnName === 'id') {
-                hasId = true;
-            }
-            else if (columnName === 'name') {
-                hasName = true;
-            }
-            if (columnName === 'id' && column.as) {
-                fkInfo = [column.expr.column];
-            }
-        });
-    }
-    if (!hasId || !hasName) {
-        return {
-            success: false,
-            message: 'Query must have an "id" and "name" column.',
-        };
-    }
-    let table = '';
-    try {
-        table = ast.ast.from[0].table;
-    }
-    catch {
-        return {
-            success: false,
-            message: 'Query must have a table',
-        };
-    }
-    fkInfo = await getFKInfo(clientId, schema, table, 'id');
-    return { success: true, table, fkInfo };
+    return { ...results.data, success: true };
 }