adminforth 1.2.98 → 1.2.100

package/dataConnectors/sqlite.ts

@@ -47,6 +47,9 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
           } else if (baseType == 'boolean') {
             field.type = AdminForthDataTypes.BOOLEAN;
             field._underlineType = 'boolean';
+          } else if (baseType == 'datetime') {
+            field.type = AdminForthDataTypes.DATETIME;
+            field._underlineType = 'datetime';
           } else {
             field.type = 'unknown'
           }
@@ -68,6 +71,8 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
           return dayjs.unix(+value).toISOString();
         } else if (field._underlineType == 'varchar') {
           return dayjs(value).toISOString();
+        } else if (field._underlineType == 'datetime') {
+          return dayjs(value).toISOString();
         } else {
           throw new Error(`AdminForth does not support row type: ${field._underlineType} for timestamps, use VARCHAR (with iso strings) or TIMESTAMP/INT (with unix timestamps). Issue in field "${field.name}"`);
         }
@@ -102,6 +107,8 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
         } else if (field._underlineType == 'varchar') {
           // value is iso string now, convert to unix timestamp
           return dayjs(value).toISOString();
+        } else {
+          return value;
         }
       } else if (field.type == AdminForthDataTypes.BOOLEAN) {
         return value ? 1 : 0;
@@ -135,12 +142,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 +157,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 +191,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 +240,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/auth.js

@@ -80,13 +80,13 @@ class AdminForthAuth {
                 console.error(`Invalid token type during verification: ${t}, must be ${mustHaveType}`);
                 return null;
             }
-            if (pk === null) {
-                decoded.isRoot = true;
-            }
-            else {
-                const dbUser = yield this.adminforth.getUserByPk(pk);
-                decoded.dbUser = dbUser;
+            const dbUser = yield this.adminforth.getUserByPk(pk);
+            if (!dbUser) {
+                console.error(`User with pk ${pk} not found in database`);
+                // will logout user which was deleted
+                return null;
             }
+            decoded.dbUser = dbUser;
             return decoded;
         });
     }

package/dist/dataConnectors/baseConnector.js

@@ -8,6 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { AdminForthFilterOperators } from "../types/AdminForthConfig.js";
+import { suggestIfTypo } from "../modules/utils.js";
 export default class AdminForthBaseConnector {
     getPrimaryKey(resource) {
         for (const col of resource.dataSourceColumns) {
@@ -24,12 +25,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) {
@@ -47,14 +50,57 @@ export default class AdminForthBaseConnector {
     createRecordOriginalValues({ resource, record }) {
         throw new Error('Method not implemented.');
     }
-    createRecord({ resource, record }) {
-        // transform value using setFieldValue and call createRecordOriginalValues
-        const newRecord = Object.assign({}, record);
-        for (const col of resource.dataSourceColumns) {
-            newRecord[col.name] = this.setFieldValue(col, record[col.name]);
-        }
-        process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record', newRecord);
-        return this.createRecordOriginalValues({ resource, record: newRecord });
+    checkUnique(resource, column, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            process.env.HEAVY_DEBUG && console.log('☝️🪲🪲🪲🪲 checkUnique|||', column, value);
+            const existingRecord = yield this.getData({
+                resource,
+                filters: [{ field: column.name, operator: AdminForthFilterOperators.EQ, value }],
+                limit: 1,
+                sort: [],
+                offset: 0,
+                getTotals: false
+            });
+            process.env.HEAVY_DEBUG && console.log('☝️🪲🪲🪲🪲 existingRecord|||', existingRecord);
+            return existingRecord.data.length > 0;
+        });
+    }
+    createRecord(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, record, adminUser }) {
+            // transform value using setFieldValue and call createRecordOriginalValues
+            const filledRecord = Object.assign({}, record);
+            const recordWithOriginalValues = Object.assign({}, record);
+            for (const col of resource.dataSourceColumns) {
+                if (col.fillOnCreate) {
+                    if (filledRecord[col.name] === undefined) {
+                        filledRecord[col.name] = col.fillOnCreate({
+                            initialRecord: record,
+                            adminUser
+                        });
+                    }
+                }
+                recordWithOriginalValues[col.name] = this.setFieldValue(col, filledRecord[col.name]);
+            }
+            let error = null;
+            yield Promise.all(resource.dataSourceColumns.map((col) => __awaiter(this, void 0, void 0, function* () {
+                if (col.isUnique && !col.virtual && !error) {
+                    const exists = yield this.checkUnique(resource, col, recordWithOriginalValues[col.name]);
+                    if (exists) {
+                        error = `Record with ${col.name} ${recordWithOriginalValues[col.name]} already exists`;
+                    }
+                }
+            })));
+            process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 error', error);
+            if (error) {
+                return { error, ok: false };
+            }
+            process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record', recordWithOriginalValues);
+            yield this.createRecordOriginalValues({ resource, record: recordWithOriginalValues });
+            return {
+                ok: true,
+                createdRecord: recordWithOriginalValues,
+            };
+        });
     }
     updateRecord({ resource, recordId, newValues }) {
         throw new Error('Method not implemented.');
@@ -63,25 +109,37 @@ 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) => {
+                    const fieldObj = resource.dataSourceColumns.find((col) => col.name == f.field);
+                    if (!fieldObj) {
+                        const similar = suggestIfTypo(resource.dataSourceColumns.map((col) => col.name), f.field);
+                        throw new Error(`Field '${f.field}' not found in resource '${resource.resourceId}'. ${similar ? `Did you mean '${similar}'?` : ''}`);
+                    }
                     if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                        f.value = f.value.map((val) => this.setFieldValue(resource.dataSourceColumns.find((col) => col.name == f.field), val));
+                        f.value = f.value.map((val) => this.setFieldValue(fieldObj, val));
                     }
                     else {
-                        f.value = this.setFieldValue(resource.dataSourceColumns.find((col) => col.name == f.field), f.value);
+                        f.value = this.setFieldValue(fieldObj, f.value);
                     }
                 });
             }
