@adminforth/crud-approve-plugin 1.0.12 → 1.0.14

package/dist/index.js

@@ -7,11 +7,242 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { AdminForthPlugin } from "adminforth";
-import { ApprovalStatusEnum } from './types.js';
+import { ActionCheckSource, AdminForthPlugin, AdminForthSortDirections, Filters } from "adminforth";
+import { AdminForthDataTypes, AllowedActionsEnum } from "adminforth";
+import { AllowedForReviewActionsEnum, ApprovalStatusEnum } from './types.js';
+import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc.js";
+import { randomUUID } from "crypto";
+dayjs.extend(utc);
 export default class CRUDApprovePlugin extends AdminForthPlugin {
     constructor(options) {
         super(options, import.meta.url);
+        this.createApprovalRequest = (_a) => __awaiter(this, [_a], void 0, function* ({ resource, action, data, user, oldRecord, updates, extra, record }) {
+            var _b;
+            //@ts-ignore
+            if (extra && extra.adminforth_plugin_crud_approve && extra.adminforth_plugin_crud_approve.callingFromApprovalPlugin) {
+                return { ok: true, error: 'Approval request creation aborted to avoid infinite loop' };
+            }
+            const recordIdFieldName = (_b = resource.columns.find((c) => c.primaryKey === true)) === null || _b === void 0 ? void 0 : _b.name;
+            const recordId = (data === null || data === void 0 ? void 0 : data[recordIdFieldName]) || (oldRecord === null || oldRecord === void 0 ? void 0 : oldRecord[recordIdFieldName]);
+            let newRecord = {};
+            const connector = this.adminforth.connectors[resource.dataSource];
+            if (action === AllowedForReviewActionsEnum.create) {
+                oldRecord = {};
+                newRecord = updates || record;
+            }
+            else if (action === AllowedForReviewActionsEnum.edit) {
+                newRecord = yield connector.getRecordByPrimaryKey(resource, recordId);
+                for (const key in updates) {
+                    newRecord[key] = updates[key];
+                }
+            }
+            else if (action === AllowedForReviewActionsEnum.delete) {
+                oldRecord = yield connector.getRecordByPrimaryKey(resource, recordId);
+            }
+            const checks = yield Promise.all(resource.columns.map((c) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                if (typeof c.backendOnly === "function") {
+                    const result = yield c.backendOnly({
+                        adminUser: user,
+                        resource,
+                        meta: {},
+                        source: ActionCheckSource.ShowRequest,
+                        adminforth: this.adminforth,
+                    });
+                    return { col: c, result };
+                }
+                return { col: c, result: (_a = c.backendOnly) !== null && _a !== void 0 ? _a : false };
+            })));
+            const backendOnlyColumns = checks
+                .filter(({ result }) => result === true)
+                .map(({ col }) => col);
+            backendOnlyColumns.forEach((c) => {
+                if (JSON.stringify(oldRecord[c.name]) != JSON.stringify(newRecord[c.name])) {
+                    if (action !== AllowedForReviewActionsEnum.delete) {
+                        newRecord[c.name] = '<hidden value after>';
+                    }
+                    if (action !== AllowedForReviewActionsEnum.create) {
+                        oldRecord[c.name] = '<hidden value before>';
+                    }
+                }
+                else {
+                    delete oldRecord[c.name];
+                    delete newRecord[c.name];
+                }
+            });
+            if (action === AllowedForReviewActionsEnum.edit) {
+                for (const key in oldRecord) {
+                    if (JSON.stringify(oldRecord[key]) === JSON.stringify(newRecord[key])) {
+                        delete oldRecord[key];
+                        delete newRecord[key];
+                    }
+                }
+            }
+            const createdAt = dayjs.utc().format();
+            const diffRecord = {
+                [this.options.resourceColumns.idColumnName]: randomUUID(),
+                [this.options.resourceColumns.resourceIdColumnName]: resource.resourceId,
+                [this.options.resourceColumns.actionColumnName]: action,
+                [this.options.resourceColumns.statusColumnName]: ApprovalStatusEnum.pending,
+                [this.options.resourceColumns.dataColumnName]: { 'oldRecord': oldRecord, 'newRecord': newRecord },
+                [this.options.resourceColumns.userIdColumnName]: user.pk,
+                [this.options.resourceColumns.recordIdColumnName]: recordId,
+                [this.options.resourceColumns.createdAtColumnName]: createdAt,
+                [this.options.resourceColumns.extraColumnName]: extra || {},
+            };
+            const diffResource = this.adminforth.config.resources.find((r) => r.resourceId === this.diffResource.resourceId);
+            yield this.adminforth.createResourceRecord({ resource: diffResource, record: diffRecord, adminUser: user });
+            return { ok: true, error: null };
+        });
+        this.callBeforeSaveHooks = (
+        // resource: AdminForthResource, action: AllowedActionsEnum, record: any, 
+        // adminUser: AdminUser, recordId?: any, extra?: HttpExtra
+        resource, action, record, adminUser, recordId, updates, oldRecord, adminforth, extra) => __awaiter(this, void 0, void 0, function* () {
+            let hooks = [];
+            if (action === AllowedActionsEnum.create) {
+                hooks = resource.hooks.create.beforeSave;
+            }
+            else if (action === AllowedActionsEnum.edit) {
+                hooks = resource.hooks.edit.beforeSave;
+            }
+            else if (action === AllowedActionsEnum.delete) {
+                hooks = resource.hooks.delete.beforeSave;
+            }
+            if (extra === undefined) {
+                extra = {};
+            }
+            //@ts-ignore
+            extra.adminforth_plugin_crud_approve = {
+                //@ts-ignore
+                callingFromApprovalPlugin: true
+                //@ts-ignore
+            };
+            for (const hook of hooks) {
+                const resp = yield hook({
+                    resource,
+                    record,
+                    adminUser,
+                    recordId,
+                    adminforth: this.adminforth,
+                    extra,
+                    updates,
+                    oldRecord,
+                });
+                if (!resp || (typeof resp.ok !== 'boolean' && (!resp.error && !resp.newRecordId))) {
+                    throw new Error(`Invalid return value from beforeSave hook. Expected: { ok: boolean, error?: string | null, newRecordId?: any }.\n` +
+                        `Note: Return { ok: false, error: null, newRecordId } to stop creation and redirect to an existing record.`);
+                }
+                if (resp.ok === false && !resp.error) {
+                    const { error, ok, newRecordId } = resp;
+                    return {
+                        error: error !== null && error !== void 0 ? error : 'Operation aborted by hook',
+                        newRecordId: newRecordId
+                    };
+                }
+                if (resp.error) {
+                    return { error: resp.error };
+                }
+            }
+            return { ok: true, error: null };
+        });
+        this.callAfterSaveHooks = (
+        // resource: AdminForthResource, action: AllowedActionsEnum, record: any, 
+        // adminUser: AdminUser, recordId: any, extra?: HttpExtra
+        resource, action, record, adminUser, recordId, updates, oldRecord, adminforth, extra) => __awaiter(this, void 0, void 0, function* () {
+            let hooks = [];
+            if (action === AllowedActionsEnum.create) {
+                hooks = resource.hooks.create.afterSave;
+            }
+            else if (action === AllowedActionsEnum.edit) {
+                hooks = resource.hooks.edit.afterSave;
+            }
+            else if (action === AllowedActionsEnum.delete) {
+                hooks = resource.hooks.delete.afterSave;
+            }
+            for (const hook of hooks) {
+                const resp = yield hook({
+                    resource,
+                    record,
+                    adminUser,
+                    recordId,
+                    adminforth: this.adminforth,
+                    extra,
+                    updates,
+                    oldRecord,
+                });
+                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 };
+                }
+            }
+        });
+        this.verifyAuth = (cookies) => __awaiter(this, void 0, void 0, function* () {
+            let authCookie;
+            for (const i in cookies) {
+                if (cookies[i].key === `adminforth_${this.adminforth.config.customization.brandNameSlug}_jwt`) {
+                    authCookie = cookies[i].value;
+                }
+            }
+            const authRes = yield this.adminforth.auth.verify(authCookie, 'auth', true);
+            if ('error' in authRes) {
+                return { error: authRes.error, authRes: null };
+            }
+            return { error: null, authRes: authRes };
+        });
+        this.createRecord = (resource, diffData, adminUser) => __awaiter(this, void 0, void 0, function* () {
+            const connector = this.adminforth.connectors[resource.dataSource];
+            //@ts-ignore
+            const err = this.adminforth.validateRecordValues(resource, diffData['newRecord'], 'create');
+            if (err) {
+                return { ok: false, error: err, createdRecord: null };
+            }
+            // remove virtual columns from record
+            for (const column of resource.columns.filter((col) => col.virtual)) {
+                if (diffData['newRecord'][column.name]) {
+                    delete diffData['newRecord'][column.name];
+                }
+            }
+            return yield connector.createRecord({ resource, record: diffData['newRecord'], adminUser });
+        });
+        this.editRecord = (resource, diffData, targetRecordId, connector) => __awaiter(this, void 0, void 0, function* () {
+            let oldRecord;
+            const dataToUse = diffData['newRecord'];
+            //@ts-ignore
+            const err = this.adminforth.validateRecordValues(resource, dataToUse, 'edit', targetRecordId);
+            if (err) {
+                return { error: err };
+            }
+            // remove editReadonly columns from record
+            oldRecord = yield connector.getRecordByPrimaryKey(resource, targetRecordId);
+            for (const column of resource.columns.filter((col) => col.editReadonly)) {
+                if (column.name in dataToUse)
+                    delete dataToUse[column.name];
+            }
+            const newValues = {};
+            for (const recordField in dataToUse) {
+                if (dataToUse[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] = dataToUse[recordField];
+                    }
+                }
+            }
+            if (Object.keys(newValues).length > 0) {
+                const { error } = yield connector.updateRecord({ resource, recordId: targetRecordId, newValues });
+                if (error) {
+                    return { ok: false, error };
+                }
+            }
+            return { ok: true, error: null };
+        });
+        this.deleteRecord = (resource, targetRecordId, connector) => __awaiter(this, void 0, void 0, function* () {
+            return yield connector.deleteRecord({ resource, recordId: targetRecordId });
+        });
         this.options = options;
     }
     modifyResourceConfig(adminforth, resourceConfig) {
@@ -19,25 +250,31 @@ export default class CRUDApprovePlugin extends AdminForthPlugin {
             modifyResourceConfig: { get: () => super.modifyResourceConfig }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            _super.modifyResourceConfig.call(this, adminforth, resourceConfig);
             // simply modify resourceConfig or adminforth.config. You can get access to plugin options via this.options;
-        });
-    }
-    createApprovalRequest(resource, action, oldData, newData, user, extra) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // create a record in diff table with oldData and newData
-            const record = {
-                [this.options.resourceColumns.resourceIdColumnName]: resource.resourceId,
-                [this.options.resourceColumns.resourceActionColumnName]: action,
-                [this.options.resourceColumns.resourceOldDataColumnName]: oldData ? JSON.stringify(oldData) : null,
-                [this.options.resourceColumns.resourceNewDataColumnName]: newData ? JSON.stringify(newData) : null,
-                [this.options.resourceColumns.resourceStatusColumnName]: ApprovalStatusEnum.PENDING,
-                [this.options.resourceColumns.resourceCreatedAtColumnName]: new Date().toISOString(),
-                // You can add userId from extra if you have authentication implemented
-                [this.options.resourceColumns.resourceUserIdColumnName]: user.pk,
+            _super.modifyResourceConfig.call(this, adminforth, resourceConfig);
+            this.adminforth = adminforth;
+            this.diffResource = this.resourceConfig;
+            let diffColumn = resourceConfig.columns.find((c) => c.name === this.options.resourceColumns.dataColumnName);
+            if (!diffColumn) {
+                throw new Error(`Column ${this.options.resourceColumns.dataColumnName} not found in ${resourceConfig.label}`);
+            }
+            if (diffColumn.type !== AdminForthDataTypes.JSON) {
+                // throw new Error(`Column ${this.options.resourceColumns.dataColumnName} must be of type 'json'`)
+            }
+            diffColumn.components = {
+                show: {
+                    file: this.componentPath('ShowPageDiffView.vue'),
+                    meta: Object.assign(Object.assign({}, this.options), { pluginInstanceId: this.pluginInstanceId })
+                },
+                list: {
+                    file: this.componentPath('ListPageDiffView.vue'),
+                    meta: Object.assign(Object.assign({}, this.options), { pluginInstanceId: this.pluginInstanceId })
+                }
+            };
+            resourceConfig.options.defaultSort = {
+                columnName: this.options.resourceColumns.createdAtColumnName,
+                direction: AdminForthSortDirections.desc
             };
-            const approvalResource = this.adminforth.config.resources.find(r => r.resourceId === this.options.diffTableName);
-            yield this.adminforth.createResourceRecord({ resource: approvalResource, record, adminUser: user });
         });
     }
     validateConfigAfterDiscover(adminforth, resourceConfig) {
@@ -48,4 +285,112 @@ export default class CRUDApprovePlugin extends AdminForthPlugin {
         // Needed if plugin can have multiple instances on one resource 
         return `single`;
     }
+    setupEndpoints(server) {
+        server.endpoint({
+            method: 'POST',
+            path: `/plugin/crud-approve/update-status`,
+            noAuth: true,
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, response, cookies }) {
+                const authRes = yield this.verifyAuth(cookies);
+                if (authRes.error) {
+                    response.status = 403;
+                    return { error: authRes.error };
+                }
+                const adminUser = authRes.authRes;
+                const { resourceId, diffId, recordId, action, approved, code } = body;
+                const diffRecord = yield this.adminforth.resource(this.diffResource.resourceId).get(Filters.EQ(this.options.resourceColumns.idColumnName, diffId));
+                if (!diffRecord) {
+                    response.status = 404;
+                    return { error: 'Diff record not found' };
+                }
+                if (diffRecord[this.options.resourceColumns.statusColumnName] !== ApprovalStatusEnum.pending) {
+                    response.status = 400;
+                    return { error: 'Diff record is not pending' };
+                }
+                let beforeSaveResp;
+                if (approved === true) {
+                    const resource = this.adminforth.config.resources.find((res) => res.resourceId == diffRecord[this.options.resourceColumns.resourceIdColumnName]);
+                    const diffData = diffRecord[this.options.resourceColumns.dataColumnName];
+                    const extra = diffRecord[this.options.resourceColumns.extraColumnName] || {};
+                    extra.body = body;
+                    extra.cookies = cookies;
+                    let oldRecord = undefined;
+                    if (action !== AllowedActionsEnum.create) {
+                        oldRecord = yield this.adminforth.connectors[resource.dataSource].getRecordByPrimaryKey(resource, diffRecord[this.options.resourceColumns.recordIdColumnName]);
+                    }
+                    beforeSaveResp = yield this.callBeforeSaveHooks(resource, action, diffData['newRecord'], adminUser, diffRecord[this.options.resourceColumns.recordIdColumnName], diffData['newRecord'], oldRecord, this.adminforth, extra);
+                    if (beforeSaveResp.error && beforeSaveResp.error !== 'Operation aborted by hook') {
+                        response.status = 500;
+                        return { error: `Failed to apply approved changes: ${beforeSaveResp.error}` };
+                    }
+                    if (beforeSaveResp.error !== 'Operation aborted by hook') {
+                        let recordUpdateResult;
+                        const connector = this.adminforth.connectors[resource.dataSource];
+                        if (action === AllowedActionsEnum.create) {
+                            recordUpdateResult = yield this.createRecord(resource, diffData, adminUser);
+                        }
+                        else if (action === AllowedActionsEnum.edit) {
+                            recordUpdateResult = yield this.editRecord(resource, diffData, diffRecord[this.options.resourceColumns.recordIdColumnName], connector);
+                        }
+                        else if (action === AllowedActionsEnum.delete) {
+                            recordUpdateResult = yield this.deleteRecord(resource, diffRecord[this.options.resourceColumns.recordIdColumnName], connector);
+                        }
+                        if (recordUpdateResult === null || recordUpdateResult === void 0 ? void 0 : recordUpdateResult.error) {
+                            response.status = 500;
+                            console.error('Error applying approved changes:', recordUpdateResult);
+                            return { error: `Failed to apply approved changes: ${recordUpdateResult.error}` };
+                        }
+                        let afterSaveResp;
+                        if (action === AllowedActionsEnum.create) {
+                            const newRecord = recordUpdateResult.createdRecord;
+                            afterSaveResp = yield this.callAfterSaveHooks(resource, action, newRecord, adminUser, diffRecord[this.options.resourceColumns.recordIdColumnName], 
+                            //@ts-ignore
+                            newRecord, {}, this.adminforth, { body });
+                        }
+                        else if (action === AllowedActionsEnum.edit) {
+                            const newRecord = diffData['newRecord'];
+                            const oldRecord = yield this.adminforth.connectors[resource.dataSource].getRecordByPrimaryKey(resource, diffRecord[this.options.resourceColumns.recordIdColumnName]);
+                            afterSaveResp = yield this.callAfterSaveHooks(resource, action, newRecord, adminUser, 
+                            //@ts-ignore
+                            recordId, newRecord, oldRecord, this.adminforth, { body });
+                        }
+                        else if (action === AllowedActionsEnum.delete) {
+                            const newRecord = diffData['newRecord'];
+                            afterSaveResp = yield this.callAfterSaveHooks(resource, action, newRecord, adminUser, diffRecord[this.options.resourceColumns.recordIdColumnName], 
+                            //@ts-ignore
+                            {}, diffData['oldRecord'], this.adminforth, { body });
+                        }
+                        if (afterSaveResp === null || afterSaveResp === void 0 ? void 0 : afterSaveResp.error) {
+                            response.status = 500;
+                            return { error: `Failed to apply approved changes: ${afterSaveResp.error}` };
+                        }
+                    }
+                }
+                const r = yield this.adminforth.updateResourceRecord({
+                    resource: this.diffResource, recordId: diffId,
+                    adminUser: adminUser, oldRecord: diffRecord,
+                    updates: {
+                        [this.options.resourceColumns.statusColumnName]: approved ? ApprovalStatusEnum.approved : ApprovalStatusEnum.rejected,
+                        [this.options.resourceColumns.responserIdColumnName]: authRes.authRes.pk,
+                    },
+                    extra: {
+                        //@ts-ignore
+                        adminforth_plugin_crud_approve: {
+                            //@ts-ignore
+                            callingFromApprovalPlugin: true
+                            //@ts-ignore
+                        }
+                    }
+                });
+                if (r.error) {
+                    response.status = 500;
+                    return { error: `Failed to update diff record status: ${r.error}` };
+                }
+                if ((beforeSaveResp === null || beforeSaveResp === void 0 ? void 0 : beforeSaveResp.error) === 'Operation aborted by hook') {
+                    return beforeSaveResp;
+                }
+                return { ok: true };
+            })
+        });
+    }
 }

