adminforth 1.2.32 → 1.2.34

package/dataConnectors/clickhouse.ts

@@ -1,10 +1,7 @@
-import betterSqlite3 from 'better-sqlite3';
 import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections, IAdminForthDataSourceConnector, AdminForthResource, AdminForthResourceColumn } from '../types/AdminForthConfig.js';
 import AdminForthBaseConnector from './baseConnector.js';
 import dayjs from 'dayjs';
-import { createClient, ClickHouseLogLevel } from '@clickhouse/client' // or '@clickhouse/client-web'
-import { isObject } from 'util';
-import { date } from 'zod';
+import { createClient } from '@clickhouse/client'
 
 
 
@@ -12,6 +9,7 @@ class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForth
 
     client: any;
     dbName: string;
+    url: string;
 
     /**
      * url: http[s]://[username:password@]hostname:port[/database][?param1=value1&param2=value2]
@@ -20,6 +18,7 @@ class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForth
     constructor({ url }: { url: string }) {
       super();
       this.dbName = new URL(url).pathname.replace('/', '');
+      this.url = url;;
       // create connection here
       this.client = createClient({ 
         url: url.replace('clickhouse://', 'http://'),
@@ -36,15 +35,23 @@ class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForth
         //   level: ClickHouseLogLevel.TRACE,
         // }
       });
+      
     }
 
     async discoverFields(resource: AdminForthResource): Promise<{[key: string]: AdminForthResourceColumn}> {
         const tableName = resource.table;
-        const q = await this.client.query({
-          query: `SELECT * FROM system.columns WHERE table = '${tableName}' and database = '${this.dbName}'`,
-          format: 'JSONEachRow',
-        });
-        const rows = await q.json();
+
+        let rows;
+        try {
+          const q = await this.client.query({
+            query: `SELECT * FROM system.columns WHERE table = '${tableName}' and database = '${this.dbName}'`,
+            format: 'JSONEachRow',
+          });
+          rows = await q.json();
+        } catch (e) {
+          console.error(` 🛑Error connecting to datasource URL ${this.url}:`, e);
+          return null;
+        }
 
         const fieldTypes = {};
         rows.forEach((row) => {

package/dist/dataConnectors/clickhouse.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections } from '../types/AdminForthConfig.js';
 import AdminForthBaseConnector from './baseConnector.js';
 import dayjs from 'dayjs';
-import { createClient } from '@clickhouse/client'; // or '@clickhouse/client-web'
+import { createClient } from '@clickhouse/client';
 class ClickhouseConnector extends AdminForthBaseConnector {
     /**
      * url: http[s]://[username:password@]hostname:port[/database][?param1=value1&param2=value2]
@@ -35,6 +35,8 @@ class ClickhouseConnector extends AdminForthBaseConnector {
             [AdminForthSortDirections.desc]: 'DESC',
         };
         this.dbName = new URL(url).pathname.replace('/', '');
+        this.url = url;
+        ;
         // create connection here
         this.client = createClient({
             url: url.replace('clickhouse://', 'http://'),
@@ -54,11 +56,18 @@ class ClickhouseConnector extends AdminForthBaseConnector {
     discoverFields(resource) {
         return __awaiter(this, void 0, void 0, function* () {
             const tableName = resource.table;
-            const q = yield this.client.query({
-                query: `SELECT * FROM system.columns WHERE table = '${tableName}' and database = '${this.dbName}'`,
-                format: 'JSONEachRow',
-            });
-            const rows = yield q.json();
+            let rows;
+            try {
+                const q = yield this.client.query({
+                    query: `SELECT * FROM system.columns WHERE table = '${tableName}' and database = '${this.dbName}'`,
+                    format: 'JSONEachRow',
+                });
+                rows = yield q.json();
+            }
+            catch (e) {
+                console.error(` 🛑Error connecting to datasource URL ${this.url}:`, e);
+                return null;
+            }
             const fieldTypes = {};
             rows.forEach((row) => {
                 const field = {};

package/dist/index.js

@@ -83,9 +83,13 @@ class AdminForth {
                     throw new Error(`Resource '${res.table}' refers to unknown dataSource '${res.dataSource}'`);
                 }
                 const fieldTypes = yield this.connectors[res.dataSource].discoverFields(res);
-                if (!Object.keys(fieldTypes).length) {
+                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`);
+                    return;
+                }
                 if (!res.columns) {
                     res.columns = Object.keys(fieldTypes).map((name) => ({ name }));
                 }

package/dist/modules/configValidator.js

@@ -246,11 +246,27 @@ export default class ConfigValidator {
                         state: 'danger',
                         icon: 'flowbite:trash-bin-outline',
                         allowed: (_b) => __awaiter(this, [_b], void 0, function* ({ resource, adminUser, allowedActions }) { return allowedActions.delete; }),
-                        action: (_c) => __awaiter(this, [_c], void 0, function* ({ selectedIds }) {
+                        action: (_c) => __awaiter(this, [_c], void 0, function* ({ selectedIds, adminUser }) {
                             const connector = this.adminforth.connectors[res.dataSource];
+                            let error = null;
                             yield Promise.all(selectedIds.map((recordId) => __awaiter(this, void 0, void 0, function* () {
+                                const record = yield connector.getRecordByPrimaryKey(res, recordId);
+                                yield Promise.all(res.hooks.delete.beforeSave.map((hook) => __awaiter(this, void 0, void 0, function* () {
+                                    const resp = yield hook({ resource: res, record, adminUser });
+                                    if (!error && resp.error) {
+                                        error = resp.error;
+                                    }
+                                })));
                                 yield connector.deleteRecord({ resource: res, recordId });
+                                // call afterDelete hook
+                                yield Promise.all(res.hooks.delete.afterSave.map((hook) => __awaiter(this, void 0, void 0, function* () {
+                                    yield hook({ resource: res, record, adminUser });
+                                })));
                             })));
+                            if (error) {
+                                return { error, ok: false };
+                            }
+                            return { ok: true };
                         })
                     });
                 }

package/index.ts

@@ -111,10 +111,13 @@ class AdminForth implements IAdminForth {
         throw new Error(`Resource '${res.table}' refers to unknown dataSource '${res.dataSource}'`);
       }
       const fieldTypes = await this.connectors[res.dataSource].discoverFields(res);
-      if (!Object.keys(fieldTypes).length) {
+      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`);
+        return;
+      }
       if (!res.columns) {
         res.columns = Object.keys(fieldTypes).map((name) => ({ name }));
       }

package/modules/configValidator.ts

@@ -5,6 +5,7 @@ import {
   AdminForthComponentDeclaration , 
   AdminForthResourcePages, AllowedActionsEnum,
   type AdminForthComponentDeclarationFull,
+  type AfterSaveFunction,
 } from "../types/AdminForthConfig.js";
 
 import fs from 'fs';
@@ -143,7 +144,7 @@ export default class ConfigValidator implements IConfigValidator {
     }
 
     if (this.config.resources) {
-      this.config.resources.forEach((res) => {
+      this.config.resources.forEach((res: AdminForthResource) => {
         if (!res.table) {
           errors.push(`Resource "${res.dataSource}" is missing table`);
         }
@@ -266,11 +267,42 @@ export default class ConfigValidator implements IConfigValidator {
             state: 'danger',
             icon: 'flowbite:trash-bin-outline',
             allowed: async ({ resource, adminUser, allowedActions }) => { return allowedActions.delete },
-            action: async ({ selectedIds }) => {
+            action: async ({ selectedIds, adminUser }) => {
               const connector = this.adminforth.connectors[res.dataSource];
-              await Promise.all(selectedIds.map(async (recordId) => {
-                await connector.deleteRecord({ resource: res, recordId });
-              }));
+              let error = null;
+
+              await Promise.all(
+                selectedIds.map(async (recordId) => {
+                  const record = await connector.getRecordByPrimaryKey(res, recordId);
+
+                  await Promise.all(
+                    (res.hooks.delete.beforeSave as AfterSaveFunction[]).map(
+                      async (hook) => {
+                        const resp = await hook({ resource: res, record, adminUser }); 
+                        if (!error && resp.error) {
+                          error = resp.error;
+                        }
+                      }
+                    )
+                  )
+                  
+                  await connector.deleteRecord({ resource: res, recordId });
+                  // call afterDelete hook
+                  await Promise.all(
+                    (res.hooks.delete.afterSave as AfterSaveFunction[]).map(
+                      async (hook) => {
+                        await hook({ resource: res, record, adminUser }); 
+                      }
+                    )
+                  )
+                  
+                })
+              );
+
+              if (error) {
+                return { error, ok: false };
+              }
+              return { ok: true };
             }
           });
         }

package/modules/restApi.ts

@@ -251,10 +251,10 @@ export default class AdminForthRestAPI {
 
     function checkAccess(action: AllowedActionsEnum, allowedActions: AllowedActions): { allowed: boolean, error?: string } {
       const allowed = (allowedActions[action] as boolean | string | undefined);
-        if (allowed !== true) {
-          return { error: typeof allowed === 'string' ? allowed : 'Action is not allowed', allowed: false };
-        }
-        return { allowed: true };
+      if (allowed !== true) {
+        return { error: typeof allowed === 'string' ? allowed : 'Action is not allowed', allowed: false };
+      }
+      return { allowed: true };
     }
    
     server.endpoint({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adminforth",
-  "version": "1.2.32",
+  "version": "1.2.34",
   "description": "OpenSource Vue3 powered forth-generation admin panel",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/types/AdminForthConfig.ts

@@ -680,7 +680,7 @@ export type AdminForthBulkAction = {
    * Callback which will be called on backend when user clicks on action button.
    * It should return Promise which will be resolved when action is done.
    */
-  action: ({ resource, selectedIds, adminUser }: { resource: AdminForthResource, selectedIds: Array<any>, adminUser: AdminUser }) => Promise<void>,
+  action: ({ resource, selectedIds, adminUser }: { resource: AdminForthResource, selectedIds: Array<any>, adminUser: AdminUser }) => Promise<{ ok: boolean, error?: string }>,
 
   /**
    * Confirmation message which will be displayed to user before action is executed.