@mft/moneyhub-api-client 4.20.0 → 5.0.0-2

package/src/exchange-code-for-token.js

@@ -1,115 +0,0 @@
-/* eslint-disable complexity */
-/* eslint-disable max-statements */
-const R = require("ramda")
-const {TokenSet} = require("openid-client")
-
-const ALLOWED_PARAMS = [
-  "access_token",
-  "code",
-  "error",
-  "error_description",
-  "error_uri",
-  "expires_in",
-  "id_token",
-  "state",
-  "token_type",
-  "session_state",
-]
-
-const RESPONSE_TYPE_REQUIRED_PARAMS = {
-  code: ["code"],
-  id_token: ["id_token"],
-  token: ["access_token", "token_type"],
-}
-
-module.exports = ({client, redirectUri}) => ({paramsFromCallback, localParams}) => {
-  const params = R.pick(ALLOWED_PARAMS, paramsFromCallback)
-  const checks = localParams
-
-  if (client.default_max_age && !checks.max_age)
-    checks.max_age = client.default_max_age
-
-  if (!params.state && checks.state) {
-    return Promise.reject(new Error("paramsFromCallback.state is missing"))
-  }
-
-  if (params.state && !checks.state) {
-    return Promise.reject(new Error("localParams.state argument is missing"))
-  }
-
-  if (checks.state !== params.state) {
-    return Promise.reject(new Error("state mismatch"))
-  }
-
-  if (params.error) {
-    return Promise.reject(new Error(params.error))
-  }
-
-  if (!params.code) {
-    return Promise.reject(new Error("paramsFromCallback.code is missing"))
-  }
-
-  if (checks.response_type) {
-    for (const type of checks.response_type.split(" ")) {
-      // eslint-disable-line no-restricted-syntax
-      if (type === "none") {
-        if (params.code || params.id_token || params.access_token) {
-          return Promise.reject(
-            new Error("unexpected params encountered for 'none' response"),
-          )
-        }
-      } else {
-        for (const param of RESPONSE_TYPE_REQUIRED_PARAMS[type]) {
-          // eslint-disable-line no-restricted-syntax, max-len
-          if (!params[param]) {
-            return Promise.reject(new Error(`${param} missing from response`))
-          }
-        }
-      }
-    }
-  }
-
-  let promise
-
-  if (params.id_token) {
-    promise = Promise.resolve(new TokenSet(params))
-      .then((tokenset) => client.decryptIdToken(tokenset))
-      .then((tokenset) =>
-        client.validateIdToken(
-          tokenset,
-          checks.nonce,
-          "authorization",
-          checks.max_age,
-          checks.state,
-        ),
-      )
-  }
-
-  if (params.code) {
-    const grantCall = () =>
-      client.grant({
-        grant_type: "authorization_code",
-        code: params.code,
-        redirect_uri: redirectUri,
-        code_verifier: checks.code_verifier,
-        sub: localParams.sub,
-      })
-        .then((tokenset) => client.decryptIdToken(tokenset))
-        .then((tokenset) =>
-          client.validateIdToken(tokenset, checks.nonce, "token", checks.max_age),
-        )
-        .then((tokenset) => {
-          if (params.session_state)
-            tokenset.session_state = params.session_state
-          return tokenset
-        })
-
-    if (promise) {
-      promise = promise.then(grantCall)
-    } else {
-      return grantCall()
-    }
-  }
-
-  return promise || Promise.resolve(new TokenSet(params))
-}

package/src/get-auth-urls.js

