adminforth 1.2.98 → 1.3.1

package/dist/dataConnectors/baseConnector.js

@@ -8,6 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { AdminForthFilterOperators } from "../types/AdminForthConfig.js";
+import { suggestIfTypo } from "../modules/utils.js";
 export default class AdminForthBaseConnector {
     getPrimaryKey(resource) {
         for (const col of resource.dataSourceColumns) {
@@ -24,12 +25,14 @@ export default class AdminForthBaseConnector {
                 offset: 0,
                 sort: [],
                 filters: [{ field: this.getPrimaryKey(resource), operator: AdminForthFilterOperators.EQ, value: id }],
-                getTotals: false
             });
-            return data.data.length > 0 ? data.data[0] : null;
+            return data.length > 0 ? data[0] : null;
         });
     }
-    getDataWithOriginalTypes({ resource, limit, offset, sort, filters, getTotals }) {
+    getDataWithOriginalTypes({ resource, limit, offset, sort, filters }) {
+        throw new Error('Method not implemented.');
+    }
+    getCount({ resource, filters }) {
         throw new Error('Method not implemented.');
     }
     discoverFields(resource) {
@@ -47,10 +50,17 @@ export default class AdminForthBaseConnector {
     createRecordOriginalValues({ resource, record }) {
         throw new Error('Method not implemented.');
     }
-    createRecord({ resource, record }) {
+    createRecord({ resource, record, adminUser }) {
         // transform value using setFieldValue and call createRecordOriginalValues
         const newRecord = Object.assign({}, record);
         for (const col of resource.dataSourceColumns) {
+            if (col.fillOnCreate) {
+                if (record[col.name] === undefined) {
+                    record[col.name] = col.fillOnCreate({
+                        initialRecord: record, adminUser
+                    });
+                }
+            }
             newRecord[col.name] = this.setFieldValue(col, record[col.name]);
         }
         process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record', newRecord);
@@ -63,25 +73,37 @@ export default class AdminForthBaseConnector {
         throw new Error('Method not implemented.');
     }
     getData(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters, getTotals }) {
             if (filters) {
                 filters.map((f) => {
+                    const fieldObj = resource.dataSourceColumns.find((col) => col.name == f.field);
+                    if (!fieldObj) {
+                        const similar = suggestIfTypo(resource.dataSourceColumns.map((col) => col.name), f.field);
+                        throw new Error(`Field '${f.field}' not found in resource '${resource.resourceId}'. ${similar ? `Did you mean '${similar}'?` : ''}`);
+                    }
                     if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                        f.value = f.value.map((val) => this.setFieldValue(resource.dataSourceColumns.find((col) => col.name == f.field), val));
+                        f.value = f.value.map((val) => this.setFieldValue(fieldObj, val));
                     }
                     else {
-                        f.value = this.setFieldValue(resource.dataSourceColumns.find((col) => col.name == f.field), f.value);
+                        f.value = this.setFieldValue(fieldObj, f.value);
                     }
                 });
             }
-            const d = yield this.getDataWithOriginalTypes({ resource, limit, offset, sort, filters, getTotals: true });
+            const promises = [this.getDataWithOriginalTypes({ resource, limit, offset, sort, filters })];
+            if (getTotals) {
+                promises.push(this.getCount({ resource, filters }));
+            }
+            else {
+                promises.push(Promise.resolve(undefined));
+            }
+            const [data, total] = yield Promise.all(promises);
             // call getFieldValue for each field
-            d.data.map((record) => {
+            data.map((record) => {
                 for (const col of resource.dataSourceColumns) {
                     record[col.name] = this.getFieldValue(col, record[col.name]);
                 }
             });
-            return d;
+            return { data, total };
         });
     }
     getMinMaxForColumns(_a) {

package/dist/dataConnectors/clickhouse.js

@@ -184,36 +184,44 @@ class ClickhouseConnector extends AdminForthBaseConnector {
         }
         return value;
     }
+    whereClause(resource, filters) {
+        return filters.length ? `WHERE ${filters.map((f, i) => {
+            const column = resource.dataSourceColumns.find((col) => col.name == f.field);
+            let placeholder = `{f${i}:${column._underlineType}}`;
+            let field = f.field;
+            let operator = this.OperatorsMap[f.operator];
+            if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                placeholder = `(${f.value.map((_, j) => `{p${i}_${j}:${column._underlineType}}`).join(', ')})`;
+            }
+            return `${field} ${operator} ${placeholder}`;
+        }).join(' AND ')}` : '';
+    }
+    whereParams(filters) {
+        const params = {};
+        filters.length ? filters.forEach((f, i) => {
+            // for arrays do set in map
+            const v = f.value;
+            if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
+                params[`f${i}`] = `%${v}%`;
+            }
+            else if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                v.forEach((_, j) => {
+                    params[`p${i}_${j}`] = v[j];
+                });
+            }
+            else {
+                params[`f${i}`] = v;
+            }
+        }) : [];
+        return params;
+    }
     getDataWithOriginalTypes(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters, getTotals }) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
