adminforth 1.0.0

package/auth.js

@@ -0,0 +1,66 @@
+
+import jwt from 'jsonwebtoken';
+
+import crypto from 'crypto';
+
+// Function to generate a password hash using PBKDF2
+function calcPasswordHash(password, salt, iterations = 100000, keyLength = 64, digest = 'sha512') {
+  return new Promise((resolve, reject) => {
+    crypto.pbkdf2(password, salt, iterations, keyLength, digest, (err, derivedKey) => {
+      if (err) reject(err);
+      resolve(derivedKey.toString('hex'));
+    });
+  });
+}
+
+// Function to generate a random salt
+function generateSalt(length = 16) {
+  return crypto.randomBytes(length).toString('hex');
+}
+
+class AdminForthAuth {
+
+  issueJWT(payload) {
+    // read ADMINFORH_SECRET from environment if not drop error
+    const secret = process.env.ADMINFORTH_SECRET;
+    if (!secret) {
+      throw new Error('ADMINFORTH_SECRET environment not set');
+    }
+
+    // issue JWT token
+    const expiresIn = process.env.ADMINFORTH_AUTH_EXPIRESIN || '1h';
+    return jwt.sign(payload, secret, { expiresIn });
+  }
+
+  verify(jwtToken) {
+    // read ADMINFORH_SECRET from environment if not drop error
+    const secret = process.env.ADMINFORTH_SECRET;
+    if (!secret) {
+      throw new Error('ADMINFORTH_SECRET environment not set');
+    }
+    try {
+      // verify JWT token
+      const decoded = jwt.verify(jwtToken, secret);
+      return decoded;
+    } catch (err) {
+      console.error('Failed to verify JWT token', err);
+      return null;
+    }
+  }
+
+  static async generatePasswordHash(password) {
+    const salt = generateSalt();
+    const hashedPassword = await calcPasswordHash(password, salt);
+    return `${salt}:${hashedPassword}`;
+  }
+
+  static async verifyPassword(password, hashedPassword) {
+    const [salt, hash] = hashedPassword.split(':');
+    const newHash = await calcPasswordHash(password, salt);
+    return newHash === hash;
+  }
+
+
+}
+
+export default AdminForthAuth;

package/dataConnectors/mongo.js

