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

SAP CDC/Gigya SDK for your React Native applications

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = _default;

var _types = require("../types");

var _getState = _interopRequireDefault(require("./getState"));

var _setSession = _interopRequireDefault(require("./setSession"));

var _isGigyaError = _interopRequireDefault(require("./isGigyaError"));

var _getAccountInfo = _interopRequireDefault(require("./getAccountInfo"));

var _finalizeRegistration = _interopRequireDefault(require("./finalizeRegistration"));

var _acceptConsentSchemas = _interopRequireDefault(require("./acceptConsentSchemas"));

var _clearErrorState = _interopRequireDefault(require("../internals/clearErrorState"));

var _getConflictingAccount = _interopRequireDefault(require("./getConflictingAccount"));

var _resendVerificationEmail = _interopRequireDefault(require("./resendVerificationEmail"));

var _getUnacceptedConsentSchemas = _interopRequireDefault(require("./getUnacceptedConsentSchemas"));

var _saveAuthenticationAttempt = _interopRequireDefault(require("../internals/saveAuthenticationAttempt"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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

const handlePendingVerification = error => new Promise(async resolve => {
  await (0, _resendVerificationEmail.default)({
    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 (0, _getConflictingAccount.default)();
    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 (0, _getUnacceptedConsentSchemas.default)();

    if (unacceptedConsentSchemas) {
      await (0, _acceptConsentSchemas.default)(unacceptedConsentSchemas, {
        noUID: true
      });
    }

    const account = await (0, _getAccountInfo.default)({
      noUID: true
    });

    if (!account.isVerified) {
      const state = await (0, _getState.default)();
      const output = await handlePendingVerification(state.error);
      return resolve(output);
    }

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

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

      await (0, _clearErrorState.default)();
      return resolve({
        handled: true,
        account: response
      });
    }

    await (0, _clearErrorState.default)();
    resolve({
      handled: true,
      account
    });
  } catch (e) {
    reject(e);
  }
});

const handlePendingRegistration = (error, options) => new Promise(async (resolve, reject) => {
  try {
    const unacceptedConsentSchemas = await (0, _getUnacceptedConsentSchemas.default)();

    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 (0, _getAccountInfo.default)({
      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 (0, _finalizeRegistration.default)(options);

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

      resolve({
        handled: true,
        account: response
      });
      await (0, _clearErrorState.default)();
    }

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

function _default(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 (0, _getState.default)();
      const error = (options === null || options === void 0 ? void 0 : options.error) || state.error;
      let output = {
        handled: false,
        error
      };

      if (error && (await (0, _isGigyaError.default)(error))) {
        await (0, _saveAuthenticationAttempt.default)(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) !== _types.GigyaSdkErrorCodes.ConflictingAccount && (error === null || error === void 0 ? void 0 : error.code) === _types.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 _types.GigyaSdkErrorCodes.PendingRegistration:
          output = await handlePendingRegistration(error, options);
          break;

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

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

        default:
          break;
      }

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