+            console.log('getDataWithOriginalTypes', 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) => {
-                const column = resource.dataSourceColumns.find((col) => col.name == f.field);
-                let placeholder = `{f${i}:${column._underlineType}}`;
-                let field = f.field;
-                let operator = this.OperatorsMap[f.operator];
-                if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                    placeholder = `(${f.value.map((_, j) => `{p${i}_${j}:${column._underlineType}}`).join(', ')})`;
-                }
-                return `${field} ${operator} ${placeholder}`;
-            }).join(' AND ')}` : '';
-            const params = {};
-            filters.length ? filters.forEach((f, i) => {
-                // for arrays do set in map
-                const v = f.value;
-                if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
-                    params[`f${i}`] = `%${v}%`;
-                }
-                else if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                    v.forEach((_, j) => {
-                        params[`p${i}_${j}`] = v[j];
-                    });
-                }
-                else {
-                    params[`f${i}`] = v;
-                }
-            }) : [];
+            const where = this.whereClause(resource, filters);
+            const params = this.whereParams(filters);
             const orderBy = sort.length ? `ORDER BY ${sort.map((s) => `${s.field} ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
             const q = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT {limit:Int} OFFSET {offset:Int}`;
             const d = Object.assign(Object.assign({}, params), { limit,
@@ -224,26 +232,27 @@ class ClickhouseConnector extends AdminForthBaseConnector {
                 query_params: d,
             });
             const rows = yield stmt.json();
-            let total = 0;
-            if (getTotals) {
-                const countQ = yield this.client.query({
-                    query: `SELECT COUNT(*) FROM ${tableName} ${where}`,
-                    format: 'JSONEachRow',
-                    query_params: d,
-                });
-                const countResp = yield countQ.json();
-                total = countResp[0]['COUNT()'];
-            }
-            return {
-                data: rows.map((row) => {
-                    const newRow = {};
-                    for (const [key, value] of Object.entries(row)) {
-                        newRow[key] = value;
-                    }
-                    return newRow;
-                }),
-                total,
-            };
+            return rows.map((row) => {
+                const newRow = {};
+                for (const [key, value] of Object.entries(row)) {
+                    newRow[key] = value;
+                }
+                return newRow;
+            });
+        });
+    }
+    getCount(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, filters, }) {
+            const tableName = resource.table;
+            const where = this.whereClause(resource, filters);
+            const d = this.whereParams(filters);
+            const countQ = yield this.client.query({
+                query: `SELECT COUNT(*) FROM ${tableName} ${where}`,
+                format: 'JSONEachRow',
+                query_params: d,
+            });
+            const countResp = yield countQ.json();
+            return countResp[0]['COUNT()'];
         });
     }
     getMinMaxForColumnsWithOriginalTypes(_a) {
@@ -291,10 +300,12 @@ class ClickhouseConnector extends AdminForthBaseConnector {
     deleteRecord(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, recordId }) {
             const pkColumn = resource.dataSourceColumns.find((col) => col.primaryKey);
-            yield this.client.command({
+            const res = yield this.client.command({
                 query: `ALTER TABLE ${this.dbName}.${resource.table} DELETE WHERE ${pkColumn.name} = {recordId:${pkColumn._underlineType}}`,
                 query_params: { recordId },
             });
+            // todo test what is in res
+            return res;
         });
     }
     close() {

package/dist/dataConnectors/mongo.js

@@ -108,25 +108,41 @@ class MongoConnector extends AdminForthBaseConnector {
         }
         return value;
     }
-    getDataWithOriginalTypes(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters, getTotals }) {
-            // const columns = resource.dataSourceColumns.filter(c=> !c.virtual).map((col) => col.name).join(', ');
-            const tableName = resource.table;
-            const collection = this.db.db().collection(tableName);
+    genQuery(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
+            const collection = this.db.db().collection(resource.table);
             const query = {};
             for (const filter of filters) {
                 query[filter.field] = this.OperatorsMap[filter.operator](filter.value);
             }
-            let total = 0;
-            if (getTotals) {
-                total = yield collection.countDocuments(query);
-            }
+            return { collection, query };
+        });
+    }
+    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 = this.genQuery({ resource, limit, offset, sort, filters });
+            const sortArray = sort.map((s) => {
+                return [s.field, this.SortDirectionsMap[s.direction]];
+            });
             const result = yield collection.find(query)
-                .sort(sort)
+                .sort(sortArray)
                 .skip(offset)
                 .limit(limit)
                 .toArray();
-            return { data: result, total };
+            return result;
+        });
+    }
+    getCount(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, filters }) {
+            const collection = this.db.db().collection(resource.table);
+            const query = {};
+            for (const filter of filters) {
+                query[filter.field] = this.OperatorsMap[filter.operator](filter.value);
+            }
+            return yield collection.countDocuments(query);
         });
     }
     getMinMaxForColumnsWithOriginalTypes(_a) {
@@ -166,7 +182,8 @@ class MongoConnector extends AdminForthBaseConnector {
         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 });
