adminforth 1.3.27 → 1.3.28

package/dataConnectors/baseConnector.ts

@@ -67,7 +67,6 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
       offset: 0,
       getTotals: false
     });
-    process.env.HEAVY_DEBUG && console.log('☝️🪲🪲🪲🪲 existingRecord|||', existingRecord);
 
     return existingRecord.data.length > 0;
   }
@@ -90,14 +89,11 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
       }
       recordWithOriginalValues[col.name] = this.setFieldValue(col, filledRecord[col.name]);
     }
-
     
     let error: string | null = null;
     await Promise.all(
       resource.dataSourceColumns.map(async (col) => {
-
         if (col.isUnique && !col.virtual && !error) {
-
           const exists = await this.checkUnique(resource, col, recordWithOriginalValues[col.name]);
           if (exists) {
             error = `Record with ${col.name} ${recordWithOriginalValues[col.name]} already exists`;
@@ -105,12 +101,12 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
         }
       })
     );
-    process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 error', error);
     if (error) {
+      process.env.HEAVY_DEBUG && console.log('🪲🆕 check unique error', error);
       return { error, ok: false };
     }
 
-    process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record', recordWithOriginalValues);
+    process.env.HEAVY_DEBUG && console.log('🪲🆕 creating record', recordWithOriginalValues);
     await this.createRecordOriginalValues({ resource, record: recordWithOriginalValues });
 
     return {
@@ -119,10 +115,26 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
     }
   }
 
-  updateRecord({ resource, recordId, newValues }: { resource: AdminForthResource; recordId: string; newValues: any; }): Promise<void> {
+  updateRecordOriginalValues({ resource, recordId, newValues }: { resource: AdminForthResource; recordId: string; newValues: any; }): Promise<void> {
     throw new Error('Method not implemented.');
   }
 
+  async updateRecord({ resource, recordId, newValues }: { resource: AdminForthResource; recordId: string; newValues: any; }): Promise<{ error?: string; ok: boolean; }> {
+    // transform value using setFieldValue and call updateRecordOriginalValues
+    const recordWithOriginalValues = {...newValues};
+
+    for (const field of Object.keys(newValues)) {
+      const col = resource.dataSourceColumns.find((col) => col.name == field);
+      recordWithOriginalValues[col.name] = this.setFieldValue(col, newValues[col.name]);
+    }
+
+    process.env.HEAVY_DEBUG && console.log(`🪲✏️ updating record id:${recordId}, values: ${JSON.stringify(recordWithOriginalValues)}`);
+
+    await this.updateRecordOriginalValues({ resource, recordId, newValues: recordWithOriginalValues });
+
+    return { ok: true };
+  }
+
   deleteRecord({ resource, recordId }: { resource: AdminForthResource; recordId: string; }): Promise<boolean> {
     throw new Error('Method not implemented.');
   }

package/dataConnectors/clickhouse.ts

@@ -303,11 +303,10 @@ class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForth
       });
     }
 
