Descarga next session - next session Source Code Descargar

Siguiente Sesión

Middleware de sesión liviano basado en promesas para Next.js. También funciona en micro o nodo.js http servidor, express y más.

También vea alternativas como la siguiente sesión de hierro. Eche un vistazo a NextJS-MongoDB-App para ver este módulo en uso.

Instalación

// NPM
npm install next-session
// Yarn
yarn add next-session

Uso

Actualización de v1.x a v2.x? ¡Lea las notas de la versión aquí!

Actualización de v2.x a v3.x? ¡Lea las notas de la versión aquí!

Actualización de v3.x a v4.x? ¡Lea las notas de la versión aquí!

Advertir el almacén de sesión predeterminado (si options?.store La tienda está undefined ), MemoryStore , no funciona en producción o entorno sin servidor. Debe usar una tienda de sesión.

 // ./lib/get-session.js
import nextSession from "next-session" ;
export const getSession = nextSession ( options ) ;

Rutas API

 import { getSession } from "./lib/get-session.js" ;

export default function handler ( req , res ) {
  const session = await getSession ( req , res ) ;
  session . views = session . views ? session . views + 1 : 1 ;
  // Also available under req.session:
  // req.session.views = req.session.views ? req.session.views + 1 : 1;
  res . send (
    `In this session, you have visited this website ${ session . views } time(s).`
  ) ;
}

El uso en las rutas API puede resultar en API resolved without sending a response . Esto se puede resolver agregando:

 import nextSession from "next-session" ;
const getSession = nextSession ( ) ;

export default function handler ( req , res ) {
  const session = await getSession ( req , res ) ;
  /* ... */
}

export const config = {
  api : {
    externalResolver : true ,
  } ,
} ;

await session.commit() o configurar options.autoCommit false

 import nextSession from "next-session" ;
const getSession = nextSession ( { autoCommit : false } ) ;

export default function handler ( req , res ) {
  const session = await getSession ( req , res ) ;
  /* ... */
  await session . commit ( ) ;
}

getServersideProps

 import { getSession } from "./lib/get-session.js" ;

export default function Page ( { views } ) {
  return (
    < div > In this session, you have visited this website { views } time(s). </ div >
  ) ;
}

export async function getServerSideProps ( { req , res } ) {
  const session = await getSession ( req , res ) ;
  session . views = session . views ? session . views + 1 : 1 ;
  // Also available under req.session:
  // req.session.views = req.session.views ? req.session.views + 1 : 1;
  return {
    props : {
      views : session . views ,
    } ,
  } ;
}

Otros

express, próxima conexión

 const express = require ( "express" ) ;
const app = express ( ) ;
app . use ( async ( req , res , next ) => {
  await getSession ( req , res ) ; // session is set to req.session
  next ( ) ;
} ) ;
app . get ( "/" , ( req , res ) => {
  req . session . views = req . session . views ? req . session . views + 1 : 1 ;
  res . send (
    `In this session, you have visited this website ${ req . session . views } time(s).`
  ) ;
} ) ;

Funciones sin servidor de Micro, Vercel

 module . exports = ( req , res ) => {
  const session = await getSession ( req , res ) ;
  res . end (
    `In this session, you have visited this website ${ session . views } time(s).`
  ) ;
} ;

Servidor node.js http

 const http = require ( "http" ) ;

