next session

session suivante

Middleware de session basé sur des promesses légères pour next.js. Fonctionne également dans Micro ou Node.js HTTP Server, Express, et plus encore.

Consultez également des alternatives comme la prochaine session. Jetez un œil à NextJS-MongoDB-App pour voir ce module utilisé.

Installation

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

Usage

Mise à niveau de v1.x à v2.x? Veuillez lire les notes de communication ici!

Mise à niveau de v2.x à v3.x? Veuillez lire les notes de communication ici!

Mise à niveau de v3.x à v4.x? Veuillez lire les notes de communication ici!

Avertissement Le magasin de session par défaut (IF options?.store undefined ), MemoryStore , ne fonctionne pas dans la production ou l'environnement sans serveur. Vous devez utiliser un magasin de session.

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

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

L'utilisation dans les routes d'API peut entraîner API resolved without sending a response . Cela peut être résolu en ajoutant:

 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 définir options.autoCommit sur false et 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 ,
    } ,
  } ;
}

Autres

Express, connexion suivante

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

Fonctions Micro, Vercel Serverless

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

Options

next-session accepte les propriétés ci-dessous.

options	description	défaut
nom	Le nom du cookie à lire à partir de la demande et défini sur la réponse.	sid
magasin	L'instance de magasin de session à utiliser. Requis pour travailler en production!	MemoryStore
génide	La fonction qui génère une chaîne pour un nouvel ID de session.	nanoid
encoder	Transforme l'ID de session avant de définir le cookie. Il prend l'ID de session RAW et renvoie l'ID de session décodé / décrypté.	indéfini
décoder	Transforme l'ID de session tout en obtenant du cookie. Il doit retourner l'ID de session codé / cryptée	indéfini
touche	Touchez seulement après un temps (en secondes) depuis le dernier accès. Désactivé par défaut ou s'il est défini sur -1 . Voir Touchafter.	-1 (désactivé)
autocommit	Commettre automatiquement la session. Désactivez ceci si vous voulez session.commit()	true
cookie.secure	Spécifie la valeur booléenne de l'attribut Secure Set-Cookie .	false
cookie.httponly	Spécifie la valeur booléenne pour l'attribut Set-Cookie httponly .	true
cookie.path	Spécifie la valeur de l'attribut Set-Cookie de chemin .	/
cookie.domain	Spécifie la valeur de l'attribut Set-Cookie de domaine .	décollé
cookie.samessite	Spécifie la valeur de l'attribut Same Set-Cookie .	décollé
cookie.maxage	(en quelques secondes) Spécifie la valeur de l'attribut Set-Cookie d'agence maximale .	Unset (session de navigateur)

touche

Le toucher fait référence à l'extension de la durée de vie de session, à la fois dans le navigateur (en modifiant l'attribut Expires dans l'en-tête Set-Cookie) et le magasin de session (en utilisant sa méthode respective) lors de l'accès. Cela empêche l'expiration de la session après un certain temps.

En mode autoCommit (qui est activé par défaut), pour l'optimisation, une session n'est touchée que, non enregistrée, si elle n'est pas modifiée. La valeur de touchAfter vous permet de sauter le toucher si la session est encore récente, ainsi, la charge de base de données décroissante.

Encoder / Decode

Vous pouvez fournir une paire de fonction personnalisée qui codent / décode ou crypter / décrypter le cookie à chaque demande.

 // `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

objet de session

Cela vous permet de définir ou d'obtenir une valeur spécifique qui s'associe à la session en cours.

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

session.touch ()

Étend manuellement l'expiration de la session par Maxage. Remarque: vous devez toujours appeler session.commit () si autoCommit = false .

 session . touch ( ) ;

Si touchAfter est défini avec une valeur non négative, cela sera automatiquement appelé en conséquence.

session.destroy ()

Détruisez à la session en cours et retirez-le du magasin de session.

 if ( loggedOut ) await session . destroy ( ) ;

session.commit ()

Enregistrez la session et définissez des en-têtes NECCESSARY. Retour Promise. Il doit être appelé avant d'envoyer les en-têtes ( res.writeHead ) ou la réponse ( res.send , res.end , etc.) .

Vous devez appeler cela si autoCommit est défini sur false .

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

session.id

L'ID unique qui s'associe à la session en cours.

Magasin de session

Le magasin de session à utiliser pour le middleware de session (voir options ci-dessus).

Mise en œuvre

Un magasin de session compatible doit inclure trois fonctions: set(sid, session) , get(sid) et destroy(sid) . La fonction touch(sid, session) est recommandée. Toutes les fonctions doivent retourner des promesses .

Reportez-vous à MemoryStore.

TypeScript: le type SessionStore peut être utilisé pour faciliter la mise en œuvre:

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

class CustomStore implements SessionStore { }

Compatibilité avec les magasins Express / Connect

Fonctions prometteuses

Pour utiliser les magasins Express / Connect, vous devez procéder des méthodes touch get , set , destroy et (si existe), à utiliser util.promisify .

Nous incluons l'Util promisifyStore dans next-session/lib/compat pour faire exactement cela:

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

Vous pouvez utiliser expressSession à partir de next-session/lib/compat si le magasin Connect a le modèle suivant.

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

Contributif

Veuillez consulter ma contribution.md.

Licence

Mit