adminforth 1.2.99 → 1.3.1

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.99",
+  "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",

package/types/AdminForthConfig.ts

@@ -51,16 +51,18 @@ export interface IHttpServer {
 
 export type AdminUser = {
   /**
-   * primaryKey field value of user in table which is defined by {@link AdminForthConfig.auth.resourceId}
-   * or null if it is user logged in as {@link AdminForthConfig.rootUser}
+   * primaryKey field value of user in table which is defined by {@link AdminForthConfig.auth.usersResourceId}
    */
   pk: string | null,
 
   /**
-   * Username which takend from {@link AdminForthConfig.auth.usernameField} field in user resource {@link AdminForthConfig.auth.resourceId}
+   * Username which taken from {@link AdminForthConfig.auth.usernameField} field in user resource {@link AdminForthConfig.auth.usersResourceId}
    */
   username: string,
-  isRoot: boolean,
+
+  /**
+   * User record fetched from database, from resource defined in {@link AdminForthConfig.auth.usersResourceId}
+   */
   dbUser: any,
 }
 
@@ -220,7 +222,11 @@ export interface IAdminForthDataSourceConnectorBase extends IAdminForthDataSourc
 
   getRecordByPrimaryKey(resource: AdminForthResource, recordId: string): Promise<any>;
 
-  createRecord({ resource, record }: { resource: AdminForthResource, record: any }): Promise<void>;
+  createRecord({ resource, record, adminUser }: { 
+    resource: AdminForthResource, 
+    record: any 
+    adminUser: AdminUser
+  }): Promise<void>;
 
   getMinMaxForColumns({ resource, columns }: { resource: AdminForthResource, columns: AdminForthResourceColumn[] }): Promise<{ [key: string]: { min: any, max: any } }>;
 }
@@ -744,7 +750,7 @@ export type AdminForthBulkAction = {
    * 
    * ```ts
    * allowed: async ({ resource, adminUser, selectedIds }) => {
-   *   if (adminUser.isRoot || adminUser.dbUser.role !== 'superadmin') {
+   *   if (adminUser.dbUser.role !== 'superadmin') {
    *    return false;
    *   } 
    *   return true;
@@ -786,7 +792,7 @@ export type AdminForthBulkAction = {
      *   ],
      *   allowedActions: \{
      *     edit: (\{ resource, adminUser, recordIds \}) => \{
-     *       return adminUser.isRoot || adminUser.dbUser.role === 'superadmin';
+     *       return adminUser.dbUser.role === 'superadmin';
      *     \}
      *   \}
      * \}
@@ -979,8 +985,8 @@ export type AdminForthResource = {
        * ```ts
        * allowedActions: {
        *  create: ({ resource, adminUser }) => {
-       *    // Allow only superadmin or root user to create records
-       *    return adminUser.isRoot || adminUser.dbUser.role === 'superadmin';
+       *    // Allow only superadmin to create records
+       *    return adminUser.dbUser.role === 'superadmin';
        *  },
        *  delete: false, // disable delete action for all users
        * }
@@ -1085,33 +1091,21 @@ export type AdminForthDataSource = {
  */
 export type AdminForthConfig = {
 
-    /**
-     * Root user should be used to login to the admin panel first time.
-     * Then you should create User for yourself using AdminForth (so it will be persisted in DB), 
-     * and then disable this option as it is less secure
-     */
-    rootUser?: {
-      /**
-       * Username for root user
-       */
-      username: string,
-
-      /**
-       * Password for root user
-       */
-      password: string,
-    },
-
     /**
      * Authorization module configuration
      */
     auth?: {
       /**
-       * Resource ID for user resource. 
+       * Resource ID for resource which stores user table.
        * Resource is a table in database where users will be stored and fetched from. Resources and their ids are defined in resources section of the config.
        * In other words this setting is a reference to a table in database where users will be fetched from on login. 
        */
-      resourceId: string,
+      usersResourceId?: string,
+
+      /**
+       * Legacy field left for backward compatibility. Use usersResourceId instead.
+       */
+      resourceId?: string,
 
       /**
        * Field name (column name) in user resource which will be used as username for searching user in database during login.
@@ -1322,6 +1316,10 @@ export type AdminForthConfig = {
     baseUrl?: string,
     
     
+    /**
+     * Whether to show delete confirmation dialog before deleting record.
+     * By default it is true.
+     */
     deleteConfirmation?: boolean,
     
    
@@ -1375,7 +1373,7 @@ export class Sorts {
 }
 
 export interface IOperationalResource {
-  get: (filter: IAdminForthFilter | IAdminForthFilter[]) => Promise<any[]>;
+  get: (filter: IAdminForthFilter | IAdminForthFilter[]) => Promise<any | null>;
 
   list: (filter: IAdminForthFilter | IAdminForthFilter[], limit: number, offset: number, sort: IAdminForthSort | IAdminForthSort[]) => Promise<any[]>;