-    async updateRecord({ resource, recordId, newValues }: { resource: AdminForthResource, recordId: any, newValues: any }) {
+    async updateRecordOriginalValues({ resource, recordId, newValues }: { resource: AdminForthResource, recordId: any, newValues: any }) {
       const columnsWithPlaceholders = Object.keys(newValues).map((col) => {
         return `${col} = {${col}:${resource.dataSourceColumns.find((c) => c.name == col)._underlineType}}`
       });
-      const values = [...Object.values(newValues), recordId];
 
       await this.client.command(
         { 

package/dataConnectors/mongo.ts

@@ -182,7 +182,7 @@ class MongoConnector extends AdminForthBaseConnector implements IAdminForthDataS
         await collection.insertOne(newRecord);
     }
 
-    async updateRecord({ resource, recordId, newValues }) {
+    async updateRecordOriginalValues({ resource, recordId, newValues }) {
         const collection = this.db.db().collection(resource.table);
         await collection.updateOne({ [this.getPrimaryKey(resource)]: recordId }, { $set: newValues });
     }

package/dataConnectors/postgres.ts

@@ -287,7 +287,7 @@ class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDa
         await this.db.query(`INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`, values);
     }
 
-    async updateRecord({ resource, recordId,  newValues }) {
+    async updateRecordOriginalValues({ resource, recordId,  newValues }) {
         const values = [...Object.values(newValues), recordId];
         const columnsWithPlaceholders = Object.keys(newValues).map((col, i) => `"${col}" = $${i + 1}`).join(', ');
         await this.db.query(`UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE "${this.getPrimaryKey(resource)}" = $${values.length}`, values);

package/dataConnectors/sqlite.ts

@@ -181,13 +181,12 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
 
       const orderBy = sort.length ? `ORDER BY ${sort.map((s) => `${s.field} ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
       
-      console.log('🪲 SQLITE Query', `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT ? OFFSET ?`, 'params:', [...filterValues, limit, offset]);
       const q = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT ? OFFSET ?`;
       const stmt = this.db.prepare(q);
       const d = [...filterValues, limit, offset];
 
       if (process.env.HEAVY_DEBUG) {
-        console.log('🪲 SQLITE Query', q, 'params:', d);
+        console.log('🪲📜 SQLITE Q', q, 'params:', d);
       }
       const rows = await stmt.all(d);
 
@@ -230,13 +229,14 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
       await q.run(values);
     }
 
-    async updateRecord({ resource, recordId, newValues }: { resource: AdminForthResource, recordId: any, newValues: any }) {
+    async updateRecordOriginalValues({ resource, recordId, newValues }: { resource: AdminForthResource, recordId: any, newValues: any }) {
       const columnsWithPlaceholders = Object.keys(newValues).map((col) => `${col} = ?`);
       const values = [...Object.values(newValues), recordId];
 
       const q = this.db.prepare(
           `UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE ${this.getPrimaryKey(resource)} = ?`
       )
+      process.env.HEAVY_DEBUG && console.log('🪲 SQLITE Query', `UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE ${this.getPrimaryKey(resource)} = ?`, 'params:', values);
       await q.run(values);
     }
 

package/dist/dataConnectors/baseConnector.js

@@ -61,7 +61,6 @@ export default class AdminForthBaseConnector {
                 offset: 0,
                 getTotals: false
             });
-            process.env.HEAVY_DEBUG && console.log('☝️🪲🪲🪲🪲 existingRecord|||', existingRecord);
             return existingRecord.data.length > 0;
         });
     }
@@ -90,11 +89,11 @@ export default class AdminForthBaseConnector {
                     }
                 }
             })));
-            process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 error', error);
             if (error) {
+                process.env.HEAVY_DEBUG && console.log('🪲🆕 check unique error', error);
                 return { error, ok: false };
             }
-            process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record', recordWithOriginalValues);
+            process.env.HEAVY_DEBUG && console.log('🪲🆕 creating record', recordWithOriginalValues);
             yield this.createRecordOriginalValues({ resource, record: recordWithOriginalValues });
             return {
                 ok: true,
@@ -102,9 +101,22 @@ export default class AdminForthBaseConnector {
             };
         });
     }
-    updateRecord({ resource, recordId, newValues }) {
+    updateRecordOriginalValues({ resource, recordId, newValues }) {
         throw new Error('Method not implemented.');
     }
+    updateRecord(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, newValues }) {
+            // transform value using setFieldValue and call updateRecordOriginalValues
+            const recordWithOriginalValues = Object.assign({}, newValues);
+            for (const field of Object.keys(newValues)) {
+                const col = resource.dataSourceColumns.find((col) => col.name == field);
+                recordWithOriginalValues[col.name] = this.setFieldValue(col, newValues[col.name]);
+            }
+            process.env.HEAVY_DEBUG && console.log(`🪲✏️ updating record id:${recordId}, values: ${JSON.stringify(recordWithOriginalValues)}`);
+            yield this.updateRecordOriginalValues({ resource, recordId, newValues: recordWithOriginalValues });
+            return { ok: true };
+        });
+    }
     deleteRecord({ resource, recordId }) {
         throw new Error('Method not implemented.');
     }

package/dist/dataConnectors/clickhouse.js

@@ -285,12 +285,11 @@ class ClickhouseConnector extends AdminForthBaseConnector {
             });
         });
     }
-    updateRecord(_a) {
+    updateRecordOriginalValues(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, recordId, newValues }) {
             const columnsWithPlaceholders = Object.keys(newValues).map((col) => {
                 return `${col} = {${col}:${resource.dataSourceColumns.find((c) => c.name == col)._underlineType}}`;
             });
-            const values = [...Object.values(newValues), recordId];
             yield this.client.command({
                 query: `ALTER TABLE ${this.dbName}.${resource.table} UPDATE ${columnsWithPlaceholders.join(', ')} WHERE ${this.getPrimaryKey(resource)} = {recordId:${resource.dataSourceColumns.find((c) => c.primaryKey)._underlineType}}`,
                 query_params: Object.assign(Object.assign({}, newValues), { recordId }),

package/dist/dataConnectors/mongo.js

@@ -171,7 +171,7 @@ class MongoConnector extends AdminForthBaseConnector {
             yield collection.insertOne(newRecord);
         });
     }
-    updateRecord(_a) {
+    updateRecordOriginalValues(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, recordId, newValues }) {
             const collection = this.db.db().collection(resource.table);
             yield collection.updateOne({ [this.getPrimaryKey(resource)]: recordId }, { $set: newValues });

package/dist/dataConnectors/postgres.js

@@ -283,7 +283,7 @@ class PostgresConnector extends AdminForthBaseConnector {
             yield this.db.query(`INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`, values);
         });
     }
-    updateRecord(_a) {
+    updateRecordOriginalValues(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, recordId, newValues }) {
             const values = [...Object.values(newValues), recordId];
             const columnsWithPlaceholders = Object.keys(newValues).map((col, i) => `"${col}" = $${i + 1}`).join(', ');

package/dist/dataConnectors/sqlite.js

@@ -196,12 +196,11 @@ class SQLiteConnector extends AdminForthBaseConnector {
             const where = this.whereClause(filters);
             const filterValues = this.whereParams(filters);
             const orderBy = sort.length ? `ORDER BY ${sort.map((s) => `${s.field} ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
-            console.log('🪲 SQLITE Query', `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT ? OFFSET ?`, 'params:', [...filterValues, limit, offset]);
             const q = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT ? OFFSET ?`;
             const stmt = this.db.prepare(q);
             const d = [...filterValues, limit, offset];
             if (process.env.HEAVY_DEBUG) {
-                console.log('🪲 SQLITE Query', q, 'params:', d);
+                console.log('🪲📜 SQLITE Q', q, 'params:', d);
             }
             const rows = yield stmt.all(d);
             return rows.map((row) => {
@@ -246,11 +245,12 @@ class SQLiteConnector extends AdminForthBaseConnector {
             yield q.run(values);
         });
     }
-    updateRecord(_a) {
+    updateRecordOriginalValues(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, recordId, newValues }) {
             const columnsWithPlaceholders = Object.keys(newValues).map((col) => `${col} = ?`);
             const values = [...Object.values(newValues), recordId];
             const q = this.db.prepare(`UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE ${this.getPrimaryKey(resource)} = ?`);
+            process.env.HEAVY_DEBUG && console.log('🪲 SQLITE Query', `UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE ${this.getPrimaryKey(resource)} = ?`, 'params:', values);
             yield q.run(values);
         });
     }

package/dist/index.js

@@ -20,7 +20,7 @@ import SQLiteConnector from './dataConnectors/sqlite.js';
 import CodeInjector from './modules/codeInjector.js';
 import ExpressServer from './servers/express.js';
 import { ADMINFORTH_VERSION, listify, suggestIfTypo } from './modules/utils.js';
-import { AdminForthFilterOperators, AdminForthDataTypes, AdminForthResourcePages, } from './types/AdminForthConfig.js';
+import { AdminForthFilterOperators, AdminForthDataTypes, } from './types/AdminForthConfig.js';
 import AdminForthPlugin from './basePlugin.js';
 import ConfigValidator from './modules/configValidator.js';
 import AdminForthRestAPI, { interpretResource } from './modules/restApi.js';
@@ -157,23 +157,15 @@ class AdminForth {
     }
     createResourceRecord(_b) {
         return __awaiter(this, arguments, void 0, function* ({ resource, record, adminUser }) {
-            var _c, _d, _e, _f, _g;
-            for (const column of resource.columns) {
-                // TODO: assuming specifity for AdminForthResourcePages.create better to move it to api for this button
-                if (((_c = column.required) === null || _c === void 0 ? void 0 : _c.create) &&
-                    record[column.name] === undefined &&
-                    column.showIn.includes(AdminForthResourcePages.create)) {
-                    return { error: `Column '${column.name}' is required`, ok: false };
-                }
-            }
+            var _c, _d, _e, _f;
             // execute hook if needed
-            for (const hook of listify((_e = (_d = resource.hooks) === null || _d === void 0 ? void 0 : _d.create) === null || _e === void 0 ? void 0 : _e.beforeSave)) {
+            for (const hook of listify((_d = (_c = resource.hooks) === null || _c === void 0 ? void 0 : _c.create) === null || _d === void 0 ? void 0 : _d.beforeSave)) {
                 const resp = yield 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, ok: false };
+                    return { error: resp.error };
                 }
             }
             // remove virtual columns from record
@@ -183,15 +175,15 @@ class AdminForth {
                 }
             }
             const connector = this.connectors[resource.dataSource];
-            process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record createResourceRecord', record);
-            const { ok, error, createdRecord } = yield connector.createRecord({ resource, record, adminUser });
-            if (!ok) {
-                return { ok, error };
+            process.env.HEAVY_DEBUG && console.log('🪲🆕 creating record createResourceRecord', record);
+            const { error, createdRecord } = yield connector.createRecord({ resource, record, adminUser });
+            if (error) {
+                return { error };
             }
             const primaryKey = record[resource.columns.find((col) => col.primaryKey).name];
             // execute hook if needed
-            for (const hook of listify((_g = (_f = resource.hooks) === null || _f === void 0 ? void 0 : _f.create) === null || _g === void 0 ? void 0 : _g.afterSave)) {
-                console.log('Hook afterSave', hook);
+            for (const hook of listify((_f = (_e = resource.hooks) === null || _e === void 0 ? void 0 : _e.create) === null || _f === void 0 ? void 0 : _f.afterSave)) {
+                process.env.HEAVY_DEBUG && console.log('🪲 Hook afterSave', hook);
                 const resp = yield hook({
                     recordId: primaryKey,
                     resource,
@@ -202,10 +194,100 @@ class AdminForth {
                     throw new Error(`Hook afterSave must return object with {ok: true} or { error: 'Error' } `);
                 }
                 if (resp.error) {
-                    return { error: resp.error, ok: false };
+                    return { error: resp.error };
+                }
+            }
+            return { error, createdRecord };
+        });
+    }
+    /**
+     * record is partial record with only changed fields
+     */
+    updateResourceRecord(_b) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, record, oldRecord, adminUser }) {
+            var _c, _d, _e, _f;
+            // execute hook if needed
+            for (const hook of listify((_d = (_c = resource.hooks) === null || _c === void 0 ? void 0 : _c.edit) === null || _d === void 0 ? void 0 : _d.beforeSave)) {
+                const resp = yield hook({
+                    recordId,
+                    resource,
+                    record,
+                    oldRecord,
+                    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 };
+                }
+            }
+            const newValues = {};
+            const connector = this.connectors[resource.dataSource];
+            for (const recordField in record) {
+                if (record[recordField] !== oldRecord[recordField]) {
+                    // leave only changed fields to reduce data transfer/modifications in db
+                    const column = resource.columns.find((col) => col.name === recordField);
+                    if (!column || !column.virtual) {
+                        // exclude virtual columns
+                        newValues[recordField] = record[recordField];
+                    }
+                }
+            }
+            if (Object.keys(newValues).length > 0) {
+                yield connector.updateRecord({ resource, recordId, newValues });
+            }
+            // execute hook if needed
+            for (const hook of listify((_f = (_e = resource.hooks) === null || _e === void 0 ? void 0 : _e.edit) === null || _f === void 0 ? void 0 : _f.afterSave)) {
+                const resp = yield hook({
+                    resource,
+                    record,
+                    adminUser,
+                    oldRecord,
+                    recordId,
+                });
+                if (!resp || (!resp.ok && !resp.error)) {
+                    throw new Error(`Hook afterSave must return object with {ok: true} or { error: 'Error' } `);
+                }
+                return { error: resp.error };
+            }
+        });
+    }
+    deleteResourceRecord(_b) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, adminUser, record }) {
+            var _c, _d, _e, _f;
+            // execute hook if needed
+            for (const hook of listify((_d = (_c = resource.hooks) === null || _c === void 0 ? void 0 : _c.delete) === null || _d === void 0 ? void 0 : _d.beforeSave)) {
+                const resp = yield hook({
+                    resource,
+                    record,
+                    adminUser,
+                    recordId,
+                });
+                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 };
+                }
+            }
+            const connector = this.connectors[resource.dataSource];
+            yield connector.deleteRecord({ resource, recordId });
+            // execute hook if needed
+            for (const hook of listify((_f = (_e = resource.hooks) === null || _e === void 0 ? void 0 : _e.delete) === null || _f === void 0 ? void 0 : _f.afterSave)) {
+                const resp = yield hook({
+                    resource,
+                    record,
+                    adminUser,
+                    recordId,
+                });
+                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 { ok, error, createdRecord };
         });
     }
     resource(resourceId) {
@@ -234,6 +316,16 @@ AdminForth.Types = AdminForthDataTypes;
 AdminForth.Utils = {
     generatePasswordHash: (password) => __awaiter(void 0, void 0, void 0, function* () {
         return yield AdminForthAuth.generatePasswordHash(password);
-    })
+    }),
+    PASSWORD_VALIDATORS: {
+        UP_LOW_NUM_SPECIAL: {
+            regExp: '^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[!@#\\$%\\^&\\*\\(\\)\\-_=\\+\\[\\]\\{\\}\\|;:\',\\.<>\\/\\?]).+$',
+            message: 'Password must include at least one uppercase letter, one lowercase letter, one number, and one special character'
+        },
+        UP_LOW_NUM: {
+            regExp: '^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9]).+$',
+            message: 'Password must include at least one uppercase letter, one lowercase letter, and one number'
+        },
+    }
 };
 export default AdminForth;

