adminforth 1.2.95 → 1.2.97

package/dataConnectors/baseConnector.ts

@@ -1,4 +1,5 @@
-import { AdminForthResource, IAdminForthDataSourceConnectorBase, AdminForthSortDirections, AdminForthFilterOperators, AdminForthResourceColumn } from "../types/AdminForthConfig.js";
+import { get } from "http";
+import { AdminForthResource, IAdminForthDataSourceConnectorBase, AdminForthSortDirections, AdminForthFilterOperators, AdminForthResourceColumn, IAdminForthSort, IAdminForthFilter } from "../types/AdminForthConfig.js";
 
 
 export default class AdminForthBaseConnector implements IAdminForthDataSourceConnectorBase {
@@ -17,19 +18,21 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
       offset: 0,
       sort: [], 
       filters: [{ field: this.getPrimaryKey(resource), operator: AdminForthFilterOperators.EQ, value: id }],
-      getTotals: false
     });
-    return data.data.length > 0 ? data.data[0] : null;
+    return data.length > 0 ? data[0] : null;
   }
 
-  getDataWithOriginalTypes({ resource, limit, offset, sort, filters, getTotals }: { 
+  getDataWithOriginalTypes({ resource, limit, offset, sort, filters }: { 
     resource: AdminForthResource, 
     limit: number, 
     offset: number, 
-    sort: { field: string, direction: AdminForthSortDirections }[], 
-    filters: { field: string, operator: AdminForthFilterOperators, value: any }[],
-    getTotals?: boolean
-  }): Promise<{ data: any[], total: number }> {
+    sort: IAdminForthSort[], 
+    filters: IAdminForthFilter[],
+  }): Promise<any[]> {
+    throw new Error('Method not implemented.');
+  }
+
+  getCount({ resource, filters }: { resource: AdminForthResource; filters: { field: string; operator: AdminForthFilterOperators; value: any; }[]; }): Promise<number> {
     throw new Error('Method not implemented.');
   }
 
@@ -67,17 +70,18 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
     throw new Error('Method not implemented.');
   }
 
