@adminforth/two-factors-auth 1.0.4 → 1.0.5

package/dist/auth.js

@@ -0,0 +1,108 @@
+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 {
+    constructor(adminforth) {
+        this.adminforth = adminforth;
+    }
+    removeAuthCookie(response) {
+        response.setHeader('Set-Cookie', `adminforth_jwt=; Path=${this.adminforth.config.baseUrl || '/'}; HttpOnly; SameSite=Strict; Expires=Thu, 01 Jan 1970 00:00:00 GMT`);
+    }
+    setAuthCookie({ response, username, pk }) {
+        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;
+        if (!secret) {
+            throw new Error('ADMINFORTH_SECRET environment not set');
+        }
+        // issue JWT token
+        const expiresIn = process.env.ADMINFORTH_AUTH_EXPIRESIN || '24h';
+        return jwt.sign(Object.assign(Object.assign({}, payload), { t: type }), secret, { expiresIn });
+    }
+    verify(jwtToken, mustHaveType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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');
+            }
+            let decoded;
+            try {
+                // verify JWT token
+                decoded = jwt.verify(jwtToken, secret);
+            }
+            catch (err) {
+                if (err.name === 'TokenExpiredError') {
+                    console.error('Token expired:', err.message);
+                }
+                else if (err.name === 'JsonWebTokenError') {
+                    console.error('Token error:', err.message);
+                }
+                else {
+                    console.error('Failed to verify JWT token', err);
+                }
+                return null;
+            }
+            const { pk, t } = decoded;
+            if (t !== mustHaveType) {
+                console.error(`Invalid token type during verification: ${t}, must be ${mustHaveType}`);
+                return null;
+            }
+            if (pk === null) {
+                decoded.isRoot = true;
+            }
+            else {
+                const dbUser = yield this.adminforth.getUserByPk(pk);
+                decoded.dbUser = dbUser;
+            }
+            return decoded;
+        });
+    }
+    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/baseConnector.js

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

package/dist/dataConnectors/mongo.js

@@ -0,0 +1,191 @@
+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 { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections } from '../types/AdminForthConfig.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) => {
+                if (!col.type) {
+                    throw new Error(`Type is not defined for column ${col.name}`);
+                }
+                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 == AdminForthDataTypes.DATETIME) {
+            if (!value) {
+                return null;
+            }
+            return dayjs(Date.parse(value)).toISOString();
+        }
+        else if (field.type == AdminForthDataTypes.DATE) {
+            if (!value) {
+                return null;
+            }
+            return dayjs(Date.parse(value)).toISOString().split('T')[0];
+        }
+        else if (field.type == AdminForthDataTypes.BOOLEAN) {
+            return !!value;
+        }
+        return value;
+    }
+    getRecordByPrimaryKeyWithOriginalTypes(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] = value;
+            }
+            console.log('newRow', newRow);
+            return newRow;
+        });
+    }
+    setFieldValue(field, value) {
+        if (field.type == AdminForthDataTypes.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 == AdminForthDataTypes.BOOLEAN) {
+            return value ? 1 : 0;
+        }
+        return value;
+    }
+    getDataWithOriginalTypes(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
+            // const columns = resource.dataSourceColumns.filter(c=> !c.virtual).map((col) => col.name).join(', ');
+            const tableName = resource.table;
+            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 };
+        });
+    }
+    getMinMaxForColumnsWithOriginalTypes(_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) {
+                newRecord[colName] = record[colName];
+            }
+            yield collection.insertOne(newRecord);
+        });
+    }
+    updateRecord(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, newValues }) {
+            const collection = this.db.db().collection(resource.table);
+            yield collection.updateOne({ [this.getPrimaryKey(resource)]: recordId }, { $set: newValues });
+        });
+    }
+    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.close();
+        });
+    }
+}
+export default MongoConnector;

package/dist/dataConnectors/postgres.js

