@mft/moneyhub-api-client 4.18.0 → 5.0.0-0

package/src/get-auth-urls.js

@@ -1,522 +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
-    },
-
-    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
-    },
-
-  }
-}

package/src/index.js

@@ -1,82 +0,0 @@
-const {Issuer, custom} = require("openid-client")
-const R = require("ramda")
-const {JWKS} = require("jose")
-const getAuthUrlsFactory = require("./get-auth-urls")
-const getTokensFactory = require("./tokens")
-const requestFactories = [
-  require("./requests/accounts"),
-  require("./requests/auth-requests"),
-  require("./requests/beneficiaries"),
-  require("./requests/payees"),
-  require("./requests/payments"),
-  require("./requests/projects"),
-  require("./requests/sync"),
-  require("./requests/tax"),
-  require("./requests/transactions"),
-  require("./requests/transaction-files"),
-  require("./requests//transaction-splits"),
-  require("./requests/unauthenticated"),
-  require("./requests/users-and-connections"),
-  require("./requests/categories"),
-  require("./requests/standing-orders"),
-  require("./requests/regular-transactions"),
-  require("./requests/rental-records"),
-  require("./requests/recurring-payments"),
-]
-const DEFAULT_TIMEOUT = 60000
-
-module.exports = async (apiClientConfig) => {
-  const config = R.evolve(
-    {
-      identityServiceUrl: (value) => value.replace("/oidc", ""),
-    },
-    apiClientConfig
-  )
-
-  const {
-    identityServiceUrl,
-    options = {},
-    client: {
-      client_id,
-      client_secret,
-      id_token_signed_response_alg,
-      request_object_signing_alg,
-      redirect_uri,
-      keys,
-      token_endpoint_auth_method,
-    },
-  } = config
-
-  const {timeout = DEFAULT_TIMEOUT} = options
-
-  custom.setHttpOptionsDefaults({
-    timeout,
-  })
-
-  const moneyhubIssuer = await Issuer.discover(identityServiceUrl + "/oidc")
-
-  const client = new moneyhubIssuer.Client(
-    {
-      client_id,
-      client_secret,
-      id_token_signed_response_alg,
-      redirect_uri,
-      token_endpoint_auth_method,
-      request_object_signing_alg,
-    },
-    {keys}
-  )
-
-  client[custom.clock_tolerance] = 10
-
-  const request = require("./request")({client, options: {timeout}})
-
-  const moneyhub = {
-    ...R.mergeAll(requestFactories.map((fn) => fn({request, config}))),
-    ...getAuthUrlsFactory({client, config}),
-    ...getTokensFactory({client, config}),
-
-    keys: () => (keys && keys.length ? JWKS.asKeyStore({keys}).toJWKS() : null),
-  }
-  return moneyhub
-}

package/src/request.js

@@ -1,58 +0,0 @@
-const got = require("got")
-const R = require("ramda")
-
-const getResponseBody = err => {
-  let body = {}
-  try {
-    const {code, message, details} = JSON.parse(R.pathOr("{}", ["response", "body"], err))
-    body = {code, message, details: typeof details === "object" ? JSON.stringify(details) : details}
-  // eslint-disable-next-line no-empty
-  } catch (e) {
-    body = {}
-  }
-
-  return body
-}
-
-const attachErrorDetails = err => {
-  const {code, message, details} = getResponseBody(err)
-  err.error = code
-  err.error_description = message
-  err.error_details = details
-  throw err
-}
-
-module.exports = ({client, options: {timeout}}) => async (url, opts = {}) => {
-  const gotOpts = {
-    method: opts.method || "GET",
-    headers: opts.headers || {},
-    searchParams: opts.searchParams,
-    timeout,
-  }
-
-  if (opts.cc) {
-    const {access_token} = await client.grant({
-      grant_type: "client_credentials",
-      scope: opts.cc.scope,
-      sub: opts.cc.sub,
-    })
-    gotOpts.headers.Authorization = `Bearer ${access_token}`
-  }
-
-  if (opts.body) {
-    gotOpts.json = opts.body
-  }
-
-  if (opts.form) {
-    gotOpts.body = opts.form
-  }
-
-  const req = got(url, gotOpts)
-  if (opts.returnStatus) {
-    return req.then(res => res.statusCode)
-      .catch(attachErrorDetails)
-  }
-
-  return req.json()
-    .catch(attachErrorDetails)
-}