adminforth 1.2.98 → 1.3.1

package/dist/types/AdminForthConfig.js

@@ -53,6 +53,43 @@ export var AdminForthResourcePages;
     AdminForthResourcePages["create"] = "create";
     AdminForthResourcePages["filter"] = "filter";
 })(AdminForthResourcePages || (AdminForthResourcePages = {}));
+export class Filters {
+    static EQ(field, value) {
+        return { field, operator: AdminForthFilterOperators.EQ, value };
+    }
+    static NEQ(field, value) {
+        return { field, operator: AdminForthFilterOperators.NE, value };
+    }
+    static GT(field, value) {
+        return { field, operator: AdminForthFilterOperators.GT, value };
+    }
+    static GTE(field, value) {
+        return { field, operator: AdminForthFilterOperators.GTE, value };
+    }
+    static LT(field, value) {
+        return { field, operator: AdminForthFilterOperators.LT, value };
+    }
+    static LTE(field, value) {
+        return { field, operator: AdminForthFilterOperators.LTE, value };
+    }
+    static IN(field, value) {
+        return { field, operator: AdminForthFilterOperators.IN, value };
+    }
+    static NOT_IN(field, value) {
+        return { field, operator: AdminForthFilterOperators.NIN, value };
+    }
+    static LIKE(field, value) {
+        return { field, operator: AdminForthFilterOperators.LIKE, value };
+    }
+}
+export class Sorts {
+    static ASC(field) {
+        return { field, direction: AdminForthSortDirections.asc };
+    }
+    static DESC(field) {
+        return { field, direction: AdminForthSortDirections.desc };
+    }
+}
 export var AllowedActionsEnum;
 (function (AllowedActionsEnum) {
     AllowedActionsEnum["show"] = "show";

package/index.ts

@@ -5,12 +5,14 @@ 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 { 
   type AdminForthConfig, 
   type IAdminForth, 
   type IConfigValidator,
-  AdminForthFilterOperators, AdminForthDataTypes, AdminForthResourcePages, IHttpServer, 
+  IOperationalResource,
+  AdminForthFilterOperators,
+  AdminForthDataTypes, AdminForthResourcePages, IHttpServer, 
   BeforeSaveFunction,
   AfterSaveFunction,
   AdminUser,
@@ -20,11 +22,13 @@ 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 implements IAdminForth {
@@ -50,7 +54,9 @@ class AdminForth implements IAdminForth {
   activatedPlugins: Array<AdminForthPlugin>;
   configValidator: IConfigValidator;
   restApi: AdminForthRestAPI;
-
+  operationalResources: {
+    [resourceId: string]: IOperationalResource,
+  }
   baseUrlSlashed: string;
 
   statuses: {
@@ -116,21 +122,24 @@ class AdminForth implements IAdminForth {
     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});  
     });
 
     await Promise.all(this.config.resources.map(async (res) => {
       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 = await 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) {
@@ -139,7 +148,8 @@ class AdminForth implements IAdminForth {
 
       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] = { ...fieldTypes[col.name], ...col };
@@ -156,6 +166,11 @@ class AdminForth implements IAdminForth {
 
     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));
   }
 
@@ -164,9 +179,12 @@ class AdminForth implements IAdminForth {
   }
 
   async getUserByPk(pk: string) {
-    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 = await this.connectors[resource.dataSource].getData({
       resource,
@@ -182,13 +200,6 @@ class AdminForth implements IAdminForth {
 
   async createResourceRecord({ resource, record, adminUser }: { resource: AdminForthResource, record: any, adminUser: AdminUser }) {
     for (const column of resource.columns) {
-        if (column.fillOnCreate) {
-            if (record[column.name] === undefined) {
-                record[column.name] = column.fillOnCreate({
-                    initialRecord: record, adminUser
-                 });
-            }
-        }
         if (
             (column.required as {create?: boolean, edit?: boolean}) ?.create &&
             record[column.name] === undefined &&
@@ -231,7 +242,7 @@ class AdminForth implements IAdminForth {
     }
     const connector = this.connectors[resource.dataSource];
     process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record createResourceRecord', record);
-    await connector.createRecord({ resource, record });
+    await connector.createRecord({ resource, record, adminUser });
     // execute hook if needed
     for (const hook of listify(resource.hooks?.create?.afterSave as AfterSaveFunction[])) {
       console.log('Hook afterSave', hook);
@@ -248,6 +259,23 @@ class AdminForth implements IAdminForth {
     return { ok: true };
   }
 
+  resource(resourceId: string) {
+    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: IHttpServer) {
     this.restApi.registerEndpoints(server);
   }

package/modules/configValidator.ts

@@ -10,7 +10,7 @@ import {
 
 import fs from 'fs';
 import path from 'path';
-import { guessLabelFromName } from './utils.js';
+import { guessLabelFromName, suggestIfTypo } from './utils.js';
 
 import crypto from 'crypto';
 
@@ -51,17 +51,6 @@ export default class ConfigValidator implements IConfigValidator {
   validateConfig() {
     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';
     }
@@ -74,8 +63,13 @@ export default class ConfigValidator implements IConfigValidator {
     }
 
     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');
@@ -86,9 +80,10 @@ export default class ConfigValidator implements IConfigValidator {
       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) {

package/modules/operationalResource.ts

@@ -0,0 +1,73 @@
+import { IAdminForthFilter, IAdminForthSort, IOperationalResource, IAdminForthDataSourceConnectorBase, AdminForthResource, IAdminForth } from '../types/AdminForthConfig.js';
+
+
+function filtersIfFilter(filter: IAdminForthFilter | IAdminForthFilter[]): IAdminForthFilter[] {
+  return (Array.isArray(filter) ? filter : [filter]) as IAdminForthFilter[];
+}
+
+function sortsIfSort(sort: IAdminForthSort | IAdminForthSort[]): IAdminForthSort[] {
+  return (Array.isArray(sort) ? sort : [sort]) as IAdminForthSort[];
+}
+
+export default class OperationalResource implements IOperationalResource {
+  dataConnector: IAdminForthDataSourceConnectorBase;
+  resourceConfig: AdminForthResource;
+
+  constructor(dataConnector: IAdminForthDataSourceConnectorBase, resourceConfig: AdminForthResource) {
+    this.dataConnector = dataConnector;
+    this.resourceConfig = resourceConfig;
+  }
+
+  async get(filter: IAdminForthFilter | IAdminForthFilter[]): Promise<any | null> {
+    return (
+      await this.dataConnector.getData({
+        resource: this.resourceConfig,
+        filters: filtersIfFilter(filter),
+        limit: 1,
+        offset: 0,
+        sort: [],
+      })
+    ).data[0] || null;
+  }
+
+  async list(
+      filter: IAdminForthFilter | IAdminForthFilter[], 
+      limit: number, 
+      offset: number, 
+      sort: IAdminForthSort | IAdminForthSort[]
+  ): Promise<any[]> {
+    const { data } = await this.dataConnector.getData({
+      resource: this.resourceConfig,
+      filters: filtersIfFilter(filter),
+      limit,
+      offset,
+      sort: sortsIfSort(sort),
+      getTotals: false,
+    });
+    return data;
+  }
+
+  async count(filter: IAdminForthFilter | IAdminForthFilter[]): Promise<number> {
+    return await this.dataConnector.getCount({
+      resource: this.resourceConfig,
+      filters: filtersIfFilter(filter),
+    });
+  }
+
+  async create(record: any): Promise<any> {
+    return await this.dataConnector.createRecord({ resource: this.resourceConfig, record, adminUser: null });
+  }
+
+  async update(primaryKey: any, record: any): Promise<any> {
+    return await this.dataConnector.updateRecord({ 
+      resource: this.resourceConfig,
+      recordId: primaryKey,
+      newValues: record 
+    });
+  }
+
+  async delete(primaryKey: any): Promise<boolean> {
+    return await this.dataConnector.deleteRecord({ resource: this.resourceConfig, recordId: primaryKey });
+  }
+
+}

package/modules/restApi.ts

@@ -67,73 +67,64 @@ export default class AdminForthRestAPI {
         let adminUser: AdminUser;
         let toReturn: { ok: boolean, redirectTo?: string, allowedLogin:boolean } = { ok: true, allowedLogin:true};
 
-        let token;
-        if (this.adminforth.config.rootUser 
-            && username === this.adminforth.config.rootUser.username 
-            && password === this.adminforth.config.rootUser.password
-        ) {
-          this.adminforth.auth.setAuthCookie({ response, username, pk: null });
-          adminUser = { isRoot: true, dbUser: null, pk: null, username: this.adminforth.config.rootUser.username};
-        } else {
-          // get resource from db
-          if (!this.adminforth.config.auth) {
-            throw new Error('No config.auth defined');
-          }
-          const userResource = this.adminforth.config.resources.find((res) => res.resourceId === this.adminforth.config.auth.resourceId);
-          // if there is no passwordHashField, in columns, add it, with backendOnly and showIn: []
-          if (!userResource.dataSourceColumns.find((col) => col.name === this.adminforth.config.auth.passwordHashField)) {
-            userResource.dataSourceColumns.push({
-              name: this.adminforth.config.auth.passwordHashField,
-              backendOnly: true,
-              showIn: [],
-              type: AdminForthDataTypes.STRING,
-            });
-            console.log('Adding passwordHashField to userResource', userResource)
-          }
-
-          const userRecord = (
-            await this.adminforth.connectors[userResource.dataSource].getData({
-              resource: userResource,
-              filters: [
-                { field: this.adminforth.config.auth.usernameField, operator: AdminForthFilterOperators.EQ, value: username },
-              ],
-              limit: 1,
-              offset: 0,
-              sort: [],
-            })
-          ).data?.[0];
-
-          if (!userRecord) {
-            return { error: 'User not found' };
-          }
-
-          const passwordHash = userRecord[this.adminforth.config.auth.passwordHashField];
-          const valid = await AdminForthAuth.verifyPassword(password, passwordHash);
-          if (valid) {
-            adminUser = { 
-              isRoot: false, dbUser: userRecord,
-              pk: userRecord[userResource.columns.find((col) => col.primaryKey).name], 
-              username,
-            };
-            const beforeLoginConfirmation = this.adminforth.config.auth.beforeLoginConfirmation as (BeforeLoginConfirmationFunction[] | undefined);
-            if (beforeLoginConfirmation?.length){
-              for (const hook of beforeLoginConfirmation) {
-                const resp = await hook({ adminUser, response });
-                
-                if (resp?.body?.redirectTo) {
-                  toReturn = {ok:resp.ok, redirectTo:resp?.body?.redirectTo, allowedLogin:resp?.body?.allowedLogin};
-                  break;
-                }
+        // get resource from db
+        if (!this.adminforth.config.auth) {
+          throw new Error('No config.auth defined we need it to find user, please follow the docs');
+        }
+        const userResource = this.adminforth.config.resources.find((res) => res.resourceId === this.adminforth.config.auth.usersResourceId);
+        // if there is no passwordHashField, in columns, add it, with backendOnly and showIn: []
+        if (!userResource.dataSourceColumns.find((col) => col.name === this.adminforth.config.auth.passwordHashField)) {
+          userResource.dataSourceColumns.push({
+            name: this.adminforth.config.auth.passwordHashField,
+            backendOnly: true,
+            showIn: [],
+            type: AdminForthDataTypes.STRING,
+          });
+          console.log('Adding passwordHashField to userResource', userResource)
+        }
+
+        const userRecord = (
+          await this.adminforth.connectors[userResource.dataSource].getData({
+            resource: userResource,
+            filters: [
+              { field: this.adminforth.config.auth.usernameField, operator: AdminForthFilterOperators.EQ, value: username },
+            ],
+            limit: 1,
+            offset: 0,
+            sort: [],
+          })
+        ).data?.[0];
+
+        if (!userRecord) {
+          return { error: 'User not found' };
+        }
+
+        const passwordHash = userRecord[this.adminforth.config.auth.passwordHashField];
+        const valid = await AdminForthAuth.verifyPassword(password, passwordHash);
+        if (valid) {
+          adminUser = { 
+            dbUser: userRecord,
+            pk: userRecord[userResource.columns.find((col) => col.primaryKey).name], 
+            username,
+          };
+          const beforeLoginConfirmation = this.adminforth.config.auth.beforeLoginConfirmation as (BeforeLoginConfirmationFunction[] | undefined);
+          if (beforeLoginConfirmation?.length){
+            for (const hook of beforeLoginConfirmation) {
+              const resp = await hook({ adminUser, response });
+              
+              if (resp?.body?.redirectTo) {
+                toReturn = {ok:resp.ok, redirectTo:resp?.body?.redirectTo, allowedLogin:resp?.body?.allowedLogin};
+                break;
               }
             }
-            if (toReturn.allowedLogin){
-              this.adminforth.auth.setAuthCookie({ response, username, pk: userRecord[userResource.columns.find((col) => col.primaryKey).name] });
-            } 
-          } else {
-            return { error: INVALID_MESSAGE };
           }
-          
+          if (toReturn.allowedLogin){
+            this.adminforth.auth.setAuthCookie({ response, username, pk: userRecord[userResource.columns.find((col) => col.primaryKey).name] });
+          } 
+        } else {
+          return { error: INVALID_MESSAGE };
         }
+          
         
         return toReturn;
     }
@@ -168,7 +159,7 @@ export default class AdminForthRestAPI {
           throw new Error('No config.auth defined');
         }
         const usernameField = this.adminforth.config.auth.usernameField;
-        const resource = this.adminforth.config.resources.find((res) => res.resourceId === this.adminforth.config.auth.resourceId);
+        const resource = this.adminforth.config.resources.find((res) => res.resourceId === this.adminforth.config.auth.usersResourceId);
         const usernameColumn = resource.columns.find((col) => col.name === usernameField);
 
         return {
@@ -188,14 +179,10 @@ export default class AdminForthRestAPI {
       handler: async ({input, adminUser, cookies}) => {
         let username = ''
         let userFullName = ''
-        if (adminUser.isRoot) {
-          // isRoot can be in JWT token still when rootUser deleted, so we check for rootUser?"
-          username = this.adminforth.config.rootUser?.username || 'RootUser';
-        } else {
-            const dbUser = adminUser.dbUser;
-            username = dbUser[this.adminforth.config.auth.usernameField]; 
-            userFullName =dbUser[this.adminforth.config.auth.userFullNameField];
-        }
+    
+        const dbUser = adminUser.dbUser;
+        username = dbUser[this.adminforth.config.auth.usernameField]; 
+        userFullName =dbUser[this.adminforth.config.auth.userFullNameField];
 
         const userData = {
             [this.adminforth.config.auth.usernameField]: username,

package/modules/utils.ts

@@ -1,6 +1,7 @@
 import path from 'path';
 import { fileURLToPath } from 'url';
 import fs from 'fs';
+import Fuse from 'fuse.js';
 // @ts-ignore-next-line
 
 
@@ -335,3 +336,24 @@ export function inverseRGBA(rgba) {
   return brightness > 128 ? 'rgba(0,0,0,1)' : 'rgba(255,255,255,1)';
 }
 
+
+export function suggestIfTypo(names: string[], name: string): string {
+  console.log('names', names)
+  console.log('name', name)
+  if (!name) {
+    return null;
+  }
+  const options = {
+    includeScore: true, // Includes score in the results to see how close matches are
+    threshold: 0.3,     // Defines the fuzziness (lower values mean stricter matches)
+  };
+  
+  const fuse = new Fuse(names.filter(
+    (n) => !!n
+  ), options);
+  // Search for a resource
+  const result = fuse.search(name);
+  if (result.length > 0) {
+    return result[0].item;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adminforth",
-  "version": "1.2.98",
+  "version": "1.3.1",
   "description": "OpenSource Vue3 powered forth-generation admin panel",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,6 +23,7 @@
     "express": "^4.19.2",
     "filewatcher": "^3.0.1",
     "fs-extra": "^11.2.0",
+    "fuse.js": "^7.0.0",
     "jsonwebtoken": "^9.0.2",
     "mongodb": "6.6",
     "node-fetch": "^3.3.2",