const server = http . createServer ( async ( req , res ) => {
  const session = await getSession ( req , res ) ;
  res . end ( `In this session, you have visited this website ${ session . views } time(s).` ;
} ) ;
server . listen ( 8080 ) ;

Opción

next-session acepta las propiedades a continuación.

opción	descripción	por defecto
nombre	El nombre de la cookie se lee de la solicitud y se establece en la respuesta.	`sid`
almacenar	La instancia de la tienda de sesiones que se utilizará. ¡Se requiere trabajar en producción!	`MemoryStore`
género	La función que genera una cadena para una nueva ID de sesión.	`nanoid`
codificar	Transforma la ID de sesión antes de configurar la cookie. Toma la ID de sesión sin procesar y devuelve la ID de sesión decodificada/descifrada.	indefinido
descodificar	Transforma la identificación de la sesión mientras se obtiene de Cookie. Debería devolver la ID de sesión codificada/encriptada	indefinido
conmovedor	Solo toque después de una cantidad de tiempo (en segundos) desde el último acceso. Desactivado de forma predeterminada o si se establece en `-1` . Ver Touchafter.	`-1` (deshabilitado)
autocomitar	COMIRSE AUTOMÁTICO SESIÓN. Deshabilite esto si desea `session.commit()`	`true`
Cookie.	Especifica el valor booleano para el atributo Secure `Set-Cookie` .	`false`
cookie.httponly	Especifica el valor booleano para el atributo httponly `Set-Cookie` .	`true`
Cookie.path	Especifica el valor para el atributo `Set-Cookie` de ruta .	`/`
cookie.domain	Especifica el valor para el atributo de conjunto de dominio `Set-Cookie` .	desacio
cookie.samesite	Especifica el valor para el atributo samsite `Set-Cookie` .	desacio
cookie.maxage	(en segundos) Especifica el valor para el atributo `Set-Cookie` máximo .	unset (sesión del navegador)

conmovedor

El toque se refiere a la extensión de la vida útil de la sesión, tanto en el navegador (modificando el atributo Expires en el encabezado de cookie) y el almacén de sesión (utilizando su método respectivo) sobre el acceso. Esto evita que la sesión expire después de un tiempo.

En el modo autoCommit (que está habilitado de forma predeterminada), para la optimización, una sesión solo se toca, no se guarda, si no se modifica. El valor de touchAfter le permite omitir el toque si la sesión sigue siendo reciente, por lo tanto, disminuye la carga de la base de datos.

codificar/decodificar

Puede suministrar un par de funciones personalizado que codifique/decodifique o cifre/descifra la cookie en cada solicitud.

 // `express-session` signing strategy
const signature = require ( "cookie-signature" ) ;
const secret = "keyboard cat" ;
session ( {
  decode : ( raw ) => signature . unsign ( raw . slice ( 2 ) , secret ) ,
  encode : ( sid ) => ( sid ? "s:" + signature . sign ( sid , secret ) : null ) ,
} ) ;

API

objeto de sesión

Esto le permite establecer o obtener un valor específico que se asocie a la sesión actual.

 //  Set a value
if ( loggedIn ) session . user = "John Doe" ;
//  Get a value
const currentUser = session . user ; // "John Doe"

session.Touch ()

Extiende manualmente el vencimiento de la sesión por Maxage. Nota: aún debe llamar a session.commit () si autoCommit = false .

 session . touch ( ) ;

Si touchAfter se establece con un valor no negativo, esto se llamará automáticamente en consecuencia.

session.destroy ()

Destruya a la sesión actual y retírela del almacén de sesiones.

 if ( loggedOut ) await session . destroy ( ) ;

session.commit ()

Guarde la sesión y establezca encabezados necesarios. Promesa de regreso. Debe llamarse antes de enviar los encabezados ( res.writeHead ) o respuesta ( res.send , res.end , etc.) .

Debe llamar a esto si autoCommit está configurado en false .

 session . hello = "world" ;
await session . commit ( ) ;
// always calling res.end or res.writeHead after the above

session.id

La identificación única que se asocia a la sesión actual.

Tienda de sesiones

El almacén de sesión para usar para el middleware de sesión (ver options anteriores).

Implementación

Una tienda de sesión compatible debe incluir tres funciones: set(sid, session) , get(sid) y destroy(sid) . Se recomienda la función touch(sid, session) . Todas las funciones deben devolver promesas .

Consulte MemoryStore.

TypeScript: el tipo SessionStore se puede utilizar para ayudar a la implementación:

 import type { SessionStore } from "next-session" ;

class CustomStore implements SessionStore { }

Compatibilidad con tiendas Express/Connect

Promisificar funciones

Para usar las tiendas Express/Connect, debe promisificar los métodos get , set , destroy y (If Existe) touch , posiblemente usando util.promisify .

Incluimos el Util promisifyStore en next-session/lib/compat para hacer exactamente eso:

 import nextSession from "next-session" ;
import { promisifyStore } from "next-session/lib/compat" ;
import SomeConnectStore from "connect-xyz" ;

const connectStore = new SomeConnectStore ( ) ;

const getSession = nextSession ( {
  store : promisifyStore ( connectStore ) ,
} ) ;

Puede usar expressSession de next-session/lib/compat si la tienda Connect tiene el siguiente patrón.

 const session = require ( "express-session" ) ;
const RedisStore = require ( "connect-redis" ) ( session ) ;

// Use `expressSession` from `next-session/lib/compat` as the replacement

import nextSession from "next-session" ;
import { expressSession , promisifyStore } from "next-session/lib/compat" ;
import RedisStoreFactory from "connect-redis" ;
import Redis from "ioredis" ;

const RedisStore = RedisStoreFactory ( expressSession ) ;
export const getSession = nextSession ( {
  store : promisifyStore (
    new RedisStore ( {
      client : new Redis ( ) ,
    } )
  ) ,
} ) ;