:recycle: formatting all the things

backend/knexfile.js

             directory: './db/seeds'
         }
     },
-};
+}

backend/lib/auth/strategies/jwt.js

-'use strict';
+'use strict'
 
-module.exports = (options) => {
+module.exports = options => {
     return {
         keys: {
             key: options.jwtKey,
-            algorithms: ['HS256']
+            algorithms: ['HS256'],
         },
         verify: {
             aud: 'urn:audience:test',
             try {
                 return {
                     isValid: true,
-                    credentials: { user: artifacts.decoded.payload.user }
+                    credentials: { user: artifacts.decoded.payload.user },
                 }
-            }
-            catch (err) {
+            } catch (err) {
                 console.error(err)
                 return {
-                    isValid: false
+                    isValid: false,
                 }
             }
-
-        }
+        },
     }
-}
+}

backend/lib/index.js

-const UserPlugin = require('./plugins/user');
-const MembershipPlugin = require('./plugins/membership');
-const TestPlugin = require('./plugins/example');
+const UserPlugin = require('./plugins/user')
+const MembershipPlugin = require('./plugins/membership')
+const TestPlugin = require('./plugins/example')
 
 /**
  * A Hapi server instance
      * @param {Object} options
      */
     register: async (server, options) => {
-
         await server.register(TestPlugin, {
-            routes: { prefix: `/example` }
+            routes: { prefix: `/example` },
         })
 
         await server.register(UserPlugin, {
-            routes: { prefix: `/user` }
+            routes: { prefix: `/user` },
         })
 
         await server.register(MembershipPlugin, {
-            routes: { prefix: `/membership` }
+            routes: { prefix: `/membership` },
         })
     },
-}
+}

backend/lib/models/grouping.js

