@eid-easy/eideasy-browser-client 1.9.1 → 2.1.0

package/src/signatureModules/createIdCardSignature.js

@@ -0,0 +1,208 @@
+import createStep from '../createStep';
+import createModuleCreator from '../createModuleCreator';
+import { getMethodByHandlingModule, methodTypes, moduleNames } from '../config';
+
+const MODULE_NAME = moduleNames.idCardSignature;
+
+const settingsSchema = {
+  iframeHolder: {
+    type: 'object',
+  },
+  docId: {
+    type: 'string',
+    required: true,
+  },
+};
+
+const createMessenger = function createMessenger({ iframe }) {
+  const url = new URL(iframe.src);
+  return {
+    post(message) {
+      iframe.contentWindow.postMessage(message, url.origin);
+    },
+  };
+};
+
+const getIframeUrl = function getIframeUrl({ countryCode, clientId, apiEndpoints }) {
+  const method = getMethodByHandlingModule(methodTypes.SIGNATURE, MODULE_NAME, countryCode);
+  return apiEndpoints.inCurrentMode.idCardIframe({
+    clientId,
+    actionType: method.actionType,
+  });
+};
+
+const createIframe = function createIframe({
+  iframeHolder, iframeUrl, i18n,
+}) {
+  const iframe = document.createElement('iframe');
+  iframe.setAttribute('src', iframeUrl);
+  iframe.setAttribute('referrerpolicy', 'origin');
+  iframe.style.width = '0';
+  iframe.style.height = '0';
+  iframe.style.position = 'absolute';
+  iframe.style.border = '0';
+  // eslint-disable-next-line no-param-reassign
+  iframeHolder.innerHTML = '';
+  const promise = new Promise((resolve, reject) => {
+    window.addEventListener('message', (e) => {
+      const { operation, error, status } = e.data;
+      if (error) {
+        reject(e.data);
+      } else if (operation === 'ready' || operation === 'welcome') {
+        if (status === 'OK') {
+          resolve(iframe);
+        } else {
+          reject(e.data);
+        }
+      } else {
+        reject(e.data);
+      }
+    }, { once: true });
+    // eslint-disable-next-line prefer-promise-reject-errors
+    window.setTimeout(() => reject({ message: i18n.t('createIframeTimeout') }), 30 * 1000);
+  });
+  iframeHolder.appendChild(iframe);
+  return promise;
+};
+
+const getCertificate = function getCertificate({ messenger }) {
+  const promise = new Promise((resolve, reject) => {
+    window.addEventListener('message', (e) => {
+      const { result, cert } = e.data;
+      if (result === 'ok' && cert) {
+        resolve(e.data);
+      } else {
+        let error = {};
+        if (e.data && e.data.result === 'user_cancel') {
+          error.isCancel = true;
+        } else {
+          error = e.data;
+        }
+        reject(error);
+      }
+    }, { once: true });
+  });
+
+  messenger.post({
+    operation: 'getCertificate',
+  });
+
+  return promise;
+};
+
+const startSigning = function startSigning({
+  certificate, clientId, docId, cancelToken, apiEndpoints, apiClient,
+}) {
+  const url = apiEndpoints.inCurrentMode.startSigning();
+  return apiClient.post({
+    url,
+    withCredentials: false,
+    data: {
+      client_id: clientId,
+      doc_id: docId,
+      sign_type: 'id-card',
+      certificate,
+    },
+    cancelToken,
+  });
+};
+
+const getSignature = function createSignature({ messenger, hexDigest }) {
+  const promise = new Promise((resolve, reject) => {
+    window.addEventListener('message', (e) => {
+      const { result, signature } = e.data;
+      if (result === 'ok' && signature) {
+        resolve(e.data);
+      } else {
+        let error = {};
+        if (e.data && e.data.result === 'user_cancel') {
+          error.isCancel = true;
+        } else {
+          error = e.data;
+        }
+        reject(error);
+      }
+    }, { once: true });
+  });
+
+  messenger.post({
+    operation: 'getSignature',
+    hexDigest,
+  });
+
+  return promise;
+};
+
+const completeSigning = function completeSigning({
+  signature, clientId, docId, cancelToken, apiEndpoints, apiClient,
+}) {
+  const url = apiEndpoints.inCurrentMode.completeSignatureIdCard();
+  return apiClient.post({
+    url,
+    withCredentials: false,
+    data: {
+      client_id: clientId,
+      doc_id: docId,
+      signature_value: signature,
+    },
+    cancelToken,
+  });
+};
+
+const executable = async function executable(config) {
+  const iframeUrl = await createStep(getIframeUrl, { shouldFormatResult: false })({
+    countryCode: config.countryCode,
+    clientId: config.clientId,
+    apiEndpoints: config.apiEndpoints,
+  });
+
+  const iframe = await createStep(createIframe, { shouldFormatResult: false })({
+    iframeUrl,
+    iframeHolder: config.iframeHolder,
+    i18n: config.i18n,
+  });
+
+  const messenger = await createStep(createMessenger, { shouldFormatResult: false })({
+    iframe,
+  });
+
+  const certificateResult = await createStep(getCertificate, {
+    shouldFormatResult: false,
+  })({
+    messenger,
+  }).catch((error) => {
+    if (!error.result) {
+      throw error;
+    }
+    if (error.result === 'no_certificates') {
+      error.userMessage = config.i18n.t('no_certificates'); // eslint-disable-line no-param-reassign
+    }
+    throw error;
+  });
+
+  const startSigningResult = await createStep(startSigning)({
+    certificate: certificateResult.cert,
+    clientId: config.clientId,
+    docId: config.docId,
+    cancelToken: config.cancelToken,
+    apiEndpoints: config.apiEndpoints,
+    apiClient: config.apiClient,
+  });
+
+  const getSignatureResult = await createStep(getSignature, { shouldFormatResult: false })({
+    messenger,
+    hexDigest: startSigningResult.data.hexDigest,
+  });
+
+  return createStep(completeSigning)({
+    signature: getSignatureResult.signature,
+    clientId: config.clientId,
+    docId: config.docId,
+    cancelToken: config.cancelToken,
+    apiEndpoints: config.apiEndpoints,
+    apiClient: config.apiClient,
+  });
+};
+
+const createIdCardSignature = createModuleCreator(MODULE_NAME, executable, settingsSchema);
+export default createIdCardSignature;

