adminforth 1.2.98 → 1.2.100

package/auth.ts

@@ -88,12 +88,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 = await this.adminforth.getUserByPk(pk);
-      decoded.dbUser = dbUser;
+    const dbUser = await 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/dataConnectors/baseConnector.ts

@@ -1,4 +1,6 @@
-import { AdminForthResource, IAdminForthDataSourceConnectorBase, AdminForthSortDirections, AdminForthFilterOperators, AdminForthResourceColumn } from "../types/AdminForthConfig.js";
+import { get } from "http";
+import { AdminForthResource, IAdminForthDataSourceConnectorBase, AdminForthSortDirections, AdminForthFilterOperators, AdminForthResourceColumn, IAdminForthSort, IAdminForthFilter } from "../types/AdminForthConfig.js";
+import { suggestIfTypo } from "../modules/utils.js";
 
 
 export default class AdminForthBaseConnector implements IAdminForthDataSourceConnectorBase {
@@ -17,19 +19,21 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
       offset: 0,
       sort: [], 
       filters: [{ field: this.getPrimaryKey(resource), operator: AdminForthFilterOperators.EQ, value: id }],
-      getTotals: false
     });
-    return data.data.length > 0 ? data.data[0] : null;
+    return data.length > 0 ? data[0] : null;
   }
 
-  getDataWithOriginalTypes({ resource, limit, offset, sort, filters, getTotals }: { 
+  getDataWithOriginalTypes({ resource, limit, offset, sort, filters }: { 
     resource: AdminForthResource, 
     limit: number, 
     offset: number, 
-    sort: { field: string, direction: AdminForthSortDirections }[], 
-    filters: { field: string, operator: AdminForthFilterOperators, value: any }[],
-    getTotals?: boolean
-  }): Promise<{ data: any[], total: number }> {
+    sort: IAdminForthSort[], 
+    filters: IAdminForthFilter[],
+  }): Promise<any[]> {
+    throw new Error('Method not implemented.');
+  }
+
+  getCount({ resource, filters }: { resource: AdminForthResource; filters: { field: string; operator: AdminForthFilterOperators; value: any; }[]; }): Promise<number> {
     throw new Error('Method not implemented.');
   }
 
@@ -53,51 +57,117 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
     throw new Error('Method not implemented.');
   }
 
-  createRecord({ resource, record }: { resource: AdminForthResource; record: any; }): Promise<void> {
+  async checkUnique(resource: AdminForthResource, column: AdminForthResourceColumn, value: any) {
+    process.env.HEAVY_DEBUG && console.log('☝️🪲🪲🪲🪲 checkUnique|||', column, value);
+    const existingRecord = await 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;
+  }
+
+  async createRecord({ resource, record, adminUser }: { 
+    resource: AdminForthResource; record: any; adminUser: any;
+  }): Promise<{ error?: string; ok: boolean; createdRecord?: any; }> {
     // transform value using setFieldValue and call createRecordOriginalValues
-    const newRecord = {...record};
+    const filledRecord = {...record};
+    const recordWithOriginalValues = {...record};
+
     for (const col of resource.dataSourceColumns) {
-        newRecord[col.name] = this.setFieldValue(col, record[col.name]);
+      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: string | null = null;
+    await Promise.all(
+      resource.dataSourceColumns.map(async (col) => {
+
+        if (col.isUnique && !col.virtual && !error) {
+
+          const exists = await 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);
+    await this.createRecordOriginalValues({ resource, record: recordWithOriginalValues });
+
+    return {
+      ok: true,
+      createdRecord: recordWithOriginalValues,
     }
-    process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record', newRecord);
-    return this.createRecordOriginalValues({ resource, record: newRecord });
   }
 
   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> {
+  deleteRecord({ resource, recordId }: { resource: AdminForthResource; recordId: string; }): Promise<boolean> {
     throw new Error('Method not implemented.');
   }
 
 
-  async getData({ resource, limit, offset, sort, filters }: { 
+  async getData({ resource, limit, offset, sort, filters, getTotals }: { 
     resource: AdminForthResource, 
     limit: number, 
     offset: number, 
     sort: { field: string, direction: AdminForthSortDirections }[], 
-    filters: { field: string, operator: AdminForthFilterOperators, value: any }[]
+    filters: { field: string, operator: AdminForthFilterOperators, value: any }[],
+    getTotals: boolean,
   }): Promise<{ data: any[], total: number }> {
     if (filters) {
       filters.map((f) => {
+        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 = await this.getDataWithOriginalTypes({ resource, limit, offset, sort, filters, getTotals: true });
+    const promises: Promise<any>[] = [this.getDataWithOriginalTypes({ resource, limit, offset, sort, filters })];
+    if (getTotals) {
+      promises.push(this.getCount({ resource, filters }));
+    } else {
+      promises.push(Promise.resolve(undefined));
+    }
+
+    const [data, total] = await Promise.all(promises);
+
     // call getFieldValue for each field
-    d.data.map((record) => {
+    data.map((record) => {
       for (const col of resource.dataSourceColumns) {
         record[col.name] = this.getFieldValue(col, record[col.name]);
       }
     });
 
-    return d;
+    return { data, total };
   }
 
   async getMinMaxForColumns({ resource, columns }: { resource: AdminForthResource; columns: AdminForthResourceColumn[]; }): Promise<{ [key: string]: { min: any; max: any; }; }> {

package/dataConnectors/clickhouse.ts

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

package/dataConnectors/mongo.ts

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

package/dataConnectors/postgres.ts

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