-const Schwifty = require('@hapipal/schwifty');
-const Joi = require('joi');
+const Schwifty = require('@hapipal/schwifty')
+const Joi = require('joi')
 
 module.exports = class Grouping extends Schwifty.Model {
-    static get tableName() { return 'groupings' }
+    static get tableName() {
+        return 'groupings'
+    }
     static get joiSchema() {
         return Joi.object({
             grouping_id: Joi.number(),

backend/lib/models/membership.js

-const Schwifty = require('@hapipal/schwifty');
-const Joi = require('joi');
+const Schwifty = require('@hapipal/schwifty')
+const Joi = require('joi')
 
 module.exports = class Membership extends Schwifty.Model {
-    static get tableName() { return 'memberships' }
+    static get tableName() {
+        return 'memberships'
+    }
     static get joiSchema() {
         return Joi.object({
             membership_id: Joi.number(),

backend/lib/models/message.js

-const Schwifty = require('@hapipal/schwifty');
-const Joi = require('joi');
+const Schwifty = require('@hapipal/schwifty')
+const Joi = require('joi')
 
 module.exports = class Message extends Schwifty.Model {
-    static get tableName() { return 'messages' }
+    static get tableName() {
+        return 'messages'
+    }
     static get joiSchema() {
         return Joi.object({
             message_id: Joi.number().required(),

backend/lib/models/profile.js

-const Schwifty = require('@hapipal/schwifty');
-const Joi = require('joi');
+const Schwifty = require('@hapipal/schwifty')
+const Joi = require('joi')
 
 module.exports = class Profile extends Schwifty.Model {
-    static get tableName() { return 'profiles' }
+    static get tableName() {
+        return 'profiles'
+    }
     static get joiSchema() {
         return Joi.object({
             profile_id: Joi.number().required(),

backend/lib/models/response-key.js

-const Schwifty = require('@hapipal/schwifty');
-const Joi = require('joi');
+const Schwifty = require('@hapipal/schwifty')
+const Joi = require('joi')
 
 module.exports = class ResponseKey extends Schwifty.Model {
-    static get tableName() { return 'response_keys' }
+    static get tableName() {
+        return 'response_keys'
+    }
     static get joiSchema() {
         return Joi.object({
             response_key_id: Joi.number().required(),

backend/lib/models/response.js

-const Schwifty = require('@hapipal/schwifty');
-const Joi = require('joi');
+const Schwifty = require('@hapipal/schwifty')
+const Joi = require('joi')
 
 module.exports = class Response extends Schwifty.Model {
-    static get tableName() { return 'responses' }
+    static get tableName() {
+        return 'responses'
+    }
     static get joiSchema() {
         return Joi.object({
             response_id: Joi.number().required(),

backend/lib/models/user.js

-const Schwifty = require('@hapipal/schwifty');
-const Joi = require('joi');
+const Schwifty = require('@hapipal/schwifty')
+const Joi = require('joi')
 
 module.exports = class User extends Schwifty.Model {
-    static get tableName() { return 'users' }
+    static get tableName() {
+        return 'users'
+    }
     static get joiSchema() {
         return Joi.object({
             user_id: Joi.number().required(),

backend/lib/plugins/example.js

     register: async (server, options) => {
         // Create a route for example
         server.route(example)
-    }
-}
+    },
+}

backend/lib/plugins/membership.js

-const Objection = require('objection');
-const Schmervice = require('@hapipal/schmervice');
+const Objection = require('objection')
+const Schmervice = require('@hapipal/schmervice')
 
-const GroupingModel = require('../models/grouping');
-const MembershipModel = require('../models/membership');
+const GroupingModel = require('../models/grouping')
+const MembershipModel = require('../models/membership')
 
-const MembershipService = require('../services/membership');
+const MembershipService = require('../services/membership')
 
-const MembershipJoinRoute = require('../routes/membership/join');
-const MembershipLeaveRoute = require('../routes/membership/leave');
-const MembershipActiveRoute = require('../routes/membership/active');
+const MembershipJoinRoute = require('../routes/membership/join')
+const MembershipLeaveRoute = require('../routes/membership/leave')
+const MembershipActiveRoute = require('../routes/membership/active')
 
 module.exports = {
     name: 'membership-plugin',
         // Bind to global context
         // So we can use Objection transactions
         server.bind({
-            transaction: (fn) => Objection.transaction(server.knex(), fn)
+            transaction: fn => Objection.transaction(server.knex(), fn),
         })
 
         await server.register(Schmervice)
         await server.route(MembershipJoinRoute)
         await server.route(MembershipLeaveRoute)
         await server.route(MembershipActiveRoute)
-    }
-}
+    },
+}

backend/lib/plugins/user.js

-const Objection = require('objection');
-const Schmervice = require('@hapipal/schmervice');
-const Schwifty = require('@hapipal/schwifty');
-const Jwt = require('@hapi/jwt');
+const Objection = require('objection')
+const Schmervice = require('@hapipal/schmervice')
+const Schwifty = require('@hapipal/schwifty')
+const Jwt = require('@hapi/jwt')
 const JwtStrategy = require('../auth/strategies/jwt')
 
-const UserModel = require('../models/user');
+const UserModel = require('../models/user')
 
-const UserCurrentRoute = require('../routes/user/current');
-const UserLoginRoute = require('../routes/user/login');
+const UserCurrentRoute = require('../routes/user/current')
+const UserLoginRoute = require('../routes/user/login')
 
-const MembershipService = require('../services/membership');
-const UserService = require('../services/user');
-const DisplayService = require('../services/display');
+const MembershipService = require('../services/membership')
+const UserService = require('../services/user')
+const DisplayService = require('../services/display')
 
 module.exports = {
     name: 'user-plugin',
         // Bind to global context
         // So we can use Objection transactions
         server.bind({
-            transaction: (fn) => Objection.transaction(server.knex(), fn)
+            transaction: fn => Objection.transaction(server.knex(), fn),
         })
 
         await server.register(Schmervice)
 
         await server.route(UserCurrentRoute)
         await server.route(UserLoginRoute)
-    }
+    },
 }
-

backend/lib/routes/example/base.js

         description: 'Test',
         notes: 'This is an example route',
         tags: ['api'],
-        auth: false
-    }
-}
+        auth: false,
+    },
+}

backend/lib/routes/membership/active.js

-'use strict';
+'use strict'
 
-const Joi = require('joi');
+const Joi = require('joi')
 
 const pluginConfig = {
     handlerType: 'grouping',
     docs: {
         description: 'active memberships',
-        notes: 'A list of groupings with active membership'
-    }
+        notes: 'A list of groupings with active membership',
+    },
 }
 
 const validators = {
     groupingsList: Joi.object({
         grouping_id: Joi.number(),
         grouping_name: Joi.string(),
-        grouping_type: Joi.string()
-    })
+        grouping_type: Joi.string(),
+    }),
 }
 
 module.exports = {
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,
-                    data: groupings
+                    data: groupings,
                 }
-            }
-            catch(err) {
+            } catch (err) {
                 return {
                     ok: false,
                     handler: pluginConfig.handlerType,
         /** Validate based on validators object */
         validate: {
             ...validators,
-            failAction: 'log'
-         },
+            failAction: 'log',
+        },
 
         /** Validate the server response */
         response: {
                 ok: Joi.bool(),
                 handler: Joi.string(),
                 data: Joi.array().items(responseSchemas.groupingsList),
-            })
-        }
-    }
+            }),
+        },
+    },
 }

backend/lib/routes/membership/join.js

-'use strict';
-
-const Joi = require('joi');
+const Joi = require('joi')
 
 const pluginConfig = {
     handlerType: 'grouping',
     docs: {
         description: 'join',
-        notes: 'Join a grouping by creating a membership record'
-    }
+        notes: 'Join a grouping by creating a membership record',
+    },
 }
 
 const validators = {
             grouping_name: Joi.string().allow(null),
             grouping_type: Joi.string().allow(null),
             role: Joi.string(),
-        })
-    }
+        }),
+    },
 }
 
 module.exports = {
          * @param {*} h
          * @returns {object}
          */
-        handler: async function (request, h) {
+        handler: async function (request) {
             try {
                 const { membershipService } = request.services()
 
                 const groupingToWrite = {
                     grouping_id: res.grouping_id,
                     grouping_name: res.grouping_name,
-                    grouping_type: res.grouping_type
+                    grouping_type: res.grouping_type,
                 }
-               
+
                 /** Default to participant role */
                 const role = res.role ? res.role : 'participant'
 
                 /** User membership service method to create membership */
-                const memberships = await membershipService.joinGrouping(res.user_id, res.target_id, groupingToWrite, role)
+                const memberships = await membershipService.joinGrouping(
+                    res.user_id,
+                    res.target_id,
+                    groupingToWrite,
+                    role,
+                )
 
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,
-                    data: { memberships, hasMatch: memberships.every(membership => membership.is_active == true) }
+                    data: {
+                        memberships,
+                        hasMatch: memberships.every(
+                            membership => membership.is_active == true,
+                        ),
+                    },
                 }
-            }
-            catch(err) {
+            } catch (err) {
                 return {
                     ok: false,
                     handler: pluginConfig.handlerType,
             schema: Joi.object({
                 ok: Joi.bool(),
                 handler: Joi.string(),
-                data: Joi.object()
+                data: Joi.object(),
             }),
-            failAction: 'log'
-        }
-    }
+            failAction: 'log',
+        },
+    },
 }

