react-native-gigya-sdk/lib/module/core/handleAuthenticationError.js

SAP CDC/Gigya SDK for your React Native applications

import { GigyaSdkErrors, GigyaSdkErrorCodes } from '../types';
import getState from './getState';
import setSession from './setSession';
import isGigyaError from './isGigyaError';
import getAccountInfo from './getAccountInfo';
import finalizeRegistration from './finalizeRegistration';
import acceptConsentSchemas from './acceptConsentSchemas';
import clearErrorState from '../internals/clearErrorState';
import getConflictingAccount from './getConflictingAccount';
import resendVerificationEmail from './resendVerificationEmail';
import getUnacceptedConsentSchemas from './getUnacceptedConsentSchemas';
import saveAuthenticationAttempt from '../internals/saveAuthenticationAttempt';

const handleExpiredRegToken = error => new Promise(async resolve => {
  resolve({
    handled: true,
    regTokenExpired: true,
    error
  });
});

const handlePendingVerification = error => new Promise(async resolve => {
  await resendVerificationEmail({
    noUID: true
  });
  resolve({
    actionRequired: {
      type: 'emailVerification'
    },
    handled: true,
    error
  });
});

const handleConflictingAccount = error => new Promise(async resolve => {
  try {
    var _error$payload;

    const conflictingAccount = error !== null && error !== void 0 && (_error$payload = error.payload) !== null && _error$payload !== void 0 && _error$payload.loginProviders ? error.payload : await getConflictingAccount();
    resolve({
      error,
      handled: true,
      actionRequired: {
        type: 'conflictingAccount',
        loginId: conflictingAccount === null || conflictingAccount === void 0 ? void 0 : conflictingAccount.loginID,
        loginProviders: conflictingAccount === null || conflictingAccount === void 0 ? void 0 : conflictingAccount.loginProviders
      }
    });
  } catch (e) {
    resolve({
      error,
      handled: true,
      actionRequired: {
        type: 'conflictingAccount'
      }
    });
  }
});

const onConsentSchemasAcceptance = options => new Promise(async (resolve, reject) => {
  try {
    const unacceptedConsentSchemas = await getUnacceptedConsentSchemas();

    if (unacceptedConsentSchemas) {
      await acceptConsentSchemas(unacceptedConsentSchemas, {
        noUID: true
      });
    }

    const account = await getAccountInfo({
      noUID: true
    });

    if (!account.isVerified) {
      const state = await getState();
      const output = await handlePendingVerification(state.error);
      return resolve(output);
    }

    if (!account.isRegistered && !(options !== null && options !== void 0 && options.noFinalize)) {
      const response = await finalizeRegistration(options);

      if (!(options !== null && options !== void 0 && options.noSetSession)) {
        try {
          await setSession(response.sessionInfo.sessionToken, response.sessionInfo.sessionSecret);
        } catch (e) {}
      }

      await clearErrorState();
      return resolve({
        handled: true,
        account: response
      });
    }

    await clearErrorState();
    resolve({
      handled: true,
      account
    });
  } catch (e) {
    reject(e);
  }
});

const handlePendingRegistration = (error, options) => new Promise(async (resolve, reject) => {
  try {
    const unacceptedConsentSchemas = await getUnacceptedConsentSchemas();

    if (unacceptedConsentSchemas !== null && unacceptedConsentSchemas !== void 0 && unacceptedConsentSchemas.length) {
      if (options !== null && options !== void 0 && options.isRegistration) {
        const output = await onConsentSchemasAcceptance(options);
        return resolve(output);
      }

      return resolve({
        handled: true,
        actionRequired: {
          type: 'acceptToS',
          callback: onConsentSchemasAcceptance
        },
        error
      });
    }

    const account = await getAccountInfo({
      noUID: true
    });

    if (!account.isVerified) {
      const output = await handlePendingVerification(error);
      return resolve(output);
    }

    if (!account.isRegistered && !(options !== null && options !== void 0 && options.noFinalize)) {
      const response = await finalizeRegistration(options);

      if (!(options !== null && options !== void 0 && options.noSetSession)) {
        try {
          await setSession(response.sessionInfo.sessionToken, response.sessionInfo.sessionSecret);
        } catch (e) {}
      }

      resolve({
        handled: true,
        account: response
      });
      await clearErrorState();
    }

    resolve({
      handled: false,
      error
    });
  } catch (e) {
    reject(e);
  }
});

export default function (type, options) {
  return new Promise(async (resolve, reject) => {
    var _error$payload4;

    try {
      var _state$regToken, _error$payload2, _error$payload3, _error$payload3$valid;

      const state = await getState();
      const error = (options === null || options === void 0 ? void 0 : options.error) || state.error;
      let output = {
        handled: false,
        error
      };

      if (error && (await isGigyaError(error))) {
        await saveAuthenticationAttempt(type, error);
      } else {
        return resolve(output);
      }

      if (!((_state$regToken = state.regToken) !== null && _state$regToken !== void 0 && _state$regToken.isStillValid)) {
        output = await handleExpiredRegToken(error);
        return resolve(output);
      }

      if ((error === null || error === void 0 ? void 0 : (_error$payload2 = error.payload) === null || _error$payload2 === void 0 ? void 0 : _error$payload2.errorCode) !== GigyaSdkErrorCodes.ConflictingAccount && (error === null || error === void 0 ? void 0 : error.code) === GigyaSdkErrors.ConflictingAccount) {
        output = await handleConflictingAccount(error);
        return resolve(output);
      }

      if (error !== null && error !== void 0 && (_error$payload3 = error.payload) !== null && _error$payload3 !== void 0 && (_error$payload3$valid = _error$payload3.validationErrors) !== null && _error$payload3$valid !== void 0 && _error$payload3$valid.filter(validationError => validationError.fieldName === 'email')) {
        output = await handleConflictingAccount(error);
        return resolve(output);
      }

      switch (error === null || error === void 0 ? void 0 : (_error$payload4 = error.payload) === null || _error$payload4 === void 0 ? void 0 : _error$payload4.errorCode) {
        case GigyaSdkErrorCodes.PendingRegistration:
          output = await handlePendingRegistration(error, options);
          break;

        case GigyaSdkErrorCodes.PendingVerification:
          output = await handlePendingVerification(error);
          break;

        case GigyaSdkErrorCodes.ConflictingAccount:
          output = await handleConflictingAccount(error);
          break;

        default:
          break;
      }

      resolve(output);
    } catch (err) {
      reject(err);
    }
  });
}
//# sourceMappingURL=handleAuthenticationError.js.map