@@ -0,0 +1,187 @@
+import dayjs from 'dayjs';
+import { MongoClient } from 'mongodb';
+import { AdminForthFilterOperators, AdminForthSortDirections, AdminForthTypes } from '../types.js';
+
+
+class MongoConnector {
+    constructor({ url, fieldtypesByTable }) {
+        this.db = new MongoClient(url, { useNewUrlParser: true, useUnifiedTopology: true });
+        if (fieldtypesByTable == null) {
+            throw new Error('fieldtypesByTable is required for MongoConnector');
+        };
+        
+        (async () => {
+            try {
+                await this.db.connect();
+                console.log('Connected to Mongo');
+            } catch (e) {
+                console.error('ERROR: Failed to connect to Mongo', e);
+            }
+        })();
+
+        this.fieldtypesByTable = fieldtypesByTable;
+    }
+
+    OperatorsMap = {
+        [AdminForthFilterOperators.EQ]: (value) => value,
+        [AdminForthFilterOperators.NE]: (value) => ({ $ne: value }),
+        [AdminForthFilterOperators.GT]: (value) => ({ $gt: value }),
+        [AdminForthFilterOperators.LT]: (value) => ({ $lt: value }),
+        [AdminForthFilterOperators.GTE]: (value) => ({ $gte: value }),
+        [AdminForthFilterOperators.LTE]: (value) => ({ $lte: value }),
+        [AdminForthFilterOperators.LIKE]: (value) => ({ $regex: value }),
+        [AdminForthFilterOperators.ILIKE]: (value) => ({ $regex: value, $options: 'i' }),
+        [AdminForthFilterOperators.IN]: (value) => ({ $in: value }),
+        [AdminForthFilterOperators.NIN]: (value) => ({ $nin: value }),
+    };
+
+    SortDirectionsMap = {
+        [AdminForthSortDirections.ASC]: 1,
+        [AdminForthSortDirections.DESC]: -1,
+    };
+
+    async discoverFields(tableName) {
+        return this.fieldtypesByTable[tableName];
+    }
+
+    getPrimaryKey(resource) {
+        for (const col of resource.dataSourceColumns) {
+            if (col.primaryKey) {
+                return col.name;
+            }
+        }
+    }
+
+    getFieldValue(field, value) {
+        if (field.type == AdminForthTypes.DATETIME) {
+          if (!value) {
+            return null;
+          }
+          if (field._underlineType == 'timestamp' || field._underlineType == 'int') {
+            return dayjs.unix(+value).toISOString();
+          } else if (field._underlineType == 'varchar') {
+            return dayjs.unix(+value).toISOString();
+          } else {
+            throw new Error(`AdminForth does not support row type: ${field._underlineType} for timestamps, use VARCHAR (with iso strings) or TIMESTAMP/INT (with unix timestamps)`);
+          }
+        } else if (field.type == AdminForthTypes.BOOLEAN) {
+          return !!value;
+        }
+        return value;
+      }
+    
+    async getRecordByPrimaryKey(resource, key) {
+        const tableName = resource.table;
+        const collection = this.db.db().collection(tableName);
+        const row = await collection.findOne({ [this.getPrimaryKey(resource)]: key });
+        if (!row) {
+            return null;
+        }
+        const newRow = {};
+        for (const [key_1, value] of Object.entries(row)) {
+            const dbKey = resource.dataSourceColumns.find((col) => col.name == key_1);
+            if (!dbKey) {
+                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);
+        }
+        console.log('newRow', newRow);
+        return newRow;
+    }
+
+    setFieldValue(field, value) {
+        if (field.type == AdminForthTypes.DATETIME) {
+          if (!value) {
+            return null;
+          }
+          if (field._underlineType == 'timestamp' || field._underlineType == 'int') {
+            // value is iso string now, convert to unix timestamp
+            return dayjs(value).unix();
+          } else if (field._underlineType == 'varchar') {
+            // value is iso string now, convert to unix timestamp
+            return dayjs(value).toISOString();
+          }
+        } else if (field.type == AdminForthTypes.BOOLEAN) {
+          return value ? 1 : 0;
+        }
+        return value;
+      }
+    
+    async getData({ resource, limit, offset, sort, filters }) {
+        // const columns = resource.dataSourceColumns.filter(c=> !c.virtual).map((col) => col.name).join(', ');
+        const tableName = resource.table;
+        
+        for (const filter of filters) {
+            if (!this.OperatorsMap[filter.operator]) {
+            throw new Error(`Operator ${filter.operator} is not allowed`);
+            }
+
+            if (!resource.dataSourceColumns.some((col) => col.name == filter.field)) {
+                throw new Error(`Field ${filter.field} is not in resource ${resource.resourceId}. Available fields: ${resource.dataSourceColumns.map((col) => col.name).join(', ')}`);
+            }
+        }
+
+        const collection = this.db.db().collection(tableName);
+        const query = {};
+        for (const filter of filters) {
+            query[filter.field] = this.OperatorsMap[filter.operator](filter.value);
+        }
+        const total = await collection.countDocuments(query);
+        const result = await collection.find(query)
+            .sort(sort)
+            .skip(offset)
+            .limit(limit)
+            .toArray();
+
+        return { data: result, total }
+    }
+
+    async getMinMaxForColumns({ resource, columns }) {
+        const tableName = resource.table;
+        const collection = this.db.db().collection(tableName);
+        const result = {};
+        for (const column of columns) {
+            result[column] = await collection
+                .aggregate([
+                    { $group: { _id: null, min: { $min: `$${column}` }, max: { $max: `$${column}` } } },
+                ])
+                .toArray();
+        }
+        return result;
+    }
+
+    async createRecord({ resource, record }) {
+        const tableName = resource.table;
+        const collection = this.db.db().collection(tableName);
+        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];
+            }
+        }
+
+        await collection.insertOne(newRecord);
+    }
+
+    async updateRecord({ resource, recordId, record, newValues }) {
+        const collection = this.db.db().collection(resource.table);
+        await collection.updateOne({ [this.getPrimaryKey(resource)]: recordId }, { $set: newValues });
+    }
+
+    async deleteRecord({ resource, recordId }) {
+        const primaryKey = this.getPrimaryKey(resource);
+        const collection = this.db.db().collection(resource.table);
+        await collection.deleteOne({ [primaryKey]: recordId });
+    }
+
+    async close() {
+        await this.db.end();
+    }
+}
+
+export default MongoConnector;

