- update to AdonisJS 6

start/env.ts

@@ -0,0 +1,36 @@
+/*
+|--------------------------------------------------------------------------
+| Validating Environment Variables
+|--------------------------------------------------------------------------
+|
+| In this file we define the rules for validating environment variables.
+| By performing validation we ensure that your application is running in
+| a stable environment with correct configuration values.
+|
+| This file is read automatically by the framework during the boot lifecycle
+| and hence do not rename or move this file to a different location.
+|
+*/
+import { Env } from "@adonisjs/core/env"
+
+export default await Env.create(new URL("../", import.meta.url), {
+  HOST: Env.schema.string({ format: 'host' }),
+  PORT: Env.schema.number(),
+  APP_KEY: Env.schema.string(),
+  APP_NAME: Env.schema.string(),
+  CACHE_VIEWS: Env.schema.boolean(),
+  SESSION_DRIVER: Env.schema.string(),
+
+  DRIVE_DISK: Env.schema.enum(['local'] as const),
+  NODE_ENV: Env.schema.enum(['development', 'production', 'test'] as const),
+  DB_CONNECTION: Env.schema.string(),
+  PG_HOST: Env.schema.string({ format: 'host' }),
+  PG_PORT: Env.schema.number(),
+  PG_USER: Env.schema.string(),
+  PG_PASSWORD: Env.schema.string.optional(),
+  PG_DB_NAME: Env.schema.string(),
+
+  REDIS_HOST: Env.schema.string({ format: 'host' }),
+  REDIS_PORT: Env.schema.number()
+})
+

start/inertia.json

@@ -9,7 +9,7 @@
 */
 
 import Inertia from '@ioc:EidelLev/Inertia';