-            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) {

package/dist/dataConnectors/clickhouse.js

@@ -184,36 +184,44 @@ class ClickhouseConnector extends AdminForthBaseConnector {
         }
         return value;
     }
+    whereClause(resource, filters) {
+        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;
+            let operator = this.OperatorsMap[f.operator];
+            if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                placeholder = `(${f.value.map((_, j) => `{p${i}_${j}:${column._underlineType}}`).join(', ')})`;
+            }
+            return `${field} ${operator} ${placeholder}`;
+        }).join(' AND ')}` : '';
+    }
+    whereParams(filters) {
+        const params = {};
+        filters.length ? filters.forEach((f, i) => {
+            // for arrays do set in map
+            const v = f.value;
+            if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
+                params[`f${i}`] = `%${v}%`;
+            }
+            else if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                v.forEach((_, j) => {
+                    params[`p${i}_${j}`] = v[j];
+                });
+            }
+            else {
+                params[`f${i}`] = v;
+            }
+        }) : [];
+        return params;
+    }
     getDataWithOriginalTypes(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters, getTotals }) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
+            console.log('getDataWithOriginalTypes', resource, limit, offset, sort, filters);
             const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
             const tableName = resource.table;
-            const where = 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;
-                let operator = this.OperatorsMap[f.operator];
-                if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                    placeholder = `(${f.value.map((_, j) => `{p${i}_${j}:${column._underlineType}}`).join(', ')})`;
-                }
-                return `${field} ${operator} ${placeholder}`;
-            }).join(' AND ')}` : '';
-            const params = {};
-            filters.length ? filters.forEach((f, i) => {
-                // for arrays do set in map
-                const v = f.value;
-                if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
-                    params[`f${i}`] = `%${v}%`;
-                }
-                else if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                    v.forEach((_, j) => {
-                        params[`p${i}_${j}`] = v[j];
-                    });
-                }
-                else {
-                    params[`f${i}`] = v;
-                }
-            }) : [];
+            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(', ')}` : '';
             const q = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT {limit:Int} OFFSET {offset:Int}`;
             const d = Object.assign(Object.assign({}, params), { limit,
@@ -224,26 +232,27 @@ class ClickhouseConnector extends AdminForthBaseConnector {
                 query_params: d,
             });
             const rows = yield stmt.json();
-            let total = 0;
-            if (getTotals) {
-                const countQ = yield this.client.query({
-                    query: `SELECT COUNT(*) FROM ${tableName} ${where}`,
-                    format: 'JSONEachRow',
-                    query_params: d,
-                });
-                const countResp = yield countQ.json();
-                total = countResp[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;
+            });
+        });
+    }
+    getCount(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, filters, }) {
+            const tableName = resource.table;
+            const where = this.whereClause(resource, filters);
+            const d = this.whereParams(filters);
+            const countQ = yield this.client.query({
+                query: `SELECT COUNT(*) FROM ${tableName} ${where}`,
+                format: 'JSONEachRow',
+                query_params: d,
+            });
+            const countResp = yield countQ.json();
+            return countResp[0]['COUNT()'];
         });
     }
     getMinMaxForColumnsWithOriginalTypes(_a) {
@@ -291,10 +300,12 @@ class ClickhouseConnector extends AdminForthBaseConnector {
     deleteRecord(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, recordId }) {
             const pkColumn = resource.dataSourceColumns.find((col) => col.primaryKey);
-            yield this.client.command({
+            const res = yield 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/dist/dataConnectors/mongo.js

@@ -108,25 +108,40 @@ class MongoConnector extends AdminForthBaseConnector {
         }
         return value;
     }
-    getDataWithOriginalTypes(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ 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);
+    genQuery(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ filters }) {
             const query = {};
             for (const filter of filters) {
                 query[filter.field] = this.OperatorsMap[filter.operator](filter.value);
             }
-            let total = 0;
-            if (getTotals) {
-                total = yield collection.countDocuments(query);
-            }
+            return query;
+        });
+    }
+    getDataWithOriginalTypes(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
+            // 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 = yield this.genQuery({ filters });
+            const sortArray = sort.map((s) => {
+                return [s.field, this.SortDirectionsMap[s.direction]];
+            });
             const result = yield collection.find(query)
-                .sort(sort)
+                .sort(sortArray)
                 .skip(offset)
                 .limit(limit)
                 .toArray();
-            return { data: result, total };
+            return result;
+        });
+    }
+    getCount(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, 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);
+            }
+            return yield collection.countDocuments(query);
         });
     }
     getMinMaxForColumnsWithOriginalTypes(_a) {
@@ -166,7 +181,8 @@ class MongoConnector extends AdminForthBaseConnector {
         return __awaiter(this, arguments, void 0, function* ({ resource, recordId }) {
             const primaryKey = this.getPrimaryKey(resource);
             const collection = this.db.db().collection(resource.table);
-            yield collection.deleteOne({ [primaryKey]: recordId });
+            const res = yield collection.deleteOne({ [primaryKey]: recordId });
+            return res.deletedCount > 0;
         });
     }
     close() {

package/dist/dataConnectors/postgres.js

@@ -184,46 +184,54 @@ class PostgresConnector extends AdminForthBaseConnector {
         }
         return value;
     }
+    whereClauseAndValues(resource, filters) {
+        let totalCounter = 1;
+        const where = filters.length ? `WHERE ${filters.map((f, i) => {
+            let placeholder = '$' + (totalCounter);
+            const fieldData = resource.dataSourceColumns.find((col) => col.name == f.field);
+            let field = f.field;
+            let operator = this.OperatorsMap[f.operator];
+            if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                placeholder = `(${f.value.map((_, i) => `$${totalCounter + i}`).join(', ')})`;
+                totalCounter += f.value.length;
+            }
+            else {
+                totalCounter += 1;
+            }
+            if (fieldData._underlineType == 'uuid') {
+                field = `cast("${field}" as text)`;
+            }
+            else {
+                field = `"${field}"`;
+            }
+            return `${field} ${operator} ${placeholder}`;
+        }).join(' AND ')}` : '';
+        const filterValues = [];
+        filters.length ? filters.forEach((f) => {
+            // for arrays do set in map
+            let v = f.value;
+            if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
+                filterValues.push(`%${v}%`);
+            }
+            else if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                filterValues.push(...v);
+            }
+            else {
+                filterValues.push(v);
+            }
+        }) : [];
+        return {
+            sql: where,
+            paramsCount: totalCounter,
+            values: filterValues,
+        };
+    }
     getDataWithOriginalTypes(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters, getTotals }) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
             const columns = resource.dataSourceColumns.map((col) => `"${col.name}"`).join(', ');
             const tableName = resource.table;
