Which frontend SDK do you use?

supertokens-web-js / mobile

supertokens-auth-react

Update Session Data

Method 1) After session verification

NodeJS

Express

import express from "express";
import { verifySession } from "supertokens-node/recipe/session/framework/express";
import { SessionRequest } from "supertokens-node/framework/express";

let app = express();

app.post("/updateinfo", verifySession(), async (req: SessionRequest, res) => {

    let session = req.session;

    let currSessionData = session!.getSessionData();

    await session!.updateSessionData(
        { newKey: "newValue", ...currSessionData }
    );

    res.json({ message: "successfully updated Session data in the database" })
});

Hapi

import Hapi from "@hapi/hapi";
import { verifySession } from "supertokens-node/recipe/session/framework/hapi";
import { SessionRequest } from "supertokens-node/framework/hapi";

let server = Hapi.server({ port: 8000 });

server.route({
    path: "/updateinfo",
    method: "post",
    options: {
        pre: [
            {
                method: verifySession()
            },
        ],
    },
    handler: async (req: SessionRequest, res) => {
        let session = req.session;

        let currSessionData = session!.getSessionData();

        await session!.updateSessionData(
            { newKey: "newValue", ...currSessionData }
        );
        return res.response({ message: "successfully updated Session data in the database" }).code(200);
    }
})

Fastify

import Fastify from "fastify";
import { verifySession } from "supertokens-node/recipe/session/framework/fastify";
import { SessionRequest } from "supertokens-node/framework/fastify";

let fastify = Fastify();

fastify.post("/updateinfo", {
    preHandler: verifySession(),
}, async (req: SessionRequest, res) => {
    let session = req.session;

    let currSessionData = session!.getSessionData();

    await session!.updateSessionData(
        { newKey: "newValue", ...currSessionData }
    );
    res.send({ message: "successfully updated Session data in the database" });
});

Koa

import { verifySession } from "supertokens-node/recipe/session/framework/awsLambda";
import { SessionEvent } from "supertokens-node/framework/awsLambda";

async function updateinfo(awsEvent: SessionEvent) {
    let session = awsEvent.session;

    let currSessionData = session!.getSessionData();

    await session!.updateSessionData(
        { newKey: "newValue", ...currSessionData }
    );

    return {
        body: JSON.stringify({ message: "successfully updated Session data in the database" }),
        statusCode: 200,
    };
};

exports.handler = verifySession(updateinfo);

Loopback

import KoaRouter from "koa-router";
import { verifySession } from "supertokens-node/recipe/session/framework/koa";
import { SessionContext } from "supertokens-node/framework/koa";

let router = new KoaRouter();

router.post("/updateinfo", verifySession(), async (ctx: SessionContext, next) => {
    let session = ctx.session;

    let currSessionData = session!.getSessionData();

    await session!.updateSessionData(
        { newKey: "newValue", ...currSessionData }
    );
    ctx.body = { message: "successfully updated Session data in the database" };
});

AWS Lambda / Netlify

import { inject, intercept } from "@loopback/core";
import { RestBindings, post, response } from "@loopback/rest";
import { verifySession } from "supertokens-node/recipe/session/framework/loopback";
import { SessionContext } from "supertokens-node/framework/loopback";

class UpdateInfo {
    constructor(@inject(RestBindings.Http.CONTEXT) private ctx: SessionContext) { }
    @post("/updateinfo")
    @intercept(verifySession())
    @response(200)
    async handler() {
        let session = this.ctx.session;

        let currSessionData = session!.getSessionData();

        await session!.updateSessionData(
            { newKey: "newValue", ...currSessionData }
        );
        return { message: "successfully updated Session data in the database" };
    }
}

Next.js

import { superTokensNextWrapper } from 'supertokens-node/nextjs'
import { verifySession } from "supertokens-node/recipe/session/framework/express";
import { SessionRequest } from "supertokens-node/framework/express";

export default async function updateInfo(req: any, res: any) {
    await superTokensNextWrapper(
        async (next) => {
            await verifySession()(req, res, next);
        },
        req,
        res
    )
    let session = (req as SessionRequest).session;

    let currSessionData = session!.getSessionData();

    await session!.updateSessionData(
        { newKey: "newValue", ...currSessionData }
    );
    res.json({ message: "successfully updated access token payload" })
}

NestJS

import { Controller, Post, UseGuards, Request, Response, Session } from "@nestjs/common";
import { SessionContainer } from "supertokens-node/recipe/session";
import { AuthGuard } from './auth/auth.guard';

@Controller()
export class ExampleController {
  @Post('example')
  @UseGuards(new AuthGuard())
  async postExample(@Session() session: SessionContainer): Promise<{ message: string }> {
    const currAccessTokenPayload = session.getAccessTokenPayload();

    const currSessionData = session.getSessionData();

    // For more information about "AuthGuard" and the "Session" decorator please read our NestJS guide.
    await session.updateSessionData(
        {newKey: "newValue", ...currSessionData}
    );
    return {message: "successfully updated Session data in the database"};
  }
}

