adminforth 1.2.99 → 1.2.100

package/index.ts

@@ -5,7 +5,7 @@ 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, 
@@ -22,11 +22,14 @@ 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';
+import { error } from 'console';
 
 // exports
 export * from './types/AdminForthConfig.js'; 
 export { interpretResource };
 export { AdminForthPlugin };
+export { suggestIfTypo };
 
 
 class AdminForth implements IAdminForth {
@@ -52,7 +55,7 @@ class AdminForth implements IAdminForth {
   activatedPlugins: Array<AdminForthPlugin>;
   configValidator: IConfigValidator;
   restApi: AdminForthRestAPI;
-  resourceInstances: {
+  operationalResources: {
     [resourceId: string]: IOperationalResource,
   }
   baseUrlSlashed: string;
@@ -120,21 +123,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) {
@@ -143,7 +149,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 };
@@ -160,6 +167,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));
   }
 
@@ -168,9 +180,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,
@@ -184,46 +199,31 @@ class AdminForth implements IAdminForth {
     return users.data[0] || null;
   }
 
-  async createResourceRecord({ resource, record, adminUser }: { resource: AdminForthResource, record: any, adminUser: AdminUser }) {
+  async createResourceRecord(
+    { resource, record, adminUser }: 
+    { resource: AdminForthResource, record: any, adminUser: AdminUser }
+  ): Promise<{ ok: boolean, error?: string, createdRecord?: any }> {
+    
     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 &&
-            column.showIn.includes(AdminForthResourcePages.create)
-        ) {
-            return { error: `Column '${column.name}' is required` };
-        }
-
-        if (column.isUnique) {
-            const existingRecord = await 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` };
-            }
-        }
+      // TODO: assuming specifity for AdminForthResourcePages.create better to move it to api for this button
+      if (
+          (column.required as {create?: boolean, edit?: boolean}) ?.create &&
+          record[column.name] === undefined &&
+          column.showIn.includes(AdminForthResourcePages.create)
+      ) {
+          return { error: `Column '${column.name}' is required`, ok: false };
+      }
     }
 
     // execute hook if needed
     for (const hook of listify(resource.hooks?.create?.beforeSave as BeforeSaveFunction[])) {
-      const resp = await hook({ resource, record, adminUser });
+      const resp = await 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 };
       }
     }
 
@@ -235,25 +235,50 @@ 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 });
+    const { ok, error, createdRecord } = await 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(resource.hooks?.create?.afterSave as AfterSaveFunction[])) {
       console.log('Hook afterSave', hook);
-      const resp = await hook({ resource, record, adminUser });
+      const resp = await 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: string) {
-    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: IHttpServer) {

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) {
@@ -135,7 +130,9 @@ export default class ConfigValidator implements IConfigValidator {
     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));
     }
@@ -282,7 +279,12 @@ export default class ConfigValidator implements IConfigValidator {
                   await Promise.all(
                     (res.hooks.delete.beforeSave as AfterSaveFunction[]).map(
                       async (hook) => {
-                        const resp = await hook({ resource: res, record, adminUser }); 
+                        const resp = await hook({ 
+                          recordId: recordId,
+                          resource: res, 
+                          record, 
+                          adminUser,
+                        }); 
                         if (!error && resp.error) {
                           error = resp.error;
                         }
@@ -299,7 +301,12 @@ export default class ConfigValidator implements IConfigValidator {
                   await Promise.all(
                     (res.hooks.delete.afterSave as AfterSaveFunction[]).map(
                       async (hook) => {
-                        await hook({ resource: res, record, adminUser }); 
+                        await hook({ 
+                          resource: res, 
+                          record, 
+                          adminUser,
+                          recordId: recordId
+                        }); 
                       }
                     )
                   )
@@ -388,8 +395,6 @@ export default class ConfigValidator implements IConfigValidator {
         }
       });
 
-
-
       if (!this.config.menu) {
         errors.push('No config.menu defined');
       }

package/modules/operationalResource.ts

@@ -1,40 +1,19 @@
+import { error } from 'console';
 import { IAdminForthFilter, IAdminForthSort, IOperationalResource, IAdminForthDataSourceConnectorBase, AdminForthResource, IAdminForth } from '../types/AdminForthConfig.js';
 
 
-// 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: IAdminForthFilter | IAdminForthFilter[]): IAdminForthFilter[] {
-  return (typeof filter === 'object' ? [filter] : filter) as IAdminForthFilter[];
+function filtersIfFilter(filter: IAdminForthFilter | IAdminForthFilter[] | undefined): IAdminForthFilter[] {
+  if (!filter) {
+    return [];
+  }
+  return (Array.isArray(filter) ? filter : [filter]) as IAdminForthFilter[];
 }
 
 function sortsIfSort(sort: IAdminForthSort | IAdminForthSort[]): IAdminForthSort[] {
-  return (typeof sort === 'object' ? [sort] : sort) as IAdminForthSort[];
+  return (Array.isArray(sort) ? sort : [sort]) as IAdminForthSort[];
 }
 
-export class OperationalResource implements IOperationalResource {
+export default class OperationalResource implements IOperationalResource {
   dataConnector: IAdminForthDataSourceConnectorBase;
   resourceConfig: AdminForthResource;
 
@@ -43,42 +22,58 @@ export class OperationalResource implements IOperationalResource {
     this.resourceConfig = resourceConfig;
   }
 
-  async get(filter: IAdminForthFilter | IAdminForthFilter[]): Promise<any[]> {
-    return await this.dataConnector.getData({
-      resource: this.resourceConfig,
-      filters: filtersIfFilter(filter),
-      limit: 1,
-      offset: 0,
-      sort: [],
-    })[0];
+  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, 
+      limit: number | null, 
+      offset: number | null, 
       sort: IAdminForthSort | IAdminForthSort[]
   ): Promise<any[]> {
+    let appliedLimit = limit;
+    if (limit === null) {
+      appliedLimit = 1000000000;
+    }
+    let appliedOffset = offset;
+    if (offset === null) {
+      appliedOffset = 0;
+    }
+
     const { data } = await this.dataConnector.getData({
       resource: this.resourceConfig,
       filters: filtersIfFilter(filter),
-      limit,
-      offset,
+      limit: appliedLimit,
+      offset: appliedOffset,
       sort: sortsIfSort(sort),
       getTotals: false,
     });
     return data;
   }
 
-  async count(filter: IAdminForthFilter | IAdminForthFilter[]): Promise<number> {
+  async count(filter: IAdminForthFilter | IAdminForthFilter[] | undefined): 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 });
+  async create(recordValues: any): Promise<{ ok: boolean; createdRecord: any; error?: string; }> {
+    const { ok, createdRecord, error } = await this.dataConnector.createRecord({ 
+      resource: this.resourceConfig, 
+      record: recordValues, 
+      adminUser: null 
+    });
+    return { ok, createdRecord, error };
   }
 
   async update(primaryKey: any, record: any): Promise<any> {
@@ -92,6 +87,5 @@ export class OperationalResource implements IOperationalResource {
   async delete(primaryKey: any): Promise<boolean> {
     return await this.dataConnector.deleteRecord({ resource: this.resourceConfig, recordId: primaryKey });
   }
-  
 
 }