package/src/signatureModules/createMobileIdSignature.js

@@ -0,0 +1,129 @@
+import createStep from '../createStep';
+import createModuleCreator from '../createModuleCreator';
+import { getMethodByHandlingModule, methodTypes, moduleNames } from '../config';
+import createApiPoller from '../createApiPoller';
+
+const MODULE_NAME = moduleNames.mobileIdSignature;
+const settingsSchema = {
+  countryCode: {
+    type: 'string',
+    required: true,
+  },
+  idcode: {
+    type: 'string',
+    required: true,
+  },
+  phone: {
+    type: 'string',
+    required: true,
+  },
+  docId: {
+    type: 'string',
+    required: true,
+  },
+};
+
+const startSigning = function startSigning({
+  phone, idcode, clientId, docId, cancelToken, apiEndpoints, apiClient, countryCode, language,
+}) {
+  const url = apiEndpoints.inCurrentMode.startSigning();
+  return apiClient.post({
+    url,
+    withCredentials: false,
+    data: {
+      doc_id: docId,
+      client_id: clientId,
+      sign_type: 'mobile-id',
+      phone,
+      idcode,
+      country: countryCode,
+      lang: language,
+    },
+    cancelToken,
+  });
+};
+
+const finishSigning = function finishSigning({
+  data, apiClient, apiEndpoints, language, cancelToken, docId, clientId,
+}) {
+  return apiClient.post({
+    url: apiEndpoints.inCurrentMode.completeSignatureMobileId(),
+    withCredentials: false,
+    data: {
+      token: data.token,
+      doc_id: docId,
+      timeout: 2,
+      lang: language,
+      client_id: clientId,
+    },
+    cancelToken,
+  });
+};
+
+const pollFinishSigning = function pollFinishSigning({
+  data, apiClient, apiEndpoints, language, cancelToken, docId, clientId,
+}) {
+  const poller = createApiPoller({
+    pollInterval: 2000,
+    // Mobile ID users have 120 seconds to enter their pin,
+    // so it doesn't make sense to poll longer than that
+    maxPollDuration: 120 * 1000,
+    fn: finishSigning,
+    fnArgs: [{
+      data,
+      apiClient,
+      apiEndpoints,
+      language,
+      cancelToken,
+      docId,
+      clientId,
+    }],
+  });
+  return poller.start();
+};
+
+const executable = async function executable({
+  clientId,
+  docId,
+  cancelToken,
+  apiEndpoints,
+  apiClient,
+  monitoringService,
+  language,
+  idcode,
+  phone,
+  countryCode,
+  started,
+}) {
+  const method = getMethodByHandlingModule(methodTypes.SIGNATURE, MODULE_NAME, countryCode);
+  monitoringService.dispatch({
+    message: `${method.actionType}: signing started`,
+  });
+
+  const startSigningResult = await createStep(startSigning)({
+    clientId,
+    docId,
+    cancelToken,
+    apiEndpoints,
+    apiClient,
+    language,
+    idcode,
+    phone,
+    countryCode,
+  });
+
+  started(startSigningResult);
+
+  return createStep(pollFinishSigning)({
+    data: startSigningResult.data,
+    apiClient,
+    apiEndpoints,
+    language,
+    cancelToken,
+    docId,
+    clientId,
+  });
+};
+
+const createMobileIdSignature = createModuleCreator(MODULE_NAME, executable, settingsSchema);
+export default createMobileIdSignature;