package/dist/types.js

@@ -1,6 +1,13 @@
+export var AllowedForReviewActionsEnum;
+(function (AllowedForReviewActionsEnum) {
+    AllowedForReviewActionsEnum["create"] = "create";
+    AllowedForReviewActionsEnum["edit"] = "edit";
+    AllowedForReviewActionsEnum["delete"] = "delete";
+    AllowedForReviewActionsEnum["custom"] = "custom";
+})(AllowedForReviewActionsEnum || (AllowedForReviewActionsEnum = {}));
 export var ApprovalStatusEnum;
 (function (ApprovalStatusEnum) {
-    ApprovalStatusEnum["PENDING"] = "pending";
-    ApprovalStatusEnum["APPROVED"] = "approved";
-    ApprovalStatusEnum["REJECTED"] = "rejected";
+    ApprovalStatusEnum[ApprovalStatusEnum["pending"] = 1] = "pending";
+    ApprovalStatusEnum[ApprovalStatusEnum["approved"] = 2] = "approved";
+    ApprovalStatusEnum[ApprovalStatusEnum["rejected"] = 3] = "rejected";
 })(ApprovalStatusEnum || (ApprovalStatusEnum = {}));

package/index.ts

@@ -58,6 +58,7 @@ export default class CRUDApprovePlugin extends AdminForthPlugin {
     {resource, action, data, user, oldRecord, updates, extra, record}:
     {resource: AdminForthResource, action: AllowedForReviewActionsEnum, data: Object, user: AdminUser, record?: Object, oldRecord?: Object, updates?: Object, extra?: HttpExtra}
   ) => {
+    //@ts-ignore
     if (extra && extra.adminforth_plugin_crud_approve && extra.adminforth_plugin_crud_approve.callingFromApprovalPlugin) {
       return { ok: true, error: 'Approval request creation aborted to avoid infinite loop' };
     }
@@ -168,8 +169,11 @@ export default class CRUDApprovePlugin extends AdminForthPlugin {
     if (extra === undefined) {
       extra = {};
     }
+    //@ts-ignore
     extra.adminforth_plugin_crud_approve = {
+      //@ts-ignore
       callingFromApprovalPlugin: true
+      //@ts-ignore
     }
     for (const hook of hooks) {
       const resp = await hook({ 
@@ -263,6 +267,7 @@ export default class CRUDApprovePlugin extends AdminForthPlugin {
 
   createRecord = async (resource: AdminForthResource, diffData: any, adminUser: AdminUser) => {
     const connector = this.adminforth.connectors[resource.dataSource];
+    //@ts-ignore
     const err = this.adminforth.validateRecordValues(resource, diffData['newRecord'], 'create');
     if (err) {
       return { ok: false, error: err, createdRecord: null };
@@ -280,6 +285,7 @@ export default class CRUDApprovePlugin extends AdminForthPlugin {
   editRecord = async (resource: AdminForthResource, diffData: any, targetRecordId: any, connector: IAdminForthDataSourceConnectorBase) => {
     let oldRecord;
     const dataToUse = diffData['newRecord'];
+    //@ts-ignore
     const err = this.adminforth.validateRecordValues(resource, dataToUse, 'edit', targetRecordId);
     if (err) {
       return { error: err };
@@ -393,6 +399,7 @@ export default class CRUDApprovePlugin extends AdminForthPlugin {
               afterSaveResp = await this.callAfterSaveHooks(
                 resource, action as AllowedActionsEnum, newRecord, adminUser, 
                 diffRecord[this.options.resourceColumns.recordIdColumnName],
+                //@ts-ignore
                 newRecord, {}, this.adminforth, { body }
               );
             } else if (action === AllowedActionsEnum.edit) {
@@ -402,6 +409,7 @@ export default class CRUDApprovePlugin extends AdminForthPlugin {
               );
               afterSaveResp = await this.callAfterSaveHooks(
                 resource, action as AllowedActionsEnum, newRecord, adminUser, 
+                //@ts-ignore
                 recordId, newRecord, oldRecord, this.adminforth, { body }
               );
             } else if (action === AllowedActionsEnum.delete) {
@@ -409,6 +417,7 @@ export default class CRUDApprovePlugin extends AdminForthPlugin {
               afterSaveResp = await this.callAfterSaveHooks(
                 resource, action as AllowedActionsEnum, newRecord, adminUser, 
                 diffRecord[this.options.resourceColumns.recordIdColumnName],
+                //@ts-ignore
                 {}, diffData['oldRecord'], this.adminforth, { body }
               );
             }
@@ -427,8 +436,11 @@ export default class CRUDApprovePlugin extends AdminForthPlugin {
             [this.options.resourceColumns.responserIdColumnName]: authRes.authRes.pk,
           },
           extra: {
+            //@ts-ignore
             adminforth_plugin_crud_approve: {
+              //@ts-ignore
               callingFromApprovalPlugin: true
+              //@ts-ignore
             }
           }
         });
@@ -443,4 +455,4 @@ export default class CRUDApprovePlugin extends AdminForthPlugin {
       }
     })
   }
-}
+} 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adminforth/crud-approve-plugin",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "publishConfig": {
     "access": "public"
   },
@@ -14,18 +14,17 @@
     "url": "https://github.com/devforth/af-crud-approve-plugin.git"
   },
   "scripts": {
-    "build": "tsc && rsync -av --exclude 'node_modules' custom dist/",
-    "prepare": "npm link adminforth"
+    "build": "tsc && rsync -av --exclude 'node_modules' custom dist/"
   },
   "author": "devforth",
   "license": "ISC",
   "dependencies": {
-    "@adminforth/two-factors-auth": "^2.10.2",
-    "adminforth": "^2.13.0-next.51",
+    "@adminforth/two-factors-auth": "^2.10.4",
+    "adminforth": "next",
     "dayjs": "^1.11.11"
   },
   "peerDependencies": {
-    "adminforth": "^2.13.0-next.51"
+    "adminforth": "^2.24.0"
   },
   "release": {
     "plugins": [
@@ -36,6 +35,7 @@
       [
         "semantic-release-slack-bot",
         {
+          "packageName": "@adminforth/crud-approve-plugin",
           "notifyOnSuccess": true,
           "notifyOnFail": true,
           "slackIcon": ":package:",