@eid-easy/eideasy-browser-client 2.7.0 → 2.10.1

package/src/signatureModules/createSmartIdSignature.js

@@ -1,124 +0,0 @@
-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/createZealIdSignature.js

@@ -1,37 +0,0 @@
-import createStep from '../createStep';
-import createModuleCreator from '../createModuleCreator';
-import { moduleNames } from '../config';
-
-const MODULE_NAME = moduleNames.zealIdSignature;
-
-const getRedirectUrl = function getRedirectUrl({ apiEndpoints, clientId, docId }) {
-  const redirectUrl = apiEndpoints.inCurrentMode.startZealIdSignature({
-    clientId,
-    docId,
-  });
-
-  return {
-    data: {
-      // we use snake case for redirect_uri to maintain consistency with the responses coming from the core API
-      redirect_uri: redirectUrl,
-    },
-  };
-};
-
-const executable = async function executable(config) {
-  const {
-    redirect,
-    apiEndpoints,
-    clientId,
-    docId,
-  } = config;
-
-  const redirectUrlResult = await createStep(getRedirectUrl)({
-    apiEndpoints, clientId, docId,
-  });
-
-  return createStep(redirect, { shouldFormatResult: false })(redirectUrlResult);
-};
-
-const createZealIdSignature = createModuleCreator(MODULE_NAME, executable);
-export default createZealIdSignature;

package/src/signatureModules/signatureModules.js

@@ -1,21 +0,0 @@
-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';
-import createAtHandySignature from './createAtHandySignature';
-import createZealIdSignature from './createZealIdSignature';
-
-export {
-  createIdCardSignature,
-  createMobileIdSignature,
-  createSmartIdSignature,
-  createEvrotrustSignature,
-  createOtpSignature,
-  createEParakstsMobileSignature,
-  createFtnSignature,
-  createAtHandySignature,
-  createZealIdSignature,
-};

package/src/tests/cloneDeep.test.js

@@ -1,31 +0,0 @@
-import cloneDeep from '../cloneDeep';
-
-describe('cloneDeep', () => {
-  let originalObj;
-
-  beforeEach(() => {
-    originalObj = {
-      lvl1: {
-        lvl2: {
-          lvl3: {
-            prop1: 'I am a string',
-            prop2: undefined,
-            prop3: null,
-            prop4: ['item1', 'item2', 'item3'],
-            prop5: new Error(),
-          },
-        },
-      },
-    };
-  });
-
-  test('object gets cloned', () => {
-    const clonedObject = cloneDeep(originalObj);
-    expect(clonedObject).toEqual(originalObj);
-  });
-
-  test('cloned object is not the original object', () => {
-    const clonedObject = cloneDeep(originalObj);
-    expect(clonedObject).not.toBe(originalObj);
-  });
-});

package/src/tests/config.test.js

@@ -1,25 +0,0 @@
-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/tests/createRequestError.test.js

@@ -1,36 +0,0 @@
-import createRequestError from '../createRequestError';
-
-describe('createRequestError', () => {
-  let requestError;
-  const errorSettings = {
-    message: 'A mock error',
-    config: 'asdfasf',
-    code: 'mockErrorCode',
-    request: 'asfdasf',
-    response: {},
-  };
-
-  beforeAll(() => {
-    requestError = createRequestError(errorSettings);
-  });
-
-  test('requestError\'s isRequestError property value is true', () => {
-    expect(requestError.isRequestError).toBe(true);
-  });
-
-  test('requestError property values match the settings', () => {
-    const actualValues = {
-      message: requestError.message,
-      config: requestError.config,
-      code: requestError.code,
-      request: requestError.request,
-      response: requestError.response,
-    };
-
-    expect(actualValues).toEqual(errorSettings);
-  });
-
-  test('requestError is instanceof Error', () => {
-    expect(requestError instanceof Error).toBe(true);
-  });
-});

package/src/tests/main.test.js

@@ -1,7 +0,0 @@
-import createClient from '../main';
-
-describe('main', () => {
-  it('should default export createClient', () => {
-    expect(createClient.name).toBe('createClient');
-  });
-});

package/src/tests/poll.test.js