-  deleteRecord({ resource, recordId }: { resource: AdminForthResource; recordId: string; }): Promise<void> {
+  deleteRecord({ resource, recordId }: { resource: AdminForthResource; recordId: string; }): Promise<boolean> {
     throw new Error('Method not implemented.');
   }
 
 
-  async getData({ resource, limit, offset, sort, filters }: { 
+  async getData({ resource, limit, offset, sort, filters, getTotals }: { 
     resource: AdminForthResource, 
     limit: number, 
     offset: number, 
     sort: { field: string, direction: AdminForthSortDirections }[], 
-    filters: { field: string, operator: AdminForthFilterOperators, value: any }[]
+    filters: { field: string, operator: AdminForthFilterOperators, value: any }[],
+    getTotals: boolean,
   }): Promise<{ data: any[], total: number }> {
     if (filters) {
       filters.map((f) => {
@@ -89,15 +93,23 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
       });
     }
 
-    const d = await this.getDataWithOriginalTypes({ resource, limit, offset, sort, filters, getTotals: true });
+    const promises: Promise<any>[] = [this.getDataWithOriginalTypes({ resource, limit, offset, sort, filters })];
+    if (getTotals) {
+      promises.push(this.getCount({ resource, filters }));
+    } else {
+      promises.push(Promise.resolve(undefined));
+    }
+
+    const [data, total] = await Promise.all(promises);
+
     // call getFieldValue for each field
-    d.data.map((record) => {
+    data.map((record) => {
       for (const col of resource.dataSourceColumns) {
         record[col.name] = this.getFieldValue(col, record[col.name]);
       }
     });
 
-    return d;
+    return { data, total };
   }
 
   async getMinMaxForColumns({ resource, columns }: { resource: AdminForthResource; columns: AdminForthResourceColumn[]; }): Promise<{ [key: string]: { min: any; max: any; }; }> {

package/dataConnectors/clickhouse.ts

@@ -172,19 +172,11 @@ class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForth
       [AdminForthSortDirections.desc]: 'DESC',
     };
     
-
-    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters, getTotals }: { 
-        resource: AdminForthResource, 
-        limit: number, 
-        offset: number, 
-        sort: { field: string, direction: AdminForthSortDirections }[], 
-        filters: { field: string, operator: AdminForthFilterOperators, value: any }[],
-        getTotals?: boolean, 
-    }): Promise<{ data: any[], total: number }> {
-      const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
-      const tableName = resource.table;
-
-      const where = filters.length ? `WHERE ${filters.map((f, i) => {
+    whereClause(
+        resource: AdminForthResource,
+        filters: { field: string, operator: AdminForthFilterOperators, value: any }[]
+    ): string {
+      return  filters.length ? `WHERE ${filters.map((f, i) => {
         const column = resource.dataSourceColumns.find((col) => col.name == f.field);
         let placeholder = `{f${i}:${column._underlineType}}`;
         let field = f.field;
@@ -197,9 +189,12 @@ class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForth
 
         return `${field} ${operator} ${placeholder}`
       }).join(' AND ')}` : '';
+    }
 
+    whereParams(
+        filters: { field: string, operator: AdminForthFilterOperators, value: any }[]
+    ): any {
       const params = {};
-      
       filters.length ? filters.forEach((f, i) => {
         // for arrays do set in map
         const v = f.value;
@@ -215,6 +210,23 @@ class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForth
         }
       }) : [];
 
+      return params;
+    }
+
+    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters }: { 
+        resource: AdminForthResource, 
+        limit: number, 
+        offset: number, 
+        sort: { field: string, direction: AdminForthSortDirections }[], 
+        filters: { field: string, operator: AdminForthFilterOperators, value: any }[],
+    }): Promise<any[]> {
+      const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
+      const tableName = resource.table;
+
+      const where = this.whereClause(resource, filters);
+
+      const params = this.whereParams(filters);
+
       const orderBy = sort.length ? `ORDER BY ${sort.map((s) => `${s.field} ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
       
 
@@ -233,27 +245,33 @@ class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForth
 
       const rows = await stmt.json();
 
-      let total = 0;
-      if (getTotals) {
-        const countQ = await this.client.query({
-          query: `SELECT COUNT(*) FROM ${tableName} ${where}`,
-          format: 'JSONEachRow',
-          query_params: d,
-        });
-        const countResp = await countQ.json()
-        total = countResp[0]['COUNT()'];
-      }
+      return rows.map((row) => {
+        const newRow = {};
+        for (const [key, value] of Object.entries(row)) {
+          newRow[key] = value;
+        }
+        return newRow;
+      });
+    }
 
-      return {
-        data: rows.map((row) => {
-          const newRow = {};
-          for (const [key, value] of Object.entries(row)) {
-            newRow[key] = value;
-          }
-          return newRow;
-        }),
-        total,
-      };
+    async getCount({
+      resource,
+      filters,
+    }: {
+      resource: AdminForthResource;
+      filters: { field: string, operator: AdminForthFilterOperators, value: any }[];
+    }): Promise<number> {
+      const tableName = resource.table;
+      const where = this.whereClause(resource, filters);
+      const d = this.whereParams(filters);
+      
+      const countQ = await this.client.query({
+        query: `SELECT COUNT(*) FROM ${tableName} ${where}`,
+        format: 'JSONEachRow',
+        query_params: d,
+      });
+      const countResp = await countQ.json()
+      return countResp[0]['COUNT()'];
     }
 
     async getMinMaxForColumnsWithOriginalTypes({ resource, columns }: { resource: AdminForthResource, columns: AdminForthResourceColumn[] }): Promise<{ [key: string]: { min: any, max: any } }> {
@@ -298,16 +316,18 @@ class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForth
       );
     }
 
-    async deleteRecord({ resource, recordId }: { resource: AdminForthResource, recordId: any }) {
+    async deleteRecord({ resource, recordId }: { resource: AdminForthResource, recordId: any }): Promise<boolean> {
       const pkColumn = resource.dataSourceColumns.find((col) => col.primaryKey);
-      await this.client.command(
+      const res = await this.client.command(
         { 
           query: `ALTER TABLE ${this.dbName}.${resource.table} DELETE WHERE ${
             pkColumn.name
           } = {recordId:${pkColumn._underlineType}}`, 
           query_params: { recordId },
-      }
+        }
       );
+      // todo test what is in res
+      return res;
     }
 
     close() {

package/dataConnectors/mongo.ts

@@ -1,6 +1,7 @@
 import dayjs from 'dayjs';
 import { MongoClient } from 'mongodb';
-import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections, IAdminForthDataSourceConnector } from '../types/AdminForthConfig.js';
+import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections, 
+    IAdminForthDataSourceConnector, AdminForthResource } from '../types/AdminForthConfig.js';
 import AdminForthBaseConnector from './baseConnector.js';
 
 class MongoConnector extends AdminForthBaseConnector implements IAdminForthDataSourceConnector {
@@ -104,28 +105,57 @@ class MongoConnector extends AdminForthBaseConnector implements IAdminForthDataS
           return value ? 1 : 0;
         }
         return value;
-      }
-    
-    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters, getTotals }) {
-        // const columns = resource.dataSourceColumns.filter(c=> !c.virtual).map((col) => col.name).join(', ');
-        const tableName = resource.table;
+    }
 
-        const collection = this.db.db().collection(tableName);
+    async genQuery({ resource, limit, offset, sort, filters }) {
+        const collection = this.db.db().collection(resource.table);
         const query = {};
         for (const filter of filters) {
             query[filter.field] = this.OperatorsMap[filter.operator](filter.value);
         }
-        let total = 0;
-        if (getTotals) {
-            total = await collection.countDocuments(query);
+        return { collection, query };
+    }
+    
+    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters }:
+        { 
+            resource: AdminForthResource, 
+            limit: number, 
+            offset: number, 
+            sort: { field: string, direction: AdminForthSortDirections }[], 
+            filters: { field: string, operator: AdminForthFilterOperators, value: any }[] 
         }
+    ): Promise<any[]> {
+
+        // const columns = resource.dataSourceColumns.filter(c=> !c.virtual).map((col) => col.name).join(', ');
+        const tableName = resource.table;
+
+        const collection = this.db.db().collection(tableName);
+        const query = this.genQuery({ resource, limit, offset, sort, filters });
+
+        const sortArray: any[] = sort.map((s) => {
+            return [s.field, this.SortDirectionsMap[s.direction]];
+        });
+
         const result = await collection.find(query)
-            .sort(sort)
+            .sort(sortArray)
             .skip(offset)
             .limit(limit)
             .toArray();
 
-        return { data: result, total }
+        return result
+    }
+
+    async getCount({ resource, filters }: { 
+            resource: AdminForthResource, 
+            filters: { field: string, operator: AdminForthFilterOperators, value: any }[] 
+    }): Promise<number> {
+
+        const collection = this.db.db().collection(resource.table);
+        const query = {};
+        for (const filter of filters) {
+            query[filter.field] = this.OperatorsMap[filter.operator](filter.value);
+        }
+        return await collection.countDocuments(query);
     }
 
     async getMinMaxForColumnsWithOriginalTypes({ resource, columns }) {
@@ -158,10 +188,11 @@ class MongoConnector extends AdminForthBaseConnector implements IAdminForthDataS
         await collection.updateOne({ [this.getPrimaryKey(resource)]: recordId }, { $set: newValues });
     }
 
-    async deleteRecord({ resource, recordId }) {
+    async deleteRecord({ resource, recordId }): Promise<boolean> {
         const primaryKey = this.getPrimaryKey(resource);
         const collection = this.db.db().collection(resource.table);
-        await collection.deleteOne({ [primaryKey]: recordId });
+        const res = await collection.deleteOne({ [primaryKey]: recordId });
+        return res.deletedCount > 0;
     }
 
     async close() {

package/dataConnectors/postgres.ts

@@ -1,6 +1,6 @@
 import dayjs from 'dayjs';
 import pkg from 'pg';
-import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections, IAdminForthDataSourceConnector } from '../types/AdminForthConfig.js';
+import { AdminForthDataTypes, AdminForthResource, AdminForthFilterOperators, AdminForthSortDirections, IAdminForthDataSourceConnector } from '../types/AdminForthConfig.js';
 import AdminForthBaseConnector from './baseConnector.js';
 const { Client } = pkg;
 
@@ -168,24 +168,26 @@ class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDa
 
 
     setFieldValue(field, value) {
-        if (field.type == AdminForthDataTypes.DATETIME) {
-          if (!value) {
-            return null;
-          }
-          if (field._underlineType == 'timestamp' || field._underlineType == 'int') {
-            return dayjs(value);
-          } else if (field._underlineType == 'varchar') {
-            return dayjs(value).toISOString();
-          }
-        } else if (field.type == AdminForthDataTypes.BOOLEAN) {
-          return value ? 1 : 0;
+      if (field.type == AdminForthDataTypes.DATETIME) {
+        if (!value) {
+          return null;
         }
-        return value;
+        if (field._underlineType == 'timestamp' || field._underlineType == 'int') {
+          return dayjs(value);
+        } else if (field._underlineType == 'varchar') {
+          return dayjs(value).toISOString();
+        }
+      } else if (field.type == AdminForthDataTypes.BOOLEAN) {
+        return value ? 1 : 0;
       }
-    
-    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters, getTotals }) {
-      const columns = resource.dataSourceColumns.map((col) => `"${col.name}"`).join(', ');
-      const tableName = resource.table;
+      return value;
+    }
+
+    whereClauseAndValues(resource: AdminForthResource, filters: { field: string, operator: AdminForthFilterOperators, value: any }[]) : {
+      sql: string,
+      paramsCount: number,
+      values: any[],
+    } {
       
       let totalCounter = 1;
       const where = filters.length ? `WHERE ${filters.map((f, i) => {
@@ -201,9 +203,9 @@ class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDa
         }
 
         if (fieldData._underlineType == 'uuid') {
-            field = `cast("${field}" as text)`
+          field = `cast("${field}" as text)`
         } else { 
-            field = `"${field}"`
+          field = `"${field}"`
         }
         return `${field} ${operator} ${placeholder}`;
       }).join(' AND ')}` : '';
@@ -221,8 +223,22 @@ class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDa
           filterValues.push(v);
         }
       }) : [];
+      return {
+        sql: where,
+        paramsCount: totalCounter,
+        values: filterValues,
+      };
+
+    }
 
-      const limitOffset = `LIMIT $${totalCounter} OFFSET $${totalCounter + 1}`; 
+    
+    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters }): Promise<any[]> {
+      const columns = resource.dataSourceColumns.map((col) => `"${col.name}"`).join(', ');
+      const tableName = resource.table;
+      
+      const { sql: where, paramsCount, values: filterValues } = this.whereClauseAndValues(resource, filters);
+
+      const limitOffset = `LIMIT $${paramsCount} OFFSET $${paramsCount + 1}`; 
       const d = [...filterValues, limit, offset];
       const orderBy = sort.length ? `ORDER BY ${sort.map((s) => `"${s.field}" ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
       const selectQuery = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} ${limitOffset}`;
@@ -231,20 +247,20 @@ class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDa
       }
       const stmt = await this.db.query(selectQuery, d);
       const rows = stmt.rows;
-      let total = 0;
-      if (getTotals) {
-        total = (await this.db.query(`SELECT COUNT(*) FROM ${tableName} ${where}`, filterValues)).rows[0].count;
-      }
-      return {
-        data: rows.map((row) => {
-          const newRow = {};
-          for (const [key, value] of Object.entries(row)) {
-              newRow[key] = value;
-          }
-          return newRow;
-        }),
-        total,
-      };
+      return rows.map((row) => {
+        const newRow = {};
+        for (const [key, value] of Object.entries(row)) {
+            newRow[key] = value;
+        }
+        return newRow;
+      });
+    }
+
+    async getCount({ resource, filters }: { resource: AdminForthResource; filters: { field: string, operator: AdminForthFilterOperators, value: any }[]; }): Promise<number> {
+        const tableName = resource.table;
+        const { sql: where, values: filterValues } = this.whereClauseAndValues(resource, filters);
+        const stmt = await this.db.query(`SELECT COUNT(*) FROM ${tableName} ${where}`, filterValues);
+        return stmt.rows[0].count;
     }
   
     async getMinMaxForColumnsWithOriginalTypes({ resource, columns }) {
@@ -277,8 +293,9 @@ class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDa
         await this.db.query(`UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE "${this.getPrimaryKey(resource)}" = $${values.length}`, values);
     }
 
-    async deleteRecord({ resource, recordId }) {
-        await this.db.query(`DELETE FROM ${resource.table} WHERE "${this.getPrimaryKey(resource)}" = $1`, [recordId]);
+    async deleteRecord({ resource, recordId }): Promise<boolean> {
+      const res = await this.db.query(`DELETE FROM ${resource.table} WHERE "${this.getPrimaryKey(resource)}" = $1`, [recordId]);
+      return res.rowCount > 0;
     }
 
     async close() {

package/dataConnectors/sqlite.ts

@@ -135,12 +135,8 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
       [AdminForthSortDirections.desc]: 'DESC',
     };
     
-
-    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters, getTotals }): Promise<{ data: any[], total: number }> {
-      const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
-      const tableName = resource.table;
-
-      const where = filters.length ? `WHERE ${filters.map((f, i) => {
+    whereClause(filters) {
+      return filters.length ? `WHERE ${filters.map((f, i) => {
         let placeholder = '?';
         let field = f.field;
         let operator = this.OperatorsMap[f.operator];
@@ -154,25 +150,31 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
 
         return `${field} ${operator} ${placeholder}`
       }).join(' AND ')}` : '';
-
-      const filterValues = [];
-      
-      filters.length ? filters.forEach((f) => {
-        // for arrays do set in map
-        const v = f.value;
-
+    }
+    whereParams(filters) {
+      return filters.reduce((acc, f) => {
         if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
-          filterValues.push(`%${v}%`);
+          acc.push(`%${f.value}%`);
         } else if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-          filterValues.push(...v);
+          acc.push(...f.value);
         } else {
-          filterValues.push(v);
+          acc.push(f.value);
         }
-      }) : [];
+        return acc;
+      }, []);
+    }
+
+    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters }): Promise<any[]> {
+      const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
+      const tableName = resource.table;
+
+      const where = this.whereClause(filters);
+
+      const filterValues = this.whereParams(filters);
 
       const orderBy = sort.length ? `ORDER BY ${sort.map((s) => `${s.field} ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
       
-
+      console.log('🪲 SQLITE Query', `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT ? OFFSET ?`, 'params:', [...filterValues, limit, offset]);
       const q = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT ? OFFSET ?`;
       const stmt = this.db.prepare(q);
       const d = [...filterValues, limit, offset];
@@ -182,22 +184,21 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
       }
       const rows = await stmt.all(d);
 
-      let total = 0;
-      if (getTotals) {
-        const totalStmt = this.db.prepare(`SELECT COUNT(*) FROM ${tableName} ${where}`);
-        total = totalStmt.get([...filterValues])['COUNT(*)'];
-      }
+      return rows.map((row) => {
+        const newRow = {};
+        for (const [key, value] of Object.entries(row)) {
+          newRow[key] = value;
+        }
+        return newRow;
+      })
+    }
 
-      return {
-        data: rows.map((row) => {
-          const newRow = {};
-          for (const [key, value] of Object.entries(row)) {
-            newRow[key] = value;
-          }
-          return newRow;
-        }),
-        total,
-      };
+    async getCount({ resource, filters }) {
+      const tableName = resource.table;
+      const where = this.whereClause(filters);
+      const filterValues = this.whereParams(filters);
+      const totalStmt = this.db.prepare(`SELECT COUNT(*) FROM ${tableName} ${where}`);
+      return totalStmt.get([...filterValues])['COUNT(*)'];
     }
 
     async getMinMaxForColumnsWithOriginalTypes({ resource, columns }: { resource: AdminForthResource, columns: AdminForthResourceColumn[] }): Promise<{ [key: string]: { min: any, max: any } }> {
@@ -232,9 +233,10 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
       await q.run(values);
     }
 
-    async deleteRecord({ resource, recordId }: { resource: AdminForthResource, recordId: any }) {
+    async deleteRecord({ resource, recordId }: { resource: AdminForthResource, recordId: any }): Promise<boolean> {
       const q = this.db.prepare(`DELETE FROM ${resource.table} WHERE ${this.getPrimaryKey(resource)} = ?`);
-      await q.run(recordId);
+      const res = await q.run(recordId);
+      return res.changes > 0;
     }
 
     close() {

package/dist/dataConnectors/baseConnector.js

@@ -24,12 +24,14 @@ export default class AdminForthBaseConnector {
                 offset: 0,
                 sort: [],
                 filters: [{ field: this.getPrimaryKey(resource), operator: AdminForthFilterOperators.EQ, value: id }],
-                getTotals: false
             });
-            return data.data.length > 0 ? data.data[0] : null;
+            return data.length > 0 ? data[0] : null;
         });
     }
-    getDataWithOriginalTypes({ resource, limit, offset, sort, filters, getTotals }) {
+    getDataWithOriginalTypes({ resource, limit, offset, sort, filters }) {
+        throw new Error('Method not implemented.');
+    }
+    getCount({ resource, filters }) {
         throw new Error('Method not implemented.');
     }
     discoverFields(resource) {
@@ -63,7 +65,7 @@ export default class AdminForthBaseConnector {
         throw new Error('Method not implemented.');
     }
     getData(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters, getTotals }) {
             if (filters) {
                 filters.map((f) => {
                     if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
@@ -74,14 +76,21 @@ export default class AdminForthBaseConnector {
                     }
                 });
             }
-            const d = yield this.getDataWithOriginalTypes({ resource, limit, offset, sort, filters, getTotals: true });
+            const promises = [this.getDataWithOriginalTypes({ resource, limit, offset, sort, filters })];
+            if (getTotals) {
+                promises.push(this.getCount({ resource, filters }));
+            }
+            else {
+                promises.push(Promise.resolve(undefined));
+            }
+            const [data, total] = yield Promise.all(promises);
             // call getFieldValue for each field
-            d.data.map((record) => {
+            data.map((record) => {
                 for (const col of resource.dataSourceColumns) {
                     record[col.name] = this.getFieldValue(col, record[col.name]);
                 }
             });
-            return d;
+            return { data, total };
         });
     }
     getMinMaxForColumns(_a) {