@@ -0,0 +1,295 @@
+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 { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections } from '../types/AdminForthConfig.js';
+import AdminForthBaseConnector from './baseConnector.js';
+const { Client } = pkg;
+class PostgresConnector extends AdminForthBaseConnector {
+    constructor({ url }) {
+        super();
+        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 = AdminForthDataTypes.INTEGER;
+                    field._underlineType = 'int';
+                }
+                else if (baseType.includes('float') || baseType.includes('double')) {
+                    field.type = AdminForthDataTypes.FLOAT;
+                    field._underlineType = 'float';
+                }
+                else if (baseType.includes('bool')) {
+                    field.type = AdminForthDataTypes.BOOLEAN;
+                    field._underlineType = 'bool';
+                }
+                else if (baseType == 'uuid') {
+                    field.type = AdminForthDataTypes.STRING;
+                    field._underlineType = 'uuid';
+                }
+                else if (baseType.includes('character varying')) {
+                    field.type = AdminForthDataTypes.STRING;
+                    field._underlineType = 'varchar';
+                    const length = baseType.match(/\d+/);
+                    field.maxLength = length ? parseInt(length[0]) : null;
+                }
+                else if (baseType == 'text') {
+                    field.type = AdminForthDataTypes.TEXT;
+                    field._underlineType = 'text';
+                }
+                else if (baseType.includes('decimal(')) {
+                    field.type = AdminForthDataTypes.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 = AdminForthDataTypes.FLOAT;
+                    field._underlineType = 'real';
+                }
+                else if (baseType == 'date') {
+                    field.type = AdminForthDataTypes.DATE;
+                    field._underlineType = 'timestamp';
+                }
+                else if (baseType.includes('date') || baseType.includes('time')) {
+                    field.type = AdminForthDataTypes.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 == AdminForthDataTypes.DATETIME) {
+            if (!value) {
+                return null;
+            }
+            if (field._underlineType == 'timestamp' || field._underlineType == 'int') {
+                return dayjs(value).toISOString();
+            }
+            else if (field._underlineType == 'varchar') {
+                return dayjs(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)`);
+            }
+        }
+        if (field.type == AdminForthDataTypes.DATE) {
+            if (!value) {
+                return null;
+            }
+            return dayjs(value).toISOString().split('T')[0];
+        }
+        return value;
+    }
+    getRecordByPrimaryKeyWithOriginalTypes(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] = value;
+            }
+            return newRow;
+        });
+    }
+    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;
+        }
+        return value;
+    }
+    getDataWithOriginalTypes(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
+            const columns = resource.dataSourceColumns.map((col) => `"${col.name}"`).join(', ');
+            const tableName = resource.table;
+            let totalCounter = 1;
+            const where = filters.length ? `WHERE ${filters.map((f, i) => {
+                let placeholder = '$' + (totalCounter);
+                const fieldData = resource.dataSourceColumns.find((col) => col.name == f.field);
+                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;
+                }
+                if (fieldData._underlineType == 'uuid') {
+                    field = `cast("${field}" as text)`;
+                }
+                else {
+                    field = `"${field}"`;
+                }
+                return `${field} ${operator} ${placeholder}`;
+            }).join(' AND ')}` : '';
+            const filterValues = [];
+            filters.length ? filters.forEach((f) => {
+                // for arrays do set in map
+                let v = f.value;
+                if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
+                    filterValues.push(`%${v}%`);
+                }
+                else if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                    filterValues.push(...v);
+                }
+                else {
+                    filterValues.push(v);
+                }
+            }) : [];
+            const 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 selectQuery = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} ${limitOffset}`;
+            if (process.env.HEAVY_DEBUG) {
+                console.log('🪲 PG selectQuery:', selectQuery, 'params:', d);
+            }
+            const stmt = yield this.db.query(selectQuery, d);
+            const rows = stmt.rows;
+            const total = (yield this.db.query(`SELECT COUNT(*) FROM ${tableName} ${where}`, filterValues)).rows[0].count;
+            return {
+                data: rows.map((row) => {
+                    const newRow = {};
+                    for (const [key, value] of Object.entries(row)) {
+                        newRow[key] = value;
+                    }
+                    return newRow;
+                }),
+                total,
+            };
+        });
+    }
+    getMinMaxForColumnsWithOriginalTypes(_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, 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) => record[colName]);
+            for (let i = 0; i < columns.length; i++) {
+                columns[i] = `"${columns[i]}"`;
+            }
+            yield this.db.query(`INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`, values);
+        });
+    }
+    updateRecord(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, newValues }) {
+            const values = [...Object.values(newValues), recordId];
+            const columnsWithPlaceholders = Object.keys(newValues).map((col, i) => `"${col}" = $${i + 1}`).join(', ');
+            yield this.db.query(`UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE "${this.getPrimaryKey(resource)}" = $${values.length}`, values);
+        });
+    }
+    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;