backend/lib/routes/membership/leave.js

-'use strict';
+'use strict'
 
-const Joi = require('joi');
+const Joi = require('joi')
 
 const pluginConfig = {
     handlerType: 'grouping',
     docs: {
         description: 'leave',
-        notes: 'Leave a grouping by creating a membership record'
-    }
+        notes: 'Leave a grouping by creating a membership record',
+    },
 }
 
 const validators = {
     leave: {
-        payload: Joi.object()
-    }
+        payload: Joi.object(),
+    },
 }
 
 module.exports = {
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,
-                    data: { foo: 'bar' }
+                    data: { foo: 'bar' },
                 }
-            }
-            catch(err) {
+            } catch (err) {
                 return {
                     ok: false,
                     handler: pluginConfig.handlerType,
             schema: Joi.object({
                 ok: Joi.bool(),
                 handler: Joi.string(),
-                data: validators.leave
+                data: validators.leave,
             }),
-            failAction: 'log'
-        }
-    }
+            failAction: 'log',
+        },
+    },
 }

backend/lib/routes/user/current.js

-'use strict';
+'use strict'
 
-const Joi = require('joi');
+const Joi = require('joi')
 
 const pluginConfig = {
     handlerType: 'user',
     docs: {
         get: {
             description: 'Get user',
-            notes: 'Returns a user item by the id passed in the path'
-        }
-    }
+            notes: 'Returns a user item by the id passed in the path',
+        },
+    },
 }
 
