adminforth 1.2.99 → 1.2.100

package/auth.ts

@@ -88,12 +88,13 @@ class AdminForthAuth {
       console.error(`Invalid token type during verification: ${t}, must be ${mustHaveType}`);
       return null;
     }
-    if (pk === null) {
-      decoded.isRoot = true;
-    } else {
-      const dbUser = await this.adminforth.getUserByPk(pk);
-      decoded.dbUser = dbUser;
+    const dbUser = await this.adminforth.getUserByPk(pk);
+    if (!dbUser) {
+      console.error(`User with pk ${pk} not found in database`);
+      // will logout user which was deleted
+      return null;
     }
+    decoded.dbUser = dbUser;
     return decoded;
   }
 

package/dataConnectors/baseConnector.ts

@@ -1,5 +1,6 @@
 import { get } from "http";
 import { AdminForthResource, IAdminForthDataSourceConnectorBase, AdminForthSortDirections, AdminForthFilterOperators, AdminForthResourceColumn, IAdminForthSort, IAdminForthFilter } from "../types/AdminForthConfig.js";
+import { suggestIfTypo } from "../modules/utils.js";
 
 
 export default class AdminForthBaseConnector implements IAdminForthDataSourceConnectorBase {
@@ -56,14 +57,66 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
     throw new Error('Method not implemented.');
   }
 
-  createRecord({ resource, record }: { resource: AdminForthResource; record: any; }): Promise<void> {
+  async checkUnique(resource: AdminForthResource, column: AdminForthResourceColumn, value: any) {
+    process.env.HEAVY_DEBUG && console.log('☝️🪲🪲🪲🪲 checkUnique|||', column, value);
+    const existingRecord = await this.getData({
+      resource,
+      filters: [{ field: column.name, operator: AdminForthFilterOperators.EQ, value }],
+      limit: 1,
+      sort: [],
+      offset: 0,
+      getTotals: false
+    });
+    process.env.HEAVY_DEBUG && console.log('☝️🪲🪲🪲🪲 existingRecord|||', existingRecord);
+
+    return existingRecord.data.length > 0;
+  }
+
+  async createRecord({ resource, record, adminUser }: { 
+    resource: AdminForthResource; record: any; adminUser: any;
+  }): Promise<{ error?: string; ok: boolean; createdRecord?: any; }> {
     // transform value using setFieldValue and call createRecordOriginalValues
-    const newRecord = {...record};
+    const filledRecord = {...record};
+    const recordWithOriginalValues = {...record};
+
     for (const col of resource.dataSourceColumns) {
-        newRecord[col.name] = this.setFieldValue(col, record[col.name]);
+      if (col.fillOnCreate) {
+        if (filledRecord[col.name] === undefined) {
+          filledRecord[col.name] = col.fillOnCreate({
+            initialRecord: record, 
+            adminUser
+          });
+        }
+      }
+      recordWithOriginalValues[col.name] = this.setFieldValue(col, filledRecord[col.name]);
+    }
+
+    
+    let error: string | null = null;
+    await Promise.all(
+      resource.dataSourceColumns.map(async (col) => {
+
+        if (col.isUnique && !col.virtual && !error) {
+
+          const exists = await this.checkUnique(resource, col, recordWithOriginalValues[col.name]);
+          if (exists) {
+            error = `Record with ${col.name} ${recordWithOriginalValues[col.name]} already exists`;
+          }
+        }
+      })
+    );
+    process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 error', error);
+    if (error) {
+      return { error, ok: false };
+    }
+
+    process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record', recordWithOriginalValues);
+    await this.createRecordOriginalValues({ resource, record: recordWithOriginalValues });
+
+    return {
+      ok: true,
+      createdRecord: recordWithOriginalValues,
     }
-    process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record', newRecord);
-    return this.createRecordOriginalValues({ resource, record: newRecord });
   }
 
   updateRecord({ resource, recordId, newValues }: { resource: AdminForthResource; recordId: string; newValues: any; }): Promise<void> {
@@ -85,10 +138,15 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
   }): Promise<{ data: any[], total: number }> {
     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);
         }
       });
     }

package/dataConnectors/clickhouse.ts

@@ -220,6 +220,7 @@ class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForth
         sort: { field: string, direction: AdminForthSortDirections }[], 
         filters: { field: string, operator: AdminForthFilterOperators, value: any }[],
     }): Promise<any[]> {
+      console.log('getDataWithOriginalTypes', resource, limit, offset, sort, filters);
       const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
       const tableName = resource.table;
 

package/dataConnectors/mongo.ts

@@ -107,13 +107,12 @@ class MongoConnector extends AdminForthBaseConnector implements IAdminForthDataS
         return value;
     }
 
