@quillsql/react 2.13.26 → 2.13.28

package/dist/esm/utils/tableProcessing.js

@@ -1,6 +1,5 @@
-import { isTextColumnType, } from '../components/ReportBuilder/ast';
 import { deepCopy } from '../components/ReportBuilder/util';
-import { convertPostgresColumn } from './columnProcessing';
+import { convertPostgresColumn, isStringType } from './columnProcessing';
 import { MAX_PIVOT_UNIQUE_VALUES, QUILL_QUERY_ENDPOINT, QUILL_SERVER, } from './constants';
 import { getData } from './dataFetcher';
 import { parseValueFromBigQueryDates } from './dataProcessing';
@@ -19,7 +18,7 @@ export const hasColumnAlias = (columns, referencedColumns) => {
     }
     return false;
 };
-export const getUniqueValuesByColumns = async (columns, query, rows, client, customFields, filters) => {
+export const getUniqueValuesByColumns = async (columns, query, rows, client, tenants, customFields, filters, dashboardName) => {
     const stringNames = columns.map((column) => column.field);
     const uniqueValues = {};
     //TODO: this bigquery case is wack, we should be able to generate a distinct query for bigquery
@@ -30,13 +29,14 @@ export const getUniqueValuesByColumns = async (columns, query, rows, client, cus
                 metadata: {
                     query: query,
                     task: 'query',
-                    orgId: client.organizationId || '*',
                     clientId: client.publicKey,
                     databaseType: client?.databaseType,
                     customFieldsByTable: customFields,
                     useNewNodeSql: true,
                     dateField: filters?.find((filter) => filter.filterType === 'date_range')?.dateField,
                     filters,
+                    dashboardName: dashboardName && tenants ? dashboardName : undefined,
+                    tenants: dashboardName && tenants ? tenants : undefined,
                 },
             };
             const cloudBody = { query };
@@ -59,7 +59,7 @@ export const getUniqueValuesByColumns = async (columns, query, rows, client, cus
     }
     else {
         const distinctValueQuery = generateDistinctQuery(stringNames, query, client.databaseType);
-        const distinctStrings = await fetchDistinctStrings(distinctValueQuery, client, customFields, filters);
+        const distinctStrings = await fetchDistinctStrings(distinctValueQuery, client, tenants, customFields, filters, dashboardName);
         if (!distinctStrings) {
             return {};
         }
@@ -69,16 +69,20 @@ export const getUniqueValuesByColumns = async (columns, query, rows, client, cus
     }
     return uniqueValues;
 };
-export const getUniqueStringValues = async (columns, tableName, client, customFields, previousUniqueValues, withExceededColumns, query) => {
+export const getUniqueStringValues = async (columns, tableName, client, tenants, customFields, previousUniqueValues, withExceededColumns, query, dashboardName) => {
     const convertedStringColumns = columns.filter((column) => {
-        return isTextColumnType(column.fieldType);
+        return isStringType(column.fieldType);
     });
     const stringNames = convertedStringColumns.map((column) => processColumnReference(column.field, client.databaseType));
-    const { filteredColumns: smallStringColumns, exceededColumns } = await getCountsByColumns(convertedStringColumns, query ?? `Select ${stringNames.join(', ')} from ${tableName}`, client, customFields ?? []);
+    const { filteredColumns: smallStringColumns, exceededColumns } = query || stringNames.length > 0
+        ? await getCountsByColumns(convertedStringColumns, query || `Select ${stringNames.join(', ')} from ${tableName}`, client, tenants, customFields ?? [], dashboardName)
+        : { filteredColumns: [], exceededColumns: undefined };
     const smallStringNames = smallStringColumns.map((column) => processColumnReference(column.field, client.databaseType));
-    const newUniqueValues = await getUniqueValuesByColumns(
-    // returns null if data error
-    smallStringColumns, query ?? `Select ${smallStringNames.join(', ')} from ${tableName}`, [], client, customFields ?? []);
+    const newUniqueValues = query || smallStringColumns.length > 0
+        ? await getUniqueValuesByColumns(
+        // returns null if data error
+        smallStringColumns, query || `Select ${smallStringNames.join(', ')} from ${tableName}`, [], client, tenants, customFields ?? [], undefined, dashboardName)
+        : null;
     if (!newUniqueValues) {
         return {};
     }
@@ -100,24 +104,24 @@ export const getUniqueStringValues = async (columns, tableName, client, customFi
         return newUniqueValues;
     }
 };
-export const getRelevantInfoFromQuery = async (columns, client, query, customFields) => {
+export const getRelevantInfoFromQuery = async (columns, client, tenants, query, customFields, dashboardName) => {
     let dateRanges = {};
     let uniqueStrings = {};
     let error = undefined;
     try {
         const convertedStringColumns = columns.filter((column) => {
-            return isTextColumnType(column.fieldType);
+            return isStringType(column.fieldType);
         });
         const stringNames = convertedStringColumns.map((column) => column.field);
         if (stringNames.length > 0) {
-            const { filteredColumns: smallStringColumns } = await getCountsByColumns(convertedStringColumns, query, client, customFields);
-            uniqueStrings = await getUniqueValuesByColumns(smallStringColumns, query, [], client, customFields);
+            const { filteredColumns: smallStringColumns } = await getCountsByColumns(convertedStringColumns, query, client, tenants, customFields, dashboardName);
+            uniqueStrings = await getUniqueValuesByColumns(smallStringColumns, query, [], client, tenants, customFields, undefined, dashboardName);
         }
         const dateColumns = columns.filter((column) => {
             return column.fieldType === 'date';
         });
         if (dateColumns.length > 0) {
-            dateRanges = await getQueryDateRangeByColumns(dateColumns, query, client, customFields);
+            dateRanges = await getQueryDateRangeByColumns(dateColumns, query, client, tenants, customFields, dashboardName);
             if (dateRanges === null) {
                 throw new Error("Couldn't fetch date ranges");
             }
@@ -132,7 +136,7 @@ export const getRelevantInfoFromQuery = async (columns, client, query, customFie
         error,
     };
 };
-export const getCountsByColumns = async (columns, query, client, customFields) => {
+export const getCountsByColumns = async (columns, query, client, tenants, customFields, dashboardName) => {
     const stringNames = columns.map((column) => column.field);
     const countQuery = generateCountQuery(stringNames, query, client.databaseType || 'postgresql');
     try {
@@ -140,11 +144,12 @@ export const getCountsByColumns = async (columns, query, client, customFields) =
             metadata: {
                 query: countQuery,
                 task: 'query',
-                orgId: client.organizationId || '*',
                 clientId: client.publicKey,
                 databaseType: client?.databaseType,
                 customFieldsByTable: customFields,
                 useNewNodeSql: true,
+                dashboardName: dashboardName && tenants ? dashboardName : undefined,
+                tenants: dashboardName && tenants ? tenants : undefined,
             },
         };
         const cloudBody = { countQuery };
@@ -173,13 +178,12 @@ export const getCountsByColumns = async (columns, query, client, customFields) =
         return { filteredColumns: columns, exceededColumns: undefined };
     }
 };
-const fetchDistinctStrings = async (query, client, customFields, filters) => {
+const fetchDistinctStrings = async (query, client, tenants, customFields, filters, dashboardName) => {
     try {
         const hostedBody = {
             metadata: {
                 query,
                 task: 'query',
-                orgId: client.organizationId || '*',
                 clientId: client.publicKey,
                 databaseType: client?.databaseType,
                 customFieldsByTable: customFields,
@@ -187,6 +191,8 @@ const fetchDistinctStrings = async (query, client, customFields, filters) => {
                 filters,
                 // @ts-ignore
                 dateField: filters?.find((filter) => filter.filterType === 'date_range')?.dateField,
+                dashboardName: dashboardName && tenants ? dashboardName : undefined,
+                tenants: dashboardName && tenants ? tenants : undefined,
             },
         };
         const cloudBody = { query };
@@ -217,25 +223,26 @@ const fetchDistinctStrings = async (query, client, customFields, filters) => {
         return null;
     }
 };
-export const getQueryDateRangeByColumns = async (columns, query, client, customFields) => {
+export const getQueryDateRangeByColumns = async (columns, query, client, tenants, customFields, dashboardName) => {
     const columnNames = columns.map(
     // @ts-ignore
     (column) => column.field || column.name);
     const distinctValueQuery = generateMinMaxDateRangeQueries(columnNames, query, client.databaseType || 'postgresql');
-    const dateRanges = await fetchQueryDateRanges(distinctValueQuery, client, customFields);
+    const dateRanges = await fetchQueryDateRanges(distinctValueQuery, client, tenants, customFields, dashboardName);
     return dateRanges;
 };
-const fetchQueryDateRanges = async (query, client, customFields) => {
+const fetchQueryDateRanges = async (query, client, tenants, customFields, dashboardName) => {
     try {
         const hostedBody = {
             metadata: {
                 query,
                 task: 'query',
-                orgId: client.organizationId || '*',
                 clientId: client.publicKey,
                 databaseType: client?.databaseType,
                 customFieldsByTable: customFields,
                 useNewNodeSql: true,
+                dashboardName: dashboardName && tenants ? dashboardName : undefined,
+                tenants: dashboardName && tenants ? tenants : undefined,
             },
         };
         const cloudBody = { query };
@@ -255,16 +262,16 @@ const fetchQueryDateRanges = async (query, client, customFields) => {
         return null;
     }
 };
-export const getPaginatedRows = async (client, query, reportId, processing, filters, customFields) => {
+export const getPaginatedRows = async (client, tenants, query, reportId, processing, filters, customFields, dashboardName) => {
     if (query) {
-        return await fetchResultsByQuery(query, client, processing, customFields);
+        return await fetchResultsByQuery(query, client, tenants, processing, customFields, filters, undefined, undefined, undefined, undefined, dashboardName);
     }
     else if (reportId) {
-        return await fetchResultsByReport(reportId, client, processing, filters, customFields);
+        return await fetchResultsByReport(reportId, client, tenants, processing, filters, customFields);
     }
     return { rows: [], columns: [] };
 };
-export const fetchResultsByQuery = async (query, client, processing, customFields, filters, dateField, rowsOnly, rowCountOnly, filterMap) => {
+export const fetchResultsByQuery = async (query, client, tenants, processing, customFields, filters, dateField, rowsOnly, rowCountOnly, filterMap, dashboardName) => {
     let rows = [];
     let columns = [];
     let error = undefined;
@@ -276,12 +283,9 @@ export const fetchResultsByQuery = async (query, client, processing, customField
                 query,
                 task: 'query',
                 filterMap,
-                orgId: client.organizationId || '*',
                 clientId: client.publicKey,
                 databaseType: client?.databaseType,
-                getCustomFields: !client.organizationId || client.organizationId === '*'
-                    ? false
-                    : true,
+                getCustomFields: !!tenants?.length,
                 customFieldsByTable: customFields,
                 additionalProcessing: processing,
                 useUpdatedDataGathering: processing ? true : false,
@@ -290,6 +294,8 @@ export const fetchResultsByQuery = async (query, client, processing, customField
                 dateField: dateField ?? undefined,
                 rowsOnly,
                 rowCountOnly,
+                dashboardName: dashboardName && tenants ? dashboardName : undefined,
+                tenants: dashboardName && tenants ? tenants : undefined,
             },
         };
         const cloudBody = { query };
@@ -318,7 +324,7 @@ export const fetchResultsByQuery = async (query, client, processing, customField
         if (resp && resp.errorMessage) {
             throw new Error(resp.errorMessage);
         }
-        if (resp.rowCount) {
+        if (resp.rowCount !== undefined) {
             rowCount = resp.rowCount;
         }
         if (!resp.error && !parsedSuccessfully) {
@@ -352,7 +358,7 @@ export const fetchResultsByQuery = async (query, client, processing, customField
     }
     return { rows, columns, rowCount, error, itemQuery };
 };
-export const fetchResultsByReport = async (reportId, client, processing, filters, customFields, rowsOnly, rowCountOnly, abortSignal) => {
+export const fetchResultsByReport = async (reportId, client, tenants, processing, filters, customFields, rowsOnly, rowCountOnly, abortSignal) => {
     const updatedProcessing = { ...processing };
     let rows = [];
     let columns = [];
@@ -378,7 +384,6 @@ export const fetchResultsByReport = async (reportId, client, processing, filters
         const hostedBody = {
             metadata: {
                 dashboardItemId: reportId,
-                orgId: client?.organizationId || '*',
                 task: 'item',
                 filters: minimalFilters,
                 clientId: client?.publicKey,
@@ -389,6 +394,7 @@ export const fetchResultsByReport = async (reportId, client, processing, filters
                 useNewNodeSql: true,
                 rowsOnly,
                 rowCountOnly,
+                tenants,
             },
         };
         const cloudBody = {
@@ -401,7 +407,7 @@ export const fetchResultsByReport = async (reportId, client, processing, filters
             throw new Error(resp.errorMessage);
         }
         processFilterErrorList(resp);
-        if (resp.rowCount) {
+        if (resp.rowCount !== undefined) {
             rowCount = resp.rowCount;
         }
         const gatheredRows = resp.rows && resp.rows.length ? resp.rows : [];
@@ -425,7 +431,7 @@ export const fetchResultsByReport = async (reportId, client, processing, filters
     }
     return { rows, columns, rowCount, error };
 };
-export const fetchTableByAST = async (ast, client, processing, customFields, rowsOnly, rowCountOnly) => {
+export const fetchTableByAST = async (ast, client, tenants, processing, customFields, rowsOnly, rowCountOnly, dashboardName) => {
     let rows = [];
     let columns = [];
     let rowCount;
@@ -437,7 +443,6 @@ export const fetchTableByAST = async (ast, client, processing, customFields, row
                 clientId: client.publicKey,
                 ast,
                 publicKey: client.publicKey,
-                orgId: client.organizationId || '*',
                 task: 'patterns',
                 getCustomFields: false,
                 customFields,
@@ -446,6 +451,8 @@ export const fetchTableByAST = async (ast, client, processing, customFields, row
                 useNewNodeSql: true,
                 rowsOnly,
                 rowCountOnly,
+                dashboardName: dashboardName && tenants ? dashboardName : undefined,
+                tenants: dashboardName && tenants ? tenants : undefined,
             },
         };
         const cloudBody = {};
@@ -454,7 +461,7 @@ export const fetchTableByAST = async (ast, client, processing, customFields, row
             throw new Error(resp.errorMessage);
         }
         processFilterErrorList(resp);
-        if (resp.rowCount) {
+        if (resp.rowCount !== undefined) {
             rowCount = resp.rowCount;
         }
         const gatheredRows = resp.rows && resp.rows.length ? resp.rows : [];

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

@@ -0,0 +1,11 @@
+import { QuillDatabaseTenant, QuillProviderClient } from '../models/Client';
+export type TenantValue = {
+    label: string;
+    value: string | number;
+};
+export type Tenant = {
+    name: string;
+    tenantField: string;
+};
+export declare const asSingleDatabaseTenant: (client: QuillProviderClient | undefined) => QuillDatabaseTenant | undefined;
+//# sourceMappingURL=tenants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tenants.d.ts","sourceRoot":"","sources":["../../../src/utils/tenants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAE5E,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,sBAAsB,WACzB,mBAAmB,GAAG,SAAS,KACtC,mBAAmB,GAAG,SASxB,CAAC"}

package/dist/esm/utils/tenants.js

@@ -0,0 +1,9 @@
+export const asSingleDatabaseTenant = (client) => {
+    if (client?.allTenantTypes?.length &&
+        client.allTenantTypes?.[0]?.scope === 'database') {
+        return client.allTenantTypes?.[0];
+    }
+    else {
+        return undefined;
+    }
+};

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

@@ -1,5 +1,6 @@
 export declare function capitalize(text: string): string;
 export declare function depluralize(text: string): string;
+export declare function matchCasing(text: string, template: string): string;
 export declare function snakeCaseToTitleCase(str: string): string;
 export declare function snakeAndCamelCaseToTitleCase(str: string): string;
 export declare function removeDoubleQuotes(str: string): string;

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

@@ -1 +1 @@
-{"version":3,"file":"textProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/textProcessing.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQhD;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,UAa/C;AAED,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,MAAM,UAiBvD;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,UAK7C"}
+{"version":3,"file":"textProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/textProcessing.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQhD;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAyDlE;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,UAa/C;AAED,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,MAAM,UAiBvD;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,UAK7C"}

package/dist/esm/utils/textProcessing.js

@@ -10,6 +10,54 @@ export function depluralize(text) {
     }
     return text;
 }
+export function matchCasing(text, template) {
+    // Detect TitleCase
+    const isTitleCase = (str) => /^[A-Z][a-z]*([A-Z][a-z]*)*$/.test(str);
+    // Detect camelCase
+    const isCamelCase = (str) => /^[a-z]+([A-Z][a-z]*)*$/.test(str);
+    // Detect snake_case
+    const isSnakeCase = (str) => /^[a-z0-9]+(_[a-z0-9]+)*$/.test(str);
+    // Detect all lowercase
+    const isAllLowerCase = (str) => /^[a-z]+$/.test(str);
+    // Detect all uppercase
+    const isAllUpperCase = (str) => /^[A-Z]+$/.test(str);
+    // Detect capitalized (first letter uppercase, rest lowercase)
+    const isCapitalized = (str) => /^[A-Z][a-z]*$/.test(str);
+    // Function to convert to TitleCase
+    const toTitleCase = (str) => str.toLowerCase().replace(/\b\w/g, (char) => char.toUpperCase());
+    // Function to convert to camelCase
+    const toCamelCase = (str) => str.replace(/_./g, (match) => match.charAt(1).toUpperCase()).toLowerCase();
+    // Function to convert to snake_case
+    const toSnakeCase = (str) => str.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`);
+    // Function to convert to all lowercase
+    const toLowerCase = (str) => str.toLowerCase();
+    // Function to convert to all uppercase
+    const toUpperCase = (str) => str.toUpperCase();
+    // Function to convert to capitalized (first letter uppercase, rest lowercase)
+    const toCapitalized = (str) => str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+    // Match casing of the template and apply to the text
+    if (isTitleCase(template)) {
+        return toTitleCase(text);
+    }
+    else if (isCamelCase(template)) {
+        return toCamelCase(text);
+    }
+    else if (isSnakeCase(template)) {
+        return toSnakeCase(text);
+    }
+    else if (isAllLowerCase(template)) {
+        return toLowerCase(text);
+    }
+    else if (isAllUpperCase(template)) {
+        return toUpperCase(text);
+    }
+    else if (isCapitalized(template)) {
+        return toCapitalized(text);
+    }
+    else {
+        return text; // Default case if no specific pattern is detected
+    }
+}
 export function snakeCaseToTitleCase(str) {
     if (!str) {
         return str;

package/dist/esm/utils/validation.js

@@ -19,7 +19,7 @@ export const validateReport = (formData, dashboardData, defaultDateFilter, allTa
             issues.push(`Delete the "${filter.label}" filter on "${formData.dashboardName}" or add to another dashboard.`);
         }
     });
-    if (formData.pivot && !isValidPivot(formData.pivot)) {
+    if (formData.pivot && !isValidPivot(formData.pivot).valid) {
         issues.push(`Pivot is invalid.`);
     }
     return issues;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillsql/react",
-  "version": "2.13.26",
+  "version": "2.13.28",
   "exports": {
     ".": {
       "import": "./dist/esm/index.js",