@nevis-security/nevis-mobile-authentication-sdk-react/lib/commonjs/operations/outOfBand/OutOfBandRegistration.js

React Native plugin for Nevis Mobile Authentication SDK. Supports only mobile.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.OutOfBandRegistrationImpl = exports.OutOfBandRegistration = void 0;
var _UserInteractionPlatformOperation = require("../../cache/operation/UserInteractionPlatformOperation");
var _PlatformOperationCache = require("../../cache/PlatformOperationCache");
var _OperationErrorConverter = require("../../error/operation/OperationErrorConverter");
var _NativeEventListener = require("../../event/NativeEventListener");
var _MobileAuthenticationSdk = _interopRequireDefault(require("../../MobileAuthenticationSdk"));
var _OutOfBandRegistrationMessage = require("../../model/messages/out/OutOfBandRegistrationMessage");
var _HttpOperation = require("../HttpOperation");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
/**
 * Copyright © 2023-2024 Nevis Security AG. All rights reserved.
 */

/**
 * The operation handling an out-of-band registration. This is the object returned by the SDK, when
 * an {@link OutOfBandPayload} was processed and the {@link OutOfBandPayload} corresponds to a
 * registration operation.
 *
 * Usage example:
 * ```ts
 *   class AuthenticatorSelectorImpl extends AuthenticatorSelector {
 *       async selectAuthenticator(
 *           context: AuthenticatorSelectionContext,
 *           handler: AuthenticatorSelectionHandler
 *       ): Promise<void> {
 *           await handler.aaid(aaid).catch(console.error);
 *       }
 *   }
 *
 *   class BiometricUserVerifierImpl extends BiometricUserVerifier {
 *       async verifyBiometric(
 *           context: BiometricUserVerificationContext,
 *           handler: BiometricUserVerificationHandler
 *       ): Promise<void> {
 *           await handler
 *               .listenForOsCredentials(
 *                   BiometricPromptOptions.create(
 *                       'Biometric authentication required',
 *                       'Cancel',
 *                       'Please identify yourself.'
 *                   )
 *               )
 *               .catch(console.error);
 *       }
 *   }
 *
 *   async registerWithOutOfBand(
 *       client: MobileAuthenticationClient,
 *       payload: OutOfBandPayload,
 *       deviceInformation: DeviceInformation
 *   ): Promise<void> {
 *        await client.operations.outOfBandOperation
 *            .payload(payload)
 *            .onRegistration((registration) => {
 *                registration
 *                    .deviceInformation(deviceInformation)
 *                    .authenticatorSelector(new AuthenticatorSelectorImpl())
 *                    .biometricUserVerifier(new BiometricUserVerifierImpl())
 *                    .onSuccess(() => {
 *                        // handle success
 *                    })
 *                    .onError((_error) => {
 *                        // handle error
 *                    })
 *                    .execute();
 *            })
 *            .onAuthentication((authentication) => {
 *                // handle authentication
 *            })
 *            .onError((_error) => {
 *                // handle out-of-band error
 *            })
 *            .execute();
 *   }
 * ```
 *
 * The biometric, device passcode and fingerprint authenticators are enrolled at the OS level. That is why,
 * if one of them must be registered, the user must authenticate through {@link BiometricUserVerifier},
 * {@link DevicePasscodeUserVerifier} or {@link FingerprintUserVerifier}.
 * In the case of the PIN and password, the credentials are enrolled during
 * registration, so no authentication is needed.
 *
 * @see {@link OutOfBandOperation.onRegistration}
 */
class OutOfBandRegistration extends _HttpOperation.HttpOperation {}
exports.OutOfBandRegistration = OutOfBandRegistration;
class OutOfBandRegistrationImpl extends _HttpOperation.HttpOperationImpl {
  constructor(operationId) {
    super();
    this.operationId = operationId;
  }
  deviceInformation(deviceInformation) {
    this._deviceInformation = deviceInformation;
    return this;
  }
  allowClass2AndroidSensors(allowClass2AndroidSensors) {
    this._allowClass2AndroidSensors = allowClass2AndroidSensors;
    return this;
  }
  allowDevicePasscodeAsFallback(allowDevicePasscodeAsFallback) {
    this._allowDevicePasscodeAsFallback = allowDevicePasscodeAsFallback;
    return this;
  }
  invalidateOnNewOsBiometrics(invalidateOnNewOsBiometrics) {
    this._invalidateOnNewOsBiometrics = invalidateOnNewOsBiometrics;
    return this;
  }
  authenticatorSelector(authenticatorSelector) {
    this._authenticatorSelector = authenticatorSelector;
    return this;
  }
  pinEnroller(pinEnroller) {
    this._pinEnroller = pinEnroller;
    return this;
  }
  passwordEnroller(passwordEnroller) {
    this._passwordEnroller = passwordEnroller;
    return this;
  }
  biometricUserVerifier(biometricUserVerifier) {
    this._biometricUserVerifier = biometricUserVerifier;
    return this;
  }
  devicePasscodeUserVerifier(devicePasscodeUserVerifier) {
    this._devicePasscodeUserVerifier = devicePasscodeUserVerifier;
    return this;
  }
  fingerprintUserVerifier(fingerprintUserVerifier) {
    this._fingerprintUserVerifier = fingerprintUserVerifier;
    return this;
  }
  onSuccess(onSuccess) {
    this._onSuccess = onSuccess;
    return this;
  }
  onError(onError) {
    this._onError = onError;
    return this;
  }
  async execute() {
    const operation = new _UserInteractionPlatformOperation.UserInteractionPlatformOperationImpl(this.operationId, undefined, this._authenticatorSelector, this._pinEnroller, this._passwordEnroller, undefined, undefined, undefined, undefined, this._biometricUserVerifier, this._devicePasscodeUserVerifier, this._fingerprintUserVerifier);
    _PlatformOperationCache.PlatformOperationCache.getInstance().put(operation);
    _NativeEventListener.NativeEventListener.getInstance().start(this.operationId);
    const message = new _OutOfBandRegistrationMessage.OutOfBandRegistrationMessage(this.operationId, false, this._authenticatorSelector !== undefined, this._pinEnroller !== undefined, this._passwordEnroller !== undefined, false, false, this._biometricUserVerifier !== undefined, this._devicePasscodeUserVerifier !== undefined, this._fingerprintUserVerifier !== undefined, this._onSuccess !== undefined, this._onError !== undefined, this.httpRequestHeaders, this._deviceInformation, this._pinEnroller?.pinPolicy, this._allowClass2AndroidSensors, this._allowDevicePasscodeAsFallback, this._invalidateOnNewOsBiometrics);
    const finish = () => {
      _NativeEventListener.NativeEventListener.getInstance().stop(this.operationId);
      _PlatformOperationCache.PlatformOperationCache.getInstance().delete(this.operationId);
    };
    return _MobileAuthenticationSdk.default.oobRegister(message).then(() => {
      finish();
      this._onSuccess?.();
    }).catch(error => {
      finish();
      const operationError = new _OperationErrorConverter.OperationErrorConverter(error).convert();
      this._onError?.(operationError);
    });
  }
}
exports.OutOfBandRegistrationImpl = OutOfBandRegistrationImpl;
//# sourceMappingURL=OutOfBandRegistration.js.map