adminforth 1.3.54-next.22 → 1.3.54-next.24

package/dist/modules/restApi.js

@@ -1,36 +1,25 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 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) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        // if (process.env.HEAVY_DEBUG) {
-        //   console.log('🪲Interpreting resource', resource.resourceId, source, 'adminUser', adminUser);
-        // }
-        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(`🪲🚥check allowed ${key}, ${value}`);
-            }
-            // if callable then call
-            if (typeof value === 'function') {
-                allowedActions[key] = yield value({ adminUser, resource, meta, source });
-            }
-            else {
-                allowedActions[key] = value;
-            }
-        })));
-        return { allowedActions };
-    });
+export async function interpretResource(adminUser, resource, meta, source) {
+    var _a;
+    // if (process.env.HEAVY_DEBUG) {
+    //   console.log('🪲Interpreting resource', resource.resourceId, source, 'adminUser', adminUser);
+    // }
+    const allowedActions = {};
+    await Promise.all(Object.entries(((_a = resource.options) === null || _a === void 0 ? void 0 : _a.allowedActions) || {}).map(async ([key, value]) => {
+        if (process.env.HEAVY_DEBUG) {
+            console.log(`🪲🚥check allowed ${key}, ${value}`);
+        }
+        // if callable then call
+        if (typeof value === 'function') {
+            allowedActions[key] = await value({ adminUser, resource, meta, source });
+        }
+        else {
+            allowedActions[key] = value;
+        }
+    }));
+    return { allowedActions };
 }
 export default class AdminForthRestAPI {
     constructor(adminforth) {
@@ -41,8 +30,8 @@ export default class AdminForthRestAPI {
             noAuth: true,
             method: 'POST',
             path: '/login',
-            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, response }) {
-                var _b, _c, _d, _e;
+            handler: async ({ body, response }) => {
+                var _a, _b, _c, _d;
                 const INVALID_MESSAGE = 'Invalid Username or Password';
                 const { username, password, rememberMe } = body;
                 let adminUser;
@@ -62,7 +51,7 @@ export default class AdminForthRestAPI {
                     });
                     console.log('Adding passwordHashField to userResource', userResource);
                 }
-                const userRecord = (_b = (yield this.adminforth.connectors[userResource.dataSource].getData({
+                const userRecord = (_a = (await this.adminforth.connectors[userResource.dataSource].getData({
                     resource: userResource,
                     filters: [
                         { field: this.adminforth.config.auth.usernameField, operator: AdminForthFilterOperators.EQ, value: username },
@@ -70,12 +59,12 @@ export default class AdminForthRestAPI {
                     limit: 1,
                     offset: 0,
                     sort: [],
-                })).data) === null || _b === void 0 ? void 0 : _b[0];
+                })).data) === null || _a === void 0 ? void 0 : _a[0];
                 if (!userRecord) {
                     return { error: INVALID_MESSAGE };
                 }
                 const passwordHash = userRecord[this.adminforth.config.auth.passwordHashField];
-                const valid = yield AdminForthAuth.verifyPassword(password, passwordHash);
+                const valid = await AdminForthAuth.verifyPassword(password, passwordHash);
                 if (valid) {
                     adminUser = {
                         dbUser: userRecord,
@@ -85,9 +74,9 @@ export default class AdminForthRestAPI {
                     const beforeLoginConfirmation = this.adminforth.config.auth.beforeLoginConfirmation;
                     if (beforeLoginConfirmation === null || beforeLoginConfirmation === void 0 ? void 0 : beforeLoginConfirmation.length) {
                         for (const hook of beforeLoginConfirmation) {
-                            const resp = yield hook({ adminUser, response });
-                            if ((_c = resp === null || resp === void 0 ? void 0 : resp.body) === null || _c === void 0 ? void 0 : _c.redirectTo) {
-                                toReturn = { ok: resp.ok, redirectTo: (_d = resp === null || resp === void 0 ? void 0 : resp.body) === null || _d === void 0 ? void 0 : _d.redirectTo, allowedLogin: (_e = resp === null || resp === void 0 ? void 0 : resp.body) === null || _e === void 0 ? void 0 : _e.allowedLogin };
+                            const resp = await hook({ adminUser, response });
+                            if ((_b = resp === null || resp === void 0 ? void 0 : resp.body) === null || _b === void 0 ? void 0 : _b.redirectTo) {
+                                toReturn = { ok: resp.ok, redirectTo: (_c = resp === null || resp === void 0 ? void 0 : resp.body) === null || _c === void 0 ? void 0 : _c.redirectTo, allowedLogin: (_d = resp === null || resp === void 0 ? void 0 : resp.body) === null || _d === void 0 ? void 0 : _d.allowedLogin };
                                 break;
                             }
                         }
@@ -106,30 +95,30 @@ export default class AdminForthRestAPI {
                     return { error: INVALID_MESSAGE };
                 }
                 return toReturn;
-            })
+            }
         });
         server.endpoint({
             method: 'POST',
             path: '/check_auth',
-            handler: (_f) => __awaiter(this, [_f], void 0, function* ({ adminUser }) {
+            handler: async ({ adminUser }) => {
                 return { ok: true };
-            }),
+            },
         });
         server.endpoint({
             noAuth: true,
             method: 'POST',
             path: '/logout',
-            handler: (_g) => __awaiter(this, [_g], void 0, function* ({ response }) {
+            handler: async ({ response }) => {
                 this.adminforth.auth.removeAuthCookie(response);
                 return { ok: true };
-            }),
+            },
         });
         server.endpoint({
             noAuth: true,
             method: 'GET',
             path: '/get_public_config',
-            handler: (_h) => __awaiter(this, [_h], void 0, function* ({ body }) {
-                var _j;
+            handler: async ({ body }) => {
+                var _a;
                 // find resource
                 if (!this.adminforth.config.auth) {
                     throw new Error('No config.auth defined');
@@ -142,19 +131,19 @@ export default class AdminForthRestAPI {
                     usernameFieldName: usernameColumn.label,
                     loginBackgroundImage: this.adminforth.config.auth.loginBackgroundImage,
                     loginBackgroundPosition: this.adminforth.config.auth.loginBackgroundPosition,
-                    title: (_j = this.adminforth.config.customization) === null || _j === void 0 ? void 0 : _j.title,
+                    title: (_a = this.adminforth.config.customization) === null || _a === void 0 ? void 0 : _a.title,
                     demoCredentials: this.adminforth.config.auth.demoCredentials,
                     loginPromptHTML: this.adminforth.config.auth.loginPromptHTML,
                     loginPageInjections: this.adminforth.config.customization.loginPageInjections,
                     rememberMeDays: this.adminforth.config.auth.rememberMeDays,
                 };
-            }),
+            },
         });
         server.endpoint({
             method: 'GET',
             path: '/get_base_config',
-            handler: (_k) => __awaiter(this, [_k], void 0, function* ({ input, adminUser, cookies }) {
-                var _l, _m, _o, _p, _q;
+            handler: async ({ input, adminUser, cookies }) => {
+                var _a, _b, _c, _d, _e;
                 let username = '';
                 let userFullName = '';
                 const dbUser = adminUser.dbUser;
@@ -176,14 +165,12 @@ export default class AdminForthRestAPI {
                         return toReturn;
                     }
                 };
-                function processMenuItem(menuItem) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        if (menuItem.badge) {
-                            if (typeof menuItem.badge === 'function') {
-                                menuItem.badge = yield menuItem.badge(adminUser);
-                            }
+                async function processMenuItem(menuItem) {
+                    if (menuItem.badge) {
+                        if (typeof menuItem.badge === 'function') {
+                            menuItem.badge = await menuItem.badge(adminUser);
                         }
-                    });
+                    }
                 }
                 let newMenu = [];
                 for (let menuItem of this.adminforth.config.menu) {
@@ -202,15 +189,15 @@ export default class AdminForthRestAPI {
                                     continue;
                                 }
                             }
-                            yield processMenuItem(newChild);
+                            await processMenuItem(newChild);
                             newChildren.push(newChild);
                         }
                         newMenuItem = Object.assign(Object.assign({}, newMenuItem), { children: newChildren });
                     }
-                    yield processMenuItem(newMenuItem);
+                    await processMenuItem(newMenuItem);
                     newMenu.push(newMenuItem);
                 }
-                const announcementBadge = (_m = (_l = this.adminforth.config.customization).announcementBadge) === null || _m === void 0 ? void 0 : _m.call(_l, adminUser);
+                const announcementBadge = (_b = (_a = this.adminforth.config.customization).announcementBadge) === null || _b === void 0 ? void 0 : _b.call(_a, adminUser);
                 return {
                     user: userData,
                     resources: this.adminforth.config.resources.map((res) => ({
@@ -227,15 +214,15 @@ export default class AdminForthRestAPI {
                         deleteConfirmation: this.adminforth.config.deleteConfirmation,
                         auth: this.adminforth.config.auth,
                         usernameField: this.adminforth.config.auth.usernameField,
-                        title: (_o = this.adminforth.config.customization) === null || _o === void 0 ? void 0 : _o.title,
-                        emptyFieldPlaceholder: (_p = this.adminforth.config.customization) === null || _p === void 0 ? void 0 : _p.emptyFieldPlaceholder,
+                        title: (_c = this.adminforth.config.customization) === null || _c === void 0 ? void 0 : _c.title,
+                        emptyFieldPlaceholder: (_d = this.adminforth.config.customization) === null || _d === void 0 ? void 0 : _d.emptyFieldPlaceholder,
                         announcementBadge,
-                        globalInjections: (_q = this.adminforth.config.customization) === null || _q === void 0 ? void 0 : _q.globalInjections,
+                        globalInjections: (_e = this.adminforth.config.customization) === null || _e === void 0 ? void 0 : _e.globalInjections,
                     },
                     adminUser,
                     version: ADMINFORTH_VERSION,
                 };
-            }),
+            },
         });
         function checkAccess(action, allowedActions) {
             const allowed = allowedActions[action];
@@ -247,7 +234,7 @@ export default class AdminForthRestAPI {
         server.endpoint({
             method: 'POST',
             path: '/get_resource',
-            handler: (_r) => __awaiter(this, [_r], void 0, function* ({ body, adminUser }) {
+            handler: async ({ body, adminUser }) => {
                 const { resourceId } = body;
                 if (!this.adminforth.statuses.dbDiscover) {
                     return { error: 'Database discovery not started' };
@@ -259,11 +246,11 @@ export default class AdminForthRestAPI {
                 if (!resource) {
                     return { error: `Resource ${resourceId} not found` };
                 }
-                const { allowedActions } = yield interpretResource(adminUser, resource, {}, ActionCheckSource.DisplayButtons);
+                const { allowedActions } = await interpretResource(adminUser, resource, {}, ActionCheckSource.DisplayButtons);
                 const allowedBulkActions = [];
-                yield Promise.all(resource.options.bulkActions.map((action) => __awaiter(this, void 0, void 0, function* () {
+                await Promise.all(resource.options.bulkActions.map(async (action) => {
                     if (action.allowed) {
-                        const res = yield action.allowed({ adminUser, resource, allowedActions });
+                        const res = await action.allowed({ adminUser, resource, allowedActions });
                         if (res) {
                             allowedBulkActions.push(action);
                         }
@@ -271,18 +258,18 @@ export default class AdminForthRestAPI {
                     else {
                         allowedBulkActions.push(action);
                     }
-                })));
+                }));
                 // exclude "plugins" key
                 return {
                     resource: Object.assign(Object.assign({}, resource), { plugins: undefined, options: Object.assign(Object.assign({}, resource.options), { bulkActions: allowedBulkActions, allowedActions }) })
                 };
-            }),
+            },
         });
         server.endpoint({
             method: 'POST',
             path: '/get_resource_data',
-            handler: (_s) => __awaiter(this, [_s], void 0, function* ({ body, adminUser }) {
-                var _t, _u, _v, _w;
+            handler: async ({ body, adminUser }) => {
+                var _a, _b, _c, _d;
                 const { resourceId, source } = body;
                 if (['show', 'list'].includes(source) === false) {
                     return { error: 'Invalid source, should be list or show' };
@@ -297,13 +284,13 @@ export default class AdminForthRestAPI {
                 if (!resource) {
                     return { error: `Resource ${resourceId} not found` };
                 }
-                const { allowedActions } = yield interpretResource(adminUser, resource, { requestBody: body }, ActionCheckSource.DisplayButtons);
+                const { allowedActions } = await interpretResource(adminUser, resource, { requestBody: body }, ActionCheckSource.DisplayButtons);
                 const { allowed, error } = checkAccess(source, allowedActions);
                 if (!allowed) {
                     return { error };
                 }
-                for (const hook of listify((_u = (_t = resource.hooks) === null || _t === void 0 ? void 0 : _t[source]) === null || _u === void 0 ? void 0 : _u.beforeDatasourceRequest)) {
-                    const resp = yield hook({ resource, query: body, adminUser });
+                for (const hook of listify((_b = (_a = resource.hooks) === null || _a === void 0 ? void 0 : _a[source]) === null || _b === void 0 ? void 0 : _b.beforeDatasourceRequest)) {
+                    const resp = await hook({ resource, query: body, adminUser });
                     if (!resp || (!resp.ok && !resp.error)) {
                         throw new Error(`Hook must return object with {ok: true} or { error: 'Error' } `);
                     }
@@ -329,7 +316,7 @@ export default class AdminForthRestAPI {
                         return { data: [], total: 0 };
                     }
                 }
-                const data = yield this.adminforth.connectors[resource.dataSource].getData({
+                const data = await this.adminforth.connectors[resource.dataSource].getData({
                     resource,
                     limit,
                     offset,
@@ -338,7 +325,7 @@ export default class AdminForthRestAPI {
                     getTotals: true,
                 });
                 // for foreign keys, add references
-                yield Promise.all(resource.columns.filter((col) => col.foreignResource).map((col) => __awaiter(this, void 0, void 0, function* () {
+                await Promise.all(resource.columns.filter((col) => col.foreignResource).map(async (col) => {
                     const targetResource = this.adminforth.config.resources.find((res) => res.resourceId == col.foreignResource.resourceId);
                     const targetConnector = this.adminforth.connectors[targetResource.dataSource];
                     const targetResourcePkField = targetResource.columns.find((col) => col.primaryKey).name;
@@ -346,7 +333,7 @@ export default class AdminForthRestAPI {
                     if (pksUnique.length === 0) {
                         return;
                     }
-                    const targetData = yield targetConnector.getData({
+                    const targetData = await targetConnector.getData({
                         resource: targetResource,
                         limit: limit,
                         offset: 0,
@@ -369,7 +356,7 @@ export default class AdminForthRestAPI {
                     data.data.forEach((item) => {
                         item[col.name] = targetDataMap[item[col.name]];
                     });
-                })));
+                }));
                 // remove all columns which are not defined in resources, or defined but backendOnly
                 data.data.forEach((item) => {
                     Object.keys(item).forEach((key) => {
@@ -380,13 +367,13 @@ export default class AdminForthRestAPI {
                     item._label = resource.recordLabel(item);
                 });
                 if (resource.options.listTableClickUrl) {
-                    yield Promise.all(data.data.map((item) => __awaiter(this, void 0, void 0, function* () {
-                        item._clickUrl = yield resource.options.listTableClickUrl(item, adminUser);
-                    })));
+                    await Promise.all(data.data.map(async (item) => {
+                        item._clickUrl = await resource.options.listTableClickUrl(item, adminUser);
+                    }));
                 }
                 // only after adminforth made all post processing, give user ability to edit it
-                for (const hook of listify((_w = (_v = resource.hooks) === null || _v === void 0 ? void 0 : _v[source]) === null || _w === void 0 ? void 0 : _w.afterDatasourceResponse)) {
-                    const resp = yield hook({ resource, response: data.data, adminUser });
+                for (const hook of listify((_d = (_c = resource.hooks) === null || _c === void 0 ? void 0 : _c[source]) === null || _d === void 0 ? void 0 : _d.afterDatasourceResponse)) {
+                    const resp = await hook({ resource, response: data.data, adminUser });
                     if (!resp || (!resp.ok && !resp.error)) {
                         throw new Error(`Hook must return object with {ok: true} or { error: 'Error' } `);
                     }
@@ -395,13 +382,13 @@ export default class AdminForthRestAPI {
                     }
                 }
                 return Object.assign(Object.assign({}, data), { options: resource === null || resource === void 0 ? void 0 : resource.options });
-            }),
+            },
         });
         server.endpoint({
             method: 'POST',
             path: '/get_resource_foreign_data',
-            handler: (_x) => __awaiter(this, [_x], void 0, function* ({ body, adminUser }) {
-                var _y, _z, _0, _1;
+            handler: async ({ body, adminUser }) => {
+                var _a, _b, _c, _d;
                 const { resourceId, column } = body;
                 if (!this.adminforth.statuses.dbDiscover) {
                     return { error: 'Database discovery not started' };
@@ -422,8 +409,8 @@ export default class AdminForthRestAPI {
                 }
                 const targetResourceId = columnConfig.foreignResource.resourceId;
                 const targetResource = this.adminforth.config.resources.find((res) => res.resourceId == targetResourceId);
-                for (const hook of listify((_z = (_y = columnConfig.foreignResource.hooks) === null || _y === void 0 ? void 0 : _y.dropdownList) === null || _z === void 0 ? void 0 : _z.beforeDatasourceRequest)) {
-                    const resp = yield hook({ query: body, adminUser, resource: targetResource });
+                for (const hook of listify((_b = (_a = columnConfig.foreignResource.hooks) === null || _a === void 0 ? void 0 : _a.dropdownList) === null || _b === void 0 ? void 0 : _b.beforeDatasourceRequest)) {
+                    const resp = await hook({ query: body, adminUser, resource: targetResource });
                     if (!resp || (!resp.ok && !resp.error)) {
                         throw new Error(`Hook must return object with {ok: true} or { error: 'Error' } `);
                     }
@@ -432,7 +419,7 @@ export default class AdminForthRestAPI {
                     }
                 }
                 const { limit, offset, filters, sort } = body;
-                const dbDataItems = yield this.adminforth.connectors[targetResource.dataSource].getData({
+                const dbDataItems = await this.adminforth.connectors[targetResource.dataSource].getData({
                     resource: targetResource,
                     limit,
                     offset,
@@ -451,8 +438,8 @@ export default class AdminForthRestAPI {
                 const response = {
                     items
                 };
-                for (const hook of listify((_1 = (_0 = columnConfig.foreignResource.hooks) === null || _0 === void 0 ? void 0 : _0.dropdownList) === null || _1 === void 0 ? void 0 : _1.afterDatasourceResponse)) {
-                    const resp = yield hook({ response, adminUser, resource: targetResource });
+                for (const hook of listify((_d = (_c = columnConfig.foreignResource.hooks) === null || _c === void 0 ? void 0 : _c.dropdownList) === null || _d === void 0 ? void 0 : _d.afterDatasourceResponse)) {
+                    const resp = await hook({ response, adminUser, resource: targetResource });
                     if (!resp || (!resp.ok && !resp.error)) {
                         throw new Error(`Hook must return object with {ok: true} or { error: 'Error' } `);
                     }
@@ -461,12 +448,12 @@ export default class AdminForthRestAPI {
                     }
                 }
                 return response;
-            }),
+            },
         });
         server.endpoint({
             method: 'POST',
             path: '/get_min_max_for_columns',
-            handler: (_2) => __awaiter(this, [_2], void 0, function* ({ body }) {
+            handler: async ({ body }) => {
                 const { resourceId } = body;
                 if (!this.adminforth.statuses.dbDiscover) {
                     return { error: 'Database discovery not started' };
@@ -478,7 +465,7 @@ export default class AdminForthRestAPI {
                 if (!resource) {
                     return { error: `Resource '${resourceId}' not found` };
                 }
-                const item = yield this.adminforth.connectors[resource.dataSource].getMinMaxForColumns({
+                const item = await this.adminforth.connectors[resource.dataSource].getMinMaxForColumns({
                     resource,
                     columns: resource.columns.filter((col) => [
                         AdminForthDataTypes.INTEGER,
@@ -490,31 +477,31 @@ export default class AdminForthRestAPI {
                     ].includes(col.type) && col.allowMinMaxQuery === true),
                 });
                 return item;
-            }),
+            },
         });
         server.endpoint({
             method: 'POST',
             path: '/create_record',
-            handler: (_3) => __awaiter(this, [_3], void 0, function* ({ body, adminUser }) {
-                var _4;
+            handler: async ({ body, adminUser }) => {
+                var _a;
                 const resource = this.adminforth.config.resources.find((res) => res.resourceId == body['resourceId']);
                 if (!resource) {
                     return { error: `Resource '${body['resourceId']}' not found` };
                 }
-                const { allowedActions } = yield interpretResource(adminUser, resource, { requestBody: body }, ActionCheckSource.CreateRequest);
+                const { allowedActions } = await interpretResource(adminUser, resource, { requestBody: body }, ActionCheckSource.CreateRequest);
                 const { allowed, error } = checkAccess(AllowedActionsEnum.create, allowedActions);
                 if (!allowed) {
                     return { error };
                 }
                 const { record } = body;
                 for (const column of resource.columns) {
-                    if (((_4 = column.required) === null || _4 === void 0 ? void 0 : _4.create) &&
+                    if (((_a = column.required) === null || _a === void 0 ? void 0 : _a.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 });
+                const response = await this.adminforth.createResourceRecord({ resource, record, adminUser });
                 if (response.error) {
                     return { error: response.error, ok: false };
                 }
@@ -523,44 +510,44 @@ export default class AdminForthRestAPI {
                     newRecordId: response.createdRecord[connector.getPrimaryKey(resource)],
                     ok: true
                 };
-            })
+            }
         });
         server.endpoint({
             method: 'POST',
             path: '/update_record',
-            handler: (_5) => __awaiter(this, [_5], void 0, function* ({ body, adminUser }) {
+            handler: async ({ body, adminUser }) => {
                 const resource = this.adminforth.config.resources.find((res) => res.resourceId == body['resourceId']);
                 if (!resource) {
                     return { error: `Resource '${body['resourceId']}' not found` };
                 }
                 const recordId = body['recordId'];
                 const connector = this.adminforth.connectors[resource.dataSource];
-                const oldRecord = yield connector.getRecordByPrimaryKey(resource, recordId);
+                const oldRecord = await connector.getRecordByPrimaryKey(resource, recordId);
                 if (!oldRecord) {
                     const primaryKeyColumn = resource.columns.find((col) => col.primaryKey);
                     return { error: `Record with ${primaryKeyColumn.name} ${recordId} not found` };
                 }
                 const record = body['record'];
-                const { allowedActions } = yield interpretResource(adminUser, resource, { requestBody: body, newRecord: record, oldRecord }, ActionCheckSource.EditRequest);
+                const { allowedActions } = await interpretResource(adminUser, resource, { requestBody: body, newRecord: record, oldRecord }, ActionCheckSource.EditRequest);
                 const { allowed, error: allowedError } = checkAccess(AllowedActionsEnum.edit, allowedActions);
                 if (!allowed) {
                     return { allowedError };
                 }
-                const { error } = yield this.adminforth.updateResourceRecord({ resource, record, adminUser, oldRecord, recordId });
+                const { error } = await this.adminforth.updateResourceRecord({ resource, record, adminUser, oldRecord, recordId });
                 if (error) {
                     return { error };
                 }
                 return {
                     ok: true
                 };
-            })
+            }
         });
         server.endpoint({
             method: 'POST',
             path: '/delete_record',
-            handler: (_6) => __awaiter(this, [_6], void 0, function* ({ body, adminUser }) {
+            handler: async ({ 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']);
+                const record = await this.adminforth.connectors[resource.dataSource].getRecordByPrimaryKey(resource, body['primaryKey']);
                 if (!resource) {
                     return { error: `Resource '${body['resourceId']}' not found` };
                 }
@@ -570,12 +557,12 @@ export default class AdminForthRestAPI {
                 if (resource.options.allowedActions.delete === false) {
                     return { error: `Resource '${resource.resourceId}' does not allow delete action` };
                 }
-                const { allowedActions } = yield interpretResource(adminUser, resource, { requestBody: body }, ActionCheckSource.DeleteRequest);
+                const { allowedActions } = await interpretResource(adminUser, resource, { requestBody: body }, ActionCheckSource.DeleteRequest);
                 const { allowed, error } = checkAccess(AllowedActionsEnum.delete, allowedActions);
                 if (!allowed) {
                     return { error };
                 }
-                const { error: deleteError } = yield this.adminforth.deleteResourceRecord({ resource, record, adminUser, recordId: body['primaryKey'] });
+                const { error: deleteError } = await this.adminforth.deleteResourceRecord({ resource, record, adminUser, recordId: body['primaryKey'] });
                 if (deleteError) {
                     return { error: deleteError };
                 }
@@ -583,33 +570,33 @@ export default class AdminForthRestAPI {
                     ok: true,
                     recordId: body['primaryKey']
                 };
-            })
+            }
         });
         server.endpoint({
             method: 'POST',
             path: '/start_bulk_action',
-            handler: (_7) => __awaiter(this, [_7], void 0, function* ({ body, adminUser }) {
+            handler: async ({ body, adminUser }) => {
                 const { resourceId, actionId, recordIds } = body;
                 const resource = this.adminforth.config.resources.find((res) => res.resourceId == resourceId);
                 if (!resource) {
                     return { error: `Resource '${resourceId}' not found` };
                 }
-                const { allowedActions } = yield interpretResource(adminUser, resource, { requestBody: body }, ActionCheckSource.BulkActionRequest);
+                const { allowedActions } = await interpretResource(adminUser, resource, { requestBody: body }, ActionCheckSource.BulkActionRequest);
                 const action = resource.options.bulkActions.find((act) => act.id == actionId);
                 if (!action) {
                     return { error: `Action '${actionId}' not found` };
                 }
                 if (action.allowed) {
-                    const execAllowed = yield action.allowed({ adminUser, resource, selectedIds: recordIds, allowedActions });
+                    const execAllowed = await action.allowed({ adminUser, resource, selectedIds: recordIds, allowedActions });
                     if (!execAllowed) {
                         return { error: `Action '${actionId}' is not allowed` };
                     }
                 }
-                const response = yield action.action({ selectedIds: recordIds, adminUser, resource });
+                const response = await action.action({ selectedIds: recordIds, adminUser, resource });
                 return Object.assign({ actionId,
                     recordIds,
                     resourceId }, response);
-            })
+            }
         });
         // setup endpoints for all plugins
         this.adminforth.activatedPlugins.forEach((plugin) => {