@@ -1,559 +0,0 @@
-const got = require("got")
-const R = require("ramda")
-const filterUndefined = R.reject(R.isNil)
-
-module.exports = ({client, config}) => {
-  const {
-    identityServiceUrl,
-    client: {
-      client_id,
-      request_object_signing_alg,
-      redirect_uri,
-      response_type,
-    },
-  } = config
-
-  const setPermissionsToClaims = permissions => claims => {
-    if (permissions && R.is(Array, permissions)) {
-      return R.mergeDeepRight(claims, {
-        id_token: {
-          "mh:consent": {
-            essential: true,
-            value: {
-              permissions
-            }
-          }
-        }
-      })
-    }
-
-    return claims
-  }
-
-  const getAuthorizeUrl = ({
-    state,
-    scope,
-    nonce,
-    claims = {},
-    permissions,
-    enableAsync,
-    expirationDateTime,
-    transactionFromDateTime,
-  }) => {
-    const defaultClaims = {
-      id_token: {
-        sub: {
-          essential: true,
-        },
-        "mh:con_id": {
-          essential: true,
-        },
-        ...(expirationDateTime || transactionFromDateTime) && {
-          "mh:consent": {
-            "essential": true,
-            "value": {
-              ...expirationDateTime && {expirationDateTime},
-              ...transactionFromDateTime && {transactionFromDateTime},
-            }
-          }
-        },
-        ...enableAsync && {
-          "mh:sync": {
-            "essential": true,
-            "value": {"enableAsync": true}
-          }
-        }
-      },
-    }
-
-    const _claims = R.compose(
-      setPermissionsToClaims(permissions),
-      R.mergeDeepRight(defaultClaims)
-    )(claims)
-
-    const authParams = filterUndefined({
-      client_id,
-      scope,
-      state,
-      nonce,
-      redirect_uri,
-      response_type,
-      prompt: "consent",
-    })
-
-    return client
-      .requestObject(
-        {
-          ...authParams,
-          claims: _claims,
-          max_age: 86400,
-        },
-        {
-          sign: request_object_signing_alg,
-        }
-      )
-      .then((request) => ({
-        ...authParams,
-        request,
-      }))
-      .then(client.authorizationUrl.bind(client))
-  }
-
-  const getAuthorizeUrlFromRequestUri = ({requestUri}) => {
-    return `${client.issuer.authorization_endpoint}?request_uri=${requestUri}`
-  }
-
-  const requestObject = ({scope, state, claims, nonce}) => {
-    const authParams = filterUndefined({
-      client_id,
-      scope,
-      state,
-      nonce,
-      claims,
-      exp: Math.round(Date.now() / 1000) + 300,
-      redirect_uri,
-      response_type,
-      prompt: "consent",
-    })
-
-    return client.requestObject(authParams)
-  }
-
-  const getRequestUri = async (requestObject) => {
-    const {body} = await got.post(identityServiceUrl + "/request", {
-      body: requestObject,
-      headers: {
-        "Content-Type": "application/jws",
-      },
-    })
-    return body
-  }
-
-  return {
-    getAuthorizeUrl,
-    getAuthorizeUrlFromRequestUri,
-    requestObject,
-    getRequestUri,
-    getAuthorizeUrlForCreatedUser: async ({
-      bankId,
-      state,
-      nonce,
-      userId,
-      claims = {},
-      permissions,
-      expirationDateTime,
-      transactionFromDateTime,
-      enableAsync,
-    }) => {
-      const scope = `id:${bankId} openid`
-      const defaultClaims = {
-        id_token: {
-          sub: {
-            essential: true,
-            value: userId,
-          },
-          "mh:con_id": {
-            essential: true,
-          },
-        },
-      }
-      const _claims = R.compose(
-        setPermissionsToClaims(permissions),
-        R.mergeDeepRight(defaultClaims)
-      )(claims)
-
-      const url = await getAuthorizeUrl({
-        state,
-        nonce,
-        scope,
-        claims: _claims,
-        expirationDateTime,
-        transactionFromDateTime,
-        enableAsync,
-      })
-      return url
-    },
-
-    getReauthAuthorizeUrlForCreatedUser: async ({
-      userId,
-      connectionId,
-      state,
-      nonce,
-      claims = {},
-      expirationDateTime,
-      transactionFromDateTime,
-      enableAsync,
-    }) => {
-      const scope = "openid reauth"
-      const defaultClaims = {
-        id_token: {
-          sub: {
-            essential: true,
-            value: userId,
-          },
-          "mh:con_id": {
-            essential: true,
-            value: connectionId,
-          },
-        },
-      }
-      const _claims = R.mergeDeepRight(defaultClaims, claims)
-
-      const url = await getAuthorizeUrl({
-        state,
-        nonce,
-        scope,
-        claims: _claims,
-        expirationDateTime,
-        transactionFromDateTime,
-        enableAsync,
-      })
-      return url
-    },
-
-    getReconsentAuthorizeUrlForCreatedUser: async ({
-      userId,
-      connectionId,
-      expiresAt,
-      state,
-      nonce,
-      claims = {},
-    }) => {
-      const scope = "openid reconsent"
-      const defaultClaims = {
-        id_token: {
-          sub: {
-            essential: true,
-            value: userId,
-          },
-          "mh:con_id": {
-            essential: true,
-            value: connectionId,
-          },
-          "mh:consent": {
-            value: {
-              expirationDateTime: expiresAt
-            }
-          }
-        },
-      }
-      const _claims = R.mergeDeepRight(defaultClaims, claims)
-
-      const url = await getAuthorizeUrl({
-        state,
-        nonce,
-        scope,
-        claims: _claims,
-      })
-      return url
-    },
-
-    getRefreshAuthorizeUrlForCreatedUser: async ({
-      userId,
-      connectionId,
-      state,
-      nonce,
-      claims = {},
-      expirationDateTime,
-      transactionFromDateTime,
-      enableAsync
-    }) => {
-      const scope = "openid refresh"
-      const defaultClaims = {
-        id_token: {
-          sub: {
-            essential: true,
-            value: userId,
-          },
-          "mh:con_id": {
-            essential: true,
-            value: connectionId,
-          },
-        },
-      }
-      const _claims = R.mergeDeepRight(defaultClaims, claims)
-
-      const url = await getAuthorizeUrl({
-        state,
-        scope,
-        nonce,
-        claims: _claims,
-        expirationDateTime,
-        transactionFromDateTime,
-        enableAsync
-      })
-      return url
-    },
-
-    getPaymentAuthorizeUrl: async ({
-      bankId,
-      payeeId,
-      payeeType,
-      amount,
-      payeeRef,
-      payerRef,
-      payerId,
-      payerType,
-      state,
-      nonce,
-      context,
-      readRefundAccount,
-      userId,
-      claims = {},
-    }) => {
-      if (!state) {
-        console.error("State is required")
-        throw new Error("Missing parameters")
-      }
-
-      if (!payeeId) {
-        console.error("PayeeId is required")
-        throw new Error("Missing parameters")
-      }
-
-      const scope = `payment openid id:${bankId}`
-      const defaultClaims = {
-        id_token: {
-          "mh:con_id": {
-            essential: true,
-          },
-          "mh:payment": {
-            essential: true,
-            value: {
-              amount,
-              payeeRef,
-              payerRef,
-              payeeId,
-              payeeType,
-              payerId,
-              payerType,
-              context,
-              readRefundAccount,
-            },
-          },
-          ...userId && {
-            sub: {
-              value: userId
-            }
-          }
-        },
-      }
-
-      const _claims = R.mergeDeepRight(defaultClaims, claims)
-
-      const request = await requestObject({
-        scope,
-        state,
-        claims: _claims,
-        nonce,
-      })
-
-      const requestUri = await getRequestUri(request)
-      const url = getAuthorizeUrlFromRequestUri({
-        requestUri,
-      })
-      return url
-    },
-
-    getReversePaymentAuthorizeUrl: async ({
-      bankId,
-      paymentId,
-      state,
-      nonce,
-      amount,
-      claims = {},
-    }) => {
-      if (!state) {
-        console.error("State is required")
-        throw new Error("Missing parameters")
-      }
-
-      if (!paymentId) {
-        console.error("PayeeId is required")
-        throw new Error("Missing parameters")
-      }
-
-      const scope = `reverse_payment openid id:${bankId}`
-      const defaultClaims = {
-        id_token: {
-          "mh:con_id": {
-            essential: true,
-          },
-          "mh:reverse_payment": {
-            essential: true,
-            value: {
-              paymentId,
-              amount,
-            },
-          },
-          "mh:payment": {
-            essential: true,
-          },
-        },
-      }
-
-      const _claims = R.mergeDeepRight(defaultClaims, claims)
-
-      const request = await requestObject({
-        scope,
-        state,
-        claims: _claims,
-        nonce,
-      })
-
-      const requestUri = await getRequestUri(request)
-      const url = getAuthorizeUrlFromRequestUri({
-        requestUri,
-      })
-      return url
-    },
-
-    getRecurringPaymentAuthorizeUrl: async ({
-      bankId,
-      payeeId,
-      payeeType,
-      payerId,
-      payerType,
-      reference,
-      validFromDate,
-      validToDate,
-      maximumIndividualAmount,
-      currency,
-      periodicLimits,
-      type,
-      context,
-      state,
-      nonce,
-      userId,
-      claims = {},
-    }) => {
-      if (!state) {
-        console.error("State is required")
-        throw new Error("Missing parameters")
-      }
-
-      const scope = `recurring_payment:create openid id:${bankId}`
-      const defaultClaims = {
-        id_token: {
-          "mh:con_id": {
-            essential: true,
-          },
-          "mh:recurring_payment": {
-            essential: true,
-            value: {
-              payeeId,
-              payeeType,
-              payerId,
-              payerType,
-              reference,
-              validFromDate,
-              validToDate,
-              maximumIndividualAmount,
-              currency,
-              periodicLimits,
-              type,
-              context,
-            },
-          },
-          ...userId && {
-            sub: {
-              value: userId
-            }
-          }
-        },
-      }
-
-      const _claims = R.mergeDeepRight(defaultClaims, claims)
-
-      const request = await requestObject({
-        scope,
-        state,
-        claims: _claims,
-        nonce,
-      })
-
-      const requestUri = await getRequestUri(request)
-      const url = getAuthorizeUrlFromRequestUri({
-        requestUri,
-      })
-      return url
-    },
-
-    getStandingOrderAuthorizeUrl: async ({
-      bankId,
-      payeeId,
-      payeeType,
-      payerId,
-      payerType,
-      reference,
-      frequency,
-      numberOfPayments,
-      firstPaymentAmount,
-      recurringPaymentAmount,
-      finalPaymentAmount,
-      currency,
-      firstPaymentDate,
-      recurringPaymentDate,
-      finalPaymentDate,
-      state,
-      nonce,
-      context,
-      claims = {},
-    }) => {
-      if (!state) {
-        console.error("State is required")
-        throw new Error("Missing parameters")
-      }
-
-      if (!payeeId) {
-        console.error("PayeeId is required")
-        throw new Error("Missing parameters")
-      }
-
-      const scope = `standing_orders:create openid id:${bankId}`
-      const defaultClaims = {
-        id_token: {
-          "mh:con_id": {
-            essential: true,
-          },
-          "mh:standing_order": {
-            essential: true,
-            value: {
-              payeeId,
-              payeeType,
-              payerId,
-              payerType,
-              reference,
-              frequency,
-              numberOfPayments,
-              firstPaymentAmount,
-              recurringPaymentAmount,
-              finalPaymentAmount,
-              currency,
-              firstPaymentDate,
-              recurringPaymentDate,
-              finalPaymentDate,
-              context,
-            },
-          },
-        },
-      }
-
-      const _claims = R.mergeDeepRight(defaultClaims, claims)
-
-      const request = await requestObject({
-        scope,
-        state,
-        claims: _claims,
-        nonce,
-      })
-
-      const requestUri = await getRequestUri(request)
-      const url = getAuthorizeUrlFromRequestUri({
-        requestUri,
-      })
-      return url
-    },
-
-  }
-}