-            let totalCounter = 1;
-            const where = filters.length ? `WHERE ${filters.map((f, i) => {
-                let placeholder = '$' + (totalCounter);
-                const fieldData = resource.dataSourceColumns.find((col) => col.name == f.field);
-                let field = f.field;
-                let operator = this.OperatorsMap[f.operator];
-                if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                    placeholder = `(${f.value.map((_, i) => `$${totalCounter + i}`).join(', ')})`;
-                    totalCounter += f.value.length;
-                }
-                else {
-                    totalCounter += 1;
-                }
-                if (fieldData._underlineType == 'uuid') {
-                    field = `cast("${field}" as text)`;
-                }
-                else {
-                    field = `"${field}"`;
-                }
-                return `${field} ${operator} ${placeholder}`;
-            }).join(' AND ')}` : '';
-            const filterValues = [];
-            filters.length ? filters.forEach((f) => {
-                // for arrays do set in map
-                let v = f.value;
-                if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
-                    filterValues.push(`%${v}%`);
-                }
-                else if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                    filterValues.push(...v);
-                }
-                else {
-                    filterValues.push(v);
-                }
-            }) : [];
-            const limitOffset = `LIMIT $${totalCounter} OFFSET $${totalCounter + 1}`;
+            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}`;
@@ -232,20 +240,21 @@ class PostgresConnector extends AdminForthBaseConnector {
             }
             const stmt = yield this.db.query(selectQuery, d);
             const rows = stmt.rows;
-            let total = 0;
-            if (getTotals) {
-                total = (yield 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;
+            });
+        });
+    }
+    getCount(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, filters }) {
+            const tableName = resource.table;
+            const { sql: where, values: filterValues } = this.whereClauseAndValues(resource, filters);
+            const stmt = yield this.db.query(`SELECT COUNT(*) FROM ${tableName} ${where}`, filterValues);
+            return stmt.rows[0].count;
         });
     }
     getMinMaxForColumnsWithOriginalTypes(_a) {
@@ -283,7 +292,8 @@ class PostgresConnector extends AdminForthBaseConnector {
     }
     deleteRecord(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, recordId }) {
-            yield this.db.query(`DELETE FROM ${resource.table} WHERE "${this.getPrimaryKey(resource)}" = $1`, [recordId]);
+            const res = yield this.db.query(`DELETE FROM ${resource.table} WHERE "${this.getPrimaryKey(resource)}" = $1`, [recordId]);
+            return res.rowCount > 0;
         });
     }
     close() {