-
 /** Validator functions by request method */
 const validators = {
     get: {
         params: Joi.object({
             name: Joi.string().min(3).max(11),
-            all: Joi.array()
-        })
-    }
+            all: Joi.array(),
+        }),
+    },
 }
 
 module.exports = {
             try {
                 const auth = {
                     credentials: request.auth.credentials,
-                    token: request.auth.artifacts.token
+                    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)
 
                     handler: pluginConfig.handlerType,
                     data: { name: request.params.name },
                 }
-            }
-            catch(err) {
+            } catch (err) {
                 return {
                     ok: false,
                     handler: pluginConfig.handlerType,
             schema: Joi.object({
                 ok: Joi.bool(),
                 handler: Joi.string(),
-                data: validators.get.params
+                data: validators.get.params,
             }),
-            failAction: 'log'
-        }
-    }
-
-}
+            failAction: 'log',
+        },
+    },
+}

backend/lib/routes/user/login.js

-'use strict';
+'use strict'
 
-const Joi = require('joi');
+const Joi = require('joi')
 
 const pluginConfig = {
     handlerType: 'user',
     docs: {
         description: 'login',
-        notes: 'Attempt login'
-    }
+        notes: 'Attempt login',
+    },
 }
 
-
 /** Validator functions by request method */
 const validators = {
     post: {
         payload: Joi.object({
             user: Joi.object(),
-            error: Joi.string()
-        })
+            error: Joi.string(),
+        }),
     },
     user: Joi.object({
         user_id: Joi.number(),
         created_at: Joi.date(),
         updated_at: Joi.date(),
         token: Joi.string(),
-    })
+    }),
 }
 
 module.exports = {
                 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)
+                const login = async txn => {
+                    return await userService.login(
+                        {
+                            email: res.user.email,
+                            password: res.user.password,
+                        },
+                        txn,
+                    )
                 }
 
                 // Bound context from your plugin server declaration
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,
-                    data: displayService.user(user, token)
+                    data: displayService.user(user, token),
                 }
-            }
-            catch(err) {
+            } catch (err) {
                 console.error(err)
                 return {
                     ok: false,
             schema: Joi.object({
                 ok: Joi.bool(),
                 handler: Joi.string(),
-                data: validators.user
+                data: validators.user,
             }),
-            failAction: 'log'
-        }
-    }
+            failAction: 'log',
+        },
+    },
 }

backend/lib/services/display.js

-'use strict';
+'use strict'
 
