Which frontend SDK do you use?

supertokens-web-js / mobile

supertokens-auth-react

How to use

Use the override config

NodeJS

info

See all the functions that can be overrided here

import SuperTokens from "supertokens-node";
import Passwordless from "supertokens-node/recipe/passwordless";

SuperTokens.init({
    appInfo: {
        apiDomain: "...",
        appName: "...",
        websiteDomain: "..."
    },
    recipeList: [
        Passwordless.init({
            contactMethod: "EMAIL", // This example will work with any contactMethod
            flowType: "USER_INPUT_CODE_AND_MAGIC_LINK", // This example will work with any flow.

            override: {
                functions: (originalImplementation) => {
                    return {
                        ...originalImplementation,

                        // here we are only overriding the function that's responsible
                        // for signing in / up a user.
                        consumeCode: async function (input) {
                            // TODO: some custom logic

                            // or call the default behaviour as show below
                            return await originalImplementation.consumeCode(input);
                        },
                        // ...
                        // TODO: override more functions
                    };
                },
            }
        })
    ]
});

• originalImplementation is an object that contain functions that have the original implementation for this recipe. They can be used in your functions as a way to use the SuperTokens' default behaviour.
• In the above code snippet, we override the consumeCode function of this recipe. This function will be used to handle the scenario when the user enters an OTP or clicks on a magic link.

GoLang

info

See all the functions that can be overrided here

import (
    "github.com/supertokens/supertokens-golang/recipe/passwordless"
    "github.com/supertokens/supertokens-golang/recipe/passwordless/plessmodels"
    "github.com/supertokens/supertokens-golang/supertokens"
)

func main() {
    supertokens.Init(supertokens.TypeInput{
        RecipeList: []supertokens.Recipe{
            passwordless.Init(plessmodels.TypeInput{
                Override: &plessmodels.OverrideStruct{
                    Functions: func(originalImplementation plessmodels.RecipeInterface) plessmodels.RecipeInterface {
                        //First we copy the original impl func
                        originalConsumeCode := *originalImplementation.ConsumeCode

                        // Then we override the functions we want to
                        (*originalImplementation.ConsumeCode) = func(userInput *plessmodels.UserInputCodeWithDeviceID, linkCode *string, preAuthSessionID string, userContext supertokens.UserContext) (plessmodels.ConsumeCodeResponse, error) {
                            // TODO: some custom logic

                            // or call the default behaviour as show below
                            return originalConsumeCode(userInput, linkCode, preAuthSessionID, userContext)
                        }

                        // TODO: Override more functions

                        return originalImplementation
                    },
                },
            }),
        },
    })
}

• originalImplementation is an object that contain functions that have the original implementation for this recipe. They can be used in your functions as a way to use the SuperTokens' default behaviour.
• In the above code snippet, we override the ConsumeCode function of this recipe. This function will be used to handle the scenario when the user enters an OTP or clicks on a magic link.

Python

info

See all the functions that can be overrided here

from supertokens_python import init, InputAppInfo
from supertokens_python.recipe import passwordless
from supertokens_python.recipe.passwordless.interfaces import ConsumeCodeOkResult, ConsumeCodeIncorrectUserInputCodeError, ConsumeCodeExpiredUserInputCodeError, ConsumeCodeRestartFlowError
from supertokens_python.recipe.passwordless.interfaces import RecipeInterface
from typing import Union, Dict, Any

def override_passwordless_functions(original_implementation: RecipeInterface):
    original_consume_code = original_implementation.consume_code
    async def consume_code(pre_auth_session_id: str,
                           user_input_code: Union[str, None],
                           device_id: Union[str, None],
                           link_code: Union[str, None],
                           user_context: Dict[str, Any]) -> Union[ConsumeCodeOkResult, ConsumeCodeIncorrectUserInputCodeError, ConsumeCodeExpiredUserInputCodeError, ConsumeCodeRestartFlowError]:
        # TODO: some custom logic
        
        # or call the default behaviour as show below
        return await original_consume_code(pre_auth_session_id, user_input_code, device_id, link_code, user_context)
    
    original_implementation.consume_code = consume_code
    return original_implementation

init(
    app_info=InputAppInfo(api_domain="...", app_name="...", website_domain="..."),
    
    framework='...', 
    recipe_list=[
        passwordless.init(
            contact_config=..., 
            flow_type="...", 
            override=passwordless.InputOverrideConfig(
                functions=override_passwordless_functions
            )
        )
    ]
)

• original_implementation is an object that contain functions that have the original implementation for this recipe. They can be used in your functions as a way to use the SuperTokens' default behaviour.
• In the above code snippet, we override the consume_code function of this recipe. This function will be used to handle the scenario when the user enters an OTP or clicks on a magic link.