@turnkey/react-wallet-kit/dist/utils/oauth/completion.mjs

The easiest and most powerful way to integrate Turnkey's Embedded Wallets into your React applications.

import { asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, objectSpread2 as _objectSpread2 } from '../../_virtual/_rollupPluginBabelHelpers.mjs';
import { TurnkeyError, TurnkeyErrorCodes } from '@turnkey/sdk-types';
import { consumePKCEVerifier } from './storage.mjs';
import { OAUTH_PROVIDER_CONFIGS } from './config.mjs';

/**
 * Unified OAuth completion handler.
 * Routes to the appropriate completion handler based on params:
 * Priority: onAddProvider > onOauthSuccess > callbacks.onOauthRedirect > completeOauth
 *
 * This is the core completion logic used by both popup and redirect flows.
 */
function completeOAuthFlow(_x) {
  return _completeOAuthFlow.apply(this, arguments);
}
/**
 * Completes OAuth flow in popup - handles both PKCE and non-PKCE providers
 */
function _completeOAuthFlow() {
  _completeOAuthFlow = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(params) {
    var provider, publicKey, oidcToken, sessionKey, callbacks, completeOauth, onOauthSuccess, onAddProvider;
    return _regenerator().w(function (_context) {
      while (1) switch (_context.n) {
        case 0:
          provider = params.provider, publicKey = params.publicKey, oidcToken = params.oidcToken, sessionKey = params.sessionKey, callbacks = params.callbacks, completeOauth = params.completeOauth, onOauthSuccess = params.onOauthSuccess, onAddProvider = params.onAddProvider;
          if (!onAddProvider) {
            _context.n = 2;
            break;
          }
          _context.n = 1;
          return onAddProvider(oidcToken);
        case 1:
          _context.n = 5;
          break;
        case 2:
          if (!onOauthSuccess) {
            _context.n = 3;
            break;
          }
          onOauthSuccess(_objectSpread2({
            publicKey: publicKey,
            oidcToken: oidcToken,
            providerName: provider
          }, sessionKey && {
            sessionKey: sessionKey
          }));
          _context.n = 5;
          break;
        case 3:
          if (!(callbacks !== null && callbacks !== void 0 && callbacks.onOauthRedirect)) {
            _context.n = 4;
            break;
          }
          callbacks.onOauthRedirect(_objectSpread2({
            idToken: oidcToken,
            publicKey: publicKey
          }, sessionKey && {
            sessionKey: sessionKey
          }));
          _context.n = 5;
          break;
        case 4:
          _context.n = 5;
          return completeOauth(_objectSpread2({
            oidcToken: oidcToken,
            publicKey: publicKey,
            providerName: provider
          }, sessionKey && {
            sessionKey: sessionKey
          }));
        case 5:
          return _context.a(2);
      }
    }, _callee);
  }));
  return _completeOAuthFlow.apply(this, arguments);
}
function completeOAuthPopup(_x2) {
  return _completeOAuthPopup.apply(this, arguments);
}
/**
 * Unified PKCE flow handler for all PKCE-based OAuth providers.
 * Handles the complete PKCE flow: verifier retrieval, token exchange, and completion routing.
 *
 * This function abstracts the common logic shared between popup and redirect flows
 * for Facebook, Discord, and Twitter/X.
 *
 * @param params - The PKCE flow parameters
 * @returns A promise that resolves when the flow is complete
 */
function _completeOAuthPopup() {
  _completeOAuthPopup = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(params) {
    var provider, publicKey, result, callbacks, completeOauth, onOauthSuccess, exchangeCodeForToken, config;
    return _regenerator().w(function (_context2) {
      while (1) switch (_context2.n) {
        case 0:
          provider = params.provider, publicKey = params.publicKey, result = params.result, callbacks = params.callbacks, completeOauth = params.completeOauth, onOauthSuccess = params.onOauthSuccess, exchangeCodeForToken = params.exchangeCodeForToken;
          config = OAUTH_PROVIDER_CONFIGS[provider];
          if (!config.usesPKCE) {
            _context2.n = 3;
            break;
          }
          if (exchangeCodeForToken) {
            _context2.n = 1;
            break;
          }
          throw new TurnkeyError("exchangeCodeForToken is required for PKCE providers", TurnkeyErrorCodes.INTERNAL_ERROR);
        case 1:
          _context2.n = 2;
          return completePKCEFlow({
            publicKey: publicKey,
            providerName: provider,
            sessionKey: result.sessionKey,
            callbacks: callbacks,
            completeOauth: completeOauth,
            onOauthSuccess: onOauthSuccess,
            exchangeCodeForToken: exchangeCodeForToken
          });
        case 2:
          _context2.n = 4;
          break;
        case 3:
          _context2.n = 4;
          return completeOAuthFlow({
            provider: provider,
            publicKey: publicKey,
            oidcToken: result.idToken,
            sessionKey: result.sessionKey,
            callbacks: callbacks,
            completeOauth: completeOauth,
            onOauthSuccess: onOauthSuccess
          });
        case 4:
          return _context2.a(2);
      }
    }, _callee2);
  }));
  return _completeOAuthPopup.apply(this, arguments);
}
function completePKCEFlow(_x3) {
  return _completePKCEFlow.apply(this, arguments);
}
function _completePKCEFlow() {
  _completePKCEFlow = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(_ref) {
    var publicKey, providerName, sessionKey, callbacks, completeOauth, onOauthSuccess, onAddProvider, exchangeCodeForToken, verifier, oidcToken;
    return _regenerator().w(function (_context3) {
      while (1) switch (_context3.n) {
        case 0:
          publicKey = _ref.publicKey, providerName = _ref.providerName, sessionKey = _ref.sessionKey, callbacks = _ref.callbacks, completeOauth = _ref.completeOauth, onOauthSuccess = _ref.onOauthSuccess, onAddProvider = _ref.onAddProvider, exchangeCodeForToken = _ref.exchangeCodeForToken;
          // Consume the verifier (retrieves and removes from storage)
          verifier = consumePKCEVerifier(providerName); // Exchange the code for an OIDC token using the provider-specific function
          _context3.n = 1;
          return exchangeCodeForToken(verifier);
        case 1:
          oidcToken = _context3.v;
          _context3.n = 2;
          return completeOAuthFlow({
            provider: providerName,
            publicKey: publicKey,
            oidcToken: oidcToken,
            sessionKey: sessionKey,
            callbacks: callbacks,
            completeOauth: completeOauth,
            onOauthSuccess: onOauthSuccess,
            onAddProvider: onAddProvider
          });
        case 2:
          return _context3.a(2);
      }
    }, _callee3);
  }));
  return _completePKCEFlow.apply(this, arguments);
}

export { completeOAuthFlow, completeOAuthPopup, completePKCEFlow };
//# sourceMappingURL=completion.mjs.map