-const Schmervice = require('@hapipal/schmervice');
-const internals = {};
+const Schmervice = require('@hapipal/schmervice')
+const internals = {}
 
 module.exports = class DisplayService extends Schmervice.Service {
     user({ password, ...user }, token) {
      * @param {*} txn
      * @returns
      */
-    async profile(currentUserId, user, txn)  {
+    async profile(currentUserId, user, txn) {
         const { User } = this.server.models()
         const { toProfile } = internals
 
-        const result = await User.fetchGraph(user, `[
+        const result = await User.fetchGraph(
+            user,
+            `[
             followedBy(currentUser) as following
-        ]`, {
-            txn
-        }).modifiers({
-            currentUser: (builder) => builder.where('Users.id', currentUserId)
+        ]`,
+            {
+                txn,
+            },
+        ).modifiers({
+            currentUser: builder => builder.where('Users.id', currentUserId),
         })
 
         return toProfile(result)
 
 internals.toProfile = ({ password, email, following, ...user }) => ({
     ...user,
-    following: (following.length > 0)
-})
+    following: following.length > 0,
+})

backend/lib/services/membership.js

-'use strict';
-
-const Schmervice = require('@hapipal/schmervice');
-
+const Schmervice = require('@hapipal/schmervice')
 
 module.exports = class MembershipService extends Schmervice.Service {
-    constructor(...args) { super(...args) }
+    constructor(...args) {
+        super(...args)
+    }
 
     /**
      * Internal method to get list of grouping_ids for this user
     async _getGroupIdsForUserId(userId) {
         const { Membership } = this.server.models()
 
-            /** Grab every Membership associated with this id */
-            const allMemberships = await Membership.query()
-                .where('user_id', userId)
+        /** Grab every Membership associated with this id */
+        const allMemberships = await Membership.query().where('user_id', userId)
 
-            /** Copy a list of the just the Groupings */
-            const groupingIdsToGrab = allMemberships.map(membership => membership.grouping_id)
+        /** Copy a list of the just the Groupings */
+        const groupingIdsToGrab = allMemberships.map(
+            membership => membership.grouping_id,
+        )
 
-            /** Uncomment to dedupe the list just in case */
-            return [...new Set(groupingIdsToGrab)]
+        /** Uncomment to dedupe the list just in case */
+        return [...new Set(groupingIdsToGrab)]
     }
 
     /**
             grouping_name: groupingToTry.grouping_name,
             grouping_type: groupingToTry.grouping_type,
         }
-        return await Grouping.query(txn)
-            .insert(groupingInfo)
+        return await Grouping.query(txn).insert(groupingInfo)
     }
 
     async findOrCreateGrouping(groupingToTry) {
         let idToReturn = groupingToTry.grouping_id
-        if(!idToReturn) {
+        if (!idToReturn) {
             /** ?: For some reason this returns the key id */
             const grouping = await this._createGrouping(groupingToTry)
             idToReturn = grouping.id
 
     async _groupingIdsInCommon(userId, targetId) {
         const dedupedUserGroupingIds = await this._getGroupIdsForUserId(userId)
-        const dedupedTargetGroupingIds = await this._getGroupIdsForUserId(targetId)
+        const dedupedTargetGroupingIds = await this._getGroupIdsForUserId(
+            targetId,
+        )
 
         /** Return true if both people have a group in common */
-        return dedupedUserGroupingIds.filter(groupingId => dedupedTargetGroupingIds.includes(groupingId))
+        return dedupedUserGroupingIds.filter(groupingId =>
+            dedupedTargetGroupingIds.includes(groupingId),
+        )
     }
     async _patchMembership(memberships, userId, patch) {
         const { Membership } = this.server.models()
 
         /** Set membership as active only if the user initiates it */
-        for(let membershipInfo of memberships) {
+        for (let membershipInfo of memberships) {
             await Membership.query()
                 .where('membership_id', membershipInfo.membership_id)
                 .where('user_id', userId)
         }
     }
 
-    async attemptMatch(userId, targetId, txn) {
+    async attemptMatch(userId, targetId) {
         const { Membership } = this.server.models()
 
         /** If both people have groups in common */
-        const matchingGroupingIds = await this._groupingIdsInCommon(userId, targetId)
-
-        if(matchingGroupingIds.length) {
+        const matchingGroupingIds = await this._groupingIdsInCommon(
+            userId,
+            targetId,
+        )
 
+        if (matchingGroupingIds.length) {
             /** Grab all memberships associated with groupingIds */
-            const memberships = await Membership.query().whereIn('grouping_id', matchingGroupingIds)
-    
+            const memberships = await Membership.query().whereIn(
+                'grouping_id',
+                matchingGroupingIds,
+            )
+
             /** Set membership as active only if the user initiates it */
-            await this._patchMembership(memberships, userId, { is_active: true })
+            await this._patchMembership(memberships, userId, {
+                is_active: true,
+            })
 
             /** Make a new query to get updated information */
-            return await Membership.query().whereIn('grouping_id', matchingGroupingIds)
+            return await Membership.query().whereIn(
+                'grouping_id',
+                matchingGroupingIds,
+            )
         }
     }
-    
+
     /**
      * Check for grouping membership then add membership record and set to active
      * or create a new grouping and add membership record for user and membership record for target
         const { Membership } = this.server.models()
 
         /** If both people have groups in common */
-        const matchingGroupingIds = await this._groupingIdsInCommon(userId, targetId)
-
-        if(matchingGroupingIds.length) {
+        const matchingGroupingIds = await this._groupingIdsInCommon(
+            userId,
+            targetId,
+        )
 
+        if (matchingGroupingIds.length) {
             /** Grab all memberships associated with groupingIds */
-            const memberships = await Membership.query().whereIn('grouping_id', matchingGroupingIds)
-    
+            const memberships = await Membership.query().whereIn(
+                'grouping_id',
+                matchingGroupingIds,
+            )
+
             /** Set membership as active only if the user initiates it */
-            await this._patchMembership(memberships, userId, { is_active: true })
+            await this._patchMembership(memberships, userId, {
+                is_active: true,
+            })
 
             /** Make a new query to get updated information */
-            return await Membership.query().whereIn('grouping_id', matchingGroupingIds)
-        }
-        
-        /** 
-         * If both have NO grouping in common create a membership
-         * for both to new group but set membership as inactive for target
-         * */
-        else {
+            return await Membership.query().whereIn(
+                'grouping_id',
+                matchingGroupingIds,
+            )
+        } else {
+            /**
+             * If both have NO grouping in common create a membership
+             * for both to new group but set membership as inactive for target
+             * */
             /** Check if the grouping exists and if NOT creat it */
             const groupingId = await this.findOrCreateGrouping(groupingToWrite)
 
                 grouping_id: groupingId,
                 membership_type: role,
                 can_edit: false,
-                is_active: true
+                is_active: true,
             })
-    
+
             const targetMembership = await Membership.query(txn).insert({
                 user_id: targetId,
                 grouping_id: groupingId,
                 membership_type: role,
                 can_edit: false,
-                is_active: false
+                is_active: false,
             })
-            
+
             return [userMembership, targetMembership]
         }
     }
         const dedupedGroupings = await this._getGroupIdsForUserId(userId)
 
         /** Do NOTHING if NOT in Grouping */
-        if(!dedupedGroupings.includes(groupingId)) return
+        if (!dedupedGroupings.includes(groupingId)) return
 
         return await Membership.query()
             .delete()
             .where('grouping_id', groupingId)
     }
-}
+}

