adminforth 1.0.17 → 1.0.24

package/dataConnectors/{mongo.js → mongo.ts}

@@ -4,12 +4,10 @@ import { AdminForthFilterOperators, AdminForthSortDirections, AdminForthTypes }
 
 
 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');
-        };
-        
+    db: any;
+
+    constructor({ url }) {
+        this.db = new MongoClient(url);
         (async () => {
             try {
                 await this.db.connect();
@@ -21,8 +19,6 @@ class MongoConnector {
                 console.error('ERROR: Failed to connect to Mongo', e);
             }
         })();
-
-        this.fieldtypesByTable = fieldtypesByTable;
     }
 
     OperatorsMap = {
@@ -43,8 +39,17 @@ class MongoConnector {
         [AdminForthSortDirections.DESC]: -1,
     };
 
-    async discoverFields(tableName) {
-        return this.fieldtypesByTable[tableName];
+    async discoverFields(resource) {
+        return resource.columns.reduce((acc, col) => {
+            acc[col.name] = {
+                name: col.name,
+                type: col.type,
+                primaryKey: col.primaryKey,
+                virtual: col.virtual,
+                _underlineType: col._underlineType,
+            };
+            return acc;
+        }, {});
     }
 
     getPrimaryKey(resource) {

package/dataConnectors/{postgres.js → postgres.ts}

@@ -5,6 +5,9 @@ const { Client } = pkg;
 
 
 class PostgresConnector {
+
+    db: any;
+
     constructor({ url }) {
         this.db = new Client({
             connectionString: url
@@ -37,7 +40,8 @@ class PostgresConnector {
         [AdminForthSortDirections.DESC]: 'DESC',
       };
 
-    async discoverFields(tableName) {
+    async discoverFields(resource) {
+        const tableName = resource.table;
         const stmt = await this.db.query(`
         SELECT
             a.attname AS name,
@@ -65,7 +69,7 @@ class PostgresConnector {
         const fieldTypes = {};
 
         rows.forEach((row) => {
-            const field = {};
+            const field: any = {};
             const baseType = row.type.toLowerCase();
             if (baseType == 'int') {
                 field.type = AdminForthTypes.INTEGER;

package/dataConnectors/{sqlite.js → sqlite.ts}

@@ -3,18 +3,22 @@ import { AdminForthTypes, AdminForthFilterOperators, AdminForthSortDirections }
 import dayjs from 'dayjs';
 
 class SQLiteConnector {
+
+    db: any;
+
     constructor({ url }) {
       // create connection here
 
       this.db = betterSqlite3(url.replace('sqlite://', ''));
     }
 
-    async discoverFields(tableName) {
+    async discoverFields(resource) {
+        const tableName = resource.table;
         const stmt = this.db.prepare(`PRAGMA table_info(${tableName})`);
         const rows = await stmt.all();
         const fieldTypes = {};
         rows.forEach((row) => {
-          const field = {};
+          const field: any = {};
           const baseType = row.type.toLowerCase();
           if (baseType == 'int') {
             field.type = AdminForthTypes.INTEGER;

package/dist/auth.js

@@ -0,0 +1,68 @@
+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 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 || '24h';
+        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 generatePasswordHash(password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const salt = generateSalt();
+            const hashedPassword = yield calcPasswordHash(password, salt);
+            return `${salt}:${hashedPassword}`;
+        });
+    }
+    static verifyPassword(password, hashedPassword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [salt, hash] = hashedPassword.split(':');
+            const newHash = yield calcPasswordHash(password, salt);
+            return newHash === hash;
+        });
+    }
+}
+export default AdminForthAuth;

package/dist/dataConnectors/mongo.js

@@ -0,0 +1,204 @@
+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 dayjs from 'dayjs';
+import { MongoClient } from 'mongodb';
+import { AdminForthFilterOperators, AdminForthSortDirections, AdminForthTypes } from '../types.js';
+class MongoConnector {
+    constructor({ url }) {
+        this.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 }),
+        };
+        this.SortDirectionsMap = {
+            [AdminForthSortDirections.ASC]: 1,
+            [AdminForthSortDirections.DESC]: -1,
+        };
+        this.db = new MongoClient(url);
+        (() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.db.connect();
+                this.db.on('error', (err) => {
+                    console.log('Mongo error: ', err.message);
+                });
+                console.log('Connected to Mongo');
+            }
+            catch (e) {
+                console.error('ERROR: Failed to connect to Mongo', e);
+            }
+        }))();
+    }
+    discoverFields(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return resource.columns.reduce((acc, col) => {
+                acc[col.name] = {
+                    name: col.name,
+                    type: col.type,
+                    primaryKey: col.primaryKey,
+                    virtual: col.virtual,
+                    _underlineType: col._underlineType,
+                };
+                return acc;
+            }, {});
+        });
+    }
+    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;
+    }
+    getRecordByPrimaryKey(resource, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tableName = resource.table;
+            const collection = this.db.db().collection(tableName);
+            const row = yield 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;
+    }
+    getData(_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;
+            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 = yield collection.countDocuments(query);
+            const result = yield collection.find(query)
+                .sort(sort)
+                .skip(offset)
+                .limit(limit)
+                .toArray();
+            return { data: result, total };
+        });
+    }
+    getMinMaxForColumns(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, columns }) {
+            const tableName = resource.table;
+            const collection = this.db.db().collection(tableName);
+            const result = {};
+            for (const column of columns) {
+                result[column] = yield collection
+                    .aggregate([
+                    { $group: { _id: null, min: { $min: `$${column}` }, max: { $max: `$${column}` } } },
+                ])
+                    .toArray();
+            }
+            return result;
+        });
+    }
+    createRecord(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ 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];
+                }
+            }
+            yield collection.insertOne(newRecord);
+        });
+    }
+    updateRecord(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, record, newValues }) {
+            const collection = this.db.db().collection(resource.table);
+            yield collection.updateOne({ [this.getPrimaryKey(resource)]: recordId }, { $set: newValues });
+        });
+    }
+    deleteRecord(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId }) {
+            const primaryKey = this.getPrimaryKey(resource);
+            const collection = this.db.db().collection(resource.table);
+            yield collection.deleteOne({ [primaryKey]: recordId });
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.db.end();
+        });
+    }
+}
+export default MongoConnector;

package/dist/dataConnectors/postgres.js

@@ -0,0 +1,298 @@
+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 dayjs from 'dayjs';
+import pkg from 'pg';
+import { AdminForthFilterOperators, AdminForthSortDirections, AdminForthTypes } from '../types.js';
+const { Client } = pkg;
+class PostgresConnector {
+    constructor({ url }) {
+        this.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',
+        };
+        this.SortDirectionsMap = {
+            [AdminForthSortDirections.ASC]: 'ASC',
+            [AdminForthSortDirections.DESC]: 'DESC',
+        };
+        this.db = new Client({
+            connectionString: url
+        });
+        (() => __awaiter(this, void 0, void 0, function* () {
+            yield this.db.connect();
+            this.db.on('error', (err) => {
+                console.log('Postgres error: ', err.message, err.stack);
+                this.db.end();
+                this.db = new PostgresConnector({ url }).db;
+            });
+        }))();
+    }
+    discoverFields(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tableName = resource.table;
+            const stmt = yield 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;
+            }
+        }
+    }
+    getRecordByPrimaryKey(resource, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tableName = resource.table;
+            const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
+            const stmt = yield 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;
+    }
+    getData(_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;
+            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 = yield this.db.query(`SELECT ${columns} FROM ${tableName} ${where} ${orderBy} ${limitOffset}`, 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);
+                    }
+                    return newRow;
+                }),
+                total,
+            };
+        });
+    }
+    getMinMaxForColumns(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, columns }) {
+            const tableName = resource.table;
+            const result = {};
+            yield Promise.all(columns.map((col) => __awaiter(this, void 0, void 0, function* () {
+                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),
+                };
+            })));
+            return result;
+        });
+    }
+    createRecord(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ 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];
+                }
+            });
+            yield this.db.query(`INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`, values);
+        });
+    }
+    updateRecord(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, record, 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);
+        });
+    }
+    deleteRecord(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId }) {
+            yield this.db.query(`DELETE FROM ${resource.table} WHERE ${this.getPrimaryKey(resource)} = $1`, [recordId]);
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.db.end();
+        });
+    }
+}
+export default PostgresConnector;