:recycle: working token | i think?

backend/lib/auth/strategies/jwt.js

             algorithms: ['HS256']
         },
         verify: {
-            aud: false,
-            iss: false,
-            sub: false
+            aud: 'urn:audience:test',
+            iss: 'urn:issuer:test',
+            sub: false,
         },
-        httpAuthScheme: 'Token',
         validate: (artifacts, request, h) => {
-            return {
-                isValid: true,
-                credentials: { user: artifacts.decoded.payload.user }
+            try {
+                return {
+                    isValid: true,
+                    credentials: { user: artifacts.decoded.payload.user }
+                }
             }
+            catch (err) {
+                console.error(err)
+                return {
+                    isValid: false
+                }
+            }
+
         }
     }
 }

backend/lib/plugins/user.js

 
         const mainApp = server.registrations['main-app-plugin']
         const jwtOptions = JwtStrategy(mainApp.options)
+
         server.auth.strategy('default_jwt', 'jwt', jwtOptions)
         server.auth.default('default_jwt')
 

backend/lib/routes/user/current.js

 module.exports = {
     method: 'get',
     path: '/{name}',
-    handler: async request => {
-        try {
-            /** Get the data for your endpoint */
-            const { User } = request.models()
-            const all = await User.query()
-
-            return {
-                ok: true,
-                handler: pluginConfig.handlerType,
-                data: { name: request.params.name, all },
-            }
-        }
-        catch(err) {
-            return {
-                ok: false,
-                handler: pluginConfig.handlerType,
-                data: { error: err },
-            }
-        }
-    },
     options: {
         ...pluginConfig.docs.get,
         tags: ['api'],
         auth: 'default_jwt',
+        handler: async function (request, h) {
+            console.log('current')
+            console.log(request)
+            try {
+                const auth = {
+                    credentials: request.auth.credentials,
+                    token: request.auth.artifacts.token
+                }
+
+                // /** Get the data for your endpoint */
+                // const { User } = request.models()
+                // const all = await User.query()
+
+
+                const { displayService } = request.services()
+                const user = displayService.user(auth.credentials, auth.token)
+
+                return {
+                    ok: true,
+                    handler: pluginConfig.handlerType,
+                    data: { name: request.params.name },
+                }
+            }
+            catch(err) {
+                return {
+                    ok: false,
+                    handler: pluginConfig.handlerType,
+                    data: { error: err },
+                }
+            }
+        },
         validate: validators.get,
         response: {
             schema: Joi.object({

backend/lib/routes/user/login.js

 'use strict';
 
 const Joi = require('joi');
-const User = require('../../models/user');
 
 const pluginConfig = {
     handlerType: 'user',
             user: Joi.object(),
             error: Joi.string()
         })
-    }
+    },
+    user: Joi.object({
+        user_id: Joi.number(),
+        user_name: Joi.string(),
+        user_email: Joi.string(),
+        created_at: Joi.date(),
+        updated_at: Joi.date(),
+        token: Joi.string(),
+    })
 }
 
 module.exports = {
     method: 'post',
     path: '/login',
-    handler: async function (request, h) {
-        try {
-            const { userService, displayService } = request.services()
+    options: {
+        ...pluginConfig.docs.post,
+        tags: ['api'],
+        auth: false,
+        handler: async function (request, h) {
+            try {
+                const { userService, displayService } = request.services()
 
-            const res = request.payload
+                const res = request.payload
 
-            // Callback to use as transaction
-            const login = async (txn) => {
-                return await userService.login({
-                    email: res.user.email,
-                    password: res.user.password
-                }, txn)
-            }
+                // Callback to use as transaction
+                const login = async (txn) => {
+                    return await userService.login({
+                        email: res.user.email,
+                        password: res.user.password
+                    }, txn)
+                }
 
-            // Bound context from your plugin server declaration
-            const user = await h.context.transaction(login)
-            const token = userService.createToken(user.id)
+                // Bound context from your plugin server declaration
+                const user = await h.context.transaction(login)
+                const token = userService.createToken(user)
 
-            return {
-                ok: true,
-                handler: pluginConfig.handlerType,
-                data: { user: displayService.user(user, token) }
+                return {
+                    ok: true,
+                    handler: pluginConfig.handlerType,
+                    data: displayService.user(user, token)
+                }
             }
-        }
-        catch(err) {
-            console.error(err)
-            return {
-                ok: false,
-                handler: pluginConfig.handlerType,
-                data: { error: `${err}` },
+            catch(err) {
+                console.error(err)
+                return {
+                    ok: false,
+                    handler: pluginConfig.handlerType,
+                    data: { error: `${err}` },
+                }
             }
-        }
-    },
-    options: {
-        ...pluginConfig.docs.post,
-        tags: ['api'],
-        auth: false,
+        },
         validate: validators.post,
         response: {
             schema: Joi.object({
                 ok: Joi.bool(),
                 handler: Joi.string(),
-                data: validators.post.payload
+                data: validators.user
             }),
             failAction: 'log'
         }

backend/lib/services/user.js

     async login({ email, password }, txn) {
         const { User } = this.server.models()
 
-        console.log('user service attempting login...')
-
         const user = await User.query(txn)
             .throwIfNotFound()
             .first()
 
         return user
     }
-    createToken(id) {
-        const key =this.server.registrations['main-app-plugin'].options.jwtKey
-        return Jwt.token.generate({ id }, {
+    createToken(user) {
+        const key = this.server.registrations['main-app-plugin'].options.jwtKey
+
+        return Jwt.token.generate({
+            aud: 'urn:audience:test',
+            iss: 'urn:issuer:test',
+            email: user.user_email
+        },
+        {
             key: key,
             algorithm: 'HS256'
         }, {
-            ttlSec: 7 * 24 * 60 * 60 // 7 days
+            ttlSec: 4 * 60 * 60 // 7 days
         })
     }
     async changePassword(id, password, txn) {