-import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
+import type { HttpContext } from '@adonisjs/core/http';
 
 Inertia.share({
     errors: (ctx) => {
@@ -28,7 +28,7 @@ Inertia.share({
     },
 
     // params: ({ params }) => params,
-    authUser: async ({ auth }: HttpContextContract) => {
+    authUser: async ({ auth }: HttpContext) => {
         if (auth.user) {
             await auth.user.load('roles');
             return auth.user;

start/kernel.ts

@@ -9,47 +9,47 @@
 |
 */
 
-import Server from '@ioc:Adonis/Core/Server';
+import server from '@adonisjs/core/services/server'
+import router from '@adonisjs/core/services/router'
 
-/*
-|--------------------------------------------------------------------------
-| Global middleware
-|--------------------------------------------------------------------------
-|
-| An array of global middleware, that will be executed in the order they
-| are defined for every HTTP requests.
-|
-*/
-Server.middleware.register([
-    () => import('@ioc:Adonis/Core/BodyParser'),
-    () => import('@ioc:EidelLev/Inertia/Middleware'),
-    // () => import('ioc:EidelLev/Stardust/Middleware'),
-    () => import('@eidellev/adonis-stardust/build/middleware/Stardust'),
-    // () => import('adonis-acl/src/Middlewares/Init'),
-]);
+server.errorHandler(
+  () => import('#exceptions/Handler')
+)
 
-/*
-|--------------------------------------------------------------------------
-| Named middleware
-|--------------------------------------------------------------------------
-|
-| Named middleware are defined as key-value pair. The value is the namespace
-| or middleware function and key is the alias. Later you can use these
-| alias on individual routes. For example:
-|
-| { auth: () => import('App/Middleware/Auth') }
-|
-| and then use it as follows
-|
-| Route.get('dashboard', 'UserController.dashboard').middleware('auth')
-|
-*/
-Server.middleware.registerNamed({
-    auth: 'App/Middleware/Auth',
-    // is: () => import('App/Middleware/Is'),
-    // can: () => import('App/Middleware/Can'),
-    // is: "Adonis/Acl/Is",
-    // can: "Adonis/Acl/Can"
-    is: () => import('App/Middleware/Role'),
-    can: () => import('App/Middleware/Can'),
-});
+/**
+ * The server middleware stack runs middleware on all the HTTP
+ * requests, even if there is no route registered for
+ * the request URL.
+ */
+server.use([
+  () => import('#middleware/container_bindings_middleware'),
+  () => import('@adonisjs/static/static_middleware'),
+  () => import('@adonisjs/inertia/inertia_middleware'),
+])
+
+/**
+ * The router middleware stack runs middleware on all the HTTP
+ * requests with a registered route.
+ */
+router.use([
+  () => import('@adonisjs/core/bodyparser_middleware'),
+  () => import('@adonisjs/session/session_middleware'),
+  () => import('@adonisjs/shield/shield_middleware'),
+  // () => import('@adonisjs/inertia/inertia_middleware'),
+  () => import('@adonisjs/auth/initialize_auth_middleware'),
+  () => import('#middleware/stardust_middleware'),
+  // () => import('@eidellev/adonis-stardust/build/middleware/Stardust.js'),
+])
+
+/**
+ * Named middleware collection must be explicitly assigned to
+ * the routes or the routes group.
+ */
+export const middleware = router.named({
+  // guest: () => import('#middleware/guest_middleware'),
+  // stardust: () => import('#middleware/stardust_middleware'),
+  // guest: () => import('#middleware/guest_middleware'),
+  auth: () => import('#middleware/auth_middleware'),
+  is: () => import('#middleware/Role'),
+  can: () => import('#middleware/Can'),
+})

start/routes.ts

@@ -18,279 +18,279 @@
 |
 */
 
-import Route from '@ioc:Adonis/Core/Route';
+import OaiController from '#controllers/Http/Oai/OaiController';
+
+import router from '@adonisjs/core/services/router';
+import type { HttpContext } from '@adonisjs/core/http';
+
 // import Inertia from '@ioc:EidelLev/Inertia';
-import AuthValidator from 'App/Validators/AuthValidator';
-import HealthCheck from '@ioc:Adonis/Core/HealthCheck';
-import User from 'App/Models/User';
-// import AuthController from 'App/Controllers/Http/Auth/AuthController';
-import './routes/api';
+import AuthValidator from '#app/Validators/AuthValidator';
+// import HealthCheck from '@ioc:Adonis/Core/HealthCheck';
+import User from '#app/Models/User';
+import AuthController from '#controllers/Http/Auth/AuthController';
+import UserController from '#controllers/Http/Auth/UserController';
+import AdminUserController from '#controllers/Http/Admin/UsersController';
+import RoleController from '#controllers/Http/Admin/RoleController';
 
-Route.get('health', async ({ response }) => {
-    const report = await HealthCheck.getReport();
-    return report.healthy ? response.ok(report) : response.badRequest(report);
-});
+import DatasetController from '#app/Controllers/Http/Submitter/DatasetController';
+import PersonController from '#app/Controllers/Http/Submitter/PersonController';
+import EditorDatasetController  from '#app/Controllers/Http/Editor/DatasetController';
+import ReviewerDatasetController  from '#app/Controllers/Http/Reviewer/DatasetController';
 
+import './routes/api.js';
+import { middleware } from './kernel.js'
+
+
+// router.get('health', async ({ response }) => {
+//     const report = await HealthCheck.getReport();
+//     return report.healthy ? response.ok(report) : response.badRequest(report);
+// });
+router.get('/health', ({ response }: HttpContext) => response.noContent());
 
 //oai:
 // Route.get( '/oai', 'Oai/RequestController.index').as('oai');
-Route.group(() => {
-    Route.get('/oai', 'Oai/OaiController.index').as('get');
-    Route.post('/oai', 'Oai/OaiController.index').as('post');
-}).as('oai');
-// Route.inertia('/about', 'App');
+router.group(() => {
+        router.get('/oai', [OaiController, 'index']).as('get');
+        router.post('/oai', [OaiController, 'index']).as('post');
+    })
+    .as('oai');
 
 //old solution:
-Route.get('/welcome', async ({ view }) => {
-    return view.render('welcome');
-}).as('welcome');
+router.get('/welcome', async ({ view }: HttpContext) => {
+        return view.render('welcome');
+    })
+    .as('welcome');
 
-Route.get('/', async ({ response }) => {
-    return response.redirect().toRoute('apps.dashboard');
-}).as('dashboard');
+router.get('/', async ({ response }: HttpContext) => {
+        return response.redirect().toRoute('apps.dashboard');
+    })
+    .as('dashboard');
 
-Route.group(() => {
-    Route.get('/dashboard', async ({ inertia }) => {
-        return inertia.render('Dashboard');
-    }).as('dashboard');
+// apps group
+router.group(() => {
+        router.get('/dashboard', async ({ inertia }: HttpContext) => {
+                return inertia.render('Dashboard');
+            })
+            .as('dashboard');
 
-    Route.get('/map', async ({ inertia }) => {
-        return inertia.render('Map');
-    }).as('map');
+        router.get('/map', async ({ inertia }: HttpContext) => {
+                return inertia.render('Map');
+            })
+            .as('map');
 
-    Route.get('/', async ({ inertia }) => {
-        const users = await User.query().orderBy('login');
-        return inertia.render('App', {
-            testing: 'this is a test',
-            users: users,
-        });
-    }).as('index');
+        router.get('/', async ({ inertia }: HttpContext) => {
+                const users = await User.query().orderBy('login');
+                return inertia.render('App', {
+                    testing: 'this is a test',
+                    users: users,
+                });
+            })
+            .as('index');
 
-    // Route.get('/login', async ({ inertia }) => {
-    // 	return inertia.render('Auth/Login');
-    // }).as('login.show');
+        // Route.get('/login', async ({ inertia }) => {
+        // 	return inertia.render('Auth/Login');
+        // }).as('login.show');
 
-    Route.get('/register', async ({ inertia }) => {
-        return inertia.render('register-view/register-view-component');
-    }).as('register.show');
+        router.get('/register', async ({ inertia }: HttpContext) => {
+                return inertia.render('register-view/register-view-component');
+            })
+            .as('register.show');
 
-    Route.post('/register', async ({ request, response }) => {
-        console.log({
-            registerBody: request.body(),
-        });
+        router.post('/register', async ({ request, response }: HttpContext) => {
+                console.log({
+                    registerBody: request.body(),
+                });
 
-        const data = await request.validate(AuthValidator);
-        console.log({ data });
+                const data = await request.validate(AuthValidator);
+                console.log({ data });
 
-        return response.redirect().toRoute('app.index');
-    }).as('register.store');
-})
+                return response.redirect().toRoute('app.index');
+            })
+            .as('register.store');
+    })
     .prefix('apps')
     .as('apps')
-    .middleware('auth');
-
+    .use(middleware.auth());
 
+    
 
 // Route.on("/login").render("signin");
-Route.get('/app/login', async ({ inertia }) => {
-    return inertia.render('Auth/Login');
+router.get('/app/login', ({ inertia }: HttpContext) => {
+        return inertia.render('Auth/Login');
 }).as('app.login.show');
 
-// Route.post("/login", "Users/AuthController.login");
-Route.post('/app/login', 'Auth/AuthController.login').as('login.store');
-Route.post('/app/twoFactorChallenge', 'Auth/AuthController.twoFactorChallenge').as('login.twoFactorChallenge');
-
-// Route.on("/signup").render("signup");
-// Route.post("/signup", "AuthController.signup");
-Route.post('/signout', 'Auth/AuthController.logout').as('logout');
+router.post('/app/login', [AuthController, 'login']).as('login.store');
+router.post('/app/twoFactorChallenge', [AuthController, 'twoFactorChallenge']).as('login.twoFactorChallenge');
+router.post('/signout', [AuthController, 'logout']).as('logout');
 
 // administrator
-Route.group(() => {
-    Route.get('/settings', async ({ inertia }) => {
-        return inertia.render('Admin/Settings');
-    
-    }).as('overview');
+router.group(() => {
+        router.get('/settings', async ({ inertia }: HttpContext) => {
+                return inertia.render('Admin/Settings');
+            })
+            .as('overview');
 
-    // user routes
-    Route.get('/user', 'UsersController.index').as('user.index').middleware(['can:user-list']);
-    Route.get('/user/create', 'UsersController.create').as('user.create').middleware(['can:user-create']);
-    Route.post('/user/store', 'UsersController.store').as('user.store').middleware(['can:user-create']);
-    Route.get('/user/:id', 'UsersController.show').as('user.show').where('id', Route.matchers.number());
-    Route.get('/user/:id/edit', 'UsersController.edit').as('user.edit').where('id', Route.matchers.number()).middleware(['can:user-edit']);
-    Route.put('/user/:id/update', 'UsersController.update')
-        .as('user.update')
-        .where('id', Route.matchers.number())
-        .middleware(['can:user-edit']);
-    // Route.delete('/user/:id', 'UsersController.destroy')
-    //     .as('user.destroy')
-    //     .where('id', Route.matchers.number())
-    //     .middleware(['can:user-delete']);
-    // Route.resource('user', 'UsersController');
+        // user routes
+        router.get('/user', [AdminUserController, 'index']).as('user.index').use(middleware.can(['user-list']));
+        router.get('/user/create', [AdminUserController, 'create']).as('user.create').use(middleware.can(['user-create']));
+        router.post('/user/store', [AdminUserController, 'store']).as('user.store').use(middleware.can(['user-create']));
+        router.get('/user/:id', [AdminUserController, 'show']).as('user.show').where('id', router.matchers.number());
+        router.get('/user/:id/edit', [AdminUserController, 'edit']).as('user.edit').where('id', router.matchers.number()).use(middleware.can(['user-edit']));
+        router.put('/user/:id/update', [AdminUserController, 'update'])
+            .as('user.update')
+            .where('id', router.matchers.number())
+            .use(middleware.can(['user-edit']));
+        // // Route.delete('/user/:id', [AdminUserController, 'destroy'])
+        // //     .as('user.destroy')
+        // //     .where('id', Route.matchers.number())
+        // //     .use(middleware.can(['user-delete']));
+        // // Route.resource('user', 'AdminUserController');
 
-    Route.get('/role', 'RoleController.index').as('role.index').middleware(['can:user-list']);
-    Route.get('/role/create', 'RoleController.create').as('role.create').middleware(['can:user-create']);
-    Route.post('/role/store', 'RoleController.store').as('role.store').middleware(['can:user-create']);
-    Route.get('/role/:id', 'RoleController.show').as('role.show').where('id', Route.matchers.number());
-    Route.get('/role/:id/edit', 'RoleController.edit').as('role.edit').where('id', Route.matchers.number()).middleware(['can:user-edit']);
-    Route.put('/role/:id/update', 'RoleController.update')
-        .as('role.update')
-        .where('id', Route.matchers.number())
-        .middleware(['can:user-edit']);
-    // Route.delete('/role/:id', 'RoleController.destroy')
-    //     .as('role.destroy')
-    //     .where('id', Route.matchers.number())
-    //     .middleware(['can:user-delete']);
-})
-    .namespace('App/Controllers/Http/Admin')
+        router.get('/role', [RoleController, 'index']).as('role.index').use(middleware.can(['user-list']));
+        router.get('/role/create', [RoleController, 'create']).as('role.create').use(middleware.can(['user-create']));
+        router.post('/role/store', [RoleController, 'store']).as('role.store').use(middleware.can(['user-create']));
+        router.get('/role/:id', [RoleController, 'show']).as('role.show').where('id', router.matchers.number());
+        router.get('/role/:id/edit', [RoleController, 'edit']).as('role.edit').where('id', router.matchers.number()).use(middleware.can(['user-edit']));
+        router.put('/role/:id/update', [RoleController, 'update'])
+            .as('role.update')
+            .where('id', router.matchers.number())
+            .use(middleware.can(['user-edit']));
+        // // Route.delete('/role/:id',  [RoleController, 'destroy'])
+        // //     .as('role.destroy')
+        // //     .where('id', Route.matchers.number())
+        // //     .use(middleware.can(['user-delete']));
+    })
     .prefix('admin')
     .as('settings')
-    // .middleware(['auth', 'can:dataset-list,dataset-publish']);
-    .middleware(['auth', 'is:administrator,moderator']);
+    .use([middleware.auth(), middleware.is(['administrator', 'moderator'])])
+    // .middleware(['auth', 'is:administrator,moderator']);
 
-
-Route.get('/settings/user/security', 'UserController.accountInfo')
+router.get('/settings/user/security', [UserController, 'accountInfo'])
     .as('settings.user')
-    .namespace('App/Controllers/Http/Auth')
-    .middleware(['auth']);
+    .use(middleware.auth());
 
-Route.post('/settings/user/store', 'UserController.accountInfoStore')
+router.post('/settings/user/store', [UserController, 'accountInfoStore'])
     .as('account.password.store')   
-    .namespace('App/Controllers/Http/Auth')
-    .middleware(['auth']);
+    .use(middleware.auth());
 // Route::post('change-password', 'UserController@changePasswordStore')->name('admin.account.password.store');
 
-Route.post('/settings/user/enable2fa', 'UserController.enableTwoFactorAuthentication')
-    .as('account.password.enable2fa')   
-    .namespace('App/Controllers/Http/Auth')
-    .middleware(['auth']);
 
-Route.post('/settings/user/disable2fa', 'UserController.disableTwoFactorAuthentication')
-    .as('account.password.disable2fa')   
-    .namespace('App/Controllers/Http/Auth')
-    .middleware(['auth']);
 
 // submitter:
-Route.group(() => {
-    // Route.get('/user', 'UsersController.index').as('user.index');
-    Route.get('/dataset', 'DatasetController.index').as('dataset.list').middleware(['auth', 'can:dataset-list']);
-    Route.get('/dataset/create', 'DatasetController.create').as('dataset.create').middleware(['auth', 'can:dataset-submit']);
-    Route.post('/dataset/first/first-step', 'DatasetController.firstStep')
+router.group(() => {
+    
+    router.get('/dataset', [DatasetController, 'index']).as('dataset.list').use([middleware.auth(), middleware.can(['dataset-list'])]);
+    router.get('/dataset/create',  [DatasetController, 'create']).as('dataset.create').use([middleware.auth(), middleware.can(['dataset-submit'])]);
+    router.post('/dataset/first/first-step', [DatasetController, 'firstStep'])
         .as('dataset.first.step')
-        .middleware(['auth', 'can:dataset-submit']);
-    Route.post('/dataset/second/second-step', 'DatasetController.secondStep')
+        .use([middleware.auth(), middleware.can(['dataset-submit'])]);
+    router.post('/dataset/second/second-step', [DatasetController, 'secondStep'])
         .as('dataset.second.step')
-        .middleware(['auth', 'can:dataset-submit']);
-    Route.post('/dataset/second/third-step', 'DatasetController.thirdStep')
+        .use([middleware.auth(), middleware.can(['dataset-submit'])]);
+    router.post('/dataset/second/third-step', [DatasetController, 'thirdStep'])
         .as('dataset.third.step')
-        .middleware(['auth', 'can:dataset-submit']);
-    Route.post('/dataset/submit', 'DatasetController.store').as('dataset.submit').middleware(['auth', 'can:dataset-submit']);
+        .use([middleware.auth(), middleware.can(['dataset-submit'])]);
+    router.post('/dataset/submit', [DatasetController, 'store']).as('dataset.submit').use([middleware.auth(), middleware.can(['dataset-submit'])]);
 
-    Route.get('/dataset/:id/release', 'DatasetController.release')
+    router.get('/dataset/:id/release', [DatasetController, 'release'])
         .as('dataset.release')
-        .where('id', Route.matchers.number())
-        .middleware(['auth', 'can:dataset-edit']);
-    Route.put('/dataset/:id/releaseupdate', 'DatasetController.releaseUpdate')
-        .as('dataset.releaseUpdate')
-        .middleware(['auth', 'can:dataset-edit']);
-    Route.get('/dataset/:id/edit', 'DatasetController.edit')
+        .where('id', router.matchers.number())
+        .use([middleware.auth(), middleware.can(['dataset-edit'])]);
+    router.put('/dataset/:id/releaseupdate', [DatasetController, 'releaseUpdate'])
+        .as('dataset.releaseUpdate')       
+        .use([middleware.auth(), middleware.can(['dataset-edit'])]);
+    router.get('/dataset/:id/edit', [DatasetController, 'edit'])
         .as('dataset.edit')
-        .where('id', Route.matchers.number())
-        .middleware(['auth', 'can:dataset-edit']);
-    Route.put('/dataset/:id/update', 'DatasetController.update')
+        .where('id', router.matchers.number())
+        .use([middleware.auth(), middleware.can(['dataset-edit'])]);
+    router.put('/dataset/:id/update', [DatasetController,'update'])
         .as('dataset.update')
-        .where('id', Route.matchers.number())
-        .middleware(['auth', 'can:dataset-edit']);
+        .where('id', router.matchers.number())
+        .use([middleware.auth(), middleware.can(['dataset-edit'])]);
 
-    Route.get('/dataset/:id/delete', 'DatasetController.delete').as('dataset.delete').middleware(['auth', 'can:dataset-delete']);
-    Route.put('/dataset/:id/deleteupdate', 'DatasetController.deleteUpdate')
+    router.get('/dataset/:id/delete', [DatasetController, 'delete']).as('dataset.delete').use([middleware.auth(), middleware.can(['dataset-delete'])]);
+    router.put('/dataset/:id/deleteupdate', [DatasetController, 'deleteUpdate'])
         .as('dataset.deleteUpdate')
-        .middleware(['auth', 'can:dataset-delete']);
+        .use([middleware.auth(), middleware.can(['dataset-delete'])]);
 
-    Route.get('/person', 'PersonController.index').as('person.index').middleware(['auth']);
-    // Route.get('/user/:id/edit', 'UsersController.edit').as('settings.user.edit').where('id', Route.matchers.number());
-    // Route.put('/user/:id/update', 'UsersController.update').as('user.update').where('id', Route.matchers.number());
-    // Route.delete('/user/:id', 'UsersController.destroy').as('user.destroy').where('id', Route.matchers.number());
-    // Route.resource('user', 'DatasetController');
+    router.get('/person', [PersonController, 'index']).as('person.index').use([middleware.auth()]);
+   
 })
-    .namespace('App/Controllers/Http/Submitter')
     .prefix('submitter');
 // .middleware(['auth', 'can:dataset-list,dataset-publish']);
 // .middleware(['auth', 'is:submitter']);
 
 // editor:
-Route.group(() => {
-    Route.get('/dataset', 'DatasetController.index').as('editor.dataset.list').middleware(['auth', 'can:dataset-editor-list']);
-    Route.get('dataset/:id/receive', 'DatasetController.receive')
+router.group(() => {
+    router.get('/dataset', [EditorDatasetController, 'index']).as('editor.dataset.list').use([middleware.auth(), middleware.can(['dataset-editor-list'])]);
+    router.get('dataset/:id/receive', [EditorDatasetController, 'receive'])
         .as('editor.dataset.receive')
-        .where('id', Route.matchers.number())
-        .middleware(['auth', 'can:dataset-receive']);
-    Route.put('dataset/:id/receive', 'DatasetController.receiveUpdate')
+        .where('id', router.matchers.number())
+        .use([middleware.auth(), middleware.can(['dataset-receive'])]);
+    router.put('dataset/:id/receive', [EditorDatasetController, 'receiveUpdate'])
         .as('editor.dataset.receiveUpdate')
-        .where('id', Route.matchers.number())
-        .middleware(['auth', 'can:dataset-receive']);
-    Route.get('dataset/:id/approve', 'DatasetController.approve')
+        .where('id', router.matchers.number())
+        .use([middleware.auth(), middleware.can(['dataset-receive'])]);
+    router.get('dataset/:id/approve', [EditorDatasetController, 'approve'])
         .as('editor.dataset.approve')
-        .where('id', Route.matchers.number())
-        .middleware(['auth', 'can:dataset-approve']);
-    Route.put('dataset/:id/approve', 'DatasetController.approveUpdate')
+        .where('id', router.matchers.number())
+        .use([middleware.auth(), middleware.can(['dataset-approve'])]);
+    router.put('dataset/:id/approve', [EditorDatasetController, 'approveUpdate'])
         .as('editor.dataset.approveUpdate')
-        .where('id', Route.matchers.number())
-        .middleware(['auth', 'can:dataset-approve']);
-    
-    Route.get('dataset/:id/publish', 'DatasetController.publish')
-        .as('editor.dataset.publish')
-        .where('id', Route.matchers.number())
-        .middleware(['auth', 'can:dataset-publish']);
-    Route.put('dataset/:id/publish', 'DatasetController.publishUpdate')
-        .as('editor.dataset.publishUpdate')
-        .where('id', Route.matchers.number())
-        .middleware(['auth', 'can:dataset-publish']);
-    
-     
-    Route.get('dataset/:id/doi', 'DatasetController.doiCreate')
-        .as('editor.dataset.doi')
-        .where('id', Route.matchers.number())
-        .middleware(['auth', 'can:dataset-publish']);
-    Route.put('dataset/:publish_id/doi', 'DatasetController.doiStore')
-        .as('editor.dataset.doiStore')
-        .where('id', Route.matchers.number())
-        .middleware(['auth', 'can:dataset-publish']);
+        .where('id', router.matchers.number())
+        .use([middleware.auth(), middleware.can(['dataset-approve'])]);
 
-    Route.put('/dataset/:id/update', 'DatasetController.update')
+    router.get('dataset/:id/publish', [EditorDatasetController, 'publish'])
+        .as('editor.dataset.publish')
+        .where('id', router.matchers.number())
+        .use([middleware.auth(), middleware.can(['dataset-publish'])]);
+    router.put('dataset/:id/publish', [EditorDatasetController, 'publishUpdate'])
+        .as('editor.dataset.publishUpdate')
+        .where('id', router.matchers.number())
+        .use([middleware.auth(), middleware.can(['dataset-publish'])]);
+
+    router.get('dataset/:id/doi', [EditorDatasetController, 'doiCreate'])
+        .as('editor.dataset.doi')
+        .where('id', router.matchers.number())
+        .use([middleware.auth(), middleware.can(['dataset-publish'])]);
+    router.put('dataset/:publish_id/doi', [EditorDatasetController, 'doiStore'])
+        .as('editor.dataset.doiStore')
+        .where('id', router.matchers.number())
+        .use([middleware.auth(), middleware.can(['dataset-publish'])]);
+
+    router.put('/dataset/:id/update', [EditorDatasetController, 'update'])
         .as('editor.dataset.update')
-        .middleware(['auth', 'can:dataset-editor-edit']);
+        .use([middleware.auth(), middleware.can(['dataset-editor-edit'])]);
 })
-    .namespace('App/Controllers/Http/Editor')
     .prefix('editor');
 
-
     // reviewer:
-Route.group(() => {
-    Route.get('/dataset', 'DatasetController.index').as('reviewer.dataset.list').middleware(['auth', 'can:dataset-review-list']);
-    Route.get('dataset/:id/review', 'DatasetController.review')
+router.group(() => {
+    router.get('/dataset', [ReviewerDatasetController, 'index']).as('reviewer.dataset.list').use([middleware.auth(), middleware.can(['dataset-review-list'])]);
+    router.get('dataset/:id/review', [ReviewerDatasetController, 'review'])
         .as('reviewer.dataset.review')
-        .where('id', Route.matchers.number())
-        .middleware(['auth', 'can:dataset-review']);
-    Route.put('dataset/:id/review', 'DatasetController.reviewUpdate')
+        .where('id', router.matchers.number())
+        .use([middleware.auth(), middleware.can(['dataset-review'])]);
+    router.put('dataset/:id/review', [ReviewerDatasetController, 'reviewUpdate'])
         .as('reviewer.dataset.reviewUpdate')
-        .where('id', Route.matchers.number())
-        .middleware(['auth', 'can:dataset-review']);
-    Route.get('dataset/:id/reject', 'DatasetController.reject')
+        .where('id', router.matchers.number())
+        .use([middleware.auth(), middleware.can(['dataset-review'])]);
+    router.get('dataset/:id/reject', [ReviewerDatasetController, 'reject'])
         .as('reviewer.dataset.reject')
-        .where('id', Route.matchers.number())
-        .middleware(['auth', 'can:dataset-review-reject']);
-    Route.put('dataset/:id/reject', 'DatasetController.rejectUpdate')
-        .as('reviewer.dataset.rejectUpdate')     
-        .where('id', Route.matchers.number())
-        .middleware(['auth', 'can:dataset-review-reject']);   
-    // Route.put('dataset/:id/approve', 'DatasetController.approveUpdate')
+        .where('id', router.matchers.number())
+        .use([middleware.auth(), middleware.can(['dataset-review-reject'])]);
+    router.put('dataset/:id/reject', [ReviewerDatasetController, 'rejectUpdate'])
+        .as('reviewer.dataset.rejectUpdate')
+        .where('id', router.matchers.number())
+        .use([middleware.auth(), middleware.can(['dataset-review-reject'])]);
+    // Route.put('dataset/:id/approve', [ReviewerDatasetController, 'approveUpdate'])
     //     .as('editor.dataset.approveUpdate')
     //     .where('id', Route.matchers.number())
     //     .middleware(['auth', 'can:dataset-approve']);
 
-    // Route.put('/dataset/:id/update', 'DatasetController.update')
+    // Route.put('/dataset/:id/update', [ReviewerDatasetController, 'update')
     //     .as('editor.dataset.update')
     //     .middleware(['auth', 'can:dataset-editor-edit']);
 })
-    .namespace('App/Controllers/Http/Reviewer')
+   
     .prefix('reviewer');

start/routes/api.ts

@@ -1,31 +1,34 @@
-import Route from '@ioc:Adonis/Core/Route';
+import router from '@adonisjs/core/services/router';
 
+import AuthorsController from '#controllers/Http/Api/AuthorsController';
+import DatasetController from '#controllers/Http/Api/DatasetController';
+import HomeController from '#controllers/Http/Api/HomeController';
+import FileController from '#controllers/Http/Api/FileController';
+import AvatarController from '#controllers/Http/Api/AvatarController';
+import UserController from '#controllers/Http/Api/UserController';
+import { middleware } from '../kernel.js'
 // API
-Route.group(() => {
-    // Route.post("register", "AuthController.register");
-    // Route.post("login", "AuthController.login");
+router.group(() => {
+  
 
-    Route.group(() => {
-        Route.get('authors', 'AuthorsController.index').as('author.index');
-        Route.get('datasets', 'DatasetController.index').as('dataset.index');
-        Route.get('persons', 'AuthorsController.persons').as('author.persons');
-        // Route.get("author/:id", "TodosController.show");
-        // Route.put("author/update", "TodosController.update");
-        // Route.post("author", "TodosController.store");
-        Route.get('/dataset', 'DatasetController.findAll').as('dataset.findAll');
-        Route.get('/dataset/:publish_id', 'DatasetController.findOne').as('dataset.findOne');
-        Route.get('/sitelinks/:year', 'HomeController.findDocumentsPerYear');
-        Route.get('/years', 'HomeController.findYears');
-        Route.get('/statistic/:year', 'HomeController.findPublicationsPerMonth');
+   
+        router.get('authors', [AuthorsController, "index"]).as('author.index');
+        router.get('datasets', [DatasetController, "index"]).as('dataset.index');
+        router.get('persons', [AuthorsController, "persons"]).as('author.persons');
+     
+        router.get('/dataset',  [DatasetController, "findAll"]).as('dataset.findAll');
+        router.get('/dataset/:publish_id', [DatasetController, "findOne"]).as('dataset.findOne');
+        router.get('/sitelinks/:year', [HomeController, "findDocumentsPerYear"]);
+        router.get('/years',  [HomeController, "findYears"]);
+        router.get('/statistic/:year',  [HomeController, "findPublicationsPerMonth"]);
 
-        Route.get('/download/:id', 'FileController.findOne').as('file.findOne');
+        router.get('/download/:id', [FileController, "findOne"]).as('file.findOne');
 
-        Route.get('/avatar/:name/:background?/:textColor?/:size?', 'AvatarController.generateAvatar');
+        router.get('/avatar/:name/:background?/:textColor?/:size?', [AvatarController, 'generateAvatar']);
 
     
-        Route.post('/twofactor_totp/settings/enable/:state/:code?', 'UserController.enable').as('apps.twofactor_totp.enable') .middleware(['auth']);;
-    });
-    // .middleware("auth:api");
+        router.post('/twofactor_totp/settings/enable/:state/:code?', [UserController, 'enable']).as('apps.twofactor_totp.enable') .use(middleware.auth());
+    
 })
-    .namespace('App/Controllers/Http/Api')
+    // .namespace('App/Controllers/Http/Api')
     .prefix('api');

start/validator.ts

@@ -9,7 +9,7 @@ https://issuehunt.io/r/adonisjs/validator/issues/84
 |
 */
 // import { string } from '@ioc:Adonis/Core/Helpers';
-import { validator } from '@ioc:Adonis/Core/Validator';
+import { validator } from '@adonisjs/validator';
 
 validator.rule('uniqueArray', (dataArray, [field], { pointer, arrayExpressionPointer, errorReporter }) => {
     const array = dataArray; //validator.helpers.getFieldValue(data, field, tip);