Download next session - Download do código -fonte next session

próxima sessão

Middleware de sessão baseado em promessa leve para o próximo.js. Também funciona no servidor HTTP Micro ou Node.js, Express e muito mais.

Confira também alternativas como a sessão do próximo ferro. Dê uma olhada no NextJS-MongoDB-App para ver este módulo em uso.

Instalação

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

Uso

Atualização de v1.x para v2.x? Por favor, leia as notas de lançamento aqui!

Atualização de v2.x para v3.x? Por favor, leia as notas de lançamento aqui!

Atualização de v3.x para v4.x? Por favor, leia as notas de lançamento aqui!

Aviso do armazenamento de sessões padrão (se options?.store é undefined ), MemoryStore , não funciona no ambiente de produção ou sem servidor. Você deve usar uma loja de sessões.

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

Rotas de 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).`
  ) ;
}

O uso em rotas de API pode resultar na API resolved without sending a response . Isso pode ser resolvido adicionando:

 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 ,
  } ,
} ;

... ou options.autoCommit false configuração await session.commit()

 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 ,
    } ,
  } ;
}

Outros

expresso, próximo conexão

 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).`
  ) ;
} ) ;

Micro, funções sem servidor 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).`
  ) ;
} ;

Node.js HTTP Server

 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 ) ;

Opções

next-session aceita as propriedades abaixo.

opções	descrição	padrão
nome	O nome do cookie a ser lido da solicitação e definido para a resposta.	`sid`
loja	A instância da loja da sessão a ser usada. Necessário para trabalhar em produção!	`MemoryStore`
Genid	A função que gera uma string para um novo ID da sessão.	`nanoid`
codificar	Transforma o ID da sessão antes de definir o cookie. Ele pega o ID da sessão bruta e retorna o ID da sessão decodificado/descriptografado.	indefinido
decodificar	Transforma o ID da sessão de volta ao chegar de Cookie. Deve retornar o ID da sessão codificado/criptografado	indefinido
Touchafter	Toque apenas após um período de tempo (em segundos) desde o último acesso. Desativado por padrão ou se definido como `-1` . Veja Touchafter.	`-1` (desativado)
AutoComit	Comprometra sessão automaticamente. Desative isso se você quiser `session.commit()`	`true`
Cookie.Secure	Especifica o valor booleano para o atributo Secure `Set-Cookie` .	`false`
Cookie.httponly	Especifica o valor booleano para o atributo httponly `Set-Cookie` .	`true`
Cookie.Path	Especifica o valor para o atributo CATH `Set-Cookie` .	`/`
Cookie.Domain	Especifica o valor para o atributo DOMAIN `Set-Cookie` .	desmembrado
Cookie.samesite	Especifica o valor para o atributo Samesite `Set-Cookie` .	desmembrado
Cookie.maxage	(em segundos) especifica o valor para o atributo `Set-Cookie` máximo .	Unset (sessão do navegador)

Touchafter

O toque refere-se à extensão da vida útil da sessão, tanto no navegador (modificando o atributo Expires no cabeçalho do conjunto de cookie) quanto no armazenamento de sessões (usando seu respectivo método) após o acesso. Isso impede que a sessão expire depois de um tempo.

No modo autoCommit (que é ativado por padrão), para otimização, uma sessão é tocada apenas, não salva, se não for modificada. O valor do touchAfter permite pular o toque se a sessão ainda for recente, diminuindo a carga do banco de dados.

codificar/decodificar

Você pode fornecer um par de funções personalizado que codifique/decodifique ou criptografa/descriptografar o cookie em todas as solicitações.

 // `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 sessão

Isso permite que você defina ou obtenha um valor específico que se associa à sessão atual.

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

session.Touch ()

Estende manualmente a expiração da sessão pela Maxage. NOTA: Você ainda deve ligar para session.Commit () se autoCommit = false .

 session . touch ( ) ;

Se touchAfter for definido com um valor não negativo, isso será chamado automaticamente de acordo.

session.Destroy ()

Destrua para a sessão atual e remova -a da loja de sessões.

 if ( loggedOut ) await session . destroy ( ) ;

session.Commit ()

Salve a sessão e defina cabeçalhos necessários. Promessa de retorno. Ele deve ser chamado antes de enviar os cabeçalhos ( res.writeHead ) ou resposta ( res.send , res.end , etc.) .

Você deve chamar isso se autoCommit estiver definido como false .

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

session.id

O ID exclusivo que se associa à sessão atual.

Loja de sessões

O armazenamento de sessão para usar no middleware da sessão (veja options acima).

Implementação

Um armazenamento de sessão compatível deve incluir três funções: set(sid, session) , get(sid) e destroy(sid) . O touch(sid, session) é recomendado. Todas as funções devem retornar promessas .

Consulte a MemoryStore.

TypeScript: O tipo SessionStore pode ser usado para ajudar a implementação:

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

class CustomStore implements SessionStore { }

Compatibilidade com lojas Express/Connect

Promisificar funções

Para usar as lojas Express/Connect, você deve promissificar, get , set , destroy e (se existir) métodos touch , possivelmente usando util.promisify .

Incluímos o Util promisifyStore na next-session/lib/compat para fazer exatamente isso:

 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 ) ,
} ) ;

Você pode usar expressSession do next-session/lib/compat se o armazenamento do Connect tiver o seguinte padrão.

 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 ( ) ,
    } )
  ) ,
} ) ;