Actualmente estamos experimentando más una molestia que un problema. Tengo la siguiente función:
export const getLoginSession = async (req: NextApiRequest): Promise<undefined | User> => {
const token = getTokenCookie(req)
if (!token) return
const session = await Iron.unseal(token, TOKEN_SECRET, Iron.defaults)
const expiresAt = session.createdAt + session.maxAge * 1000
// Validate the expiration date of the session
if (Date.now() > expiresAt) {
throw new Error('Session expired')
}
return session
}
y eslint(consistent-return) me dice: La función de flecha asíncrona no esperaba ningún valor de retorno.
Pensé, ¿por qué no intentarlo así?
export const getLoginSession = async (req: NextApiRequest): Promise<undefined | User> => {
const token = getTokenCookie(req)
if (token) {
const session = await Iron.unseal(token, TOKEN_SECRET, Iron.defaults)
const expiresAt = session.createdAt + session.maxAge * 1000
if (Date.now() > expiresAt) {
throw new Error('Session expired')
}
return session
}
}
pero luego obtengo eslint: Se espera que devuelva un valor al final de la función de flecha asíncrona.
Una solución es volver a la primera iteración y devolver falso si (!token) devuelve falso, lo que soluciona el problema.
Mi pregunta es
¿Es esa la mejor manera de manejarlo cuando normalmente no devolvemos falso explícitamente?
Soy nuevo en Typecript, es un tipo de retorno de Promesa<undefinido | Usuario> ¿adecuado?
tipo Usuario contiene id: cadena, nombre de usuario: cadena, etc...
------------------------------------
Respondiendo a tu pregunta, sí, hay una manera mejor. Siempre debe rechazar la promesa si el resultado de la misma no es del tipo que espera. Devolver indefinido aún hará que la persona que llama de esa promesa maneje este caso y, en mi experiencia, se vuelve un poco confuso.
Yo lo cambiaría por algo como esto:
export const getLoginSession = async (req: NextApiRequest): Promise<User> => { // <-- this promise will return a user or throw
const token = getTokenCookie(req)
if (!token) {
throw new Error('invalid token') // <-- unexpected we should throw
}
const session = await Iron.unseal(token, TOKEN_SECRET, Iron.defaults)
const expiresAt = session.createdAt + session.maxAge * 1000
// Validate the expiration date of the session
if (Date.now() > expiresAt) {
throw new Error('Session expired')
}
return session
}
De esta manera tenemos un mejor flujo de control y es fácil razonar.
try {
const session = await getLoginSession(req)
// do something with the session
} catch (error) {
// handle the error
console.log(error)
}
Acerca de la devolución consistente, es porque no definiste un valor después de la devolución. Por lo tanto, devolver falso funciona pero devolver undefinido o devolver void 0 también funcionará.
De los documentos:
requiereVolver a devolver declaraciones para especificar valores siempre o nunca
ref: retorno-consistente
------------------------------------
En el siguiente código, la sesión no existe cuando regresa, los valores constantes/let tienen un alcance de bloque, por lo tanto, el alcance de la sesión solo existe dentro de ese bloque si no está fuera de él. Necesitas hacerlo. regrese dentro del bloque if y devuelva la promesa de error o simplemente haga el respaldo cuando el token se vuelva falso y, si no, devuelva la sesión
if (token) {
const session = await Iron.unseal(token, TOKEN_SECRET, Iron.defaults)
const expiresAt = session.createdAt + session.maxAge * 1000
if (Date.now() > expiresAt) {
throw new Error('Session expired')
}
return session
}
