Is it true, that ``createNewSession`` get's called before ``emailPasswordSignUpPOST`` upon registration? I wanted to store a user in the db using ``emailPasswordSignUpPOST`` and store the information in the session using ``createNewSession``. Weirdly, this illustrations tells the opposite behaviour I am having: https://supertokens.com/docs/thirdpartyemailpassword/architecture

CreateNewSession gets called inside emailPasswordSignUpPOST function

never mind, I just overlooked it. 👍 Thanks for your help

hey!

I am confused. Above you told me, that I should use the ``signUp`` for inserting the user. (click on the response link above to see what I mean)

well.. you get access to the request object in the API override. So you can read the form field in that, and save it in the context object (https://supertokens.com/docs/thirdpartyemailpassword/advanced-customizations/user-context) and then you can access it in the

signUp

recipe function override.

Like this?

javascript
export const backendConfig = (): TypeInput => {
  return {
    framework: "express",
    supertokens: {
      connectionURI: "<REDACTED>",
      apiKey: process.env.SUPERTOKENS_API_KEY,
    },
    appInfo,
    recipeList: [
      ThirdPartyEmailPasswordNode.init({
        providers: [
          // We have provided you with development keys which you can use for testsing.
          // IMPORTANT: Please replace them with your own OAuth keys for production use.
          ThirdPartyEmailPasswordNode.Google({
            clientId:
              "<REDACTED>",
            clientSecret: "<REDACTED></REDACTED>",
          }),
        ],
        signUpFeature: {
          formFields: [
            {
              id: "username",
            },
          ],
        },
        override: {
          functions: (originalImplementation) => {
            return {
              ...originalImplementation,
              emailPasswordSignUp(input) {
                const usernameFromContext = input.userContext.username;
                console.log("usernameFromContext", usernameFromContext);

                return originalImplementation.emailPasswordSignUp(input);
              },
            };
          },
          apis: (originalImplementation) => {
            return {
              ...originalImplementation,
              emailPasswordSignUpPOST: async function (input) {
                if (
                  originalImplementation.emailPasswordSignUpPOST === undefined
                ) {
                  throw Error("Should never come here");
                }

                // First we call the original implementation
                let response =
                  await originalImplementation.emailPasswordSignUpPOST(input);

                // If sign up was successful
                if (response.status === "OK") {
                  // We can get the form fields from the input like this
                  let formFields = input.formFields;
                  let user = response.user;

                  console.log(formFields);

                  const fieldUsername = formFields.find(
                    (field) => field.id === "username"
                  );

                  input.userContext.username = fieldUsername?.value;
                }

                return response;
              },
            };
          },
        },
      }),
      SessionNode.init({
        override: {
          functions: (originalImplementation) => {
            return {
              ...originalImplementation,
              createNewSession: async function (input) {
                let userId = input.userId;

                console.log(input.userContext);

                const username = "todo";

                // This goes in the access token, and is availble to read on the frontend.
                input.accessTokenPayload = {
                  ...input.accessTokenPayload,
                  username: username,
                };

                // This is stored in the db against the sessionHandle for this session
                input.sessionData = {
                  ...input.sessionData,
                  username: username,
                };

                const session = originalImplementation.createNewSession(input);
                console.log(`user ${userId} created a new session`);

                return session;
              },
            };
          },
        },
      }),
    ],
    isInServerlessEnv: true,
  };
};

Context in ``emailPasswordSignUp`` still seems to be undefined.

usernameFromContext undefined
{}
user 92c11c44-308d-4ef9-b504-35f19d43a1ff created a new session
[
  { id: 'email', value: 'manicraft27@gmail.com' },
  { id: 'password', value: 'sml12345' },
  { id: 'username', value: 'Mani27' }
]

I also can't find an example in the documentation, even tho this is a common customisation.

You need to modify input.userContext before calling the originalImplementation

ok thanks, I'll try it 👌