package/src/signatureModules/createOtpSignature.js

@@ -0,0 +1,68 @@
+import createStep from '../createStep';
+import createModuleCreator from '../createModuleCreator';
+import { getMethodByHandlingModule, methodTypes, moduleNames } from '../config';
+
+const MODULE_NAME = moduleNames.otpSignature;
+const settingsSchema = {
+  docId: {
+    type: 'string',
+    required: true,
+  },
+  emailToken: {
+    type: 'string',
+  },
+  smsToken: {
+    type: 'string',
+  },
+};
+
+const finishSigning = function finishSigning({
+  apiClient, apiEndpoints, language, cancelToken, docId, clientId, emailToken, smsToken,
+}) {
+  return apiClient.post({
+    url: apiEndpoints.inCurrentMode.completeOtp(),
+    withCredentials: false,
+    data: {
+      doc_id: docId,
+      timeout: 2,
+      lang: language,
+      client_id: clientId,
+      email_token: emailToken,
+      sms_token: smsToken,
+    },
+    cancelToken,
+  });
+};
+
+const executable = async function executable({
+  clientId,
+  docId,
+  cancelToken,
+  apiEndpoints,
+  apiClient,
+  monitoringService,
+  language,
+  countryCode,
+  emailToken,
+  smsToken,
+}) {
+  const method = getMethodByHandlingModule(methodTypes.SIGNATURE, MODULE_NAME, countryCode);
+  console.log(method);
+  monitoringService.dispatch({
+    message: `${method.actionType}: signing started`,
+  });
+
+  return createStep(finishSigning)({
+    apiClient,
+    apiEndpoints,
+    language,
+    cancelToken,
+    docId,
+    clientId,
+    emailToken,
+    smsToken,
+  });
+};
+
+const createOtpSignature = createModuleCreator(MODULE_NAME, executable, settingsSchema);
+export default createOtpSignature;

package/src/signatureModules/createSmartIdSignature.js

@@ -0,0 +1,124 @@
+import createStep from '../createStep';
+import createModuleCreator from '../createModuleCreator';
+import { getMethodByHandlingModule, methodTypes, moduleNames } from '../config';
+import createApiPoller from '../createApiPoller';
+
+const MODULE_NAME = moduleNames.smartIdSignature;
+const settingsSchema = {
+  countryCode: {
+    type: 'string',
+    required: true,
+  },
+  idcode: {
+    type: 'string',
+    required: true,
+  },
+  docId: {
+    type: 'string',
+    required: true,
+  },
+};
+
+const startSigning = function startSigning({
+  contractId, idcode, clientId, docId, cancelToken, apiEndpoints, apiClient, countryCode, language,
+}) {
+  const url = apiEndpoints.inCurrentMode.startSigning();
+  return apiClient.post({
+    url,
+    withCredentials: false,
+    data: {
+      doc_id: docId,
+      contract_id: contractId,
+      client_id: clientId,
+      sign_type: 'smart-id',
+      idcode,
+      country: countryCode,
+      lang: language,
+    },
+    cancelToken,
+  });
+};
+
+const finishSigning = function finishSigning({
+  data, apiClient, apiEndpoints, language, cancelToken, docId, clientId,
+}) {
+  return apiClient.post({
+    url: apiEndpoints.inCurrentMode.completeSignatureSmartId(),
+    withCredentials: false,
+    data: {
+      token: data.token,
+      doc_id: docId,
+      lang: language,
+      client_id: clientId,
+    },
+    cancelToken,
+  });
+};
+
+const pollFinishSigning = function pollFinishSigning({
+  data, apiClient, apiEndpoints, language, cancelToken, docId, clientId,
+}) {
+  const poller = createApiPoller({
+    pollInterval: 2000,
+    // Smart ID users have ~120 seconds to enter their pin,
+    // so it doesn't make sense to poll longer than that
+    maxPollDuration: 120 * 1000,
+    fn: finishSigning,
+    fnArgs: [{
+      data,
+      apiClient,
+      apiEndpoints,
+      language,
+      cancelToken,
+      docId,
+      clientId,
+    }],
+  });
+  return poller.start();
+};
+
+const executable = async function executable({
+  clientId,
+  docId,
+  contractId,
+  cancelToken,
+  apiEndpoints,
+  apiClient,
+  monitoringService,
+  language,
+  idcode,
+  countryCode,
+  started,
+}) {
+  const method = getMethodByHandlingModule(methodTypes.SIGNATURE, MODULE_NAME, countryCode);
+  monitoringService.dispatch({
+    message: `${method.actionType}: signing started`,
+  });
+
+  const startSigningResult = await createStep(startSigning)({
+    clientId,
+    docId,
+    cancelToken,
+    apiEndpoints,
+    apiClient,
+    language,
+    idcode,
+    countryCode,
+    contractId,
+  });
+
+  started(startSigningResult);
+
+  return createStep(pollFinishSigning)({
+    data: startSigningResult.data,
+    apiClient,
+    apiEndpoints,
+    language,
+    cancelToken,
+    docId,
+    clientId,
+  });
+};
+
+const createSmartIdSignature = createModuleCreator(MODULE_NAME, executable, settingsSchema);
+export default createSmartIdSignature;

