@quillsql/admin 1.6.1 → 1.6.2

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

@@ -1,2 +1,15 @@
-export declare function processJoinASTWithDuplicateColumns(duplicateColumnsNames: string[], tableNames: string[], schema: any, ast: any): any;
+import { QuillReport } from '@quillsql/react';
+import { QuillProviderClient } from '../Admin';
+export declare function processJoinASTWithDuplicateColumns(duplicateColumnsNames: string[], tableInfo: {
+    tableName: string;
+    alias: string;
+}[], schema: any, ast: any): any;
+export declare function getSelectFromAST(ast: any): any;
+export declare const astifyReport: (report: QuillReport, client: QuillProviderClient, getToken: () => Promise<string>) => Promise<{
+    ast: any;
+}>;
+/**
+ * Function that extracts a field value
+ */
+export declare function getFieldFromExpression(expr: any): string | undefined;
 //# sourceMappingURL=astProcessing.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"astProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/astProcessing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAG/C,wBAAgB,kCAAkC,CAChD,qBAAqB,EAAE,MAAM,EAAE,EAC/B,SAAS,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,EACjD,MAAM,EAAE,GAAG,EACX,GAAG,EAAE,GAAG,OAqDT;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,OAQxC;AAED,eAAO,MAAM,YAAY,WACf,WAAW,UACX,mBAAmB,YACjB,MAAM,OAAO,CAAC,MAAM,CAAC,KAC9B,OAAO,CAAC;IAAE,GAAG,EAAE,GAAG,CAAA;CAAE,CAyBtB,CAAC;AAEF;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAYpE"}

package/dist/esm/utils/astProcessing.js