-    async genQuery({ resource, limit, offset, sort, filters }) {
-        const collection = this.db.db().collection(resource.table);
+    async genQuery({ filters }) {
         const query = {};
         for (const filter of filters) {
             query[filter.field] = this.OperatorsMap[filter.operator](filter.value);
         }
-        return { collection, query };
+        return query;
     }
     
     async getDataWithOriginalTypes({ resource, limit, offset, sort, filters }:
@@ -130,7 +129,7 @@ class MongoConnector extends AdminForthBaseConnector implements IAdminForthDataS
         const tableName = resource.table;
 
         const collection = this.db.db().collection(tableName);
-        const query = this.genQuery({ resource, limit, offset, sort, filters });
+        const query = await this.genQuery({ filters });
 
         const sortArray: any[] = sort.map((s) => {
             return [s.field, this.SortDirectionsMap[s.direction]];

package/dataConnectors/sqlite.ts

@@ -47,6 +47,9 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
           } else if (baseType == 'boolean') {
             field.type = AdminForthDataTypes.BOOLEAN;
             field._underlineType = 'boolean';
+          } else if (baseType == 'datetime') {
+            field.type = AdminForthDataTypes.DATETIME;
+            field._underlineType = 'datetime';
           } else {
             field.type = 'unknown'
           }
@@ -68,6 +71,8 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
           return dayjs.unix(+value).toISOString();
         } 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}"`);
         }
@@ -102,6 +107,8 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
         } else if (field._underlineType == 'varchar') {
           // 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;

package/dist/auth.js

@@ -80,13 +80,13 @@ class AdminForthAuth {
                 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;
+            const dbUser = yield this.adminforth.getUserByPk(pk);
+            if (!dbUser) {
+                console.error(`User with pk ${pk} not found in database`);
+                // will logout user which was deleted
+                return null;
             }
+            decoded.dbUser = dbUser;
             return decoded;
         });
     }

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) {
@@ -49,14 +50,57 @@ export default class AdminForthBaseConnector {
     createRecordOriginalValues({ resource, record }) {
         throw new Error('Method not implemented.');
     }
-    createRecord({ resource, record }) {
-        // transform value using setFieldValue and call createRecordOriginalValues
-        const newRecord = Object.assign({}, record);
-        for (const col of resource.dataSourceColumns) {
-            newRecord[col.name] = this.setFieldValue(col, record[col.name]);
-        }
-        process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record', newRecord);
-        return this.createRecordOriginalValues({ resource, record: newRecord });
+    checkUnique(resource, column, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            process.env.HEAVY_DEBUG && console.log('☝️🪲🪲🪲🪲 checkUnique|||', column, value);
+            const existingRecord = yield this.getData({
+                resource,
+                filters: [{ field: column.name, operator: AdminForthFilterOperators.EQ, value }],
+                limit: 1,
+                sort: [],
+                offset: 0,
+                getTotals: false
+            });
+            process.env.HEAVY_DEBUG && console.log('☝️🪲🪲🪲🪲 existingRecord|||', existingRecord);
+            return existingRecord.data.length > 0;
+        });
+    }
+    createRecord(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, record, adminUser }) {
+            // transform value using setFieldValue and call createRecordOriginalValues
+            const filledRecord = Object.assign({}, record);
+            const recordWithOriginalValues = Object.assign({}, record);
+            for (const col of resource.dataSourceColumns) {
+                if (col.fillOnCreate) {
+                    if (filledRecord[col.name] === undefined) {
+                        filledRecord[col.name] = col.fillOnCreate({
+                            initialRecord: record,
+                            adminUser
+                        });
+                    }
+                }
+                recordWithOriginalValues[col.name] = this.setFieldValue(col, filledRecord[col.name]);
+            }
+            let error = null;
+            yield Promise.all(resource.dataSourceColumns.map((col) => __awaiter(this, void 0, void 0, function* () {
+                if (col.isUnique && !col.virtual && !error) {
+                    const exists = yield this.checkUnique(resource, col, recordWithOriginalValues[col.name]);
+                    if (exists) {
+                        error = `Record with ${col.name} ${recordWithOriginalValues[col.name]} already exists`;
+                    }
+                }
+            })));
+            process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 error', error);
+            if (error) {
+                return { error, ok: false };
+            }
+            process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record', recordWithOriginalValues);
+            yield this.createRecordOriginalValues({ resource, record: recordWithOriginalValues });
+            return {
+                ok: true,
+                createdRecord: recordWithOriginalValues,
+            };
+        });
     }
     updateRecord({ resource, recordId, newValues }) {
         throw new Error('Method not implemented.');
@@ -68,11 +112,16 @@ export default class AdminForthBaseConnector {
         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);
                     }
                 });
             }

package/dist/dataConnectors/clickhouse.js

@@ -217,6 +217,7 @@ class ClickhouseConnector extends AdminForthBaseConnector {
     }
     getDataWithOriginalTypes(_a) {
         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 = this.whereClause(resource, filters);

package/dist/dataConnectors/mongo.js

@@ -109,13 +109,12 @@ class MongoConnector extends AdminForthBaseConnector {
         return value;
     }
     genQuery(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
-            const collection = this.db.db().collection(resource.table);
+        return __awaiter(this, arguments, void 0, function* ({ filters }) {
             const query = {};
             for (const filter of filters) {
                 query[filter.field] = this.OperatorsMap[filter.operator](filter.value);
             }
-            return { collection, query };
+            return query;
         });
     }
     getDataWithOriginalTypes(_a) {
@@ -123,7 +122,7 @@ class MongoConnector extends AdminForthBaseConnector {
             // 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 query = yield this.genQuery({ filters });
             const sortArray = sort.map((s) => {
                 return [s.field, this.SortDirectionsMap[s.direction]];
             });

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;

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,23 +184,46 @@ 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) {
-        return this.config.resources.find((res) => res.resourceId === 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) {