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

package/dist/src/exchange-code-for-token.d.ts

@@ -0,0 +1,9 @@
+declare function _exports({ client, redirectUri }: {
+    client: any;
+    redirectUri: any;
+}): ({ paramsFromCallback, localParams }: {
+    paramsFromCallback: any;
+    localParams: any;
+}) => any;
+export = _exports;
+//# sourceMappingURL=exchange-code-for-token.d.ts.map

package/dist/src/exchange-code-for-token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exchange-code-for-token.d.ts","sourceRoot":"","sources":["../../src/exchange-code-for-token.js"],"names":[],"mappings":"AAwBiB;;;;;;UA0FhB"}

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

@@ -0,0 +1,91 @@
+"use strict";
+/* 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));
+};
+//# sourceMappingURL=exchange-code-for-token.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exchange-code-for-token.js","sourceRoot":"","sources":["../../src/exchange-code-for-token.js"],"names":[],"mappings":"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"}

package/dist/src/get-auth-urls.d.ts

@@ -0,0 +1,142 @@
+declare function _exports({ client, config }: {
+    client: any;
+    config: any;
+}): {
+    getAuthorizeUrl: ({ state, scope, nonce, claims, permissions, enableAsync, expirationDateTime, transactionFromDateTime, }: {
+        state: any;
+        scope: any;
+        nonce: any;
+        claims?: {} | undefined;
+        permissions: any;
+        enableAsync: any;
+        expirationDateTime: any;
+        transactionFromDateTime: any;
+    }) => any;
+    getAuthorizeUrlFromRequestUri: ({ requestUri }: {
+        requestUri: any;
+    }) => string;
+    requestObject: ({ scope, state, claims, nonce }: {
+        scope: any;
+        state: any;
+        claims: any;
+        nonce: any;
+    }) => any;
+    getRequestUri: (requestObject: any) => Promise<any>;
+    getAuthorizeUrlForCreatedUser: ({ bankId, state, nonce, userId, claims, permissions, expirationDateTime, transactionFromDateTime, enableAsync, }: {
+        bankId: any;
+        state: any;
+        nonce: any;
+        userId: any;
+        claims?: {} | undefined;
+        permissions: any;
+        expirationDateTime: any;
+        transactionFromDateTime: any;
+        enableAsync: any;
+    }) => Promise<any>;
+    getReauthAuthorizeUrlForCreatedUser: ({ userId, connectionId, state, nonce, claims, expirationDateTime, transactionFromDateTime, enableAsync, }: {
+        userId: any;
+        connectionId: any;
+        state: any;
+        nonce: any;
+        claims?: {} | undefined;
+        expirationDateTime: any;
+        transactionFromDateTime: any;
+        enableAsync: any;
+    }) => Promise<any>;
+    getReconsentAuthorizeUrlForCreatedUser: ({ userId, connectionId, expiresAt, state, nonce, claims, }: {
+        userId: any;
+        connectionId: any;
+        expiresAt: any;
+        state: any;
+        nonce: any;
+        claims?: {} | undefined;
+    }) => Promise<any>;
+    getRefreshAuthorizeUrlForCreatedUser: ({ userId, connectionId, state, nonce, claims, expirationDateTime, transactionFromDateTime, enableAsync }: {
+        userId: any;
+        connectionId: any;
+        state: any;
+        nonce: any;
+        claims?: {} | undefined;
+        expirationDateTime: any;
+        transactionFromDateTime: any;
+        enableAsync: any;
+    }) => Promise<any>;
+    getPaymentAuthorizeUrl: ({ bankId, payeeId, payeeType, amount, payeeRef, payerRef, payerId, payerType, state, nonce, context, readRefundAccount, userId, claims, }: {
+        bankId: any;
+        payeeId: any;
+        payeeType: any;
+        amount: any;
+        payeeRef: any;
+        payerRef: any;
+        payerId: any;
+        payerType: any;
+        state: any;
+        nonce: any;
+        context: any;
+        readRefundAccount: any;
+        userId: any;
+        claims?: {} | undefined;
+    }) => Promise<string>;
+    getReversePaymentAuthorizeUrl: ({ bankId, paymentId, state, nonce, amount, claims, }: {
+        bankId: any;
+        paymentId: any;
+        state: any;
+        nonce: any;
+        amount: any;
+        claims?: {} | undefined;
+    }) => Promise<string>;
+    getRecurringPaymentAuthorizeUrl: ({ bankId, payeeId, payeeType, payerId, payerType, reference, validFromDate, validToDate, maximumIndividualAmount, currency, periodicLimits, type, context, state, nonce, userId, claims, }: {
+        bankId: any;
+        payeeId: any;
+        payeeType: any;
+        payerId: any;
+        payerType: any;
+        reference: any;
+        validFromDate: any;
+        validToDate: any;
+        maximumIndividualAmount: any;
+        currency: any;
+        periodicLimits: any;
+        type: any;
+        context: any;
+        state: any;
+        nonce: any;
+        userId: any;
+        claims?: {} | undefined;
+    }) => Promise<string>;
+    getStandingOrderAuthorizeUrl: ({ bankId, payeeId, payeeType, payerId, payerType, reference, frequency, numberOfPayments, firstPaymentAmount, recurringPaymentAmount, finalPaymentAmount, currency, firstPaymentDate, recurringPaymentDate, finalPaymentDate, state, nonce, context, claims, }: {
+        bankId: any;
+        payeeId: any;
+        payeeType: any;
+        payerId: any;
+        payerType: any;
+        reference: any;
+        frequency: any;
+        numberOfPayments: any;
+        firstPaymentAmount: any;
+        recurringPaymentAmount: any;
+        finalPaymentAmount: any;
+        currency: any;
+        firstPaymentDate: any;
+        recurringPaymentDate: any;
+        finalPaymentDate: any;
+        state: any;
+        nonce: any;
+        context: any;
+        claims?: {} | undefined;
+    }) => Promise<string>;
+    getPushedAuthorisationRequestUrl: ({ bankId, state, nonce, userId, claims, permissions, expirationDateTime, transactionFromDateTime, enableAsync, codeChallenge, }: {
+        bankId: any;
+        state: any;
+        nonce: any;
+        userId: any;
+        claims?: {} | undefined;
+        permissions: any;
+        expirationDateTime: any;
+        transactionFromDateTime: any;
+        enableAsync: any;
+        codeChallenge: any;
+    }) => Promise<any>;
+};
+export = _exports;
+//# sourceMappingURL=get-auth-urls.d.ts.map

package/dist/src/get-auth-urls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-auth-urls.d.ts","sourceRoot":"","sources":["../../src/get-auth-urls.js"],"names":[],"mappings":"AAIiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2mBhB"}

package/dist/src/get-auth-urls.js

@@ -0,0 +1,438 @@
+"use strict";
+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;
+        },
+        getPushedAuthorisationRequestUrl: async ({ bankId, state, nonce, userId, claims = {}, permissions, expirationDateTime, transactionFromDateTime, enableAsync, codeChallenge, }) => {
+            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 authParams = filterUndefined({
+                client_id,
+                scope,
+                state,
+                nonce,
+                redirect_uri,
+                response_type,
+                prompt: "consent",
+            });
+            const pkceParams = codeChallenge && {
+                code_challenge: codeChallenge,
+                code_challenge_method: "S256",
+            };
+            const request = await client.requestObject({
+                ...authParams,
+                ...pkceParams,
+                claims: _claims,
+                expirationDateTime,
+                transactionFromDateTime,
+                enableAsync,
+            }, {
+                sign: request_object_signing_alg,
+            });
+            const pushedRequest = await client.pushedAuthorizationRequest({ request });
+            const url = client.authorizationUrl(pushedRequest);
+            return url;
+        },
+    };
+};
+//# sourceMappingURL=get-auth-urls.js.map