adminforth 1.1.73 → 1.1.75

package/auth.ts

@@ -37,6 +37,20 @@ class AdminForthAuth {
     response.setHeader('Set-Cookie', `adminforth_jwt=${token}; Path=${this.adminforth.config.baseUrl || '/'}; HttpOnly; SameSite=Strict`);
   }
 
+  removeCustomCookie({response, name}) {
+    response.setHeader('Set-Cookie', `adminforth_test'='2'; Path=${this.adminforth.config.baseUrl || '/'}; HttpOnly; SameSite=Strict`);
+  }
+
+  setCustomCookie({ response, payload }: {
+    response: any, payload: {name: string, value: string, expiry: number, httpOnly: boolean}
+  }) {
+    const {name,value,expiry,httpOnly} = payload
+    response.setHeader('Set-Cookie', `adminforth_${name}=${value}; Path=${this.adminforth.config.baseUrl || '/'}; HttpOnly; SameSite=Strict; Expires=${new Date(Date.now() + expiry).toUTCString() } `);
+  }
+
+ 
+
+
   issueJWT(payload: Object, type: string) {
     // read ADMINFORH_SECRET from environment if not drop error
     const secret = process.env.ADMINFORTH_SECRET;

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/auth.js

@@ -34,6 +34,13 @@ class AdminForthAuth {
         const token = this.issueJWT({ username, pk, }, 'auth');
         response.setHeader('Set-Cookie', `adminforth_jwt=${token}; Path=${this.adminforth.config.baseUrl || '/'}; HttpOnly; SameSite=Strict`);
     }
+    removeCustomCookie({ response, name }) {
+        response.setHeader('Set-Cookie', `adminforth_test'='2'; Path=${this.adminforth.config.baseUrl || '/'}; HttpOnly; SameSite=Strict`);
+    }
+    setCustomCookie({ response, payload }) {
+        const { name, value, expiry, httpOnly } = payload;
+        response.setHeader('Set-Cookie', `adminforth_${name}=${value}; Path=${this.adminforth.config.baseUrl || '/'}; HttpOnly; SameSite=Strict; Expires=${new Date(Date.now() + expiry).toUTCString()} `);
+    }
     issueJWT(payload, type) {
         // read ADMINFORH_SECRET from environment if not drop error
         const secret = process.env.ADMINFORTH_SECRET;

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;
+        });
+    }
+}