adminforth 1.2.99 → 1.3.1

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,10 +57,21 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
     throw new Error('Method not implemented.');
   }
 
-  createRecord({ resource, record }: { resource: AdminForthResource; record: any; }): Promise<void> {
+  createRecord({ resource, record, adminUser }: { 
+    resource: AdminForthResource; record: any; adminUser: any;
+  }): Promise<void> {
     // transform value using setFieldValue and call createRecordOriginalValues
     const newRecord = {...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);
@@ -85,10 +97,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/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,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);
@@ -68,11 +76,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/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,13 +159,6 @@ 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
-                        });
-                    }
-                }
                 if (((_c = column.required) === null || _c === void 0 ? void 0 : _c.create) &&
                     record[column.name] === undefined &&
                     column.showIn.includes(AdminForthResourcePages.create)) {
@@ -191,7 +195,7 @@ class AdminForth {
             }
             const connector = this.connectors[resource.dataSource];
             process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record createResourceRecord', record);
-            yield connector.createRecord({ resource, record });
+            yield connector.createRecord({ resource, record, adminUser });
             // 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);
@@ -207,7 +211,21 @@ class AdminForth {
         });
     }
     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 = [];

package/dist/modules/operationalResource.js

@@ -7,42 +7,26 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-// export interface IOperationalResource {
-//   get: (filters: IAdminForthFilter | IAdminForthFilter[]) => Promise<any[]>;
-//   list: (filters: IAdminForthFilter | IAdminForthFilter[], limit: number, offset: number, sort: IAdminForthSort | IAdminForthSort[]) => Promise<any[]>;
-//   count: (filters: IAdminForthFilter | IAdminForthFilter[]) => Promise<number>;
-//   create: (record: any) => Promise<any>;
-//   update: (primaryKey: any, record: any) => Promise<any>;
-//   delete: (primaryKey: any) => Promise<boolean>;
-//   deleteMany: (primaryKeys: any[]) => Promise<boolean>;
-// }
-// async getData({ resource, limit, offset, sort, filters }: { 
-//   resource: AdminForthResource, 
-//   limit: number, 
-//   offset: number, 
-//   sort: { field: string, direction: AdminForthSortDirections }[], 
-//   filters: { field: string, operator: AdminForthFilterOperators, value: any }[]
-// }): Promise<{ data: any[], total: number }> {
 function filtersIfFilter(filter) {
-    return (typeof filter === 'object' ? [filter] : filter);
+    return (Array.isArray(filter) ? filter : [filter]);
 }
 function sortsIfSort(sort) {
-    return (typeof sort === 'object' ? [sort] : sort);
+    return (Array.isArray(sort) ? sort : [sort]);
 }
-export class OperationalResource {
+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({
+            return (yield this.dataConnector.getData({
                 resource: this.resourceConfig,
                 filters: filtersIfFilter(filter),
                 limit: 1,
                 offset: 0,
                 sort: [],
-            })[0];
+            })).data[0] || null;
         });
     }
     list(filter, limit, offset, sort) {
@@ -68,7 +52,7 @@ export class OperationalResource {
     }
     create(record) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.dataConnector.createRecord({ resource: this.resourceConfig, record });
+            return yield this.dataConnector.createRecord({ resource: this.resourceConfig, record, adminUser: null });
         });
     }
     update(primaryKey, record) {