package/dist/modules/codeInjector.js

@@ -217,13 +217,13 @@ class CodeInjector {
                         dereference: true, // needed to dereference types
                     });
                     if (process.env.HEAVY_DEBUG) {
-                        console.log('🪲 await fsExtra.copy copy single file', src, dest);
+                        console.log('🪲⚙️ fsExtra.copy copy single file', src, dest);
                     }
                 })));
             }
             else {
                 if (process.env.HEAVY_DEBUG) {
-                    console.log(`🪲 await fsExtra.copy from ${path.join(ADMIN_FORTH_ABSOLUTE_PATH, 'spa')}, -> ${CodeInjector.SPA_TMP_PATH}`);
+                    console.log(`🪲⚙️ fsExtra.copy from ${path.join(ADMIN_FORTH_ABSOLUTE_PATH, 'spa')}, -> ${CodeInjector.SPA_TMP_PATH}`);
                 }
                 // try to rm SPA_TMP_PATH/src/types directory 
                 try {
@@ -237,7 +237,7 @@ class CodeInjector {
                     filter: (src) => {
                         const filterPasses = !src.includes('/adminforth/spa/node_modules') && !src.includes('/adminforth/spa/dist');
                         if (process.env.HEAVY_DEBUG && !filterPasses) {
-                            console.log('🪲 await fsExtra.copy filtered out', src);
+                            console.log('🪲⚙️ fsExtra.copy filtered out', src);
                         }
                         return filterPasses;
                     },
@@ -261,7 +261,7 @@ class CodeInjector {
                 for (const [src, dest] of Object.entries(this.srcFoldersToSync)) {
                     const to = path.join(CodeInjector.SPA_TMP_PATH, 'src', 'custom', dest);
                     if (process.env.HEAVY_DEBUG) {
-                        console.log(`🪲 await fsExtra.copy from ${src}, ${to}`);
+                        console.log(`🪲⚙️ fsExtra.copy from ${src}, ${to}`);
                     }
                     yield fsExtra.copy(src, to, {
                         recursive: true,
@@ -465,7 +465,7 @@ class CodeInjector {
             });
             yield collectDirectories(spaPath);
             if (process.env.HEAVY_DEBUG) {
-                console.log('🔎 Watching for changes in:', directories.join(','));
+                console.log('🪲🔎 Watch for:', directories.join(','));
             }
             const watcher = filewatcher();
             directories.forEach((dir) => {
@@ -514,11 +514,11 @@ class CodeInjector {
             yield collectDirectories(customComponentsDir);
             const watcher = filewatcher();
             files.forEach((file) => {
-                process.env.HEAVY_DEBUG && console.log(`🔎 Watching for changes in file ${file}`);
+                process.env.HEAVY_DEBUG && console.log(`🪲🔎 Watch for file ${file}`);
                 watcher.add(file);
             });
             if (process.env.HEAVY_DEBUG) {
-                console.log('🔎 Watching for changes in:', directories.join(','));
+                console.log('🪲🔎 Watch for:', directories.join(','));
             }
             watcher.on('change', (fileOrDir) => __awaiter(this, void 0, void 0, function* () {
                 // copy one file
@@ -568,7 +568,7 @@ class CodeInjector {
             }
             else {
                 const command = 'run dev';
-                console.log(`⚙️ spawn: npm ${command}...`);
+                console.log(`🪲⚙️ spawn: npm ${command}...`);
                 const nodeBinary = process.execPath;
                 const npmPath = path.join(path.dirname(nodeBinary), 'npm');
                 const env = Object.assign({ VITE_ADMINFORTH_PUBLIC_PATH: this.adminforth.config.baseUrl, FORCE_COLOR: '1' }, process.env);

package/dist/modules/restApi.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { AdminForthFilterOperators, AdminForthDataTypes, AllowedActionsEnum, ActionCheckSource } from "../types/AdminForthConfig.js";
+import { AdminForthFilterOperators, AdminForthDataTypes, AllowedActionsEnum, ActionCheckSource, AdminForthResourcePages } from "../types/AdminForthConfig.js";
 import { ADMINFORTH_VERSION, listify } from './utils.js';
 import AdminForthAuth from "../auth.js";
 export function interpretResource(adminUser, resource, meta, source) {
@@ -19,7 +19,7 @@ export function interpretResource(adminUser, resource, meta, source) {
         const allowedActions = {};
         yield Promise.all(Object.entries(((_a = resource.options) === null || _a === void 0 ? void 0 : _a.allowedActions) || {}).map((_b) => __awaiter(this, [_b], void 0, function* ([key, value]) {
             if (process.env.HEAVY_DEBUG) {
-                console.log('🪲checking for allowed call', key, 'value:', value, 'typeof', typeof value);
+                console.log(`🪲🚥check allowed ${key}, ${value}`);
             }
             // if callable then call
             if (typeof value === 'function') {
@@ -485,6 +485,7 @@ export default class AdminForthRestAPI {
             method: 'POST',
             path: '/create_record',
             handler: (_2) => __awaiter(this, [_2], void 0, function* ({ body, adminUser }) {
+                var _3;
                 const resource = this.adminforth.config.resources.find((res) => res.resourceId == body['resourceId']);
                 if (!resource) {
                     return { error: `Resource '${body['resourceId']}' not found` };
@@ -495,6 +496,13 @@ export default class AdminForthRestAPI {
                     return { error };
                 }
                 const { record } = body;
+                for (const column of resource.columns) {
+                    if (((_3 = column.required) === null || _3 === void 0 ? void 0 : _3.create) &&
+                        record[column.name] === undefined &&
+                        column.showIn.includes(AdminForthResourcePages.create)) {
+                        return { error: `Column '${column.name}' is required`, ok: false };
+                    }
+                }
                 const response = yield this.adminforth.createResourceRecord({ resource, record, adminUser });
                 if (response.error) {
                     return { error: response.error, ok: false };
@@ -509,8 +517,7 @@ export default class AdminForthRestAPI {
         server.endpoint({
             method: 'POST',
             path: '/update_record',
-            handler: (_3) => __awaiter(this, [_3], void 0, function* ({ body, adminUser }) {
-                var _4, _5, _6, _7;
+            handler: (_4) => __awaiter(this, [_4], void 0, function* ({ body, adminUser }) {
                 const resource = this.adminforth.config.resources.find((res) => res.resourceId == body['resourceId']);
                 if (!resource) {
                     return { error: `Resource '${body['resourceId']}' not found` };
@@ -524,68 +531,23 @@ export default class AdminForthRestAPI {
                 }
                 const record = body['record'];
                 const { allowedActions } = yield interpretResource(adminUser, resource, { requestBody: body, newRecord: record, oldRecord }, ActionCheckSource.EditRequest);
-                const { allowed, error } = checkAccess(AllowedActionsEnum.edit, allowedActions);
+                const { allowed, error: allowedError } = checkAccess(AllowedActionsEnum.edit, allowedActions);
                 if (!allowed) {
-                    return { error };
-                }
-                // execute hook if needed
-                for (const hook of listify((_5 = (_4 = resource.hooks) === null || _4 === void 0 ? void 0 : _4.edit) === null || _5 === void 0 ? void 0 : _5.beforeSave)) {
-                    const resp = yield hook({
-                        recordId,
-                        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 { allowedError };
                 }
-                const newValues = {};
-                for (const recordField in record) {
-                    if (record[recordField] !== oldRecord[recordField]) {
-                        const column = resource.columns.find((col) => col.name === recordField);
-                        if (column) {
-                            if (!column.virtual) {
-                                newValues[recordField] = connector.setFieldValue(column, record[recordField]);
-                            }
-                        }
-                        else {
-                            newValues[recordField] = record[recordField];
-                        }
-                    }
-                }
-                if (Object.keys(newValues).length > 0) {
-                    yield connector.updateRecord({ resource, recordId, newValues });
-                }
-                // execute hook if needed
-                for (const hook of listify((_7 = (_6 = resource.hooks) === null || _6 === void 0 ? void 0 : _6.edit) === null || _7 === void 0 ? void 0 : _7.afterSave)) {
-                    const resp = yield hook({
-                        resource,
-                        record,
-                        adminUser,
-                        oldRecord,
-                        recordId,
-                    });
-                    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 };
-                    }
+                const { error } = yield this.adminforth.updateResourceRecord({ resource, record, adminUser, oldRecord, recordId });
+                if (error) {
+                    return { error };
                 }
                 return {
-                    newRecordId: recordId
+                    ok: true
                 };
             })
         });
         server.endpoint({
             method: 'POST',
             path: '/delete_record',
-            handler: (_8) => __awaiter(this, [_8], void 0, function* ({ body, adminUser }) {
-                var _9, _10, _11, _12;
+            handler: (_5) => __awaiter(this, [_5], void 0, function* ({ body, adminUser }) {
                 const resource = this.adminforth.config.resources.find((res) => res.resourceId == body['resourceId']);
                 const record = yield this.adminforth.connectors[resource.dataSource].getRecordByPrimaryKey(resource, body['primaryKey']);
                 if (!resource) {
@@ -602,39 +564,12 @@ export default class AdminForthRestAPI {
                 if (!allowed) {
                     return { error };
                 }
-                // execute hook if needed
-                for (const hook of listify((_10 = (_9 = resource.hooks) === null || _9 === void 0 ? void 0 : _9.delete) === null || _10 === void 0 ? void 0 : _10.beforeSave)) {
-                    const resp = yield hook({
-                        resource,
-                        record,
-                        adminUser,
-                        recordId: body['primaryKey']
-                    });
-                    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 };
-                    }
-                }
-                const connector = this.adminforth.connectors[resource.dataSource];
-                yield connector.deleteRecord({ resource, recordId: body['primaryKey'] });
-                // execute hook if needed
-                for (const hook of listify((_12 = (_11 = resource.hooks) === null || _11 === void 0 ? void 0 : _11.delete) === null || _12 === void 0 ? void 0 : _12.afterSave)) {
-                    const resp = yield hook({
-                        resource,
-                        record,
-                        adminUser,
-                        recordId: body['primaryKey']
-                    });
-                    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 };
-                    }
+                const { error: deleteError } = yield this.adminforth.deleteResourceRecord({ resource, record, adminUser, recordId: body['primaryKey'] });
+                if (deleteError) {
+                    return { error: deleteError };
                 }
                 return {
+                    ok: true,
                     recordId: body['primaryKey']
                 };
             })
@@ -642,7 +577,7 @@ export default class AdminForthRestAPI {
         server.endpoint({
             method: 'POST',
             path: '/start_bulk_action',
-            handler: (_13) => __awaiter(this, [_13], void 0, function* ({ body, adminUser }) {
+            handler: (_6) => __awaiter(this, [_6], void 0, function* ({ body, adminUser }) {
                 const { resourceId, actionId, recordIds } = body;
                 const resource = this.adminforth.config.resources.find((res) => res.resourceId == resourceId);
                 if (!resource) {

package/index.ts

@@ -17,6 +17,7 @@ import {
   AfterSaveFunction,
   AdminUser,
   AdminForthResource,
+  IAdminForthDataSourceConnectorBase,
 } from './types/AdminForthConfig.js';
 import AdminForthPlugin from './basePlugin.js';
 import ConfigValidator from './modules/configValidator.js';
@@ -38,6 +39,17 @@ class AdminForth implements IAdminForth {
   static Utils = {
     generatePasswordHash: async (password) => {
       return await AdminForthAuth.generatePasswordHash(password);
+    },
+
+    PASSWORD_VALIDATORS: {
+      UP_LOW_NUM_SPECIAL: {
+        regExp: '^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[!@#\\$%\\^&\\*\\(\\)\\-_=\\+\\[\\]\\{\\}\\|;:\',\\.<>\\/\\?]).+$',
+        message: 'Password must include at least one uppercase letter, one lowercase letter, one number, and one special character'
+      },
+      UP_LOW_NUM: {
+        regExp: '^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9]).+$',
+        message: 'Password must include at least one uppercase letter, one lowercase letter, and one number'
+      },
     }
   }
 
@@ -49,7 +61,9 @@ class AdminForth implements IAdminForth {
   express: ExpressServer;
   auth: AdminForthAuth;
   codeInjector: CodeInjector;
-  connectors;
+  connectors: {
+    [dataSourceId: string]: IAdminForthDataSourceConnectorBase,
+  };
   connectorClasses: any;
   runningHotReload: boolean;
   activatedPlugins: Array<AdminForthPlugin>;
@@ -202,18 +216,7 @@ class AdminForth implements IAdminForth {
   async createResourceRecord(
     { resource, record, adminUser }: 
     { resource: AdminForthResource, record: any, adminUser: AdminUser }
-  ): Promise<{ ok: boolean, error?: string, createdRecord?: any }> {
-    
-    for (const column of resource.columns) {
-      // 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 };
-      }
-    }
+  ): Promise<{ error?: string, createdRecord?: any }> {
 
     // execute hook if needed
     for (const hook of listify(resource.hooks?.create?.beforeSave as BeforeSaveFunction[])) {
@@ -223,28 +226,28 @@ class AdminForth implements IAdminForth {
       }
 
       if (resp.error) {
-        return { error: resp.error, ok: false };
+        return { error: resp.error };
       }
     }
 
     // remove virtual columns from record
     for (const column of resource.columns.filter((col) => col.virtual)) {
-        if (record[column.name]) {
-          delete record[column.name];
-        }
+      if (record[column.name]) {
+        delete record[column.name];
+      }
     }
     const connector = this.connectors[resource.dataSource];
-    process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record createResourceRecord', record);
-    const { ok, error, createdRecord } = await connector.createRecord({ resource, record, adminUser });
-    if (!ok) {
-      return { ok, error };
+    process.env.HEAVY_DEBUG && console.log('🪲🆕 creating record createResourceRecord', record);
+    const { error, createdRecord } = await connector.createRecord({ resource, record, adminUser });
+    if ( error ) {
+      return { 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);
+      process.env.HEAVY_DEBUG && console.log('🪲 Hook afterSave', hook);
       const resp = await hook({ 
         recordId: primaryKey, 
         resource, 
@@ -257,11 +260,112 @@ class AdminForth implements IAdminForth {
       }
 
       if (resp.error) {
-        return { error: resp.error, ok: false };
+        return { error: resp.error };
+      }
+    }
+
+    return { error, createdRecord };
+  }
+
+  /**
+   * record is partial record with only changed fields
+   */
+  async updateResourceRecord(
+    { resource, recordId, record, oldRecord, adminUser }:
+    { resource: AdminForthResource, recordId: any, record: any, oldRecord: any, adminUser: AdminUser }
+  ): Promise<{ error?: string }> {
+
+    // execute hook if needed
+    for (const hook of listify(resource.hooks?.edit?.beforeSave as BeforeSaveFunction[])) {
+      const resp = await hook({
+        recordId,
+        resource,
+        record,
+        oldRecord,
+        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 };
       }
     }
+    const newValues = {};
+    const connector = this.connectors[resource.dataSource];
+
+    for (const recordField in record) {
+      if (record[recordField] !== oldRecord[recordField]) {
+        // leave only changed fields to reduce data transfer/modifications in db
+        const column = resource.columns.find((col) => col.name === recordField);
+        if (!column || !column.virtual) {
+          // exclude virtual columns
+          newValues[recordField] = record[recordField];
+        }
+      }
+    } 
 
-    return { ok, error, createdRecord };
+    if (Object.keys(newValues).length > 0) {
+      await connector.updateRecord({ resource, recordId, newValues });
+    }
+    
+    // execute hook if needed
+    for (const hook of listify(resource.hooks?.edit?.afterSave as AfterSaveFunction[])) {
+      const resp = await hook({ 
+        resource, 
+        record, 
+        adminUser, 
+        oldRecord,
+        recordId,
+      });
+      if (!resp || (!resp.ok && !resp.error)) {
+        throw new Error(`Hook afterSave must return object with {ok: true} or { error: 'Error' } `);
+      }
+
+      return { error: resp.error };
+    }
+  }
+
+  async deleteResourceRecord(
+    { resource, recordId, adminUser, record }:
+    { resource: AdminForthResource, recordId: any, adminUser: AdminUser, record: any }
+  ): Promise<{ error?: string }> {
+    // execute hook if needed
+    for (const hook of listify(resource.hooks?.delete?.beforeSave as BeforeSaveFunction[])) {
+      const resp = await hook({ 
+        resource, 
+        record, 
+        adminUser,
+        recordId,
+      });
+      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 };
+      }
+    }
+
+    const connector = this.connectors[resource.dataSource];
+    await connector.deleteRecord({ resource, recordId});
+
+    // execute hook if needed
+    for (const hook of listify(resource.hooks?.delete?.afterSave as BeforeSaveFunction[])) {
+      const resp = await hook({ 
+        resource, 
+        record, 
+        adminUser,
+        recordId,
+      });
+      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 };
+      }
+    }
   }
 
   resource(resourceId: string): IOperationalResource {

package/modules/codeInjector.ts

@@ -236,13 +236,13 @@ class CodeInjector implements ICodeInjector {
           dereference: true, // needed to dereference types
         });
         if (process.env.HEAVY_DEBUG) {
-          console.log('🪲 await fsExtra.copy copy single file', src, dest);
+          console.log('🪲⚙️ fsExtra.copy copy single file', src, dest);
         }
 
       }));
     } else {
       if (process.env.HEAVY_DEBUG) {
-        console.log(`🪲 await fsExtra.copy from ${path.join(ADMIN_FORTH_ABSOLUTE_PATH, 'spa')}, -> ${CodeInjector.SPA_TMP_PATH}`);
+        console.log(`🪲⚙️ fsExtra.copy from ${path.join(ADMIN_FORTH_ABSOLUTE_PATH, 'spa')}, -> ${CodeInjector.SPA_TMP_PATH}`);
       }
 
       // try to rm SPA_TMP_PATH/src/types directory 
@@ -257,7 +257,7 @@ class CodeInjector implements ICodeInjector {
         filter: (src) => {
           const filterPasses = !src.includes('/adminforth/spa/node_modules') && !src.includes('/adminforth/spa/dist')
           if (process.env.HEAVY_DEBUG && !filterPasses) {
-            console.log('🪲 await fsExtra.copy filtered out', src);
+            console.log('🪲⚙️ fsExtra.copy filtered out', src);
           }
 
           return filterPasses
@@ -287,7 +287,7 @@ class CodeInjector implements ICodeInjector {
       for (const [src, dest] of Object.entries(this.srcFoldersToSync)) {
         const to = path.join(CodeInjector.SPA_TMP_PATH, 'src', 'custom', dest);
         if (process.env.HEAVY_DEBUG) {
-          console.log(`🪲 await fsExtra.copy from ${src}, ${to}`);
+          console.log(`🪲⚙️ fsExtra.copy from ${src}, ${to}`);
         }
 
         await fsExtra.copy(src, to, {
@@ -534,7 +534,7 @@ class CodeInjector implements ICodeInjector {
     await collectDirectories(spaPath);
 
     if (process.env.HEAVY_DEBUG) {
-      console.log('🔎 Watching for changes in:', directories.join(','));
+      console.log('🪲🔎 Watch for:', directories.join(','));
     }
 
     const watcher = filewatcher();
@@ -593,12 +593,12 @@ class CodeInjector implements ICodeInjector {
 
     const watcher = filewatcher();
     files.forEach((file) => {
-      process.env.HEAVY_DEBUG && console.log(`🔎 Watching for changes in file ${file}`);
+      process.env.HEAVY_DEBUG && console.log(`🪲🔎 Watch for file ${file}`);
       watcher.add(file);
     });
 
     if (process.env.HEAVY_DEBUG) {
-      console.log('🔎 Watching for changes in:', directories.join(','));
+      console.log('🪲🔎 Watch for:', directories.join(','));
     }
     
     watcher.on(
@@ -657,7 +657,7 @@ class CodeInjector implements ICodeInjector {
       await this.runNpmShell({command: 'run build-only', cwd});
     } else {
       const command = 'run dev';
-      console.log(`⚙️ spawn: npm ${command}...`);
+      console.log(`🪲⚙️ spawn: npm ${command}...`);
       const nodeBinary = process.execPath; 
       const npmPath = path.join(path.dirname(nodeBinary), 'npm');
       const env = {

package/modules/operationalResource.ts

@@ -87,7 +87,7 @@ export default class OperationalResource implements IOperationalResource {
     return await this.dataConnector.updateRecord({ 
       resource: this.resourceConfig,
       recordId: primaryKey,
-      newValues: record 
+      newValues: record
     });
   }
 

package/modules/restApi.ts

@@ -13,7 +13,8 @@ import {
   AfterDataSourceResponseFunction,
   BeforeDataSourceRequestFunction,
   AfterSaveFunction,
-  AllowedActionsResolved
+  AllowedActionsResolved,
+  AdminForthResourcePages
 
 } from "../types/AdminForthConfig.js";
 
@@ -32,7 +33,7 @@ export async function interpretResource(adminUser: AdminUser, resource: AdminFor
     Object.entries(resource.options?.allowedActions || {}).map(
       async ([key, value]: [string, AllowedActionValue]) => {
         if (process.env.HEAVY_DEBUG) {
-          console.log('🪲checking for allowed call', key, 'value:', value, 'typeof', typeof value);
+          console.log(`🪲🚥check allowed ${key}, ${value}`)
         }
       
         // if callable then call
@@ -575,6 +576,16 @@ export default class AdminForthRestAPI {
 
             const { record } = body;
 
+            for (const column of resource.columns) {
+              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 };
+              }
+            }
+
             const response = await this.adminforth.createResourceRecord({ resource, record, adminUser });
             if (response.error) {
               return { error: response.error, ok: false };
@@ -607,66 +618,17 @@ export default class AdminForthRestAPI {
 
             const { allowedActions } = await interpretResource(adminUser, resource, { requestBody: body, newRecord: record, oldRecord}, ActionCheckSource.EditRequest);
 
-            const { allowed, error } = checkAccess(AllowedActionsEnum.edit, allowedActions);
+            const { allowed, error: allowedError } = checkAccess(AllowedActionsEnum.edit, allowedActions);
             if (!allowed) {
-              return { error };
+              return { allowedError };
             }
 
-            // execute hook if needed
-            for (const hook of listify(resource.hooks?.edit?.beforeSave as BeforeSaveFunction[])) {
-              const resp = await hook({
-                recordId,
-                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 };
-              }
-            }
-            const newValues = {};
-
-            for (const recordField in record) {
-              if (record[recordField] !== oldRecord[recordField]) {
-                const column = resource.columns.find((col) => col.name === recordField);
-                if (column) {
-                  if (!column.virtual) {
-                    newValues[recordField] = connector.setFieldValue(column, record[recordField]);
-                  }
-                } else {
-                  newValues[recordField] = record[recordField];
-                }
-              }
-            } 
-
-            if (Object.keys(newValues).length > 0) {
-                await connector.updateRecord({ resource, recordId, newValues});
-            }
-            
-            // execute hook if needed
-            for (const hook of listify(resource.hooks?.edit?.afterSave as AfterSaveFunction[])) {
-              const resp = await hook({ 
-                resource, 
-                record, 
-                adminUser, 
-                oldRecord,
-                recordId,
-              });
-              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 };
-              }
+            const { error } = await this.adminforth.updateResourceRecord({ resource, record, adminUser, oldRecord, recordId });
+            if (error) {
+              return { error };
             }
-
             return {
-              newRecordId: recordId
+              ok: true
             }
         }
     });
@@ -693,43 +655,12 @@ export default class AdminForthRestAPI {
               return { error };
             }
 
-            // execute hook if needed
-            for (const hook of listify(resource.hooks?.delete?.beforeSave as BeforeSaveFunction[])) {
-              const resp = await hook({ 
-                resource, 
-                record, 
-                adminUser,
-                recordId: body['primaryKey']
-              });
-              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 };
-              }
-            }
-
-            const connector = this.adminforth.connectors[resource.dataSource];
-            await connector.deleteRecord({ resource, recordId: body['primaryKey']});
-
-            // execute hook if needed
-            for (const hook of listify(resource.hooks?.delete?.afterSave as BeforeSaveFunction[])) {
-              const resp = await hook({ 
-                resource, 
-                record, 
-                adminUser,
-                recordId: body['primaryKey']
-              });
-              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 };
-              }
+            const { error: deleteError } = await this.adminforth.deleteResourceRecord({ resource, record, adminUser, recordId: body['primaryKey'] });
+            if (deleteError) {
+              return { error: deleteError };
             }
             return {
+              ok: true,
               recordId: body['primaryKey']
             }
         }

package/package.json

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

package/spa/src/components/ResourceForm.vue

@@ -145,7 +145,7 @@
 
 import CustomDatePicker from "@/components/CustomDatePicker.vue";
 import Dropdown from '@/components/Dropdown.vue';
-import { callAdminForthApi, getCustomComponent } from '@/utils';
+import { applyRegexValidation, callAdminForthApi, getCustomComponent } from '@/utils';
 import { IconExclamationCircleSolid, IconEyeSlashSolid, IconEyeSolid } from '@iconify-prerendered/vue-flowbite';
 import { computedAsync } from '@vueuse/core';
 import { initFlowbite } from 'flowbite';
@@ -172,7 +172,7 @@ const currentValues = ref(null);
 
 const customComponentsInValidity = ref({});
 const customComponentsEmptiness = ref({});
-
+  
 
 const columnError = (column) => {
   const val = computed(() => {
@@ -212,22 +212,12 @@ const columnError = (column) => {
         return `This field must be less than ${column.maxValue}`;
       }
     }
-    if ( column.validation && column.validation.length ) {
-      const validationArray = column.validation;
-      for (let i = 0; i < validationArray.length; i++) {
-        if (validationArray[i].regExp) {
-          const regExp = new RegExp(validationArray[i].regExp);
-          let value = currentValues.value[column.name];
-          if (value === undefined || value === null) {
-            value = '';
-          }
-          if (!regExp.test(value)) {
-            return validationArray[i].message;
-          }
-        }
-      }
 
+    const error = applyRegexValidation(currentValues.value[column.name], column.validation);
+    if (error) {
+      return error;
     }
+
     return null;
   });
   return val.value;

package/spa/src/utils.ts

@@ -1,5 +1,7 @@
 import { onMounted, ref, resolveComponent } from 'vue';
-import type {  CoreConfig } from './spa_types/core';
+import type { CoreConfig } from './spa_types/core';
+import type { ValidationObject } from './types/AdminForthConfig';
+
 
 import router from "./router";
 import { useCoreStore } from './stores/core';
@@ -113,4 +115,35 @@ export function initThreeDotsDropdown() {
       dd.hide();
     }
   }
+}
+
+export function applyRegexValidation(value: any, validation: ValidationObject[] | undefined) {
+
+  if ( validation?.length ) {
+    const validationArray = validation;
+    for (let i = 0; i < validationArray.length; i++) {
+      if (validationArray[i].regExp) {
+        let flags = '';
+        if (validationArray[i].caseSensitive) {
+          flags += 'i';
+        }
+        if (validationArray[i].multiline) {
+          flags += 'm';
+        }
+        if (validationArray[i].global) {
+          flags += 'g';
+        }
+
+        const regExp = new RegExp(validationArray[i].regExp, flags);
+        if (value === undefined || value === null) {
+          value = '';
+        }
+        let valueS = `${value}`;
+
+        if (!regExp.test(valueS)) {
+          return validationArray[i].message;
+        }
+      }
+    }
+  }
 }

package/types/AdminForthConfig.ts

@@ -189,14 +189,12 @@ export interface IAdminForthDataSourceConnector {
   createRecordOriginalValues({ resource, record }: { resource: AdminForthResource, record: any }): Promise<void>;
 
   /**
-   * Used to update record in database.
+   * Update record in database. newValues might have not all fields in record, but only changed ones.
    * recordId is value of field which is marked as {@link AdminForthResourceColumn.primaryKey}
-   * newValues is array of fields which should be updated (might be not all fields in record, but only changed fields).
    */
-  updateRecord({ resource, recordId, newValues }:
-    { resource: AdminForthResource, recordId: string, newValues: any }
-  ): Promise<void>;
-  
+  updateRecordOriginalValues({ resource, recordId, newValues }: { resource: AdminForthResource; recordId: string; newValues: any; }): Promise<void>;
+
+
   /**
    * Used to delete record in database.
    */
@@ -228,12 +226,18 @@ export interface IAdminForthDataSourceConnectorBase extends IAdminForthDataSourc
     adminUser: AdminUser
   }): Promise<{ok: boolean, error?: string, createdRecord?: any}>;
 
+  updateRecord({ resource, recordId, newValues }: { 
+    resource: AdminForthResource, 
+    recordId: string, 
+    newValues: any, 
+  }): Promise<{ok: boolean, error?: string}>;
+
   getMinMaxForColumns({ resource, columns }: { resource: AdminForthResource, columns: AdminForthResourceColumn[] }): Promise<{ [key: string]: { min: any, max: any } }>;
 }
 
 
 export interface IAdminForthDataSourceConnectorConstructor {
-  new ({ url }: { url: string }): IAdminForthDataSourceConnector;
+  new ({ url }: { url: string }): IAdminForthDataSourceConnectorBase;
 }
 
 export interface IAdminForthAuth {
@@ -266,7 +270,15 @@ export interface IAdminForth {
 
   createResourceRecord(
     params: { resource: AdminForthResource, record: any, adminUser: AdminUser }
-  ): Promise<{ ok: boolean, error?: string, createdRecord?: any }>;
+  ): Promise<{ error?: string, createdRecord?: any }>;
+
+  updateResourceRecord(
+    params: { resource: AdminForthResource, recordId: any, record: any, oldRecord: any, adminUser: AdminUser }
+  ): Promise<{ error?: string }>;
+
+  deleteResourceRecord(
+    params: { resource: AdminForthResource, recordId: string, adminUser: AdminUser, record: any }
+  ): Promise<{ error?: string }>;
 
   auth: IAdminForthAuth;
 
@@ -701,13 +713,13 @@ export type AfterDataSourceResponseFunction = (params: {resource: AdminForthReso
  * Modify record to change how data is saved to database.
  * Return ok: false and error: string to stop execution and show error message to user. Return ok: true to continue execution.
  */
-export type BeforeSaveFunction = (params: {resource: AdminForthResource, recordId: any, adminUser: AdminUser, record: any}) => Promise<{ok: boolean, error?: string}>;
+export type BeforeSaveFunction = (params: {resource: AdminForthResource, recordId: any, adminUser: AdminUser, record: any, oldRecord?: any}) => Promise<{ok: boolean, error?: string}>;
 
 /**
  * Modify record to change how data is saved to database.
  * Return ok: false and error: string to stop execution and show error message to user. Return ok: true to continue execution.
  */
-export type AfterSaveFunction = (params: {resource: AdminForthResource, recordId: any, adminUser: AdminUser, record: any}) => Promise<{ok: boolean, error?: string}>;
+export type AfterSaveFunction = (params: {resource: AdminForthResource, recordId: any, adminUser: AdminUser, record: any, oldRecord?: any}) => Promise<{ok: boolean, error?: string}>;
 
 /**
  * Allow to get user data before login confirmation, will triger when user try to login.
@@ -1508,6 +1520,21 @@ export type ValidationObject = {
      * Example: "Invalid email format"
      */
     message: string,
+
+    /**
+     * Whether to check case sensitivity (i flag)
+     */
+    caseSensitive: boolean,
+    
+    /**
+     * Whether to check Multiline strings (m flag)
+     */
+    multiline: boolean, 
+    
+    /**
+     * Whether to check global strings (g flag)
+     */
+    global: boolean
   }
 
 export type AdminForthComponentDeclarationFull = {