@@ -1,18 +1,26 @@
-export function processJoinASTWithDuplicateColumns(duplicateColumnsNames, tableNames, schema, ast) {
+import { quillFetch } from './dataFetcher';
+export function processJoinASTWithDuplicateColumns(duplicateColumnsNames, tableInfo, schema, ast) {
     const columns = [];
     schema.forEach((table) => {
-        if (tableNames.includes(table.tableName)) {
+        const currentTableInfo = tableInfo.find((tableInfo) => tableInfo.tableName === table.tableName);
+        if (currentTableInfo) {
             table.columns.forEach((column) => {
-                let tableName = table.tableName;
-                if (table.tableName.includes('.')) {
-                    tableName = table.tableName.split('.')[1] || table.tableName;
+                let tableName = currentTableInfo.alias;
+                let schema = undefined;
+                if (currentTableInfo.alias.includes('.')) {
+                    tableName =
+                        currentTableInfo.alias.split('.')[1] || currentTableInfo.alias;
+                    schema = currentTableInfo.alias.split('.')[0];
                 }
-                if (duplicateColumnsNames.includes(column.columnName)) {
+                const alreadyExists = columns.find((column) => column.expr.column === column.columnName);
+                if (duplicateColumnsNames.includes(column.columnName) ||
+                    alreadyExists) {
                     columns.push({
                         type: 'expr',
                         as: `${tableName}_${column.columnName}`,
                         expr: {
                             type: 'column_ref',
+                            schema: schema,
                             table: tableName,
                             column: column.columnName,
                         },
@@ -24,6 +32,7 @@ export function processJoinASTWithDuplicateColumns(duplicateColumnsNames, tableN
                         as: null,
                         expr: {
                             type: 'column_ref',
+                            schema: schema,
                             table: tableName,
                             column: column.columnName,
                         },
@@ -35,3 +44,55 @@ export function processJoinASTWithDuplicateColumns(duplicateColumnsNames, tableN
     ast.columns = columns;
     return ast;
 }
+export function getSelectFromAST(ast) {
+    if (Array.isArray(ast)) {
+        return ast[0];
+    }
+    else if (ast.select) {
+        return ast.select;
+    }
+    else {
+        return ast;
+    }
+}
+export const astifyReport = async (report, client, getToken) => {
+    try {
+        if (!report) {
+            throw new Error('Report not found');
+        }
+        const { data: resp } = await quillFetch({
+            client,
+            task: 'astify',
+            metadata: {
+                query: report.queryString,
+                useNewNodeSql: true,
+            },
+            getToken,
+        });
+        if (resp.success === false) {
+            throw new Error("Couldn't process report query.");
+        }
+        const ast = getSelectFromAST(resp.ast);
+        return { ast };
+    }
+    catch (e) {
+        console.log(e);
+        return {
+            ast: null,
+        };
+    }
+};
+/**
+ * Function that extracts a field value
+ */
+export function getFieldFromExpression(expr) {
+    return (expr.column?.expr?.value ||
+        expr.column ||
+        expr.value ||
+        expr.args?.value?.[0]?.value?.expr?.value ||
+        expr.args?.value?.[0]?.column?.expr?.value ||
+        expr.args?.value?.[0]?.column ||
+        expr.args?.value?.[0]?.value ||
+        expr.args?.source?.column?.expr?.value ||
+        expr.args?.source?.column);
+}

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

@@ -1,9 +1,12 @@
-import { processJoinASTWithDuplicateColumns } from "./astProcessing";
+import { processJoinASTWithDuplicateColumns } from './astProcessing';
 describe('astProcessing', () => {
     describe('processJoinASTWithDuplicateColumns', () => {
-        it('should return a new ast object with unambiguous columns', () => {
+        it('should return a new ast object with unambiguous columns should use alias', () => {
             const dummyAst = { where: 'dummy where' };
-            const tableNames = ['table1', 'table2'];
+            const tableNames = [
+                { tableName: 'table1', alias: 't1' },
+                { tableName: 'table2', alias: 't2' },
+            ];
             const duplicateColumns = ['amount'];
             const schema = [
                 {
@@ -17,7 +20,8 @@ describe('astProcessing', () => {
             ];
             const resultAst = processJoinASTWithDuplicateColumns(duplicateColumns, tableNames, schema, dummyAst);
             expect(resultAst.columns.length).toEqual(4);
-            expect(resultAst.columns[0].as).toEqual('table1_amount');
+            expect(resultAst.columns[0].as).toEqual('t1_amount');
+            expect(resultAst.columns[0].expr.table).toEqual('t1');
             expect(resultAst.columns[1].as).toEqual(null);
         });
     });

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

@@ -1,3 +1,15 @@
+import { ColumnInternal } from './table';
+export type ColumnInfo = {
+    _id: string;
+    fieldType: string;
+    name: string;
+    displayName: string;
+    isVisible: true;
+};
 export declare function convertFieldTypeToJSType(fieldType: string): string;
 export declare function processColumnReference(column: string, databaseType: string): string;
+export declare function convertColumnInfoToColumnInternal(columnInfo: ColumnInfo): ColumnInternal;
+export declare function isStringType(fieldType: string): boolean;
+export declare function isDateType(fieldType: string): boolean;
+export declare function isNumberType(fieldType: string): boolean;
 //# sourceMappingURL=columnProcessing.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"columnProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/columnProcessing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,cAAc,EAAE,MAAM,SAAS,CAAC;AAErD,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,IAAI,CAAC;CACjB,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAwDlE;AAsED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,UAuB1E;AAED,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,UAAU,GACrB,cAAc,CAShB;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAYvD;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CASrD;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAwBvD"}

package/dist/esm/utils/columnProcessing.js

@@ -1,37 +1,200 @@
 export function convertFieldTypeToJSType(fieldType) {
+    let jsType = '';
     switch (fieldType) {
         case 'bool':
-            return 'bool';
+            jsType = 'bool';
+            break;
         case 'int8':
         case 'int2':
         case 'int4':
         case 'float4':
         case 'float8':
         case 'numeric':
-            return 'number';
+            jsType = 'number';
+            break;
         case 'date':
         case 'time':
         case 'timestamptz':
         case 'timestamp':
-            return 'date';
+            jsType = 'date';
+            break;
+        case 'json':
+        case 'jsonb':
+        case 'json[]':
+        case 'jsonb[]':
+        case 'int2[]':
+        case 'int4[]':
+        case 'int8[]':
+        case 'float4[]':
+        case 'float8[]':
+        case 'text[]':
+        case 'char[]':
+        case 'bool[]':
+        case 'uuid[]':
+        case 'varchar[]':
+        case 'interval[]':
+        case 'numeric[]':
+        case 'bytea[]':
+        case 'cidr[]':
+        case 'inet[]':
+        case 'macaddr[]':
+        case 'date[]':
+        case 'timestamp[]':
+        case 'timestamptz[]':
+        case 'timetz[]':
+            jsType = 'object';
+            break;
         case 'interval':
         case 'varchar':
         case 'text':
+        case 'uuid':
+        default:
+            jsType = 'string';
+    }
+    return jsType;
+}
+function fieldTypeToDataTypeID(fieldType) {
+    switch (fieldType) {
+        case 'bool':
+            return 16;
+        case 'int8':
+            return 20;
+        case 'int2':
+            return 21;
+        case 'int4':
+            return 23;
+        case 'json':
+            return 114;
+        case 'json[]':
+            return 199;
+        case 'float4':
+            return 700;
+        case 'float8':
+            return 701;
+        case 'numeric':
+            return 1700;
+        case 'date':
+            return 1082;
+        case 'time':
+            return 1083;
+        case 'timestamptz':
+            return 1184;
+        case 'timestamp':
+            return 1114;
+        case 'interval':
+            return 1186;
+        case 'uuid':
+            return 2950;
+        case 'uuid[]':
+            return 2951;
+        case 'jsonb':
+            return 3802;
+        case 'jsonb[]':
+            return 3807;
+        case 'varchar':
+        default:
+            return 1043;
+    }
+}
+function fieldTypeToFormat(fieldType) {
+    switch (fieldType) {
+        case 'bool':
+            return 'string';
+        case 'int8':
+        case 'int2':
+        case 'int4':
+            return 'whole_number';
+        case 'float4':
+        case 'float8':
+        case 'numeric':
+            return 'two_decimal_places';
+        case 'date':
+        case 'time':
+        case 'timestamptz':
+        case 'timestamp':
+            return 'MMM_dd_yyyy';
+        case 'interval':
+        case 'varchar':
         default:
             return 'string';
     }
 }
 export function processColumnReference(column, databaseType) {
-    if (['postgresql', 'snowflake'].includes(databaseType.toLowerCase())) {
+    if (['postgresql', 'snowflake', 'clickhouse'].includes(databaseType.toLowerCase())) {
         const columnParts = column.split('.');
         if (columnParts.length > 1) {
             return `"${columnParts[0]}"."${columnParts[1]}"`;
         }
         return `"${column}"`;
     }
+    else if (databaseType.toLowerCase() === 'mssql') {
+        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}\``;
 }
+export function convertColumnInfoToColumnInternal(columnInfo) {
+    return {
+        label: columnInfo.name,
+        field: columnInfo.name,
+        format: fieldTypeToFormat(columnInfo.fieldType),
+        fieldType: columnInfo.fieldType,
+        dataTypeID: fieldTypeToDataTypeID(columnInfo.fieldType),
+        jsType: convertFieldTypeToJSType(columnInfo.fieldType),
+    };
+}
+export function isStringType(fieldType) {
+    return [
+        'string',
+        'varchar',
+        'nvarchar',
+        'text',
+        'char',
+        'bpchar',
+        'citext',
+        'uuid',
+        'uniqueidentifier',
+    ].includes(fieldType.toLowerCase());
+}
+export function isDateType(fieldType) {
+    return [
+        'date',
+        'datetime',
+        'time',
+        'timestamptz',
+        'timestamp',
+        'interval',
+    ].includes(fieldType.toLowerCase());
+}
+export function isNumberType(fieldType) {
+    return [
+        'int64',
+        'int32',
+        'int16',
+        'int8',
+        'int4',
+        'int2',
+        'float2',
+        'float4',
+        'float8',
+        'float16',
+        'numeric',
+        'number',
+        'smallint',
+        'bigint',
+        'tinyint',
+        'mediumint',
+        'integer',
+        'int',
+        'uint32',
+        'uint16',
+        'uint8',
+    ].includes(fieldType.toLowerCase());
+}

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

@@ -1,26 +1,9 @@
 /**
  * Initial date range default options.
  */
-export declare const InitialDateRangeOptions: readonly [{
-    readonly value: "LAST_90_DAYS";
-    readonly label: "Last 90 days";
-}, {
-    readonly value: "LAST_30_DAYS";
-    readonly label: "Last 30 days";
-}, {
-    readonly value: "THIS_MONTH";
-    readonly label: "This Month";
-}, {
-    readonly value: "THIS_WEEK";
-    readonly label: "This Week";
-}, {
-    readonly value: "ALL_TIME";
-    readonly label: "All time";
-}];
-export type DateRangeOption = (typeof InitialDateRangeOptions)[number];
-export declare const defaultDateRange: {
-    readonly value: "LAST_90_DAYS";
-    readonly label: "Last 90 days";
-};
+export declare const ALL_TENANTS = "QUILL_ALL_TENANTS";
+export declare const SINGLE_TENANT = "QUILL_SINGLE_TENANT";
+export declare const SAVED_QUERIES_DASHBOARD = "quill-saved-queries";
 export declare const QUILL_SERVER: string;
+export declare const QUILL_QUERY_ENDPOINT: string;
 //# sourceMappingURL=constants.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/utils/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;EAM1B,CAAC;AACX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AACvE,eAAO,MAAM,gBAAgB;;;CAA6B,CAAC;AAE3D,eAAO,MAAM,YAAY,QACiD,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/utils/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAWH,eAAO,MAAM,WAAW,sBAAsB,CAAC;AAC/C,eAAO,MAAM,aAAa,wBAAwB,CAAC;AACnD,eAAO,MAAM,uBAAuB,wBAAwB,CAAC;AAE7D,eAAO,MAAM,YAAY,QAGoB,CAAC;AAC9C,eAAO,MAAM,oBAAoB,QAGnB,CAAC"}

package/dist/esm/utils/constants.js

@@ -1,12 +1,21 @@
 /**
  * Initial date range default options.
  */
-export const InitialDateRangeOptions = [
-    { value: 'LAST_90_DAYS', label: 'Last 90 days' },
-    { value: 'LAST_30_DAYS', label: 'Last 30 days' },
-    { value: 'THIS_MONTH', label: 'This Month' },
-    { value: 'THIS_WEEK', label: 'This Week' },
-    { value: 'ALL_TIME', label: 'All time' },
-];
-export const defaultDateRange = InitialDateRangeOptions[0];
-export const QUILL_SERVER = process.env.QUILL_SERVER_HOST ?? 'https://quill-344421.uc.r.appspot.com';
+// export const InitialDateRangeOptions = [
+//   { value: 'LAST_90_DAYS', label: 'Last 90 days' },
+//   { value: 'LAST_30_DAYS', label: 'Last 30 days' },
+//   { value: 'THIS_MONTH', label: 'This Month' },
+//   { value: 'THIS_WEEK', label: 'This Week' },
+//   { value: 'ALL_TIME', label: 'All time' },
+// ] as const;
+// export type DateRangeOption = (typeof InitialDateRangeOptions)[number];
+// export const defaultDateRange = InitialDateRangeOptions[1];
+export const ALL_TENANTS = 'QUILL_ALL_TENANTS';
+export const SINGLE_TENANT = 'QUILL_SINGLE_TENANT';
+export const SAVED_QUERIES_DASHBOARD = 'quill-saved-queries';
+export const QUILL_SERVER = typeof process !== 'undefined' && process.env
+    ? (process.env.QUILL_SERVER_HOST ?? 'https://quill-344421.uc.r.appspot.com')
+    : 'https://quill-344421.uc.r.appspot.com';
+export const QUILL_QUERY_ENDPOINT = typeof process !== 'undefined' && process.env
+    ? (process.env.QUILL_QUERY_ENDPOINT ?? '/cloud')
+    : '/cloud';

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

@@ -1,4 +1,5 @@
-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>;
+import { State } from '../AdminProvider';
+export declare const editVirtualTable: (editName: string, editViewQuery: string, editViewId: string, customFieldInfo: any, state: State, ownerTenantFields: string[], getToken: () => Promise<string>, noCustomerField?: boolean) => Promise<import("./dataFetcher").QuillResults | undefined>;
+export declare const addVirtualTable: (name: string, editViewQuery: string, customFieldInfo: any, state: State, ownerTenantFields: string[], getToken: () => Promise<string>, noCustomerField?: boolean) => Promise<import("./dataFetcher").QuillResults | undefined>;
+export declare const deleteVirtualTable: (id: string, state: State, getToken: () => Promise<string>) => Promise<import("./dataFetcher").QuillResults>;
 //# 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,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"}
+{"version":3,"file":"dataEditor.d.ts","sourceRoot":"","sources":["../../../src/utils/dataEditor.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAGzC,eAAO,MAAM,gBAAgB,aACjB,MAAM,iBACD,MAAM,cACT,MAAM,mBACD,GAAG,SACb,KAAK,qBACO,MAAM,EAAE,YACjB,MAAM,OAAO,CAAC,MAAM,CAAC,oBACb,OAAO,8DAqC1B,CAAC;AAEF,eAAO,MAAM,eAAe,SACpB,MAAM,iBACG,MAAM,mBACJ,GAAG,SACb,KAAK,qBACO,MAAM,EAAE,YACjB,MAAM,OAAO,CAAC,MAAM,CAAC,oBACb,OAAO,8DAgC1B,CAAC;AAEF,eAAO,MAAM,kBAAkB,OACzB,MAAM,SACH,KAAK,YACF,MAAM,OAAO,CAAC,MAAM,CAAC,kDAoBhC,CAAC"}

package/dist/esm/utils/dataEditor.js

@@ -1,5 +1,5 @@
-import { QUILL_SERVER } from './constants';
-export const editSQLView = async (editName, editViewQuery, editViewId, customFieldInfo, state) => {
+import { quillFetch } from './dataFetcher';
+export const editVirtualTable = async (editName, editViewQuery, editViewId, customFieldInfo, state, ownerTenantFields, getToken, noCustomerField) => {
     if (!editName.length) {
         alert('Please enter a table name.');
         return;
@@ -12,48 +12,30 @@ export const editSQLView = async (editName, editViewQuery, editViewId, customFie
         alert('Could not save.');
         return;
     }
-    let response;
-    if (state.queryEndpoint) {
-        response = await fetch(state.queryEndpoint, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...state.queryHeaders,
-            },
-            body: JSON.stringify({
-                metadata: {
-                    preQueries: [editViewQuery.replace(/;/, '')],
-                    name: editName,
-                    customFieldInfo: customFieldInfo,
-                    task: 'view',
-                    id: editViewId,
-                    clientId: state.client._id,
-                    runQueryConfig: { getColumns: true },
-                    databaseType: state.client.databaseType,
-                },
-            }),
-            credentials: state.withCredentials ? 'include' : 'omit', // If withCredentials is true, set to 'include'. Otherwise, set to 'omit'.
-        });
-    }
-    else {
-        response = await fetch(`${QUILL_SERVER}/table/${state.client._id}/`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer `,
-            },
-            body: JSON.stringify({
-                viewQuery: editViewQuery[editViewQuery.length - 1] === ';'
-                    ? editViewQuery.slice(0, -1)
-                    : editViewQuery,
-                name: editName,
-                id: editViewId,
-            }),
-        });
-    }
-    return await response.json();
+    return await quillFetch({
+        client: {
+            queryEndpoint: state.queryEndpoint,
+            clientId: state.client._id,
+            withCredentials: !!state.withCredentials,
+            queryHeaders: state.queryHeaders,
+        },
+        task: 'view',
+        metadata: {
+            preQueries: [editViewQuery.replace(/;/, '')],
+            name: editName,
+            customFieldInfo: customFieldInfo,
+            id: editViewId,
+            clientId: state.client._id,
+            runQueryConfig: { getColumns: true },
+            databaseType: state.client.databaseType,
+            ownerTenantFields,
+            noCustomerField,
+            useNewNodeSql: true,
+        },
+        getToken,
+    });
 };
-export const addSqlView = async (name, editViewQuery, customFieldInfo, state) => {
+export const addVirtualTable = async (name, editViewQuery, customFieldInfo, state, ownerTenantFields, getToken, noCustomerField) => {
     if (!name.length) {
         alert('Please enter a table name.');
         return;
@@ -62,79 +44,45 @@ export const addSqlView = async (name, editViewQuery, customFieldInfo, state) =>
         alert('Please enter a table query.');
         return;
     }
-    let response;
-    if (state.queryEndpoint) {
-        response = await fetch(state.queryEndpoint, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...state.queryHeaders,
-            },
-            body: JSON.stringify({
-                metadata: {
-                    preQueries: [editViewQuery.replace(/;/, '')],
-                    customFieldInfo: customFieldInfo,
-                    name: name,
-                    task: 'view',
-                    clientId: state.client._id,
-                    runQueryConfig: { getColumns: true },
-                    databaseType: state.client.databaseType,
-                },
-            }),
-            credentials: state.withCredentials ? 'include' : 'omit', // If withCredentials is true, set to 'include'. Otherwise, set to 'omit'.
-        });
-    }
-    else {
-        response = await fetch(`${QUILL_SERVER}/table/${state.client._id}/`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer `,
-            },
-            body: JSON.stringify({
-                viewQuery: editViewQuery[editViewQuery.length - 1] === ';'
-                    ? editViewQuery.slice(0, -1)
-                    : editViewQuery,
-                name: name,
-            }),
-        });
-    }
-    return await response.json();
+    return await quillFetch({
+        client: {
+            queryEndpoint: state.queryEndpoint,
+            clientId: state.client._id,
+            withCredentials: !!state.withCredentials,
+            queryHeaders: state.queryHeaders,
+        },
+        task: 'view',
+        metadata: {
+            preQueries: [editViewQuery.replace(/;/, '')],
+            customFieldInfo: customFieldInfo,
+            name: name,
+            clientId: state.client._id,
+            runQueryConfig: { getColumns: true },
+            databaseType: state.client.databaseType,
+            noCustomerField,
+            useNewNodeSql: true,
+            ownerTenantFields,
+        },
+        getToken,
+    });
 };
-export const deleteSQLView = async (id, state) => {
-    let response;
-    if (state.queryEndpoint) {
-        response = await fetch(state.queryEndpoint, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...state.queryHeaders,
-            },
-            body: JSON.stringify({
-                metadata: {
-                    task: 'view',
-                    id: id,
-                    deleted: true,
-                    clientId: state.client._id,
-                    runQueryConfig: { getColumns: true },
-                    databaseType: state.client.databaseType,
-                },
-            }),
-            credentials: state.withCredentials ? 'include' : 'omit', // If withCredentials is true, set to 'include'. Otherwise, set to 'omit'.
-        });
-    }
-    else {
-        response = await fetch(`${QUILL_SERVER}/table/${state.client._id}/`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer `,
-            },
-            body: JSON.stringify({
-                id: id,
-                deleted: true,
-            }),
-        });
-    }
-    return await response.json();
+export const deleteVirtualTable = async (id, state, getToken) => {
+    return await quillFetch({
+        client: {
+            queryEndpoint: state.queryEndpoint,
+            clientId: state.client._id,
+            withCredentials: !!state.withCredentials,
+            queryHeaders: state.queryHeaders,
+        },
+        task: 'view',
+        metadata: {
+            id: id,
+            deleted: true,
+            clientId: state.client._id,
+            runQueryConfig: { getColumns: true },
+            databaseType: state.client.databaseType,
+            useNewNodeSql: true,
+        },
+        getToken,
+    });
 };