package/dataConnectors/postgres.js

@@ -0,0 +1,283 @@
+import dayjs from 'dayjs';
+import pkg from 'pg';
+import { AdminForthFilterOperators, AdminForthSortDirections, AdminForthTypes } from '../types.js';
+const { Client } = pkg;
+
+
+class PostgresConnector {
+    constructor({ url }) {
+        this.db = new Client({
+            connectionString: url
+        });
+        (async () => {
+            await this.db.connect();
+        })();
+    }
+
+    OperatorsMap = {
+        [AdminForthFilterOperators.EQ]: '=',
+        [AdminForthFilterOperators.NE]: '!=',
+        [AdminForthFilterOperators.GT]: '>',
+        [AdminForthFilterOperators.LT]: '<',
+        [AdminForthFilterOperators.GTE]: '>=',
+        [AdminForthFilterOperators.LTE]: '<=',
+        [AdminForthFilterOperators.LIKE]: 'LIKE',
+        [AdminForthFilterOperators.ILIKE]: 'ILIKE',
+        [AdminForthFilterOperators.IN]: 'IN',
+        [AdminForthFilterOperators.NIN]: 'NOT IN',
+      };
+  
+      SortDirectionsMap = {
+        [AdminForthSortDirections.ASC]: 'ASC',
+        [AdminForthSortDirections.DESC]: 'DESC',
+      };
+
+    async discoverFields(tableName) {
+        const stmt = await this.db.query(`
+        SELECT
+            a.attname AS name,
+            pg_catalog.format_type(a.atttypid, a.atttypmod) AS type,
+            a.attnotnull AS notnull,
+            COALESCE(pg_get_expr(d.adbin, d.adrelid), '') AS dflt_value,
+            CASE
+                WHEN ct.contype = 'p' THEN 1
+                ELSE 0
+            END AS pk
+        FROM
+            pg_catalog.pg_attribute a
+        LEFT JOIN pg_catalog.pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+        LEFT JOIN pg_catalog.pg_constraint ct ON a.attnum = ANY (ct.conkey) AND a.attrelid = ct.conrelid
+        LEFT JOIN pg_catalog.pg_class c ON a.attrelid = c.oid
+        LEFT JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
+        WHERE
+            c.relname = $1
+            AND a.attnum > 0
+            AND NOT a.attisdropped
+        ORDER BY
+            a.attnum;
+    `, [tableName]);
+        const rows = stmt.rows;
+        const fieldTypes = {};
+
+        rows.forEach((row) => {
+            const field = {};
+            const baseType = row.type.toLowerCase();
+            if (baseType == 'int') {
+                field.type = AdminForthTypes.INTEGER;
+                field._underlineType = 'int';
+
+            } else if (baseType.includes('float') || baseType.includes('double')) {
+                field.type = AdminForthTypes.FLOAT;
+                field._underlineType = 'float';
+
+            } else if (baseType.includes('bool')) {
+                field.type = AdminForthTypes.BOOLEAN;
+                field._underlineType = 'bool';
+
+            } else if (baseType.includes('character varying')) {
+                field.type = AdminForthTypes.STRING;
+                field._underlineType = 'varchar';
+                const length = baseType.match(/\d+/);
+                field.maxLength = length ? parseInt(length[0]) : null;
+
+            } else if (baseType == 'text') {
+                field.type = AdminForthTypes.TEXT;
+                field._underlineType = 'text';
+
+            } else if (baseType.includes('decimal(')) {
+                field.type = AdminForthTypes.DECIMAL;
+                field._underlineType = 'decimal';
+                const [precision, scale] = baseType.match(/\d+/g);
+                field.precision = parseInt(precision);
+                field.scale = parseInt(scale);
+
+            } else if (baseType == 'real') {
+                field.type = AdminForthTypes.FLOAT;
+                field._underlineType = 'real';
+
+            } else if (baseType.includes('date') || baseType.includes('time')) {
+                field.type = AdminForthTypes.DATETIME;
+                field._underlineType = 'timestamp';
+
+            } else {
+                field.type = 'unknown'
+            }
+            field._baseTypeDebug = baseType;
+            field.primaryKey = row.pk == 1;
+            field.default = row.dflt_value;
+            field.required = row.notnull && !row.dflt_value;
+            fieldTypes[row.name] = field
+            });
+            return fieldTypes;
+    }
+
+    getFieldValue(field, value) {
+        if (field.type == AdminForthTypes.DATETIME) {
+          if (!value) {
+            return null;
+          }
+          if (field._underlineType == 'timestamp' || field._underlineType == 'int') {
+            return dayjs.unix(+value).toISOString();
+          } else if (field._underlineType == 'varchar') {
+            return dayjs.unix(+value).toISOString();
+          } else {
+            throw new Error(`AdminForth does not support row type: ${field._underlineType} for timestamps, use VARCHAR (with iso strings) or TIMESTAMP/INT (with unix timestamps)`);
+          }
+        }
+
+
+        return value;
+      }
+
+    getPrimaryKey(resource) {
+        for (const col of resource.dataSourceColumns) {
+            if (col.primaryKey) {
+                return col.name;
+            }
+        }
+    }
+
+    async getRecordByPrimaryKey(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]);
+        const row = stmt.rows[0];
+        if (!row) {
+            return null;
+        }
+        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);
+        }
+        return newRow;
+    }
+
+    setFieldValue(field, value) {
+        if (field.type == AdminForthTypes.DATETIME) {
+          if (!value) {
+            return null;
+          }
+          if (field._underlineType == 'timestamp' || field._underlineType == 'int') {
+            // value is iso string now, convert to unix timestamp
+            return dayjs(value).unix();
+          } else if (field._underlineType == 'varchar') {
+            // value is iso string now, convert to unix timestamp
+            return dayjs(value).toISOString();
+          }
+        } else if (field.type == AdminForthTypes.BOOLEAN) {
+          return value ? 1 : 0;
+        }
+        return value;
+      }
+    
+    async getData({ resource, limit, offset, sort, filters }) {
+      const columns = resource.dataSourceColumns.filter(c=> !c.virtual).map((col) => col.name).join(', ');
+      const tableName = resource.table;
+      
+      for (const filter of filters) {
+        if (!this.OperatorsMap[filter.operator]) {
+          throw new Error(`Operator ${filter.operator} is not allowed`);
+        }
+        if (!resource.dataSourceColumns.some((col) => col.name == filter.field)) {
+          throw new Error(`Field ${filter.field} is not in resource ${resource.resourceId}. Available fields: ${resource.dataSourceColumns.map((col) => col.name).join(', ')}`);
+        }
+      }
+      let totalCounter = 1;
+      const where = filters.length ? `WHERE ${filters.map((f, i) => {
+        let placeholder = '$'+(totalCounter);
+        let field = f.field;
+        let operator = this.OperatorsMap[f.operator];
+        if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+            placeholder = `(${f.value.map((_, i) => `$${totalCounter + i}`).join(', ')})`;
+            totalCounter += f.value.length;
+        } else {
+            totalCounter += 1;
+        }
+        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 limitOffset = `LIMIT $${totalCounter} OFFSET $${totalCounter + 1}`; 
+      const d = [...filterValues, limit, offset];
+      const orderBy = sort.length ? `ORDER BY ${sort.map((s) => `${s.field} ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
+      const stmt = await this.db.query(`SELECT ${columns} FROM ${tableName} ${where} ${orderBy} ${limitOffset}`, d);
+      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)) {
+            console.log('key', key, value, resource.dataSourceColumns.find((col) => col.name == key));
+              newRow[key] = this.getFieldValue(resource.dataSourceColumns.find((col) => col.name == key), value);
+          }
+          return newRow;
+        }),
+        total,
+      };
+    }
+  
+    async getMinMaxForColumns({ 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),
+            };
+        }))
+        return result;
+    }
+
+    async createRecord({ resource, record }) {
+        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];
+            }
+        });
+        await this.db.query(`INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`, values);
+    }
+
+    async updateRecord({ resource, recordId, record, 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);
+    }
+
+    async deleteRecord({ resource, recordId }) {
+        await this.db.query(`DELETE FROM ${resource.table} WHERE ${this.getPrimaryKey(resource)} = $1`, [recordId]);
+    }
+
+    async close() {
+        await this.db.end();
+    }
+}
+
+export default PostgresConnector;