package/src/signatureModules/signatureModules.js

@@ -0,0 +1,17 @@
+import createIdCardSignature from './createIdCardSignature';
+import createMobileIdSignature from './createMobileIdSignature';
+import createSmartIdSignature from './createSmartIdSignature';
+import createEvrotrustSignature from './createEvrotrustSignature';
+import createOtpSignature from './createOtpSignature';
+import createEParakstsMobileSignature from './createEParakstsMobileSignature';
+import createFtnSignature from './createFtnSignature';
+
+export {
+  createIdCardSignature,
+  createMobileIdSignature,
+  createSmartIdSignature,
+  createEvrotrustSignature,
+  createOtpSignature,
+  createEParakstsMobileSignature,
+  createFtnSignature,
+};

package/src/{cloneDeep.test.js → tests/cloneDeep.test.js}

@@ -1,4 +1,4 @@
-import cloneDeep from './cloneDeep';
+import cloneDeep from '../cloneDeep';
 
 describe('cloneDeep', () => {
   let originalObj;

package/src/tests/config.test.js

@@ -0,0 +1,25 @@
+import {
+  getMethodByHandlingModule, methodTypes, moduleNames, methodActionTypes,
+} from '../config';
+
+describe('config', () => {
+  test('getMethodByHandlingModule returns correct module in case country is not provided', () => {
+    const method = getMethodByHandlingModule(methodTypes.IDENTIFICATION, moduleNames.idCard);
+    expect(method.handlingModule).toBe(moduleNames.idCard);
+  });
+
+  test('getMethodByHandlingModule returns correct module in case country is provided', () => {
+    const method = getMethodByHandlingModule(methodTypes.IDENTIFICATION, moduleNames.idCard, 'FI');
+    expect(method.actionType).toBe(methodActionTypes.FI_ID_LOGIN);
+  });
+
+  test('getMethodByHandlingModule returns correct module in case country is provided and method has multiple countries', () => {
+    const method = getMethodByHandlingModule(methodTypes.IDENTIFICATION, moduleNames.frejaEid, 'NO');
+    expect(method.actionType).toBe(methodActionTypes.FREJA_EID_LOGIN);
+  });
+
+  test('getMethodByHandlingModule returns correct module in case country is not provided and method has multiple countries', () => {
+    const method = getMethodByHandlingModule(methodTypes.IDENTIFICATION, moduleNames.frejaEid);
+    expect(method.actionType).toBe(methodActionTypes.FREJA_EID_LOGIN);
+  });
+});

package/src/{createRequestError.test.js → tests/createRequestError.test.js}

@@ -1,4 +1,4 @@
-import createRequestError from './createRequestError';
+import createRequestError from '../createRequestError';
 
 describe('createRequestError', () => {
   let requestError;

package/src/{main.test.js → tests/main.test.js}

@@ -1,4 +1,4 @@
-import createClient from './main';
+import createClient from '../main';
 
 describe('main', () => {
   it('should default export createClient', () => {

package/src/{poll.test.js → tests/poll.test.js}

@@ -1,4 +1,4 @@
-import poll from './poll';
+import poll from '../poll';
 
 describe('poll', () => {
   test('function is called 10 times', async () => {

package/src/{windowOpen.test.js → tests/windowOpen.test.js}

@@ -1,4 +1,4 @@
-import { calculateChildPosition } from './windowOpen';
+import { calculateChildPosition } from '../windowOpen';
 
 describe('calculateChildPosition', () => {
   it('should center the child window relative to parent if child is smaller than parent', () => {