+            const res = yield collection.deleteOne({ [primaryKey]: recordId });
+            return res.deletedCount > 0;
         });
     }
     close() {

package/dist/dataConnectors/postgres.js

@@ -184,46 +184,54 @@ class PostgresConnector extends AdminForthBaseConnector {
         }
         return value;
     }
+    whereClauseAndValues(resource, filters) {
+        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);
+            }
+        }) : [];
+        return {
+            sql: where,
+            paramsCount: totalCounter,
+            values: filterValues,
+        };
+    }
     getDataWithOriginalTypes(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters, getTotals }) {
+        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 { sql: where, paramsCount, values: filterValues } = this.whereClauseAndValues(resource, filters);
+            const limitOffset = `LIMIT $${paramsCount} OFFSET $${paramsCount + 1}`;
             const d = [...filterValues, limit, offset];
             const orderBy = sort.length ? `ORDER BY ${sort.map((s) => `"${s.field}" ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
             const selectQuery = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} ${limitOffset}`;
@@ -232,20 +240,21 @@ class PostgresConnector extends AdminForthBaseConnector {
             }
             const stmt = yield this.db.query(selectQuery, d);
             const rows = stmt.rows;
-            let total = 0;
-            if (getTotals) {
-                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,
-            };
+            return rows.map((row) => {
+                const newRow = {};
+                for (const [key, value] of Object.entries(row)) {
+                    newRow[key] = value;
+                }
+                return newRow;
+            });
+        });
+    }
+    getCount(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, filters }) {
+            const tableName = resource.table;
+            const { sql: where, values: filterValues } = this.whereClauseAndValues(resource, filters);
+            const stmt = yield this.db.query(`SELECT COUNT(*) FROM ${tableName} ${where}`, filterValues);
+            return stmt.rows[0].count;
         });
     }
     getMinMaxForColumnsWithOriginalTypes(_a) {
@@ -283,7 +292,8 @@ class PostgresConnector extends AdminForthBaseConnector {
     }
     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]);
+            const res = yield this.db.query(`DELETE FROM ${resource.table} WHERE "${this.getPrimaryKey(resource)}" = $1`, [recordId]);
+            return res.rowCount > 0;
         });
     }
     close() {

package/dist/dataConnectors/sqlite.js

@@ -149,39 +149,44 @@ class SQLiteConnector extends AdminForthBaseConnector {
         }
         return value;
     }
+    whereClause(filters) {
+        return 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 ')}` : '';
+    }
+    whereParams(filters) {
+        return filters.reduce((acc, f) => {
+            if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
+                acc.push(`%${f.value}%`);
+            }
+            else if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                acc.push(...f.value);
+            }
+            else {
+                acc.push(f.value);
+            }
+            return acc;
+        }, []);
+    }
     getDataWithOriginalTypes(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters, getTotals }) {
+        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 where = this.whereClause(filters);
+            const filterValues = this.whereParams(filters);
             const orderBy = sort.length ? `ORDER BY ${sort.map((s) => `${s.field} ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
+            console.log('🪲 SQLITE Query', `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT ? OFFSET ?`, 'params:', [...filterValues, limit, offset]);
             const q = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT ? OFFSET ?`;
             const stmt = this.db.prepare(q);
             const d = [...filterValues, limit, offset];
@@ -189,21 +194,22 @@ class SQLiteConnector extends AdminForthBaseConnector {
                 console.log('🪲 SQLITE Query', q, 'params:', d);
             }
             const rows = yield stmt.all(d);
-            let total = 0;
-            if (getTotals) {
-                const totalStmt = this.db.prepare(`SELECT COUNT(*) FROM ${tableName} ${where}`);
-                total = totalStmt.get([...filterValues])['COUNT(*)'];
-            }
-            return {
-                data: rows.map((row) => {
-                    const newRow = {};
-                    for (const [key, value] of Object.entries(row)) {
-                        newRow[key] = value;
-                    }
-                    return newRow;
-                }),
-                total,
-            };
+            return rows.map((row) => {
+                const newRow = {};
+                for (const [key, value] of Object.entries(row)) {
+                    newRow[key] = value;
+                }
+                return newRow;
+            });
+        });
+    }
+    getCount(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, filters }) {
+            const tableName = resource.table;
+            const where = this.whereClause(filters);
+            const filterValues = this.whereParams(filters);
+            const totalStmt = this.db.prepare(`SELECT COUNT(*) FROM ${tableName} ${where}`);
+            return totalStmt.get([...filterValues])['COUNT(*)'];
         });
     }
     getMinMaxForColumnsWithOriginalTypes(_a) {
@@ -241,7 +247,8 @@ class SQLiteConnector extends AdminForthBaseConnector {
     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);
+            const res = yield q.run(recordId);
+            return res.changes > 0;
         });
     }
     close() {