adminforth 1.1.73 → 1.1.74

package/dataConnectors/baseConnector.ts

@@ -0,0 +1,107 @@
+import { AdminForthResource, AdminForthDataSourceConnectorBase, AdminForthSortDirections, AdminForthFilterOperators, AdminForthResourceColumn } from "../types/AdminForthConfig.js";
+
+
+export default class AdminForthBaseConnector implements AdminForthDataSourceConnectorBase {
+  getPrimaryKey(resource: AdminForthResource): string {
+    for (const col of resource.dataSourceColumns) {
+        if (col.primaryKey) {
+            return col.name;
+        }
+    }
+  }
+
+  getRecordByPrimaryKeyWithOriginalTypes(resource: AdminForthResource, id: string): Promise<any> {
+    throw new Error('Method not implemented.');
+  }
+
+  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<{ data: any[], total: number }> {
+    throw new Error('Method not implemented.');
+  }
+
+  discoverFields(resource: AdminForthResource): Promise<{ [key: string]: AdminForthResourceColumn; }> {
+    throw new Error('Method not implemented.');
+  }
+
+  getFieldValue(field: AdminForthResourceColumn, value: any) {
+    throw new Error('Method not implemented.');
+  }
+
+  setFieldValue(field: AdminForthResourceColumn, value: any) {
+    throw new Error('Method not implemented.');
+  }
+
+  getMinMaxForColumnsWithOriginalTypes({ resource, columns }: { resource: AdminForthResource; columns: AdminForthResourceColumn[]; }): Promise<{ [key: string]: { min: any; max: any; }; }> {
+    throw new Error('Method not implemented.');
+  }
+
+  createRecord({ resource, record }: { resource: AdminForthResource; record: any; }): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+
+  updateRecord({ resource, recordId, newValues }: { resource: AdminForthResource; recordId: string; newValues: any; }): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+
+  deleteRecord({ resource, recordId }: { resource: AdminForthResource; recordId: string; }): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+
+
+  async getData({ resource, limit, offset, sort, filters }: { 
+    resource: AdminForthResource, 
+    limit: number, 
+    offset: number, 
+    sort: { field: string, direction: AdminForthSortDirections }[], 
+    filters: { field: string, operator: AdminForthFilterOperators, value: any }[] 
+  }): Promise<{ data: any[], total: number }> {
+    if (filters) {
+      filters.map((f) => {
+        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));
+        } else {
+          f.value = this.setFieldValue(resource.dataSourceColumns.find((col) => col.name == f.field), f.value);
+        }
+      });
+    }
+
+    const d = await this.getDataWithOriginalTypes({ resource, limit, offset, sort, filters });
+    // call getFieldValue for each field
+    d.data.map((record) => {
+      for (const col of resource.dataSourceColumns) {
+        record[col.name] = this.getFieldValue(col, record[col.name]);
+      }
+    });
+
+    return d;
+  }
+
+  async getMinMaxForColumns({ resource, columns }: { resource: AdminForthResource; columns: AdminForthResourceColumn[]; }): Promise<{ [key: string]: { min: any; max: any; }; }> {
+    const mm = await this.getMinMaxForColumnsWithOriginalTypes({ resource, columns });
+    const result = {};
+    for (const col of columns) {
+        result[col.name] = {
+            min: this.getFieldValue(col, mm[col.name].min),
+            max: this.getFieldValue(col, mm[col.name].max),
+        };
+    }
+    return result;
+  }
+
+  getRecordByPrimaryKey(resource: AdminForthResource, recordId: string): Promise<any> {
+    return this.getRecordByPrimaryKeyWithOriginalTypes(resource, recordId).then((record) => {
+        const newRecord = {};
+        for (const col of resource.dataSourceColumns) {
+            newRecord[col.name] = this.getFieldValue(col, record[col.name]);
+        }
+        return newRecord;
+    });
+  }
+
+    
+}

package/dataConnectors/mongo.ts

@@ -83,7 +83,7 @@ class MongoConnector implements AdminForthDataSourceConnector {
         return value;
       }
     
