EmailPassword.signIn

javascript
async login(payload: { email: string; password: string }) {
  const response = await EmailPassword.signIn({
    formFields: [
      {
        id: "email",
        value: payload.email,
      },
      {
        id: "password",
        value: payload.password,
      },
    ],
  });

  if (response.status === "OK") {
    const verification = await EmailVerification.isEmailVerified();

    if (!verification.isVerified) {
      await EmailVerification.sendVerificationEmail();
      throw Error("emailverification");
    } else {
      await this.verifyAuth();
    }
    return;
  }
  throw Error(response.status);
}

go
func (c *UserController) getUser(ctx *gin.Context) {
    session := session.GetSessionFromRequestContext(ctx.Request.Context())
    userID := uuid.MustParse(session.GetUserID())

    // Request the full user
    u, err := c.getFullUser(userID)
    if err != nil {
        NewError(ctx, err)
        return
    }

    ctx.JSON(http.StatusOK, u)
}

getFullUser(userID)

go
func OnlyAuthorized(options *sessmodels.VerifySessionOptions) gin.HandlerFunc {
    return func(c *gin.Context) {
        session.VerifySession(
            options,
            func(rw http.ResponseWriter, r *http.Request) {
                c.Request = c.Request.WithContext(r.Context())
                c.Next()
            },
        )(c.Writer, c.Request)
        // We call Abort so that the next handler in the chain is not called, unless we call Next explicitly
        c.Abort()
    }
}

ts
async register(payload: { email: string; password: string }) {
  const response = await EmailPassword.signUp({
    formFields: [
      {
        id: "email",
        value: payload.email,
      },
      {
        id: "password",
        value: payload.password,
      },
    ],
  });

  if (response.status === "OK") {
    await EmailVerification.sendVerificationEmail();
    return;
  }
  throw Error(response.status);
}

c.dataService.DB.User.Query().Where(user.ID(userID))

go
// Adding the SuperTokens middleware
r.Use(func(c *gin.Context) {
    supertokens.Middleware(
        http.HandlerFunc(
            func(rw http.ResponseWriter, r *http.Request) {
                c.Next()
            },
        ),
    ).ServeHTTP(c.Writer, c.Request)
    c.Abort()
})

emailpassword_users

this.verifyAuth()

ts
async verifyAuth() {
  if (await Session.doesSessionExist()) {
    if (!(await EmailVerification.isEmailVerified()).isVerified) {
      return false;
    }
    try {
      const resp = await axiosInstance.get<SuperTokenUserViewModel>(
        "/api/v1/user"
      );
      this.setUser(resp.data);
      return true;
    } catch (error) {
      if (axios.isAxiosError(error)) {
        if (error.code === "ERR_NETWORK") {
          this.setGlobalToast({
            detail: i18n.global.t(trans.NETWORK_PROBLEM_PLEASE_TRY_AGAIN),
            life: 3000,
            severity: "error",
          });
        }
      }
      return false;
    }
  }
  return false;
}

session_info