adminforth 1.2.98 → 1.2.100

package/dist/dataConnectors/sqlite.js

@@ -75,6 +75,10 @@ class SQLiteConnector extends AdminForthBaseConnector {
                     field.type = AdminForthDataTypes.BOOLEAN;
                     field._underlineType = 'boolean';
                 }
+                else if (baseType == 'datetime') {
+                    field.type = AdminForthDataTypes.DATETIME;
+                    field._underlineType = 'datetime';
+                }
                 else {
                     field.type = 'unknown';
                 }
@@ -98,6 +102,9 @@ class SQLiteConnector extends AdminForthBaseConnector {
             else if (field._underlineType == 'varchar') {
                 return dayjs(value).toISOString();
             }
+            else if (field._underlineType == 'datetime') {
+                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}"`);
             }
@@ -134,6 +141,9 @@ class SQLiteConnector extends AdminForthBaseConnector {
                 // value is iso string now, convert to unix timestamp
                 return dayjs(value).toISOString();
             }
+            else {
+                return value;
+            }
         }
         else if (field.type == AdminForthDataTypes.BOOLEAN) {
             return value ? 1 : 0;
@@ -149,39 +159,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 +204,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 +257,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() {

package/dist/index.js

@@ -19,16 +19,18 @@ import PostgresConnector from './dataConnectors/postgres.js';
 import SQLiteConnector from './dataConnectors/sqlite.js';
 import CodeInjector from './modules/codeInjector.js';
 import ExpressServer from './servers/express.js';
-import { ADMINFORTH_VERSION, listify } from './modules/utils.js';
+import { ADMINFORTH_VERSION, listify, suggestIfTypo } from './modules/utils.js';
 import { AdminForthFilterOperators, AdminForthDataTypes, AdminForthResourcePages, } from './types/AdminForthConfig.js';
 import AdminForthPlugin from './basePlugin.js';
 import ConfigValidator from './modules/configValidator.js';
 import AdminForthRestAPI, { interpretResource } from './modules/restApi.js';
 import ClickhouseConnector from './dataConnectors/clickhouse.js';
+import OperationalResource from './modules/operationalResource.js';
 // exports
 export * from './types/AdminForthConfig.js';
 export { interpretResource };
 export { AdminForthPlugin };
+export { suggestIfTypo };
 class AdminForth {
     constructor(config) {
         _AdminForth_defaultConfig.set(this, {
@@ -85,20 +87,22 @@ class AdminForth {
             this.config.dataSources.forEach((ds) => {
                 const dbType = ds.url.split(':')[0];
                 if (!this.config.databaseConnectors[dbType]) {
-                    throw new Error(`Database type ${dbType} is not supported, consider using databaseConnectors in AdminForth config`);
+                    throw new Error(`Database type '${dbType}' is not supported, consider using one of ${Object.keys(this.connectorClasses).join(', ')} or create your own data-source connector`);
                 }
                 this.connectors[ds.id] = new this.config.databaseConnectors[dbType]({ url: ds.url });
             });
             yield Promise.all(this.config.resources.map((res) => __awaiter(this, void 0, void 0, function* () {
                 if (!this.connectors[res.dataSource]) {
-                    throw new Error(`Resource '${res.table}' refers to unknown dataSource '${res.dataSource}'`);
+                    const similar = suggestIfTypo(Object.keys(this.connectors), res.dataSource);
+                    throw new Error(`Resource '${res.table}' refers to unknown dataSource '${res.dataSource}' ${similar
+                        ? `. Did you mean '${similar}'?` : 'Available dataSources: ' + Object.keys(this.connectors).join(', ')}`);
                 }
                 const fieldTypes = yield this.connectors[res.dataSource].discoverFields(res);
                 if (fieldTypes !== null && !Object.keys(fieldTypes).length) {
                     throw new Error(`Table '${res.table}' (In resource '${res.resourceId}') has no fields or does not exist`);
                 }
                 if (fieldTypes === null) {
-                    console.error(`DataSource ${res.dataSource} was not able to perform field discovery. It will not work properly`);
+                    console.error(`⛔ DataSource ${res.dataSource} was not able to perform field discovery. It will not work properly`);
                     return;
                 }
                 if (!res.columns) {
@@ -106,7 +110,8 @@ class AdminForth {
                 }
                 res.columns.forEach((col, i) => {
                     if (!fieldTypes[col.name] && !col.virtual) {
-                        throw new Error(`Resource '${res.table}' has no column '${col.name}'`);
+                        const similar = suggestIfTypo(Object.keys(fieldTypes), col.name);
+                        throw new Error(`Resource '${res.table}' has no column '${col.name}'. ${similar ? `Did you mean '${similar}'?` : ''}`);
                     }
                     // first find discovered values, but allow override
                     res.columns[i] = Object.assign(Object.assign({}, fieldTypes[col.name]), col);
@@ -118,6 +123,10 @@ class AdminForth {
                 }
             })));
             this.statuses.dbDiscover = 'done';
+            this.operationalResources = {};
+            this.config.resources.forEach((resource) => {
+                this.operationalResources[resource.resourceId] = new OperationalResource(this.connectors[resource.dataSource], resource);
+            });
             // console.log('⚙️⚙️⚙️ Database discovery done', JSON.stringify(this.config.resources, null, 2));
         });
     }
@@ -128,9 +137,11 @@ class AdminForth {
     }
     getUserByPk(pk) {
         return __awaiter(this, void 0, void 0, function* () {
-            const resource = this.config.resources.find((res) => res.resourceId === this.config.auth.resourceId);
+            const resource = this.config.resources.find((res) => res.resourceId === this.config.auth.usersResourceId);
             if (!resource) {
-                throw new Error('No auth resource found');
+                const similar = suggestIfTypo(this.config.resources.map((res) => res.resourceId), this.config.auth.usersResourceId);
+                throw new Error(`No resource with  ${this.config.auth.usersResourceId} found. ${similar ?
+                    `Did you mean '${similar}' in config.auth.usersResourceId?` : 'Please set correct resource in config.auth.usersResourceId'}`);
             }
             const users = yield this.connectors[resource.dataSource].getData({
                 resource,
@@ -148,39 +159,21 @@ class AdminForth {
         return __awaiter(this, arguments, void 0, function* ({ resource, record, adminUser }) {
             var _c, _d, _e, _f, _g;
             for (const column of resource.columns) {
-                if (column.fillOnCreate) {
-                    if (record[column.name] === undefined) {
-                        record[column.name] = column.fillOnCreate({
-                            initialRecord: record, adminUser
-                        });
-                    }
-                }
+                // TODO: assuming specifity for AdminForthResourcePages.create better to move it to api for this button
                 if (((_c = column.required) === null || _c === void 0 ? void 0 : _c.create) &&
                     record[column.name] === undefined &&
                     column.showIn.includes(AdminForthResourcePages.create)) {
-                    return { error: `Column '${column.name}' is required` };
-                }
-                if (column.isUnique) {
-                    const existingRecord = yield this.connectors[resource.dataSource].getData({
-                        resource,
-                        filters: [{ field: column.name, operator: AdminForthFilterOperators.EQ, value: record[column.name] }],
-                        limit: 1,
-                        sort: [],
-                        offset: 0
-                    });
-                    if (existingRecord.data.length > 0) {
-                        return { error: `Record with ${column.name} ${record[column.name]} already exists` };
-                    }
+                    return { error: `Column '${column.name}' is required`, ok: false };
                 }
             }
             // execute hook if needed
             for (const hook of listify((_e = (_d = resource.hooks) === null || _d === void 0 ? void 0 : _d.create) === null || _e === void 0 ? void 0 : _e.beforeSave)) {
-                const resp = yield hook({ resource, record, adminUser });
+                const resp = yield hook({ recordId: undefined, resource, record, adminUser });
                 if (!resp || (!resp.ok && !resp.error)) {
                     throw new Error(`Hook beforeSave must return object with {ok: true} or { error: 'Error' } `);
                 }
                 if (resp.error) {
-                    return { error: resp.error };
+                    return { error: resp.error, ok: false };
                 }
             }
             // remove virtual columns from record
@@ -191,21 +184,47 @@ class AdminForth {
             }
             const connector = this.connectors[resource.dataSource];
             process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record createResourceRecord', record);
-            yield connector.createRecord({ resource, record });
+            const { ok, error, createdRecord } = yield connector.createRecord({ resource, record, adminUser });
+            if (!ok) {
+                return { ok, error };
+            }
+            const primaryKey = record[resource.columns.find((col) => col.primaryKey).name];
             // execute hook if needed
             for (const hook of listify((_g = (_f = resource.hooks) === null || _f === void 0 ? void 0 : _f.create) === null || _g === void 0 ? void 0 : _g.afterSave)) {
                 console.log('Hook afterSave', hook);
-                const resp = yield hook({ resource, record, adminUser });
+                const resp = yield hook({
+                    recordId: primaryKey,
+                    resource,
+                    record: createdRecord,
+                    adminUser
+                });
                 if (!resp || (!resp.ok && !resp.error)) {
                     throw new Error(`Hook afterSave must return object with {ok: true} or { error: 'Error' } `);
                 }
                 if (resp.error) {
-                    return { error: resp.error };
+                    return { error: resp.error, ok: false };
                 }
             }
-            return { ok: true };
+            return { ok, error, createdRecord };
         });
     }
+    resource(resourceId) {
+        if (this.statuses.dbDiscover !== 'done') {
+            if (this.statuses.dbDiscover === 'running') {
+                throw new Error('Database discovery is running. You can\'t use data API while database discovery is not finished.\n' +
+                    'Consider moving your code to a place where it will be executed after database discovery is already done (after await admin.discoverDatabases())');
+            }
+            else {
+                throw new Error('Database discovery is not yet started. You can\'t use data API before database discovery is done. \n' +
+                    'Call admin.discoverDatabases() first and await it before using data API');
+            }
+        }
+        if (!this.operationalResources[resourceId]) {
+            const closeName = suggestIfTypo(Object.keys(this.operationalResources), resourceId);
+            throw new Error(`Resource with id '${resourceId}' not found${closeName ? `. Did you mean '${closeName}'?` : ''}`);
+        }
+        return this.operationalResources[resourceId];
+    }
     setupEndpoints(server) {
         this.restApi.registerEndpoints(server);
     }

package/dist/modules/configValidator.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { AdminForthResourcePages, AllowedActionsEnum, } from "../types/AdminForthConfig.js";
 import fs from 'fs';
 import path from 'path';
-import { guessLabelFromName } from './utils.js';
+import { guessLabelFromName, suggestIfTypo } from './utils.js';
 import crypto from 'crypto';
 export default class ConfigValidator {
     constructor(adminforth, config) {
@@ -47,15 +47,6 @@ export default class ConfigValidator {
     validateConfig() {
         var _a;
         const errors = [];
-        if (this.config.rootUser) {
-            if (!this.config.rootUser.username) {
-                throw new Error('rootUser.username is required');
-            }
-            if (!this.config.rootUser.password) {
-                throw new Error('rootUser.password is required');
-            }
-            console.log('\n ☝️☝️☝️ [INSECURE ALERT] config.rootUser is set, please create a new user to login in backoffice and remove config.rootUser from config ASAP when you are in production\n');
-        }
         if (!this.config.customization.customComponentsDir) {
             this.config.customization.customComponentsDir = './custom';
         }
@@ -67,8 +58,12 @@ export default class ConfigValidator {
             this.config.customization.customComponentsDir = undefined;
         }
         if (this.config.auth) {
-            if (!this.config.auth.resourceId) {
-                throw new Error('No config.auth.resourceId defined');
+            // TODO: remove in future releases
+            if (!this.config.auth.usersResourceId && this.config.auth.resourceId) {
+                this.config.auth.usersResourceId = this.config.auth.resourceId;
+            }
+            if (!this.config.auth.usersResourceId) {
+                throw new Error('No config.auth.usersResourceId defined');
             }
             if (!this.config.auth.passwordHashField) {
                 throw new Error('No config.auth.passwordHashField defined');
@@ -79,9 +74,10 @@ export default class ConfigValidator {
             if (this.config.auth.loginBackgroundImage) {
                 errors.push(...this.checkCustomFileExists(this.config.auth.loginBackgroundImage));
             }
-            const userResource = this.config.resources.find((res) => res.resourceId === this.config.auth.resourceId);
+            const userResource = this.config.resources.find((res) => res.resourceId === this.config.auth.usersResourceId);
             if (!userResource) {
-                throw new Error(`Resource with id "${this.config.auth.resourceId}" not found`);
+                const similar = suggestIfTypo(this.config.resources.map((res) => res.resourceId || res.table), this.config.auth.usersResourceId);
+                throw new Error(`Resource with id "${this.config.auth.usersResourceId}" not found. ${similar ? `Did you mean "${similar}"?` : ''}`);
             }
             if (!this.config.auth.beforeLoginConfirmation) {
                 this.config.auth.beforeLoginConfirmation = [];
@@ -126,6 +122,9 @@ export default class ConfigValidator {
         if (this.config.customization.brandLogo) {
             errors.push(...this.checkCustomFileExists(this.config.customization.brandLogo));
         }
+        if (this.config.customization.showBrandNameInSidebar === undefined) {
+            this.config.customization.showBrandNameInSidebar = true;
+        }
         if (this.config.customization.favicon) {
             errors.push(...this.checkCustomFileExists(this.config.customization.favicon));
         }
@@ -254,7 +253,12 @@ export default class ConfigValidator {
                             yield Promise.all(selectedIds.map((recordId) => __awaiter(this, void 0, void 0, function* () {
                                 const record = yield connector.getRecordByPrimaryKey(res, recordId);
                                 yield Promise.all(res.hooks.delete.beforeSave.map((hook) => __awaiter(this, void 0, void 0, function* () {
-                                    const resp = yield hook({ resource: res, record, adminUser });
+                                    const resp = yield hook({
+                                        recordId: recordId,
+                                        resource: res,
+                                        record,
+                                        adminUser,
+                                    });
                                     if (!error && resp.error) {
                                         error = resp.error;
                                     }
@@ -265,7 +269,12 @@ export default class ConfigValidator {
                                 yield connector.deleteRecord({ resource: res, recordId });
                                 // call afterDelete hook
                                 yield Promise.all(res.hooks.delete.afterSave.map((hook) => __awaiter(this, void 0, void 0, function* () {
-                                    yield hook({ resource: res, record, adminUser });
+                                    yield hook({
+                                        resource: res,
+                                        record,
+                                        adminUser,
+                                        recordId: recordId
+                                    });
                                 })));
                             })));
                             if (error) {

package/dist/modules/operationalResource.js

@@ -0,0 +1,88 @@
+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());
+    });
+};
+function filtersIfFilter(filter) {
+    if (!filter) {
+        return [];
+    }
+    return (Array.isArray(filter) ? filter : [filter]);
+}
+function sortsIfSort(sort) {
+    return (Array.isArray(sort) ? sort : [sort]);
+}
+export default class OperationalResource {
+    constructor(dataConnector, resourceConfig) {
+        this.dataConnector = dataConnector;
+        this.resourceConfig = resourceConfig;
+    }
+    get(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.dataConnector.getData({
+                resource: this.resourceConfig,
+                filters: filtersIfFilter(filter),
+                limit: 1,
+                offset: 0,
+                sort: [],
+            })).data[0] || null;
+        });
+    }
+    list(filter, limit, offset, sort) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let appliedLimit = limit;
+            if (limit === null) {
+                appliedLimit = 1000000000;
+            }
+            let appliedOffset = offset;
+            if (offset === null) {
+                appliedOffset = 0;
+            }
+            const { data } = yield this.dataConnector.getData({
+                resource: this.resourceConfig,
+                filters: filtersIfFilter(filter),
+                limit: appliedLimit,
+                offset: appliedOffset,
+                sort: sortsIfSort(sort),
+                getTotals: false,
+            });
+            return data;
+        });
+    }
+    count(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.dataConnector.getCount({
+                resource: this.resourceConfig,
+                filters: filtersIfFilter(filter),
+            });
+        });
+    }
+    create(recordValues) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { ok, createdRecord, error } = yield this.dataConnector.createRecord({
+                resource: this.resourceConfig,
+                record: recordValues,
+                adminUser: null
+            });
+            return { ok, createdRecord, error };
+        });
+    }
+    update(primaryKey, record) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.dataConnector.updateRecord({
+                resource: this.resourceConfig,
+                recordId: primaryKey,
+                newValues: record
+            });
+        });
+    }
+    delete(primaryKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.dataConnector.deleteRecord({ resource: this.resourceConfig, recordId: primaryKey });
+        });
+    }
+}