Installation

npm install sveltekit-session

sveltekit-session offers first class support for redis as a session store. In order to use redis, you need to install ioredis.

npm install sveltekit-session ioredis

Quickstart

1. Create an instance of SessionManager. This example uses the built-in RedisStore.

   /src/lib/server/session.ts

   import { SessionManager } from 'sveltekit-session';
   import RedisStore from 'sveltekit-session/redis';
   import Redis from 'ioredis';
   
   const redisClient = new Redis({ port: 6379, host: 'localhost' });
   
   const redisStore = new RedisStore(redisClient); // pass in the redisClient
   
   //new SessionManager(sessionOptions: SessionOptions, store: Store, cookieOptions?: CookieOptions)
   export const sessionManager = new SessionManager({ ttl: 60 * 60 * 24 * 7, refreshSession: true }, redisStore, { path: '/' });

   See SessionManager Options for more information.

2. Add the handle hook in /src/hooks.server.ts.

   import type { Handle } from '@sveltejs/kit';
   import { sequence } from '@sveltejs/kit/hooks';
   import { handleSession } from 'sveltekit-session';
   import { sessionManager } from '$lib/server/session';
   
   // your handle hook
   export const myHandle = (async ({ event, resolve }) => {
   	const session = event.locals.session; // session data is ready to be accessed
   	const response = await resolve(event);
   	return response;
   }) satisfies Handle;
   
   export const handle = sequence(handleSession(sessionManager), myHandle); // make sure to add handleSession before any other hooks that make use of the session

   Check out the SvelteKit docs on sequence.

3. Using SvelteKit-Session is then as simple as this.

   import { sessionManager } from '$lib/server/session';
   
   export const load = async (event) => {
   	// check if session exists
   	if (!event.locals.session) {
   		throw error(401, 'Not logged in');
   	}
   
   	// create session
   	await sessionManager.createSession({ username: 'foo' }, event);
   
   	// use session
   	request.locals.session.email = '[email protected]';
   
   	// destroy session
   	request.locals.session.destroy();
   
   	// get a list of all sessionIds
   	await sessionManager.listSessions();
   
   	// remove specific sessionId from store
   	// THIS WILL NOT DELETE THE COOKIE. USE session.destroy() INSTEAD
   	await sessionManager.deleteSession(sessionId);
   
   	// remove all sessionIds from store
   	await sessionManager.deleteAllSessions();
   };

Typing your session

Import the Session type and add it to the App.Locals interface, then pass your type to the Session type.

/src/app.d.ts

type MySessionData = {
	username: string;
	email?: string;
};

declare namespace App {
	interface Locals {
		session?: import('sveltekit-session').Session<MySessionData>;
	}
}

Custom stores

Custom stores can be easily created by implementing the Store interface.

Check out the RedisStore for an example.

interface Store {
	set(key: string, value: any, ttl?: number): Promise<void>;
	get(key: string): Promise<unknown>;
	update(key: string, value: any, ttl?: number): Promise<void>;
	delete(key: string): Promise<void>;
	clear(): Promise<void>;
	keys(): Promise<string[]>;
}

SessionManager options

type SessionOptions = {
	/**
	 * Number of seconds until the session expires.
	 */
	ttl: number;
	/** @defaultValue `true`
	 * If true, the session will be refreshed on every request.
	 */
	refreshSession?: boolean;
	/** @defaultValue `sessionId`
	 * The name of the session cookie
	 */
	name?: string;
};

type CookieOptions = Omit<CookieSerializeOptions, 'expires' | 'maxAge'>; // expires and maxAge are automatically set based on the ttl
// Take a look at the @types/cookie package for more information on CookieSerializeOptions
// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/cookie/index.d.ts#L14