@@ -1,64 +0,0 @@
-import poll from '../poll';
-
-describe('poll', () => {
-  test('function is called 10 times', async () => {
-    const mockFunction = jest.fn();
-
-    await poll({
-      fn: mockFunction,
-      interval: 3,
-      shouldContinue({
-        attempts,
-      }) {
-        return attempts < 10;
-      },
-    });
-    expect(mockFunction).toHaveBeenCalledTimes(10);
-  });
-
-  test('shouldcontinue callback receives the error and terminates polling after 2 calls', async () => {
-    const mockFunction = jest.fn();
-    mockFunction
-      .mockReturnValueOnce(true)
-      .mockImplementation(() => {
-        throw new Error('Mock error message');
-      });
-
-    const result = await poll({
-      fn: mockFunction,
-      interval: 3,
-      shouldContinue({
-        attempts,
-        error,
-      }) {
-        return !(error || attempts > 9);
-      },
-    });
-    expect(mockFunction).toHaveBeenCalledTimes(2);
-    expect(result.error).not.toBe(undefined);
-  });
-
-  test('poll returns the final value in correct format', async () => {
-    const mockFunction = jest.fn();
-    mockFunction
-      .mockReturnValue({
-        mockProperty: 'mockPropertyValue',
-      });
-
-    const result = await poll({
-      fn: mockFunction,
-      interval: 3,
-      shouldContinue({
-        attempts,
-      }) {
-        return attempts < 1;
-      },
-    });
-    expect(result).toEqual({
-      result: {
-        mockProperty: 'mockPropertyValue',
-      },
-      error: undefined,
-    });
-  });
-});

package/src/tests/windowOpen.test.js

@@ -1,43 +0,0 @@
-import { calculateChildPosition } from '../windowOpen';
-
-describe('calculateChildPosition', () => {
-  it('should center the child window relative to parent if child is smaller than parent', () => {
-    const childPosition = calculateChildPosition({
-      parent: {
-        width: 1300,
-        height: 700,
-        left: 600,
-        top: 500,
-      },
-      child: {
-        width: 800,
-        height: 600,
-      },
-    });
-
-    expect(childPosition).toEqual({
-      top: 550,
-      left: 850,
-    });
-  });
-
-  it('should center the child window relative to parent if child is bigger than parent', () => {
-    const childPosition = calculateChildPosition({
-      parent: {
-        width: 700,
-        height: 400,
-        left: 600,
-        top: 500,
-      },
-      child: {
-        width: 950,
-        height: 650,
-      },
-    });
-
-    expect(childPosition).toEqual({
-      top: 375,
-      left: 475,
-    });
-  });
-});

package/src/windowOpen.js

@@ -1,46 +0,0 @@
-const calculateChildPosition = function calculateChildPosition({
-  parent,
-  child,
-}) {
-  // center the child window relative to the parent window
-  return {
-    left: (parent.width / 2) - (child.width / 2) + parent.left,
-    top: (parent.height / 2) - (child.height / 2) + parent.top,
-  };
-};
-
-const windowOpen = function windowOpen(url) {
-  const child = {
-    width: 800,
-    height: 600,
-  };
-
-  const childPosition = calculateChildPosition({
-    parent: {
-      width: window.outerWidth,
-      height: window.outerHeight,
-      left: window.screenLeft,
-      top: window.screenTop,
-    },
-    child,
-  });
-
-  const features = [
-    'toolbar=no',
-    'location=no',
-    'directories=no',
-    'status=no',
-    'menubar=no',
-    'scrollbars=no',
-    'resizable=no',
-    'copyhistory=no',
-    `width=${child.width}`,
-    `height=${child.height}`,
-    `left=${childPosition.left}`,
-    `top=${childPosition.top}`,
-  ];
-  return window.open(url, 'eID Easy', features.join(', '));
-};
-
-export default windowOpen;
-export { calculateChildPosition };

package/webpack.config.js

@@ -1,55 +0,0 @@
-const path = require('path');
-const webpack = require('webpack');
-const { merge } = require('webpack-merge');
-const { CleanWebpackPlugin } = require('clean-webpack-plugin');
-const ESLintPlugin = require('eslint-webpack-plugin');
-const dotenv = require('dotenv');
-
-const modeConfig = (env) => require(`./build-utils/webpack.${env}`)(env);
-const presetConfig = require('./build-utils/loadPresets');
-
-module.exports = ({
-  mode,
-  presets,
-} = {
-  mode: 'production',
-  presets: [],
-}) => merge(
-  {
-    mode,
-    stats: {
-      chunks: true,
-    },
-    entry: './src/index.js',
-    output: {
-      path: path.resolve(__dirname, 'dist'),
-      filename: 'eideasy-browser-client.js',
-      library: 'eidEasyBrowserClient',
-      libraryTarget: 'umd',
-    },
-    devServer: {
-      contentBase: './dist',
-    },
-    module: {
-      rules: [
-        {
-          test: /\.js$/,
-          exclude: /node_modules/,
-          use: ['babel-loader'],
-        },
-      ],
-    },
-    plugins: [
-      new CleanWebpackPlugin(),
-      new ESLintPlugin(),
-      new webpack.ProgressPlugin(),
-      new webpack.DefinePlugin({
-        'process.env': JSON.stringify(dotenv.config({
-          path: path.join(__dirname, `.env.${mode}`),
-        }).parsed),
-      }),
-    ],
-  },
-  modeConfig(mode),
-  presetConfig({ mode, presets }),
-);