GoLang

import (
    "net/http"

    "github.com/supertokens/supertokens-golang/recipe/session"
    "github.com/supertokens/supertokens-golang/supertokens"
)

// We assume that you have wrapped this handler with session.VerifySession
func updateInfo(w http.ResponseWriter, r *http.Request) {
    // retrieve the session object as shown below
    sessionContainer := session.GetSessionFromRequestContext(r.Context())

    currSessionData, err := sessionContainer.GetSessionData()
    if err != nil {
        err = supertokens.ErrorHandler(err, r, w)
        if err != nil {
            // TODO: Send 500 to client
        }
        return
    }

    currSessionData["newKey"] = "newValue"

    err = sessionContainer.UpdateSessionData(currSessionData)
    if err != nil {
        err = supertokens.ErrorHandler(err, r, w)
        if err != nil {
            // TODO: Send 500 to client
        }
        return
    }
}

Python

FastAPI

from supertokens_python.recipe.session.framework.fastapi import verify_session
from supertokens_python.recipe.session import SessionContainer
from fastapi import Depends
from fastapi.responses import PlainTextResponse

@app.post('/update_info') 
async def update_info(session: SessionContainer = Depends(verify_session())):
    # retrieve the session object as shown below
    currSessionData = await session.get_session_data()

    currSessionData['newKey'] = 'newValue'

    await session.update_session_data(currSessionData)

    return PlainTextResponse(content='success')

Flask

from supertokens_python.recipe.session.framework.flask import verify_session
from supertokens_python.recipe.session import SessionContainer
from flask import g

@app.route('/update-jwt', methods=['POST']) 
@verify_session()
def update_info():
    session: SessionContainer = g.supertokens 

    # retrieve the session object as shown below
    currSessionData = session.get_access_token_payload()

    currSessionData['newKey'] = 'newValue'

    session.sync_update_session_data(currSessionData)

    return 'success'

Django

from supertokens_python.recipe.session.framework.django.asyncio import verify_session
from django.http import HttpRequest
from supertokens_python.recipe.session import SessionContainer

@verify_session()
async def update_info(request: HttpRequest):
    session: SessionContainer = request.supertokens 
    # retrieve the session object as shown below
    currSessionData = await session.get_session_data()

    currSessionData['newKey'] = 'newValue'

    await session.update_session_data(currSessionData)

• We first require session verification in order to get the session object
• Using that object, we call the updateSessionData with new content. This content completely overrides the existing object, that's why we first get the currSessionData info.
• The result is that the session data stored in the database (against the verified session) is updated. The change is instantly visible to other calls of getSessionData for this session.

Method 2) Without session verification

NodeJS

import Session from "supertokens-node/recipe/session";

async function updateSessionData() {
      let userId = "...";
      // we first get all the sessionHandles (string[]) for a user
      let sessionHandles = await Session.getAllSessionHandlesForUser(userId);

      // we update all the session's data for this user
      sessionHandles.forEach(async (handle) => {
            let currSessionInfo = await Session.getSessionInformation(handle)
            if (currSessionInfo === undefined) {
                  return;
            }
            let currSessionData = currSessionInfo.sessionData;

            await Session.updateSessionData(handle,
                  { newKey: "newValue", ...currSessionData }
            );
      })
}

GoLang

import "github.com/supertokens/supertokens-golang/recipe/session"

func main() {
    // we first get all the sessionHandles (string[]) for a user
    sessionHandles, err := session.GetAllSessionHandlesForUser("userId")
    if err != nil {
        // TODO: handle error
        return
    }

    // we update all the session's session data for this user
    for _, handle := range sessionHandles {
        sessionInfo, err := session.GetSessionInformation(handle)
        if err != nil {
            // TODO: handle error
            return
        }

        if sessionInfo == nil {
            continue
        }

        currSessionData := sessionInfo.SessionData
        currSessionData["newKey"] = "newValue"

        _, err = session.UpdateSessionData(handle, currSessionData)
        if err != nil {
            // TODO: handle error
            return
        }
    }
}

Python

Asyncio

from supertokens_python.recipe.session.asyncio import get_all_session_handles_for_user, update_session_data, get_session_information

async def some_func():
    # we first get all the session_handles (List[string]) for a user
    session_handles = await get_all_session_handles_for_user("userId")

    for handle in session_handles:
        session_information = await get_session_information(handle)
        if session_information is None:
            continue

        current_session_data = session_information.session_data

        current_session_data["newKey"] = "newValue"
        await update_session_data(handle, current_session_data)

Syncio

from supertokens_python.recipe.session.syncio import get_all_session_handles_for_user, update_session_data, get_session_information

# we first get all the session_handles (List[string]) for a user
session_handles = get_all_session_handles_for_user("userId")

for handle in session_handles:
    session_information = get_session_information(handle)
    if session_information is None:
        continue

    current_session_data = session_information.session_data

    current_session_data["newKey"] = "newValue"
    update_session_data(handle, current_session_data)