adminforth 1.1.91 → 1.1.93

package/plugins/TwoFactorsAuthPlugin/dist/dataConnectors/sqlite.js

@@ -0,0 +1,246 @@
+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 betterSqlite3 from 'better-sqlite3';
+import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections } from '../types/AdminForthConfig.js';
+import AdminForthBaseConnector from './baseConnector.js';
+import dayjs from 'dayjs';
+class SQLiteConnector 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',
+        };
+        // create connection here
+        this.db = betterSqlite3(url.replace('sqlite://', ''));
+    }
+    discoverFields(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tableName = resource.table;
+            const stmt = this.db.prepare(`PRAGMA table_info(${tableName})`);
+            const rows = yield stmt.all();
+            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('varchar(')) {
+                    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; //8-byte IEEE floating point number. It
+                    field._underlineType = 'real';
+                }
+                else if (baseType == 'timestamp') {
+                    field.type = AdminForthDataTypes.DATETIME;
+                    field._underlineType = 'timestamp';
+                }
+                else if (baseType == 'boolean') {
+                    field.type = AdminForthDataTypes.BOOLEAN;
+                    field._underlineType = 'boolean';
+                }
+                else {
+                    field.type = 'unknown';
+                }
+                field._baseTypeDebug = baseType;
+                field.required = row.notnull == 1;
+                field.primaryKey = row.pk == 1;
+                field.default = 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.unix(+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). Issue in field "${field.name}"`);
+            }
+        }
+        else if (field.type == AdminForthDataTypes.DATE) {
+            if (!value) {
+                return null;
+            }
+            return dayjs(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 columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
+            const tableName = resource.table;
+            const stmt = this.db.prepare(`SELECT ${columns} FROM ${tableName} WHERE ${this.getPrimaryKey(resource)} = ?`);
+            const row = stmt.get(key);
+            if (!row) {
+                return null;
+            }
+            const newRow = {};
+            for (const [key, value] of Object.entries(row)) {
+                newRow[key] = value;
+            }
+            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.map((col) => col.name).join(', ');
+            const tableName = resource.table;
+            const where = filters.length ? `WHERE ${filters.map((f, i) => {
+                let placeholder = '?';
+                let field = f.field;
+                let operator = this.OperatorsMap[f.operator];
+                if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                    placeholder = `(${f.value.map(() => '?').join(', ')})`;
+                }
+                else if (f.operator == AdminForthFilterOperators.ILIKE) {
+                    placeholder = `LOWER(?)`;
+                    field = `LOWER(${f.field})`;
+                    operator = 'LIKE';
+                }
+                return `${field} ${operator} ${placeholder}`;
+            }).join(' AND ')}` : '';
+            const filterValues = [];
+            filters.length ? filters.forEach((f) => {
+                // for arrays do set in map
+                const 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 orderBy = sort.length ? `ORDER BY ${sort.map((s) => `${s.field} ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
+            const q = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT ? OFFSET ?`;
+            const stmt = this.db.prepare(q);
+            const d = [...filterValues, limit, offset];
+            if (process.env.HEAVY_DEBUG) {
+                console.log('🪲 SQLITE Query', q, 'params:', d);
+            }
+            const rows = yield stmt.all(d);
+            const total = (yield this.db.prepare(`SELECT COUNT(*) FROM ${tableName} ${where}`).get([...filterValues]))['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.prepare(`SELECT MIN(${col.name}) as min, MAX(${col.name}) as max FROM ${tableName}`);
+                const { min, max } = stmt.get();
+                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(() => '?').join(', ');
+            const values = columns.map((colName) => record[colName]);
+            const q = this.db.prepare(`INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`);
+            yield q.run(values);
+        });
+    }
+    updateRecord(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, newValues }) {
+            const columnsWithPlaceholders = Object.keys(newValues).map((col) => `${col} = ?`);
+            const values = [...Object.values(newValues), recordId];
+            const q = this.db.prepare(`UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE ${this.getPrimaryKey(resource)} = ?`);
+            yield q.run(values);
+        });
+    }
+    deleteRecord(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId }) {
+            const q = this.db.prepare(`DELETE FROM ${resource.table} WHERE ${this.getPrimaryKey(resource)} = ?`);
+            yield q.run(recordId);
+        });
+    }
+    close() {
+        this.db.close();
+    }
+}
+export default SQLiteConnector;