adminforth 1.2.98 → 1.2.100

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,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 {
@@ -50,7 +55,9 @@ class AdminForth implements IAdminForth {
   activatedPlugins: Array<AdminForthPlugin>;
   configValidator: IConfigValidator;
   restApi: AdminForthRestAPI;
-
+  operationalResources: {
+    [resourceId: string]: IOperationalResource,
+  }
   baseUrlSlashed: string;
 
   statuses: {
@@ -116,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) {
@@ -139,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 };
@@ -156,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));
   }
 
@@ -164,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,
@@ -180,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 };
       }
     }
 
@@ -231,21 +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) {
+    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

@@ -0,0 +1,91 @@
+import { error } from 'console';
+import { IAdminForthFilter, IAdminForthSort, IOperationalResource, IAdminForthDataSourceConnectorBase, AdminForthResource, IAdminForth } from '../types/AdminForthConfig.js';
+
+
+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 (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 | 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: appliedLimit,
+      offset: appliedOffset,
+      sort: sortsIfSort(sort),
+      getTotals: false,
+    });
+    return data;
+  }
+
+  async count(filter: IAdminForthFilter | IAdminForthFilter[] | undefined): Promise<number> {
+    return await this.dataConnector.getCount({
+      resource: this.resourceConfig,
+      filters: filtersIfFilter(filter),
+    });
+  }
+
+  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> {
+    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 });
+  }
+
+}