-    async getRecordByPrimaryKey(resource, key) {
+    async getRecordByPrimaryKeyWithOriginalTypes(resource, key) {
         const tableName = resource.table;
         const collection = this.db.db().collection(tableName);
         const row = await collection.findOne({ [this.getPrimaryKey(resource)]: key });
@@ -97,7 +97,7 @@ class MongoConnector implements AdminForthDataSourceConnector {
                 continue; // should I continue or throw an error?
                 throw new Error(`Resource '${resource.table}' has no column '${key_1}' defined`);
             }
-            newRow[key_1] = this.getFieldValue(dbKey, value);
+            newRow[key_1] = value;
         }
         console.log('newRow', newRow);
         return newRow;
@@ -121,7 +121,7 @@ class MongoConnector implements AdminForthDataSourceConnector {
         return value;
       }
     
-    async getData({ resource, limit, offset, sort, filters }) {
+    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters }) {
         // const columns = resource.dataSourceColumns.filter(c=> !c.virtual).map((col) => col.name).join(', ');
         const tableName = resource.table;
 
@@ -140,7 +140,7 @@ class MongoConnector implements AdminForthDataSourceConnector {
         return { data: result, total }
     }
 
-    async getMinMaxForColumns({ resource, columns }) {
+    async getMinMaxForColumnsWithOriginalTypes({ resource, columns }) {
         const tableName = resource.table;
         const collection = this.db.db().collection(tableName);
         const result = {};
@@ -160,18 +160,12 @@ class MongoConnector implements AdminForthDataSourceConnector {
         const columns = Object.keys(record);
         const newRecord = {};
         for (const colName of columns) {
-            const col = resource.dataSourceColumns.find((col) => col.name == colName);
-            if (col) {
-                newRecord[colName] = this.setFieldValue(col, record[colName]);
-            } else {
-                newRecord[colName] = record[colName];
-            }
+            newRecord[colName] = record[colName];
         }
-
         await collection.insertOne(newRecord);
     }
 
-    async updateRecord({ resource, recordId, record, newValues }) {
+    async updateRecord({ resource, recordId, newValues }) {
         const collection = this.db.db().collection(resource.table);
         await collection.updateOne({ [this.getPrimaryKey(resource)]: recordId }, { $set: newValues });
     }

package/dataConnectors/postgres.ts

@@ -1,15 +1,16 @@
 import dayjs from 'dayjs';
 import pkg from 'pg';
 import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections, AdminForthDataSourceConnector } from '../types/AdminForthConfig.js';
-
+import AdminForthBaseConnector from './baseConnector.js';
 const { Client } = pkg;
 
 
-class PostgresConnector implements AdminForthDataSourceConnector {
+class PostgresConnector extends AdminForthBaseConnector implements AdminForthDataSourceConnector {
 
     db: any;
 
     constructor({ url }) {
+        super();
         this.db = new Client({
             connectionString: url
         });
@@ -34,12 +35,12 @@ class PostgresConnector implements AdminForthDataSourceConnector {
         [AdminForthFilterOperators.ILIKE]: 'ILIKE',
         [AdminForthFilterOperators.IN]: 'IN',
         [AdminForthFilterOperators.NIN]: 'NOT IN',
-      };
+    };
   
-      SortDirectionsMap = {
+    SortDirectionsMap = {
         [AdminForthSortDirections.asc]: 'ASC',
         [AdminForthSortDirections.desc]: 'DESC',
-      };
+    };
 
     async discoverFields(resource) {
         const tableName = resource.table;
@@ -125,8 +126,8 @@ class PostgresConnector implements AdminForthDataSourceConnector {
             field.default = row.dflt_value;
             field.required = row.notnull && !row.dflt_value;
             fieldTypes[row.name] = field
-            });
-            return fieldTypes;
+        });
+        return fieldTypes;
     }
 
     getFieldValue(field, value) {
@@ -153,15 +154,8 @@ class PostgresConnector implements AdminForthDataSourceConnector {
         return value;
       }
 
-    getPrimaryKey(resource) {
-        for (const col of resource.dataSourceColumns) {
-            if (col.primaryKey) {
-                return col.name;
-            }
-        }
-    }
 
-    async getRecordByPrimaryKey(resource, key) {
+    async getRecordByPrimaryKeyWithOriginalTypes(resource, key) {
         const tableName = resource.table;
         const columns = resource.dataSourceColumns.map((col) => `"${col.name}"`).join(', ');
         const stmt = await this.db.query(`SELECT ${columns} FROM ${tableName} WHERE ${this.getPrimaryKey(resource)} = $1`, [key]);
@@ -171,7 +165,7 @@ class PostgresConnector implements AdminForthDataSourceConnector {
         }
         const newRow = {};
         for (const [key_1, value] of Object.entries(row)) {
-            newRow[key_1] = this.getFieldValue(resource.dataSourceColumns.find((col_1) => col_1.name == key_1), value);
+            newRow[key_1] = value;
         }
         return newRow;
     }
@@ -192,7 +186,7 @@ class PostgresConnector implements AdminForthDataSourceConnector {
         return value;
       }
     
-    async getData({ resource, limit, offset, sort, filters }) {
+    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters }) {
       const columns = resource.dataSourceColumns.map((col) => `"${col.name}"`).join(', ');
       const tableName = resource.table;
       
@@ -220,12 +214,7 @@ class PostgresConnector implements AdminForthDataSourceConnector {
       const filterValues = [];
       filters.length ? filters.forEach((f) => {
         // for arrays do set in map
-        let v;
-        if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-          v = f.value.map((val) => this.setFieldValue(resource.dataSourceColumns.find((col) => col.name == f.field), val));
-        } else {
-          v = this.setFieldValue(resource.dataSourceColumns.find((col) => col.name == f.field), f.value);
-        }
+        let v = f.value;
 
         if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
           filterValues.push(`%${v}%`);
@@ -247,12 +236,11 @@ class PostgresConnector implements AdminForthDataSourceConnector {
       const rows = stmt.rows;
       
       const total = (await this.db.query(`SELECT COUNT(*) FROM ${tableName} ${where}`, filterValues)).rows[0].count;
-      // run all fields via getFieldValue
       return {
         data: rows.map((row) => {
           const newRow = {};
           for (const [key, value] of Object.entries(row)) {
-              newRow[key] = this.getFieldValue(resource.dataSourceColumns.find((col) => col.name == key), value);
+              newRow[key] = value;
           }
           return newRow;
         }),
@@ -260,15 +248,14 @@ class PostgresConnector implements AdminForthDataSourceConnector {
       };
     }
   
-    async getMinMaxForColumns({ resource, columns }) {
+    async getMinMaxForColumnsWithOriginalTypes({ resource, columns }) {
         const tableName = resource.table;
         const result = {};
         await Promise.all(columns.map(async (col) => {
             const stmt = await this.db.query(`SELECT MIN(${col.name}) as min, MAX(${col.name}) as max FROM ${tableName}`);
             const { min, max } = stmt.rows[0];
             result[col.name] = {
-                min: this.getFieldValue(col, min),
-                max: this.getFieldValue(col, max),
+                min, max,
             };
         }))
         return result;
@@ -278,21 +265,14 @@ class PostgresConnector implements AdminForthDataSourceConnector {
         const tableName = resource.table;
         const columns = Object.keys(record);
         const placeholders = columns.map((_, i) => `$${i + 1}`).join(', ');
-        const values = columns.map((colName) => {
-            const col = resource.dataSourceColumns.find((col) => col.name == colName);
-            if (col) {
-                return this.setFieldValue(col, record[colName])
-            } else {
-                return record[colName];
-            }
-        });
+        const values = columns.map((colName) => record[colName]);
         for (let i = 0; i < columns.length; i++) {
             columns[i] = `"${columns[i]}"`;
         }
         await this.db.query(`INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`, values);
     }
 
-    async updateRecord({ resource, recordId, record, newValues }) {
+    async updateRecord({ resource, recordId, newValues }) {
         const values = [...Object.values(newValues), recordId];
         const columnsWithPlaceholders = Object.keys(newValues).map((col, i) => `"${col}" = $${i + 1}`).join(', ');
         await this.db.query(`UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE "${this.getPrimaryKey(resource)}" = $${values.length}`, values);

package/dataConnectors/sqlite.ts

@@ -1,19 +1,19 @@
 import betterSqlite3 from 'better-sqlite3';
-import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections, AdminForthDataSourceConnector } from '../types/AdminForthConfig.js';
-
+import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections, AdminForthDataSourceConnector, AdminForthResource, AdminForthResourceColumn } from '../types/AdminForthConfig.js';
+import AdminForthBaseConnector from './baseConnector.js';
 import dayjs from 'dayjs';
 
-class SQLiteConnector implements AdminForthDataSourceConnector {
+class SQLiteConnector extends AdminForthBaseConnector implements AdminForthDataSourceConnector {
 
     db: any;
 
-    constructor({ url }) {
+    constructor({ url }: { url: string }) {
+      super();
       // create connection here
-
       this.db = betterSqlite3(url.replace('sqlite://', ''));
     }
 
-    async discoverFields(resource) {
+    async discoverFields(resource: AdminForthResource): Promise<{[key: string]: AdminForthResourceColumn}> {
         const tableName = resource.table;
         const stmt = this.db.prepare(`PRAGMA table_info(${tableName})`);
         const rows = await stmt.all();
@@ -59,15 +59,7 @@ class SQLiteConnector implements AdminForthDataSourceConnector {
         return fieldTypes;
     }
 
-    getPrimaryKey(resource) {
-        for (const col of resource.dataSourceColumns) {
-            if (col.primaryKey) {
-                return col.name;
-            }
-        }
-    }
-
-    getFieldValue(field, value) {
+    getFieldValue(field: AdminForthResourceColumn, value: any): any {
       if (field.type == AdminForthDataTypes.DATETIME) {
         if (!value) {
           return null;
@@ -93,7 +85,7 @@ class SQLiteConnector implements AdminForthDataSourceConnector {
       return value;
     }
 
-    async getRecordByPrimaryKey(resource, key) {
+    async getRecordByPrimaryKeyWithOriginalTypes(resource: AdminForthResource, key: any): Promise<any> {
         const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
         const tableName = resource.table;
         const stmt = this.db.prepare(`SELECT ${columns} FROM ${tableName} WHERE ${this.getPrimaryKey(resource)} = ?`);
@@ -103,12 +95,12 @@ class SQLiteConnector implements AdminForthDataSourceConnector {
         }
         const newRow = {};
         for (const [key, value] of Object.entries(row)) {
-            newRow[key] = this.getFieldValue(resource.dataSourceColumns.find((col) => col.name == key), value);
+            newRow[key] = value;
         }
         return newRow;
     }
 
-    setFieldValue(field, value) {
+    setFieldValue(field: AdminForthResourceColumn, value: any): any {
       if (field.type == AdminForthDataTypes.DATETIME) {
         if (!value) {
           return null;
@@ -146,7 +138,13 @@ class SQLiteConnector implements AdminForthDataSourceConnector {
     };
     
 
-    getData({ resource, limit, offset, sort, filters }) {
+    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<{ data: any[], total: number }> {
       const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
       const tableName = resource.table;
 
@@ -165,17 +163,11 @@ class SQLiteConnector implements AdminForthDataSourceConnector {
         return `${field} ${operator} ${placeholder}`
       }).join(' AND ')}` : '';
 
-
       const filterValues = [];
       
       filters.length ? filters.forEach((f) => {
         // for arrays do set in map
-        let v;
-        if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-          v = f.value.map((val) => this.setFieldValue(resource.dataSourceColumns.find((col) => col.name == f.field), val));
-        } else {
-          v = this.setFieldValue(resource.dataSourceColumns.find((col) => col.name == f.field), f.value);
-        }
+        const v = f.value;
 
         if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
           filterValues.push(`%${v}%`);
@@ -196,15 +188,17 @@ class SQLiteConnector implements AdminForthDataSourceConnector {
       if (process.env.HEAVY_DEBUG) {
         console.log('🪲 SQLITE Query', q, 'params:', d);
       }
-      const rows = stmt.all(d);
+      const rows = await stmt.all(d);
+
+      const total = (
+        await this.db.prepare(`SELECT COUNT(*) FROM ${tableName} ${where}`).get([...filterValues])
+      )['COUNT(*)'];
 
-      const total = this.db.prepare(`SELECT COUNT(*) FROM ${tableName} ${where}`).get([...filterValues])['COUNT(*)'];
-      // run all fields via getFieldValue
       return {
         data: rows.map((row) => {
           const newRow = {};
           for (const [key, value] of Object.entries(row)) {
-            newRow[key] = this.getFieldValue(resource.dataSourceColumns.find((col) => col.name == key), value);
+            newRow[key] = value;
           }
           return newRow;
         }),
@@ -212,50 +206,45 @@ class SQLiteConnector implements AdminForthDataSourceConnector {
       };
     }
 
-    async getMinMaxForColumns({ resource, columns }) {
+    async getMinMaxForColumnsWithOriginalTypes({ resource, columns }: { resource: AdminForthResource, columns: AdminForthResourceColumn[] }): Promise<{ [key: string]: { min: any, max: any } }> {
       const tableName = resource.table;
       const result = {};
       await Promise.all(columns.map(async (col) => {
         const stmt = await this.db.prepare(`SELECT MIN(${col.name}) as min, MAX(${col.name}) as max FROM ${tableName}`);
         const { min, max } = stmt.get();
         result[col.name] = {
-          min: this.getFieldValue(col, min),
-          max: this.getFieldValue(col, max),
+          min, max,
         };
       }))
       return result;
     }
 
-    async createRecord({ resource, record }) {
-        const tableName = resource.table;
-        const columns = Object.keys(record);
-        const placeholders = columns.map(() => '?').join(', ');
-        const values = columns.map((colName) => {
-          const col = resource.dataSourceColumns.find((col) => col.name == colName);
-          if (col) {
-            return this.setFieldValue(col, record[colName])
-          } else {
-            return record[colName];
-          }
-        });
-        this.db.prepare(`INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`).run(values);
+    async createRecord({ resource, record }: { resource: AdminForthResource, record: any }) {
+      const tableName = resource.table;
+      const columns = Object.keys(record);
+      const placeholders = columns.map(() => '?').join(', ');
+      const values = columns.map((colName) => record[colName]);
+      const q = this.db.prepare(`INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`)
+      await q.run(values);
     }
 
-    async updateRecord({ resource, recordId, record, newValues }) {
-        const columnsWithPlaceholders = Object.keys(newValues).map((col) => `${col} = ?`);
-        const values = [...Object.values(newValues), recordId];
+    async updateRecord({ resource, recordId, newValues }: { resource: AdminForthResource, recordId: any, newValues: any }) {
+      const columnsWithPlaceholders = Object.keys(newValues).map((col) => `${col} = ?`);
+      const values = [...Object.values(newValues), recordId];
 
-        this.db.prepare(
-            `UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE ${this.getPrimaryKey(resource)} = ?`
-        ).run(values);
+      const q = this.db.prepare(
+          `UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE ${this.getPrimaryKey(resource)} = ?`
+      )
+      await q.run(values);
     }
 
-    async deleteRecord({ resource, recordId }) {
-        this.db.prepare(`DELETE FROM ${resource.table} WHERE ${this.getPrimaryKey(resource)} = ?`).run(recordId);
+    async deleteRecord({ resource, recordId }: { resource: AdminForthResource, recordId: any }) {
+      const q = this.db.prepare(`DELETE FROM ${resource.table} WHERE ${this.getPrimaryKey(resource)} = ?`);
+      await q.run(recordId);
     }
 
     close() {
-        this.db.close();
+      this.db.close();
     }
 }
 

package/dist/dataConnectors/baseConnector.js

@@ -0,0 +1,90 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { AdminForthFilterOperators } from "../types/AdminForthConfig.js";
+export default class AdminForthBaseConnector {
+    getPrimaryKey(resource) {
+        for (const col of resource.dataSourceColumns) {
+            if (col.primaryKey) {
+                return col.name;
+            }
+        }
+    }
+    getRecordByPrimaryKeyWithOriginalTypes(resource, id) {
+        throw new Error('Method not implemented.');
+    }
+    getDataWithOriginalTypes({ resource, limit, offset, sort, filters }) {
+        throw new Error('Method not implemented.');
+    }
+    discoverFields(resource) {
+        throw new Error('Method not implemented.');
+    }
+    getFieldValue(field, value) {
+        throw new Error('Method not implemented.');
+    }
+    setFieldValue(field, value) {
+        throw new Error('Method not implemented.');
+    }
+    getMinMaxForColumnsWithOriginalTypes({ resource, columns }) {
+        throw new Error('Method not implemented.');
+    }
+    createRecord({ resource, record }) {
+        throw new Error('Method not implemented.');
+    }
+    updateRecord({ resource, recordId, newValues }) {
+        throw new Error('Method not implemented.');
+    }
+    deleteRecord({ resource, recordId }) {
+        throw new Error('Method not implemented.');
+    }
+    getData(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
+            if (filters) {
+                filters.map((f) => {
+                    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));
+                    }
+                    else {
+                        f.value = this.setFieldValue(resource.dataSourceColumns.find((col) => col.name == f.field), f.value);
+                    }
+                });
+            }
+            const d = yield this.getDataWithOriginalTypes({ resource, limit, offset, sort, filters });
+            // call getFieldValue for each field
+            d.data.map((record) => {
+                for (const col of resource.dataSourceColumns) {
+                    record[col.name] = this.getFieldValue(col, record[col.name]);
+                }
+            });
+            return d;
+        });
+    }
+    getMinMaxForColumns(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, columns }) {
+            const mm = yield this.getMinMaxForColumnsWithOriginalTypes({ resource, columns });
+            const result = {};
+            for (const col of columns) {
+                result[col.name] = {
+                    min: this.getFieldValue(col, mm[col.name].min),
+                    max: this.getFieldValue(col, mm[col.name].max),
+                };
+            }
+            return result;
+        });
+    }
+    getRecordByPrimaryKey(resource, recordId) {
+        return this.getRecordByPrimaryKeyWithOriginalTypes(resource, recordId).then((record) => {
+            const newRecord = {};
+            for (const col of resource.dataSourceColumns) {
+                newRecord[col.name] = this.getFieldValue(col, record[col.name]);
+            }
+            return newRecord;
+        });
+    }
+}

package/dist/dataConnectors/mongo.js

@@ -84,7 +84,7 @@ class MongoConnector {
         }
         return value;
     }
-    getRecordByPrimaryKey(resource, key) {
+    getRecordByPrimaryKeyWithOriginalTypes(resource, key) {
         return __awaiter(this, void 0, void 0, function* () {
             const tableName = resource.table;
             const collection = this.db.db().collection(tableName);
@@ -99,7 +99,7 @@ class MongoConnector {
                     continue; // should I continue or throw an error?
                     throw new Error(`Resource '${resource.table}' has no column '${key_1}' defined`);
                 }
-                newRow[key_1] = this.getFieldValue(dbKey, value);
+                newRow[key_1] = value;
             }
             console.log('newRow', newRow);
             return newRow;
@@ -124,7 +124,7 @@ class MongoConnector {
         }
         return value;
     }
-    getData(_a) {
+    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;
@@ -142,7 +142,7 @@ class MongoConnector {
             return { data: result, total };
         });
     }
-    getMinMaxForColumns(_a) {
+    getMinMaxForColumnsWithOriginalTypes(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, columns }) {
             const tableName = resource.table;
             const collection = this.db.db().collection(tableName);
@@ -164,19 +164,13 @@ class MongoConnector {
             const columns = Object.keys(record);
             const newRecord = {};
             for (const colName of columns) {
-                const col = resource.dataSourceColumns.find((col) => col.name == colName);
-                if (col) {
-                    newRecord[colName] = this.setFieldValue(col, record[colName]);
-                }
-                else {
-                    newRecord[colName] = record[colName];
-                }
+                newRecord[colName] = record[colName];
             }
             yield collection.insertOne(newRecord);
         });
     }
     updateRecord(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, record, newValues }) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, newValues }) {
             const collection = this.db.db().collection(resource.table);
             yield collection.updateOne({ [this.getPrimaryKey(resource)]: recordId }, { $set: newValues });
         });

package/dist/dataConnectors/postgres.js

@@ -10,9 +10,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import dayjs from 'dayjs';
 import pkg from 'pg';
 import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections } from '../types/AdminForthConfig.js';
+import AdminForthBaseConnector from './baseConnector.js';
 const { Client } = pkg;
-class PostgresConnector {
+class PostgresConnector extends AdminForthBaseConnector {
     constructor({ url }) {
+        super();
         this.OperatorsMap = {
             [AdminForthFilterOperators.EQ]: '=',
             [AdminForthFilterOperators.NE]: '!=',
@@ -152,14 +154,7 @@ class PostgresConnector {
         }
         return value;
     }
-    getPrimaryKey(resource) {
-        for (const col of resource.dataSourceColumns) {
-            if (col.primaryKey) {
-                return col.name;
-            }
-        }
-    }
-    getRecordByPrimaryKey(resource, key) {
+    getRecordByPrimaryKeyWithOriginalTypes(resource, key) {
         return __awaiter(this, void 0, void 0, function* () {
             const tableName = resource.table;
             const columns = resource.dataSourceColumns.map((col) => `"${col.name}"`).join(', ');
@@ -170,7 +165,7 @@ class PostgresConnector {
             }
             const newRow = {};
             for (const [key_1, value] of Object.entries(row)) {
-                newRow[key_1] = this.getFieldValue(resource.dataSourceColumns.find((col_1) => col_1.name == key_1), value);
+                newRow[key_1] = value;
             }
             return newRow;
         });
@@ -192,7 +187,7 @@ class PostgresConnector {
         }
         return value;
     }
-    getData(_a) {
+    getDataWithOriginalTypes(_a) {
         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;
@@ -220,13 +215,7 @@ class PostgresConnector {
             const filterValues = [];
             filters.length ? filters.forEach((f) => {
                 // for arrays do set in map
-                let v;
-                if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                    v = f.value.map((val) => this.setFieldValue(resource.dataSourceColumns.find((col) => col.name == f.field), val));
-                }
-                else {
-                    v = this.setFieldValue(resource.dataSourceColumns.find((col) => col.name == f.field), f.value);
-                }
+                let v = f.value;
                 if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
                     filterValues.push(`%${v}%`);
                 }
@@ -247,12 +236,11 @@ class PostgresConnector {
             const stmt = yield this.db.query(selectQuery, d);
             const rows = stmt.rows;
             const total = (yield this.db.query(`SELECT COUNT(*) FROM ${tableName} ${where}`, filterValues)).rows[0].count;
-            // run all fields via getFieldValue
             return {
                 data: rows.map((row) => {
                     const newRow = {};
                     for (const [key, value] of Object.entries(row)) {
-                        newRow[key] = this.getFieldValue(resource.dataSourceColumns.find((col) => col.name == key), value);
+                        newRow[key] = value;
                     }
                     return newRow;
                 }),
@@ -260,7 +248,7 @@ class PostgresConnector {
             };
         });
     }
-    getMinMaxForColumns(_a) {
+    getMinMaxForColumnsWithOriginalTypes(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, columns }) {
             const tableName = resource.table;
             const result = {};
@@ -268,8 +256,7 @@ class PostgresConnector {
                 const stmt = yield this.db.query(`SELECT MIN(${col.name}) as min, MAX(${col.name}) as max FROM ${tableName}`);
                 const { min, max } = stmt.rows[0];
                 result[col.name] = {
-                    min: this.getFieldValue(col, min),
-                    max: this.getFieldValue(col, max),
+                    min, max,
                 };
             })));
             return result;
@@ -280,15 +267,7 @@ class PostgresConnector {
             const tableName = resource.table;
             const columns = Object.keys(record);
             const placeholders = columns.map((_, i) => `$${i + 1}`).join(', ');
-            const values = columns.map((colName) => {
-                const col = resource.dataSourceColumns.find((col) => col.name == colName);
-                if (col) {
-                    return this.setFieldValue(col, record[colName]);
-                }
-                else {
-                    return record[colName];
-                }
-            });
+            const values = columns.map((colName) => record[colName]);
             for (let i = 0; i < columns.length; i++) {
                 columns[i] = `"${columns[i]}"`;
             }
@@ -296,7 +275,7 @@ class PostgresConnector {
         });
     }
     updateRecord(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, record, newValues }) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, newValues }) {
             const values = [...Object.values(newValues), recordId];
             const columnsWithPlaceholders = Object.keys(newValues).map((col, i) => `"${col}" = $${i + 1}`).join(', ');
             yield this.db.query(`UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE "${this.getPrimaryKey(resource)}" = $${values.length}`, values);

package/dist/dataConnectors/sqlite.js

@@ -9,10 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import betterSqlite3 from 'better-sqlite3';
 import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections } from '../types/AdminForthConfig.js';
+import AdminForthBaseConnector from './baseConnector.js';
 import dayjs from 'dayjs';
-class SQLiteConnector {
+class SQLiteConnector extends AdminForthBaseConnector {
     constructor({ url }) {
-        // create connection here
+        super();
         this.OperatorsMap = {
             [AdminForthFilterOperators.EQ]: '=',
             [AdminForthFilterOperators.NE]: '!=',
@@ -29,6 +30,7 @@ class SQLiteConnector {
             [AdminForthSortDirections.asc]: 'ASC',
             [AdminForthSortDirections.desc]: 'DESC',
         };
+        // create connection here
         this.db = betterSqlite3(url.replace('sqlite://', ''));
     }
     discoverFields(resource) {
@@ -85,13 +87,6 @@ class SQLiteConnector {
             return fieldTypes;
         });
     }
-    getPrimaryKey(resource) {
-        for (const col of resource.dataSourceColumns) {
-            if (col.primaryKey) {
-                return col.name;
-            }
-        }
-    }
     getFieldValue(field, value) {
         if (field.type == AdminForthDataTypes.DATETIME) {
             if (!value) {
@@ -118,7 +113,7 @@ class SQLiteConnector {
         }
         return value;
     }
-    getRecordByPrimaryKey(resource, key) {
+    getRecordByPrimaryKeyWithOriginalTypes(resource, key) {
         return __awaiter(this, void 0, void 0, function* () {
             const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
             const tableName = resource.table;
@@ -129,7 +124,7 @@ class SQLiteConnector {
             }
             const newRow = {};
             for (const [key, value] of Object.entries(row)) {
-                newRow[key] = this.getFieldValue(resource.dataSourceColumns.find((col) => col.name == key), value);
+                newRow[key] = value;
             }
             return newRow;
         });
@@ -153,65 +148,60 @@ class SQLiteConnector {
         }
         return value;
     }
-    getData({ 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) => {
-            let placeholder = '?';
-            let field = f.field;
-            let operator = this.OperatorsMap[f.operator];
-            if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                placeholder = `(${f.value.map(() => '?').join(', ')})`;
-            }
-            else if (f.operator == AdminForthFilterOperators.ILIKE) {
-                placeholder = `LOWER(?)`;
-                field = `LOWER(${f.field})`;
-                operator = 'LIKE';
-            }
-            return `${field} ${operator} ${placeholder}`;
-        }).join(' AND ')}` : '';
-        const filterValues = [];
-        filters.length ? filters.forEach((f) => {
-            // for arrays do set in map
-            let v;
-            if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                v = f.value.map((val) => this.setFieldValue(resource.dataSourceColumns.find((col) => col.name == f.field), val));
-            }
-            else {
-                v = this.setFieldValue(resource.dataSourceColumns.find((col) => col.name == f.field), 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 orderBy = sort.length ? `ORDER BY ${sort.map((s) => `${s.field} ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
-        const q = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT ? OFFSET ?`;
-        const stmt = this.db.prepare(q);
-        const d = [...filterValues, limit, offset];
-        if (process.env.HEAVY_DEBUG) {
-            console.log('🪲 SQLITE Query', q, 'params:', d);
-        }
-        const rows = stmt.all(d);
-        const total = this.db.prepare(`SELECT COUNT(*) FROM ${tableName} ${where}`).get([...filterValues])['COUNT(*)'];
-        // run all fields via getFieldValue
-        return {
-            data: rows.map((row) => {
-                const newRow = {};
-                for (const [key, value] of Object.entries(row)) {
-                    newRow[key] = this.getFieldValue(resource.dataSourceColumns.find((col) => col.name == key), value);
+    getDataWithOriginalTypes(_a) {
+        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;
+            const where = filters.length ? `WHERE ${filters.map((f, i) => {
+                let placeholder = '?';
+                let field = f.field;
+                let operator = this.OperatorsMap[f.operator];
+                if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                    placeholder = `(${f.value.map(() => '?').join(', ')})`;
                 }
-                return newRow;
-            }),
-            total,
-        };
+                else if (f.operator == AdminForthFilterOperators.ILIKE) {
+                    placeholder = `LOWER(?)`;
+                    field = `LOWER(${f.field})`;
+                    operator = 'LIKE';
+                }
+                return `${field} ${operator} ${placeholder}`;
+            }).join(' AND ')}` : '';
+            const filterValues = [];
+            filters.length ? filters.forEach((f) => {
+                // for arrays do set in map
+                const 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 orderBy = sort.length ? `ORDER BY ${sort.map((s) => `${s.field} ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
+            const q = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT ? OFFSET ?`;
+            const stmt = this.db.prepare(q);
+            const d = [...filterValues, limit, offset];
+            if (process.env.HEAVY_DEBUG) {
+                console.log('🪲 SQLITE Query', q, 'params:', d);
+            }
+            const rows = yield stmt.all(d);
+            const total = (yield this.db.prepare(`SELECT COUNT(*) FROM ${tableName} ${where}`).get([...filterValues]))['COUNT(*)'];
+            return {
+                data: rows.map((row) => {
+                    const newRow = {};
+                    for (const [key, value] of Object.entries(row)) {
+                        newRow[key] = value;
+                    }
+                    return newRow;
+                }),
+                total,
+            };
+        });
     }
-    getMinMaxForColumns(_a) {
+    getMinMaxForColumnsWithOriginalTypes(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, columns }) {
             const tableName = resource.table;
             const result = {};
@@ -219,8 +209,7 @@ class SQLiteConnector {
                 const stmt = yield this.db.prepare(`SELECT MIN(${col.name}) as min, MAX(${col.name}) as max FROM ${tableName}`);
                 const { min, max } = stmt.get();
                 result[col.name] = {
-                    min: this.getFieldValue(col, min),
-                    max: this.getFieldValue(col, max),
+                    min, max,
                 };
             })));
             return result;
@@ -231,28 +220,23 @@ class SQLiteConnector {
             const tableName = resource.table;
             const columns = Object.keys(record);
             const placeholders = columns.map(() => '?').join(', ');
-            const values = columns.map((colName) => {
-                const col = resource.dataSourceColumns.find((col) => col.name == colName);
-                if (col) {
-                    return this.setFieldValue(col, record[colName]);
-                }
-                else {
-                    return record[colName];
-                }
-            });
-            this.db.prepare(`INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`).run(values);
+            const values = columns.map((colName) => record[colName]);
+            const q = this.db.prepare(`INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`);
+            yield q.run(values);
         });
     }
     updateRecord(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, record, newValues }) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, newValues }) {
             const columnsWithPlaceholders = Object.keys(newValues).map((col) => `${col} = ?`);
             const values = [...Object.values(newValues), recordId];
-            this.db.prepare(`UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE ${this.getPrimaryKey(resource)} = ?`).run(values);
+            const q = this.db.prepare(`UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE ${this.getPrimaryKey(resource)} = ?`);
+            yield q.run(values);
         });
     }
     deleteRecord(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, recordId }) {
-            this.db.prepare(`DELETE FROM ${resource.table} WHERE ${this.getPrimaryKey(resource)} = ?`).run(recordId);
+            const q = this.db.prepare(`DELETE FROM ${resource.table} WHERE ${this.getPrimaryKey(resource)} = ?`);
+            yield q.run(recordId);
         });
     }
     close() {

package/dist/index.js

@@ -968,7 +968,14 @@ class AdminForth {
                 if (!allowed) {
                     return { error };
                 }
-                yield this.createResourceRecord({ resource, record: body['record'], adminUser });
+                const { record } = body;
+                // call setFieldValue for each column
+                for (const column of resource.columns) {
+                    if (record[column.name] !== undefined) {
+                        record[column.name] = this.connectors[resource.dataSource].setFieldValue(column, record[column.name]);
+                    }
+                }
+                yield this.createResourceRecord({ resource, record, adminUser });
                 const connector = this.connectors[resource.dataSource];
                 return {
                     newRecordId: body['record'][connector.getPrimaryKey(resource)]

package/index.ts

@@ -1102,7 +1102,15 @@ class AdminForth implements AdminForthClass {
               return { error };
             }
 
-            await this.createResourceRecord({ resource, record: body['record'], adminUser });
+            const { record } = body;
+            // call setFieldValue for each column
+            for (const column of resource.columns) {
+              if (record[column.name] !== undefined) {
+                record[column.name] = this.connectors[resource.dataSource].setFieldValue(column, record[column.name]);
+              }
+            }
+
+            await this.createResourceRecord({ resource, record, adminUser });
             const connector = this.connectors[resource.dataSource];
 
             return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adminforth",
-  "version": "1.1.73",
+  "version": "1.1.74",
   "description": "OpenSource Vue3 powered forth-generation admin panel",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/types/AdminForthConfig.ts

@@ -82,9 +82,113 @@ export interface AdminForthDataSourceConnector {
   /**
    * Function which will be called to fetch record from database.
    */
+  getRecordByPrimaryKeyWithOriginalTypes(resource: AdminForthResource, recordId: string): Promise<any>;
+
+
+  /**
+   * Function should go over all columns of table defined in resource.table and try to guess
+   * data and constraints for each columns. 
+   * Type should be saved to:
+   * -  {@link AdminForthResourceColumn.type}
+   * Constraints:
+   *  - {@link AdminForthResourceColumn.required}
+   *  - {@link AdminForthResourceColumn.primaryKey}
+   * For string fields:
+   *  - {@link AdminForthResourceColumn.maxLength}
+   * For numbers:
+   *  - {@link AdminForthResourceColumn.min}
+   *  - {@link AdminForthResourceColumn.max}
+   *  - {@link AdminForthResourceColumn.minValue}, {@link AdminForthResourceColumn.maxValue}, {@link AdminForthResourceColumn.enum}, {@link AdminForthResourceColumn.foreignResource}, {@link AdminForthResourceColumn.sortable}, {@link AdminForthResourceColumn.backendOnly}, {@link AdminForthResourceColumn.masked}, {@link AdminForthResourceColumn.virtual}, {@link AdminForthResourceColumn.components}, {@link AdminForthResourceColumn.allowMinMaxQuery}, {@link AdminForthResourceColumn.editingNote}, {@link AdminForthResourceColumn.showIn}, {@link AdminForthResourceColumn.isUnique}, {@link AdminForthResourceColumn.validation})
+   * Also you can additionally save original column type to {@link AdminForthResourceColumn._underlineType}. This might be later used
+   * in {@link AdminForthDataSourceConnector.getFieldValue} and {@link AdminForthDataSourceConnector.setFieldValue} methods.
+   * 
+   * 
+   * @param resource 
+   */
+  discoverFields(resource: AdminForthResource): Promise<{[key: string]: AdminForthResourceColumn}>;
+
+
+  /**
+   * Used to transform record after fetching from database.
+   * According to AdminForth convention, if {@link AdminForthResourceColumn.type} is set to {@link AdminForthDataTypes.DATETIME} then it should be transformed to ISO string.
+   * @param field 
+   * @param value 
+   */
+  getFieldValue(field: AdminForthResourceColumn, value: any): any;
+
+  /**
+   * Used to transform record before saving to database. Should perform operation inverse to {@link AdminForthDataSourceConnector.getFieldValue}
+   * @param field 
+   * @param value 
+   */
+  setFieldValue(field: AdminForthResourceColumn, value: any): any;
+
+  /**
+   * Used to fetch data from database.
+   * This method is reused both to list records and show one record (by passing limit 1 and offset 0) .
+   * 
+   * Fields are returned from db "as is" then {@link AdminForthBaseConnector.getData} will transform each field using {@link AdminForthDataSourceConnector.getFieldValue}
+   */
+  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<{data: Array<any>, total: number}>;
+
+
+  /**
+   * Optional method which used to get min and max values for columns in resource.
+   * Called only for columns which have {@link AdminForthResourceColumn.allowMinMaxQuery} set to true.
+   * 
+   * Internally should call {@link AdminForthDataSourceConnector.getFieldValue} for both min and max values.
+   */
+  getMinMaxForColumnsWithOriginalTypes({ resource, columns }: { resource: AdminForthResource, columns: AdminForthResourceColumn[] }): Promise<{ [key: string]: { min: any, max: any } }>;
+
+
+  /**
+   * Used to create record in database.
+   */
+  createRecord({ resource, record }: { resource: AdminForthResource, record: any }): Promise<void>;
+
+  /**
+   * Used to update record in database.
+   * recordId is value of field which is marked as {@link AdminForthResourceColumn.primaryKey}
+   * newValues is array of fields which should be updated (might be not all fields in record, but only changed fields).
+   */
+  updateRecord({ resource, recordId, newValues }:
+    { resource: AdminForthResource, recordId: string, newValues: any }
+  ): Promise<void>;
+  
+  /**
+   * Used to delete record in database.
+   */
+  deleteRecord({ resource, recordId }: { resource: AdminForthResource, recordId: any }): Promise<void>;
+}
+
+
+/**
+ * Interface that exposes methods to interact with AdminForth in standard way
+ */
+export interface AdminForthDataSourceConnectorBase extends AdminForthDataSourceConnector {
+
+  getPrimaryKey(resource: AdminForthResource): string;
+
+  getData({ resource, limit, offset, sort, filters }: {
+    resource: AdminForthResource,
+    limit: number,
+    offset: number,
+    sort: { field: string, direction: AdminForthSortDirections }[],
+    filters: { field: string, operator: AdminForthFilterOperators, value: any }[]
+  }): Promise<{ data: Array<any>, total: number }>;
+
   getRecordByPrimaryKey(resource: AdminForthResource, recordId: string): Promise<any>;
+
+  getMinMaxForColumns({ resource, columns }: { resource: AdminForthResource, columns: AdminForthResourceColumn[] }): Promise<{ [key: string]: { min: any, max: any } }>;
 }
 
+
 export interface AdminForthDataSourceConnectorConstructor {
   new ({ url }: { url: string }): AdminForthDataSourceConnector;
 }
@@ -95,7 +199,7 @@ export interface AdminForthClass {
   express: GenericHttpServer;
 
   connectors: {
-    [key: string]: AdminForthDataSourceConnector,
+    [key: string]: AdminForthDataSourceConnectorBase;
   };
 
   createResourceRecord(params: { resource: AdminForthResource, record: any, adminUser: AdminUser }): Promise<any>;
@@ -425,21 +529,57 @@ export type AdminForthResourceColumn = {
      * Custom components which will be used to render this field in the admin panel.
      */
     components?: AdminForthFieldComponents
+
+    /**
+     * Maximum length of string that can be entered in this field.
+     */
     maxLength?: number, 
+
+    /**
+     * Minimum length of string that can be entered in this field.
+     */
     minLength?: number,
+
     min?: number,
     max?: number,
+
+    /**
+     * Minimum value that can be entered in this field.
+     */
     minValue?: number,
+
+    /**
+     * Maximum value that can be entered in this field.
+     */
     maxValue?: number,
+
+    /**
+     * Enum of possible values for this field.
+     */
     enum?: Array<AdminForthColumnEnumItem>,
+
+    /**
+     * Foreign resource which has pk column with values same that written in this column.
+     */
     foreignResource?:AdminForthForeignResource,
+
     sortable?: boolean,
-    backendOnly?: boolean, // if true field will not be passed to UI under no circumstances, but will be presented in hooks
+
+    /**
+     * if true field will !not be passed to UI under no circumstances, but will be presented in hooks
+     */
+    backendOnly?: boolean,
 
     /**
      * Masked fields will be displayed as `*****` on Edit and Create pages.
      */
     masked?: boolean,
+
+
+    /**
+     * Internal type which indicates original type of column in database.
+     */
+    _underlineType?: string,
 }