Checking if login token is valid

[sgup]

Hi, I have a react native app where I'd like to just use the login token if a valid one is available. Is this the correct way?

const token = (await getLoginToken()) || null;

if(token) {
   const tokenExpires = await AsyncStorage.getItem('Meteor.loginTokenExpires');
   const tokenIsValid = new Date() < new Date(tokenExpires)

  if(tokenIsValid) // take user to homepage
  else // take user to login or use stored email/pass to loginWithPassword
}

[brightchip]

Did you find out ? How do we check the token on server? Can it use seperated Redis for Token checking

[brightchip]

I think i got this:

schema:

` import { gql } from 'apollo-server-express';

export default gql

type Query { users: [User!] user(_id: ID!): User

}

extend type Mutation { updateUser(username: String!): User!

resumeLogin(token:String!,services:VaildSerivesEnumType!): User

}

type Email { address: String verified: Boolean }

type Token { token: String! }

type lastlogin{ date:Date ipAddr:String }

type UserStatus{ lastlogin:lastlogin userAgent:String online:Boolean page:String idle:Boolean }

enum VaildSerivesEnumType{ password google }

type User { id: ID username: String displayName: String password:String roles: [String!] heartbeat:Date hideMe:Boolean status:UserStatus

registered_emails: [Email]
createdAt:Date

emails: [Email]

picture:String
coverImg:String
description:String
brief:String

}

`

resolver: ` import { Resolvers } from 'meteor/nicolaslopezj:apollo-accounts/src/Mutation/hashPassword.js' import { combineResolvers } from 'graphql-resolvers'; import { isAuthenticated } from './authorization';

import { Accounts } from 'meteor/accounts-base';

export default { Query: { users: async(parent, args, { models }) => { return await Meteor.users.find(); }, user: async(parent, { _id }, { models }) => { return await Meteor.users.findById(_id); }, },

Mutation: {
    resumeLogin: async(parent, { token, services }, { models }) => {
        const hashedToken = Accounts._hashLoginToken(token);
        let selector = {};

        if ('password' == services) {
            selector['services.resume.loginTokens.hashedToken'] = hashedToken
        } else if ('google' == services) {
            selector['services.google.accessToken'] = hashedToken
        } else {
            return
        }
        // console.log('selector', selector)
        return await Meteor.users.find(selector).fetch()[0];
    },
    ...Resolvers,
    updateUser: combineResolvers(
        isAuthenticated,
        async(parent, { username }, { models, me }) => {
            return await models.User.findByIdAndUpdate(
                me.id, { username }, { new: true },
            );
        },
    ),

},

}; And then you can resume login on each request that need auth: mutation{ resumeLogin(token:"TOKEN",services:password){ id
} }`

enum:

` import { GraphQLEnumType, } from 'graphql';

const VaildSerivesEnumType = new GraphQLEnumType({ name: 'VAILD_SERIVCES', values: { password: { value: 'password', }, google: { value: 'google', }, }, }); `