backend/lib/services/user.js

-'use strict';
+'use strict'
 
-const Util = require('util');
-const Jwt = require('@hapi/jwt');
-const Schmervice = require('@hapipal/schmervice');
-const SecurePassword = require('secure-password');
+const Util = require('util')
+const Jwt = require('@hapi/jwt')
+const Schmervice = require('@hapipal/schmervice')
+const SecurePassword = require('secure-password')
 
 /** Class for methods used in the User plugin */
 module.exports = class UserService extends Schmervice.Service {
         const pwd = new SecurePassword()
         this.pwd = {
             hash: Util.promisify(pwd.hash.bind(pwd)),
-            verify: Util.promisify(pwd.verify.bind(pwd))
+            verify: Util.promisify(pwd.verify.bind(pwd)),
         }
     }
 
     async findByUsername(username, txn) {
         const { User } = this.server.models()
 
-        return await User.query(txn).throwIfNotFound().first().where({ username })
+        return await User.query(txn)
+            .throwIfNotFound()
+            .first()
+            .where({ username })
     }
 
     /**
         const { User } = this.server.models()
 
         if (Object.keys(userInfo).length > 0) {
-            await User.query(txn).throwIfNotFound().where({ id }).patch(userInfo)
+            await User.query(txn)
+                .throwIfNotFound()
+                .where({ id })
+                .patch(userInfo)
         }
 
         if (password) {
             .first()
             .where({ user_email: email })
 
-
         /** Uncomment to run password check using SecurePassword */
         // const passwordCheck = await this.pwd.verify(Buffer.from(password), user.password)
         // if (passwordCheck === SecurePassword.VALID_NEEDS_REHASH) {
     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: 4 * 60 * 60 // 7 days
-        })
+        return Jwt.token.generate(
+            {
+                aud: 'urn:audience:test',
+                iss: 'urn:issuer:test',
+                email: user.user_email,
+            },
+            {
+                key: key,
+                algorithm: 'HS256',
+            },
+            {
+                ttlSec: 4 * 60 * 60, // 7 days
+            },
+        )
     }
 
     /**
     async changePassword(id, password, txn) {
         const { User } = this.server.models()
 
-        await User.query(txn).throwIfNotFound().where({ id }).patch({
-            password: await this.pwd.hash(Buffer.from(password))
-        })
+        await User.query(txn)
+            .throwIfNotFound()
+            .where({ id })
+            .patch({
+                password: await this.pwd.hash(Buffer.from(password)),
+            })
         return id
     }
-}
+}

backend/package.json

   },
   "devDependencies": {
     "ava": "^3.15.0",
+    "eslint": "^7.28.0",
     "nodemon": "^2.0.7",
     "nyc": "^15.1.0"
   }

backend/server/index.js

-const Glue = require('@hapi/glue');
-const Exiting = require('exiting');
-const Manifest = require('./manifest');
+const Glue = require('@hapi/glue')
+const Exiting = require('exiting')
+const Manifest = require('./manifest')
 /**
  * Our main app server
  * @param {boolean} start
 
     if (start) {
         await Exiting.createManager(server).start()
-        server.log(['start'], `Server started at ${server.info.uri}`);
+        server.log(['start'], `Server started at ${server.info.uri}`)
         return server
     }