brazy-auth/core/lib/callback-handler.js

Authentication for Next.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = callbackHandler;
var _crypto = require("crypto");
var _utils = require("./utils");
async function callbackHandler(params) {
  const {
    sessionToken,
    profile,
    account,
    options
  } = params;
  if (!(account !== null && account !== void 0 && account.id) || !account.type) throw new Error("Missing or invalid provider account");
  if (!["email", "oauth", "openid"].includes(account.type)) throw new Error("Provider not supported");
  const {
    adapter,
    jwt,
    events,
    session: {
      strategy: sessionStrategy
    }
  } = options;

  if (!adapter) {
    return {
      user: profile,
      account,
      session: {}
    };
  }
  const {
    createUser,
    updateUser,
    getUser,
    getUserByAccount,
    getUserByEmail,
    linkAccount,
    createSession,
    getSessionAndUser,
    deleteSession,
    getAccountBySteamId
  } = adapter;
  let session = null;
  let user = null;
  let isNewUser = false;
  const useJwtSession = sessionStrategy === "jwt";
  console.log('sessionToken:', sessionToken);
  if (sessionToken) {
    console.log('useJwtSession:', useJwtSession);
    if (useJwtSession) {
      try {
        session = await jwt.decode({
          ...jwt,
          token: sessionToken
        });
        console.log("session:", session);
        if (session && "sub" in session && session.sub) {
          user = await getUser(session.sub);
          console.log("user", user);
        }
      } catch (_unused) {
        console.log("Error: Session not excists");
      }
    } else {
      console.log("getSessionAndUser:", sessionToken);
      const userAndSession = await getSessionAndUser(sessionToken);
      console.log("userAndSession:", userAndSession);
      if (userAndSession) {
        session = userAndSession.session;
        user = userAndSession.user;
        console.log("session:", session);
        console.log("user:", user);
      }
    }
  }
  if (account.type === "openid") {
    console.log("Callback handler for openid");
    const userByAccount = await getUserByAccount({
      steamId: account.id,
      provider: account.provider
    });
    let accountInstance;
    console.log("userByAccount:", userByAccount);
    if (!userByAccount) {
      var _events$createUser, _events$linkAccount;
      console.log("Create user", {
        ...profile,
        emailVerified: null
      });
      const newUser = {
        ...profile,
        emailVerified: null
      };
      delete newUser.id;
      user = await createUser(newUser);
      await ((_events$createUser = events.createUser) === null || _events$createUser === void 0 ? void 0 : _events$createUser.call(events, {
        user
      }));

      console.log("Create account:", {
        ...account,
        userId: user.id
      });
      const newAccount = await linkAccount({
        id: _crypto.randomUUID === null || _crypto.randomUUID === void 0 ? void 0 : (0, _crypto.randomUUID)(),
        type: account.type,
        provider: account.provider,
        steamId: account.id,
        name: profile.name,
        image: profile.image,
        userId: user.id
      });
      await ((_events$linkAccount = events.linkAccount) === null || _events$linkAccount === void 0 ? void 0 : _events$linkAccount.call(events, {
        user,
        account,
        profile
      }));
      console.log('new account?', newAccount);

      console.log("Create session:", newAccount);
      session = await createSession({
        sessionToken: generateSessionToken(),
        accountId: newAccount === null || newAccount === void 0 ? void 0 : newAccount.id,
        expires: (0, _utils.fromDate)(options.session.maxAge)
      });
      return {
        session,
        user,
        isNewUser: true,
        accountInstance: newAccount
      };
    } else {
      console.log("Get account");
      accountInstance = await getAccountBySteamId(account.id);
      console.log("Create session based on account:", accountInstance);
      session = await createSession({
        sessionToken: generateSessionToken(),
        accountId: accountInstance.id,
        expires: (0, _utils.fromDate)(options.session.maxAge)
      });
      return {
        session,
        user: userByAccount,
        isNewUser: false,
        accountInstance
      };
    }
  }
}
function generateSessionToken() {
  var _randomUUID;
  return (_randomUUID = _crypto.randomUUID === null || _crypto.randomUUID === void 0 ? void 0 : (0, _crypto.randomUUID)()) !== null && _randomUUID !== void 0 ? _randomUUID : (0, _crypto.randomBytes)(32).toString("hex");
}