- replaced validation library @adonisjs/validator with @vinejs/vine (performance)

- npm updates

app/Controllers/Http/Admin/AdminuserController.ts

@@ -1,15 +1,13 @@
 import type { HttpContext } from '@adonisjs/core/http';
 import User from '#models/user';
 import Role from '#models/role';
-import { ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
-import CreateUserValidator from '#validators/create_user_validator';
-import UpdateUserValidator from '#validators/update_user_validator';
+import { ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
+import { createUserValidator, updateUserValidator } from '#validators/user';
 // import { schema, rules } from '@ioc:Adonis/Core/Validator';
 // import Hash from '@ioc:Adonis/Core/Hash';
 // import { schema, rules } from '@ioc:Adonis/Core/Validator';
 
 export default class AdminuserController {
-    
     public async index({ auth, request, inertia }: HttpContext) {
         const page = request.input('page', 1);
         // const limit = 10
@@ -48,7 +46,7 @@ export default class AdminuserController {
             // .preload('focusInterests')
             // .preload('role')
             .paginate(page, 5);
-       
+
         // var test = request.all();
 
         return inertia.render('Admin/User/Index', {
@@ -79,7 +77,8 @@ export default class AdminuserController {
         // node ace make:validator CreateUser
         try {
             //  Step 2 - Validate request body against  the schema
-            await request.validate(CreateUserValidator);
+            // await request.validate(CreateUserValidator);
+            await request.validateUsing(createUserValidator);
             // console.log({ payload });
         } catch (error) {
             // Step 3 - Handle errors
@@ -94,7 +93,7 @@ export default class AdminuserController {
         }
 
         session.flash('message', 'User has been created successfully');
-        return response.redirect().toRoute('user.index');
+        return response.redirect().toRoute('settings.user.index');
     }
 
     public async show({ request, inertia }: HttpContext) {
@@ -133,7 +132,11 @@ export default class AdminuserController {
         const user = await User.query().where('id', id).firstOrFail();
 
         // validate update form
-        await request.validate(UpdateUserValidator);
+        await request.validateUsing(updateUserValidator, {
+            meta: {
+                userId: user.id,
+            },
+        });
 
         // password is optional
         let input;
@@ -160,7 +163,7 @@ export default class AdminuserController {
         await user.delete();
 
         session.flash('message', `User ${user.login} has been deleted.`);
-        return response.redirect().toRoute('user.index');
+        return response.redirect().toRoute('settings.user.index');
     }
 
     // private async syncRoles(userId: number, roleIds: Array<number>) {

app/Controllers/Http/Admin/RoleController.ts

@@ -1,9 +1,8 @@
 import type { HttpContext } from '@adonisjs/core/http';
 import Role from '#models/role';
 import Permission from '#models/permission';
-import CreateRoleValidator from '#validators/create_role_validator';
-import UpdateRoleValidator from '#validators/update_role_validator';
-import type { ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
+import { createRoleValidator, updateRoleValidator } from '#validators/role';
+import type { ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
 
 // import { schema, rules } from '@ioc:Adonis/Core/Validator';
 
@@ -59,7 +58,8 @@ export default class RoleController {
         // node ace make:validator CreateUser
         try {
             //  Step 2 - Validate request body against  the schema
-            await request.validate(CreateRoleValidator);
+            // await request.validate(CreateRoleValidator);
+            await request.validateUsing(createRoleValidator);
             // await request.validate({ schema: roleSchema });
             // console.log({ payload });
         } catch (error) {
@@ -76,7 +76,7 @@ export default class RoleController {
         }
 
         session.flash('message', `Role ${role.name} has been created successfully`);
-        return response.redirect().toRoute('role.index');
+        return response.redirect().toRoute('settings.role.index');
     }
 
     public async show({ request, inertia }: HttpContext) {
@@ -115,7 +115,12 @@ export default class RoleController {
         const role = await Role.query().where('id', id).firstOrFail();
 
         // validate update form
-        await request.validate(UpdateRoleValidator);
+        // await request.validate(UpdateRoleValidator);
+        await request.validateUsing(updateRoleValidator, {
+            meta: {
+                roleId: role.id,
+            },
+        });
 
         // password is optional
 
@@ -138,6 +143,6 @@ export default class RoleController {
         await role.delete();
 
         session.flash('message', `Role ${role.name} has been deleted.`);
-        return response.redirect().toRoute('role.index');
+        return response.redirect().toRoute('settings.role.index');
     }
 }

app/Controllers/Http/Auth/AuthController.ts

@@ -2,7 +2,7 @@ import type { HttpContext } from '@adonisjs/core/http';
 import User from '#models/user';
 // import Hash from '@ioc:Adonis/Core/Hash';
 // import InvalidCredentialException from 'App/Exceptions/InvalidCredentialException';
-import AuthValidator from '#validators/auth_validator';
+import { authValidator } from '#validators/auth';
 
 import TwoFactorAuthProvider from '#app/services/TwoFactorAuthProvider';
 // import { Authenticator } from '@adonisjs/auth';
@@ -18,7 +18,8 @@ export default class AuthController {
         // console.log({
         // 	registerBody: request.body(),
         // });
-        await request.validate(AuthValidator);
+        // await request.validate(AuthValidator);
+        await request.validateUsing(authValidator);
 
         // const plainPassword = await request.input('password');
         // const email = await request.input('email');

app/Controllers/Http/Auth/UserController.ts

@@ -3,7 +3,8 @@ import User from '#models/user';
 // import { RenderResponse } from '@ioc:EidelLev/Inertia';
 import TwoFactorAuthProvider from '#app/services/TwoFactorAuthProvider';
 import hash from '@adonisjs/core/services/hash';
-import { schema, rules } from '@adonisjs/validator';
+// import { schema, rules } from '@adonisjs/validator';
+import vine, { SimpleMessagesProvider } from '@vinejs/vine';
 
 // Here we are generating secret and recovery codes for the user that’s enabling 2FA and storing them to our database.
 export default class UserController {
@@ -26,13 +27,23 @@ export default class UserController {
     }
 
     public async accountInfoStore({ auth, request, response, session }: HttpContext) {
-        const passwordSchema = schema.create({
-            old_password: schema.string({ trim: true }, [rules.required()]),
-            new_password: schema.string({ trim: true }, [rules.minLength(8), rules.maxLength(255), rules.confirmed('confirm_password')]),
-            confirm_password: schema.string({ trim: true }, [rules.required()]),
+        // const passwordSchema = schema.create({
+        //     old_password: schema.string({ trim: true }, [rules.required()]),
+        //     new_password: schema.string({ trim: true }, [rules.minLength(8), rules.maxLength(255), rules.confirmed('confirm_password')]),
+        //     confirm_password: schema.string({ trim: true }, [rules.required()]),
+        // });
+        const passwordSchema = vine.object({
+            // first step
+            old_password: vine
+                .string()
+                .trim()
+                .regex(/^[a-zA-Z0-9]+$/),
+            new_password: vine.string().confirmed({ confirmationField: 'confirm_password' }).trim().minLength(8).maxLength(255),
         });
         try {
-            await request.validate({ schema: passwordSchema });
+            // await request.validate({ schema: passwordSchema });
+            const validator = vine.compile(passwordSchema);
+            await request.validateUsing(validator);
         } catch (error) {
             // return response.badRequest(error.messages);
             throw error;
@@ -58,7 +69,7 @@ export default class UserController {
 
             // return response.status(200).send({ message: 'Password updated successfully.' });
             session.flash({ message: 'Password updated successfully.' });
-            return response.redirect().toRoute('settings.user.index');
+            return response.redirect().toRoute('settings.user');
         } catch (error) {
             // return response.status(500).send({ message: 'Internal server error.' });
             return response.flash('warning', `Invalid server state. Internal server error.`).redirect().back();

app/Controllers/Http/Editor/DatasetController.ts

@@ -8,7 +8,6 @@ import { XMLBuilder } from 'xmlbuilder2/lib/interfaces.js';
 import { create } from 'xmlbuilder2';
 import { readFileSync } from 'fs';
 import SaxonJS from 'saxon-js';
-import { schema } from '@adonisjs/validator';
 import { DateTime } from 'luxon';
 import Index from '#app/Library/Utils/Index';
 import { getDomain } from '#app/utils/utility-functions';
@@ -17,14 +16,14 @@ import DoiClientException from '#app/exceptions/DoiClientException';
 import logger from '@adonisjs/core/services/logger';
 import { HttpException } from 'node-exceptions';
 import { ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
-import { CustomMessages } from "@adonisjs/validator/types";
+import vine, { SimpleMessagesProvider } from '@vinejs/vine';
 
 // Create a new instance of the client
 const client = new Client({ node: 'http://localhost:9200' }); // replace with your OpenSearch endpoint
 
 export default class DatasetsController {
     private proc;
-    public messages: CustomMessages = {
+    public messages = {
         // 'required': '{{ field }} is required',
         // 'licenses.minLength': 'at least {{ options.minLength }} permission must be defined',
         'reviewer_id.required': 'reviewer_id must be defined',
@@ -184,11 +183,13 @@ export default class DatasetsController {
     }
 
     public async approveUpdate({ request, response }: HttpContext) {
-        const approveDatasetSchema = schema.create({
-            reviewer_id: schema.number(),
+        const approveDatasetSchema = vine.object({
+            reviewer_id: vine.number(),
         });
         try {
-            await request.validate({ schema: approveDatasetSchema, messages: this.messages });
+            // await request.validate({ schema: approveDatasetSchema, messages: this.messages });
+            const validator = vine.compile(approveDatasetSchema);
+            await request.validateUsing(validator, { messagesProvider: new SimpleMessagesProvider(this.messages) });
         } catch (error) {
             // return response.badRequest(error.messages);
             throw error;
@@ -252,13 +253,14 @@ export default class DatasetsController {
     }
 
     public async publishUpdate({ request, response }: HttpContext) {
-        const publishDatasetSchema = schema.create({
-            publisher_name: schema.string({ trim: true }),
+        const publishDatasetSchema = vine.object({
+            publisher_name: vine.string().alphaNumeric().trim(),
         });
         try {
-            await request.validate({ schema: publishDatasetSchema, messages: this.messages });
+            // await request.validate({ schema: publishDatasetSchema, messages: this.messages });
+            const validator = vine.compile(publishDatasetSchema);
+            await request.validateUsing(validator, { messagesProvider: new SimpleMessagesProvider(this.messages) });
         } catch (error) {
-            // return response.badRequest(error.messages);
             throw error;
         }
         const id = request.param('id');

app/Controllers/Http/Reviewer/DatasetController.ts

@@ -4,8 +4,8 @@ import Dataset from '#models/dataset';
 import Field from '#app/Library/Field';
 import BaseModel from '#models/base_model';
 import { DateTime } from 'luxon';
-import { schema, rules } from '@adonisjs/validator';
 import { ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
+import vine from '@vinejs/vine';
 
 interface Dictionary {
     [index: string]: string;
@@ -227,13 +227,19 @@ export default class DatasetsController {
             })
             .firstOrFail();
 
-        const newSchema = schema.create({
-            server_state: schema.string({ trim: true }),
-            reject_reviewer_note: schema.string({ trim: true }, [rules.minLength(10), rules.maxLength(500)]),
+        // const newSchema = schema.create({
+        //     server_state: schema.string({ trim: true }),
+        //     reject_reviewer_note: schema.string({ trim: true }, [rules.minLength(10), rules.maxLength(500)]),
+        // });
+        const newSchema = vine.object({
+            server_state: vine.string().trim(),
+            reject_reviewer_note: vine.string().trim().minLength(10).maxLength(500),
         });
 
         try {
-            await request.validate({ schema: newSchema });
+            // await request.validate({ schema: newSchema });
+            const validator = vine.compile(newSchema);
+            await request.validateUsing(validator);
         } catch (error) {
             // return response.badRequest(error.messages);
             throw error;

app/Controllers/Http/Submitter/DatasetController.ts

@@ -8,15 +8,14 @@ import Description from '#models/description';
 import Language from '#models/language';
 import Coverage from '#models/coverage';
 import Collection from '#models/collection';
-import { schema, rules } from '@adonisjs/validator';
-import { CustomMessages } from '@adonisjs/validator/types';
 import dayjs from 'dayjs';
 import Person from '#models/person';
 import db from '@adonisjs/lucid/services/db';
 import { TransactionClientContract } from '@adonisjs/lucid/types/database';
 import Subject from '#models/subject';
-import CreateDatasetValidator from '#validators/create_dataset_validator';
-import UpdateDatasetValidator from '#validators/update_dataset_validator';
+// import CreateDatasetValidator from '#validators/create_dataset_validator';
+import { createDatasetValidator, updateDatasetValidator } from '#validators/dataset';
+// import UpdateDatasetValidator from '#validators/update_dataset_validator';
 import {
     TitleTypes,
     DescriptionTypes,
@@ -32,7 +31,7 @@ import DatasetReference from '#models/dataset_reference';
 import { cuid } from '@adonisjs/core/helpers';
 import File from '#models/file';
 import ClamScan from 'clamscan';
-import { ValidationException } from '@adonisjs/validator';
+// import { ValidationException } from '@adonisjs/validator';
 // import Drive from '@ioc:Adonis/Core/Drive';
 import drive from '#services/drive';
 import { Exception } from '@adonisjs/core/exceptions';
@@ -41,6 +40,7 @@ import * as crypto from 'crypto';
 interface Dictionary {
     [index: string]: string;
 }
+import vine, { SimpleMessagesProvider, errors } from '@vinejs/vine';
 
 export default class DatasetController {
     public async index({ auth, request, inertia }: HttpContext) {
@@ -125,8 +125,6 @@ export default class DatasetController {
         //     mixedtype: 'Mixed Type',
         //     vocabulary: 'Vocabulary',
         // };
-
-        // const languages = await Database.from('languages').select('*').where('active', true);
         return inertia.render('Submitter/Dataset/Create', {
             licenses: licenses,
             doctypes: DatasetTypes,
@@ -146,75 +144,98 @@ export default class DatasetController {
     }
 
     public async firstStep({ request, response }: HttpContext) {
-        const newDatasetSchema = schema.create({
-            language: schema.string({ trim: true }, [
-                rules.regex(/^[a-zA-Z0-9-_]+$/), //Must be alphanumeric with hyphens or underscores
-            ]),
-            licenses: schema.array([rules.minLength(1)]).members(schema.number()), // define at least one license for the new dataset
-            rights: schema.string([rules.equalTo('true')]),
+        // const newDatasetSchema = schema.create({
+        //     language: schema.string({ trim: true }, [
+        //         rules.regex(/^[a-zA-Z0-9-_]+$/), //Must be alphanumeric with hyphens or underscores
+        //     ]),
+        //     licenses: schema.array([rules.minLength(1)]).members(schema.number()), // define at least one license for the new dataset
+        //     rights: schema.string([rules.equalTo('true')]),
+        // });
+        const newDatasetSchema = vine.object({
+            // first step
+            language: vine
+                .string()
+                .trim()
+                .regex(/^[a-zA-Z0-9]+$/),
+            licenses: vine.array(vine.number()).minLength(1), // define at least one license for the new dataset
+            rights: vine.string().in(['true']),
         });
-
         // await request.validate({ schema: newDatasetSchema, messages: this.messages });
         try {
             //  Step 2 - Validate request body against  the schema
-
-            await request.validate({ schema: newDatasetSchema, messages: this.messages });
-            // console.log({ payload });
+            // await request.validate({ schema: newDatasetSchema, messages: this.messages });
+            const validator = vine.compile(newDatasetSchema);
+            await request.validateUsing(validator, { messagesProvider: new SimpleMessagesProvider(this.messages) });
         } catch (error) {
             // Step 3 - Handle errors
-            // return response.badRequest(error.messages);
             throw error;
         }
         return response.redirect().back();
     }
 
     public async secondStep({ request, response }: HttpContext) {
-        const newDatasetSchema = schema.create({
+        const newDatasetSchema = vine.object({
             // first step
-            language: schema.string({ trim: true }, [
-                rules.regex(/^[a-zA-Z0-9-_]+$/), //Must be alphanumeric with hyphens or underscores
-            ]),
-            licenses: schema.array([rules.minLength(1)]).members(schema.number()), // define at least one license for the new dataset
-            rights: schema.string([rules.equalTo('true')]),
+            language: vine
+                .string()
+                .trim()
+                .regex(/^[a-zA-Z0-9]+$/),
+            licenses: vine.array(vine.number()).minLength(1), // define at least one license for the new dataset
+            rights: vine.string().in(['true']),
             // second step
-            type: schema.string({ trim: true }, [rules.minLength(3), rules.maxLength(255)]),
-            creating_corporation: schema.string({ trim: true }, [rules.minLength(3), rules.maxLength(255)]),
-            titles: schema.array([rules.minLength(1)]).members(
-                schema.object().members({
-                    value: schema.string({ trim: true }, [rules.minLength(3), rules.maxLength(255)]),
-                    type: schema.enum(Object.values(TitleTypes)),
-                    language: schema.string({ trim: true }, [
-                        rules.minLength(2),
-                        rules.maxLength(255),
-                        rules.translatedLanguage('/language', 'type'),
-                    ]),
-                }),
-            ),
-            descriptions: schema.array([rules.minLength(1)]).members(
-                schema.object().members({
-                    value: schema.string({ trim: true }, [rules.minLength(3), rules.maxLength(255)]),
-                    type: schema.enum(Object.values(DescriptionTypes)),
-                    language: schema.string({ trim: true }, [
-                        rules.minLength(2),
-                        rules.maxLength(255),
-                        rules.translatedLanguage('/language', 'type'),
-                    ]),
-                }),
-            ),
-            authors: schema.array([rules.minLength(1)]).members(schema.object().members({ email: schema.string({ trim: true }) })),
-            contributors: schema.array.optional().members(
-                schema.object().members({
-                    email: schema.string({ trim: true }),
-                    pivot_contributor_type: schema.enum(Object.keys(ContributorTypes)),
-                }),
-            ),
-            // project_id: schema.number(),
+            type: vine.string().trim().minLength(3).maxLength(255),
+            creating_corporation: vine.string().trim().minLength(3).maxLength(255),
+            titles: vine
+                .array(
+                    vine.object({
+                        value: vine.string().trim().minLength(3).maxLength(255),
+                        type: vine.enum(Object.values(TitleTypes)),
+                        language: vine
+                            .string()
+                            .trim()
+                            .minLength(2)
+                            .maxLength(255)
+                            .translatedLanguage({ mainLanguageField: 'language', typeField: 'type' }),
+                    }),
+                )
+                .minLength(1),
+            descriptions: vine
+                .array(
+                    vine.object({
+                        value: vine.string().trim().minLength(3).maxLength(255),
+                        type: vine.enum(Object.values(DescriptionTypes)),
+                        language: vine
+                            .string()
+                            .trim()
+                            .minLength(2)
+                            .maxLength(255)
+                            .translatedLanguage({ mainLanguageField: 'language', typeField: 'type' }),
+                    }),
+                )
+                .minLength(1),
+            authors: vine
+                .array(
+                    vine.object({
+                        email: vine.string().trim().maxLength(255).email().normalizeEmail(),
+                    }),
+                )
+                .minLength(1),
+            contributors: vine
+                .array(
+                    vine.object({
+                        email: vine.string().trim().maxLength(255).email().normalizeEmail(),
+                        pivot_contributor_type: vine.enum(Object.keys(ContributorTypes)),
+                    }),
+                )
+                .optional(),
+            project_id: vine.number().optional(),
         });
 
         try {
             //  Step 2 - Validate request body against  the schema
-            await request.validate({ schema: newDatasetSchema, messages: this.messages });
-            // console.log({ payload });
+            // await request.validate({ schema: newDatasetSchema, messages: this.messages });
+            const validator = vine.compile(newDatasetSchema);
+            await request.validateUsing(validator, { messagesProvider: new SimpleMessagesProvider(this.messages) });
         } catch (error) {
             // Step 3 - Handle errors
             // return response.badRequest(error.messages);
@@ -224,84 +245,112 @@ export default class DatasetController {
     }
 
     public async thirdStep({ request, response }: HttpContext) {
-        const newDatasetSchema = schema.create({
+        const newDatasetSchema = vine.object({
             // first step
-            language: schema.string({ trim: true }, [
-                rules.regex(/^[a-zA-Z0-9-_]+$/), //Must be alphanumeric with hyphens or underscores
-            ]),
-            licenses: schema.array([rules.minLength(1)]).members(schema.number()), // define at least one license for the new dataset
-            rights: schema.string([rules.equalTo('true')]),
+            language: vine
+                .string()
+                .trim()
+                .regex(/^[a-zA-Z0-9]+$/),
+            licenses: vine.array(vine.number()).minLength(1), // define at least one license for the new dataset
+            rights: vine.string().in(['true']),
             // second step
-            type: schema.string({ trim: true }, [rules.minLength(3), rules.maxLength(255)]),
-            creating_corporation: schema.string({ trim: true }, [rules.minLength(3), rules.maxLength(255)]),
-            titles: schema.array([rules.minLength(1)]).members(
-                schema.object().members({
-                    value: schema.string({ trim: true }, [rules.minLength(3), rules.maxLength(255)]),
-                    type: schema.enum(Object.values(TitleTypes)),
-                    language: schema.string({ trim: true }, [
-                        rules.minLength(2),
-                        rules.maxLength(255),
-                        rules.translatedLanguage('/language', 'type'),
-                    ]),
-                }),
-            ),
-            descriptions: schema.array([rules.minLength(1)]).members(
-                schema.object().members({
-                    value: schema.string({ trim: true }, [rules.minLength(3), rules.maxLength(255)]),
-                    type: schema.enum(Object.values(DescriptionTypes)),
-                    language: schema.string({ trim: true }, [
-                        rules.minLength(2),
-                        rules.maxLength(255),
-                        rules.translatedLanguage('/language', 'type'),
-                    ]),
-                }),
-            ),
-            authors: schema.array([rules.minLength(1)]).members(schema.object().members({ email: schema.string({ trim: true }) })),
-            contributors: schema.array.optional().members(
-                schema.object().members({
-                    email: schema.string({ trim: true }),
-                    pivot_contributor_type: schema.enum(Object.keys(ContributorTypes)),
-                }),
-            ),
+            type: vine.string().trim().minLength(3).maxLength(255),
+            creating_corporation: vine.string().trim().minLength(3).maxLength(255),
+            titles: vine
+                .array(
+                    vine.object({
+                        value: vine.string().trim().minLength(3).maxLength(255),
+                        type: vine.enum(Object.values(TitleTypes)),
+                        language: vine
+                            .string()
+                            .trim()
+                            .minLength(2)
+                            .maxLength(255)
+                            .translatedLanguage({ mainLanguageField: 'language', typeField: 'type' }),
+                    }),
+                )
+                .minLength(1),
+            descriptions: vine
+                .array(
+                    vine.object({
+                        value: vine.string().trim().minLength(3).maxLength(255),
+                        type: vine.enum(Object.values(DescriptionTypes)),
+                        language: vine
+                            .string()
+                            .trim()
+                            .minLength(2)
+                            .maxLength(255)
+                            .translatedLanguage({ mainLanguageField: 'language', typeField: 'type' }),
+                    }),
+                )
+                .minLength(1),
+            authors: vine
+                .array(
+                    vine.object({
+                        email: vine.string().trim().maxLength(255).email().normalizeEmail(),
+                    }),
+                )
+                .minLength(1),
+            contributors: vine
+                .array(
+                    vine.object({
+                        email: vine.string().trim().maxLength(255).email().normalizeEmail(),
+                        pivot_contributor_type: vine.enum(Object.keys(ContributorTypes)),
+                    }),
+                )
+                .optional(),
             // third step
-            project_id: schema.number.optional(),
-            embargo_date: schema.date.optional({ format: 'yyyy-MM-dd' }, [rules.after(10, 'days')]),
-            coverage: schema.object().members({
-                x_min: schema.number(),
-                x_max: schema.number(),
-                y_min: schema.number(),
-                y_max: schema.number(),
-                elevation_absolut: schema.number.optional(),
-                elevation_min: schema.number.optional([rules.requiredIfExists('elevation_max')]),
-                elevation_max: schema.number.optional([rules.requiredIfExists('elevation_min')]),
-                depth_absolut: schema.number.optional(),
-                depth_min: schema.number.optional([rules.requiredIfExists('depth_max')]),
-                depth_max: schema.number.optional([rules.requiredIfExists('depth_min')]),
+            project_id: vine.number().optional(),
+            // embargo_date: schema.date.optional({ format: 'yyyy-MM-dd' }, [rules.after(10, 'days')]),
+            embargo_date: vine
+                .date({
+                    formats: ['YYYY-MM-DD'],
+                })
+                .afterOrEqual((_field) => {
+                    return dayjs().add(10, 'day').format('YYYY-MM-DD');
+                })
+                .optional(),
+            coverage: vine.object({
+                x_min: vine.number(),
+                x_max: vine.number(),
+                y_min: vine.number(),
+                y_max: vine.number(),
+                elevation_absolut: vine.number().optional(),
+                elevation_min: vine.number().optional().requiredIfExists('elevation_max'),
+                elevation_max: vine.number().optional().requiredIfExists('elevation_min'),
+                // type: vine.enum(Object.values(DescriptionTypes)),
+                depth_absolut: vine.number().optional(),
+                depth_min: vine.number().optional().requiredIfExists('depth_max'),
+                depth_max: vine.number().optional().requiredIfExists('depth_min'),
             }),
-            references: schema.array.optional([rules.uniqueArray('value')]).members(
-                schema.object().members({
-                    value: schema.string({ trim: true }, [rules.minLength(3), rules.maxLength(255)]),
-                    type: schema.enum(Object.values(ReferenceIdentifierTypes)),
-                    relation: schema.enum(Object.values(RelationTypes)),
-                    label: schema.string({ trim: true }, [rules.minLength(2), rules.maxLength(255)]),
-                }),
-            ),
-            subjects: schema.array([rules.minLength(3), rules.uniqueArray('value')]).members(
-                schema.object().members({
-                    value: schema.string({ trim: true }, [
-                        rules.minLength(3),
-                        rules.maxLength(255),
-                        // rules.unique({ table: 'dataset_subjects', column: 'value' }),
-                    ]),
-                    // type: schema.enum(Object.values(TitleTypes)),
-                    language: schema.string({ trim: true }, [rules.minLength(2), rules.maxLength(255)]),
-                }),
-            ),
+            references: vine
+                .array(
+                    vine.object({
+                        value: vine.string().trim().minLength(3).maxLength(255),
+                        type: vine.enum(Object.values(ReferenceIdentifierTypes)),
+                        relation: vine.enum(Object.values(RelationTypes)),
+                        label: vine.string().trim().minLength(2).maxLength(255),
+                    }),
+                )
+                .optional(),
+            subjects: vine
+                .array(
+                    vine.object({
+                        value: vine.string().trim().minLength(3).maxLength(255),
+                        // pivot_contributor_type: vine.enum(Object.keys(ContributorTypes)),
+                        language: vine.string().trim().minLength(2).maxLength(255),
+                    }),
+                )
+                .minLength(3)
+                .distinct('value')
+                .optional(),
         });
 
         try {
-            //  Step 2 - Validate request body against  the schema
-            await request.validate({ schema: newDatasetSchema, messages: this.messages });
+            //  Step 3 - Validate request body against  the schema
+            // await request.validate({ schema: newDatasetSchema, messages: this.messages });
+            const validator = vine.compile(newDatasetSchema);
+            await request.validateUsing(validator, { messagesProvider: new SimpleMessagesProvider(this.messages) });
             // console.log({ payload });
         } catch (error) {
             // Step 3 - Handle errors
@@ -316,7 +365,8 @@ export default class DatasetController {
         try {
             //  Step 2 - Validate request body against  the schema
             // await request.validate({ schema: newDatasetSchema, messages: this.messages });
-            await request.validate(CreateDatasetValidator);
+            // await request.validate(CreateDatasetValidator);
+            await request.validateUsing(createDatasetValidator);
             // console.log({ payload });
         } catch (error) {
             // Step 3 - Handle errors
@@ -505,13 +555,15 @@ export default class DatasetController {
                 const { file, isInfected, viruses } = await clamscan.isInfected(filePath);
                 if (isInfected) {
                     console.log(`${file} is infected with ${viruses}!`);
-                    reject(new ValidationException(true, { 'upload error': `File ${file} is infected!` }));
+                    // reject(new ValidationException(true, { 'upload error': `File ${file} is infected!` }));
+                    reject(new errors.E_VALIDATION_ERROR({ 'upload error': `File ${file} is infected!` }));
                 } else {
                     resolve();
                 }
             } catch (error) {
                 // If there's an error scanning the file, throw a validation exception
-                reject(new ValidationException(true, { 'upload error': `${error.message}` }));
+                // reject(new ValidationException(true, { 'upload error': `${error.message}` }));
+                reject(new errors.E_VALIDATION_ERROR({ 'upload error': `${error.message}!` }));
             }
         });
     }
@@ -553,24 +605,24 @@ export default class DatasetController {
         return pivotAttributes;
     }
 
-    public messages: CustomMessages = {
-        'minLength': '{{ field }} must be at least {{ options.minLength }} characters long',
-        'maxLength': '{{ field }} must be less then {{ options.maxLength }} characters long',
+    public messages = {
+        'minLength': '{{ field }} must be at least {{ min }} characters long',
+        'maxLength': '{{ field }} must be less then {{ max }} characters long',
         'required': '{{ field }} is required',
         'unique': '{{ field }} must be unique, and this value is already taken',
         // 'confirmed': '{{ field }} is not correct',
-        'licenses.minLength': 'at least {{ options.minLength }} permission must be defined',
+        'licenses.minLength': 'at least {{ min }} permission must be defined',
         'licenses.*.number': 'Define roles as valid numbers',
-        'rights.equalTo': 'you must agree to continue',
+        'rights.in': 'you must agree to continue',
 
-        'titles.0.value.minLength': 'Main Title  must be at least {{ options.minLength }} characters long',
+        'titles.0.value.minLength': 'Main Title  must be at least {{ min }} characters long',
         'titles.0.value.required': 'Main Title is required',
         'titles.*.value.required': 'Additional title is required, if defined',
         'titles.*.type.required': 'Additional title type is required',
         'titles.*.language.required': 'Additional title language is required',
         'titles.*.language.translatedLanguage': 'The language of the translated title must be different from the language of the dataset',
 
-        'descriptions.0.value.minLength': 'Main Abstract  must be at least {{ options.minLength }} characters long',
+        'descriptions.0.value.minLength': 'Main Abstract  must be at least {{ min }} characters long',
         'descriptions.0.value.required': 'Main Abstract is required',
         'descriptions.*.value.required': 'Additional description is required, if defined',
         'descriptions.*.type.required': 'Additional description type is required',
@@ -578,26 +630,26 @@ export default class DatasetController {
         'descriptions.*.language.translatedLanguage':
             'The language of the translated description must be different from the language of the dataset',
 
-        'authors.minLength': 'at least {{ options.minLength }} author must be defined',
+        'authors.array.minLength': 'at least {{ min }} author must be defined',
         'contributors.*.pivot_contributor_type.required': 'contributor type is required, if defined',
 
         'after': `{{ field }} must be older than ${dayjs().add(10, 'day')}`,
 
-        'subjects.minLength': 'at least {{ options.minLength }} keywords must be defined',
-        'subjects.uniqueArray': 'The {{ options.array }} array must have unique values based on the {{ options.field }} attribute.',
+        'subjects.array.minLength': 'at least {{ min }} keywords must be defined',
         'subjects.*.value.required': 'keyword value is required',
-        'subjects.*.value.minLength': 'keyword value  must be at least {{ options.minLength }} characters long',
+        'subjects.*.value.minLength': 'keyword value  must be at least {{ min }} characters long',
         'subjects.*.type.required': 'keyword type is required',
         'subjects.*.language.required': 'language of keyword is required',
+        'subjects.distinct': 'The {{ field }} array must have unique values based on the {{ fields }} attribute.',
 
         'references.*.value.required': 'Additional reference value is required, if defined',
         'references.*.type.required': 'Additional reference identifier type is required',
         'references.*.relation.required': 'Additional reference relation type is required',
         'references.*.label.required': 'Additional reference label is required',
 
-        'files.minLength': 'At least {{ options.minLength }}  file upload is required.',
+        'files.array.minLength': 'At least {{ min }}  file upload is required.',
         'files.*.size': 'file size is to big',
-        'files.extnames': 'file extension is not supported',
+        'files.*.extnames': 'file extension is not supported',
     };
 
     // public async release({ params, view }) {
@@ -654,16 +706,18 @@ export default class DatasetController {
         const preferredReviewerEmail = request.input('preferred_reviewer_email');
 
         if (preferation === 'yes_preferation') {
-            const newSchema = schema.create({
-                preferred_reviewer: schema.string({ trim: true }, [rules.minLength(3), rules.maxLength(255)]),
-                preferred_reviewer_email: schema.string([rules.email()]),
+            const newSchema = vine.object({
+                preferred_reviewer: vine.string().alphaNumeric().trim().minLength(3).maxLength(255),
+                preferred_reviewer_email: vine.string().maxLength(255).email().normalizeEmail(),
             });
 
             try {
-                await request.validate({
-                    schema: newSchema,
-                    // reporter: validator.reporters.vanilla,
-                });
+                // await request.validate({
+                //     schema: newSchema,
+                //     // reporter: validator.reporters.vanilla,
+                // });
+                const validator = vine.compile(newSchema);
+                await request.validateUsing(validator);
             } catch (error) {
                 // return response.badRequest(error.messages);
                 throw error;
@@ -799,8 +853,8 @@ export default class DatasetController {
 
     public async update({ request, response, session }: HttpContext) {
         try {
-            // await request.validate({ schema: newDatasetSchema, messages: this.messages });
-            await request.validate(UpdateDatasetValidator);
+            // await request.validate(UpdateDatasetValidator);
+            await request.validateUsing(updateDatasetValidator);
         } catch (error) {
             // - Handle errors
             // return response.badRequest(error.messages);
@@ -1068,7 +1122,7 @@ export default class DatasetController {
                 }
             }
         } catch (error) {
-            if (error instanceof ValidationException) {
+            if (error instanceof errors.E_VALIDATION_ERROR) {
                 // Validation exception handling
                 throw error;
             } else if (error instanceof Exception) {