3.1.3

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojoio/tink",
-  "version": "2.0.0",
+  "version": "3.1.3",
   "private": false,
   "description": "an unofficial api abstraction for tink.com",
   "main": "dist_ts/index.js",
@@ -13,17 +13,19 @@
     "build": "(tsbuild --web)"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.61",
-    "@gitzone/tsbundle": "^1.0.102",
-    "@gitzone/tstest": "^1.0.70",
-    "@pushrocks/qenv": "^4.0.10",
-    "@pushrocks/tapbundle": "^5.0.3",
-    "@types/node": "^17.0.25",
-    "tslint": "^6.1.3",
-    "tslint-config-prettier": "^1.15.0"
+    "@gitzone/tsbuild": "^2.1.65",
+    "@gitzone/tsbundle": "^2.0.7",
+    "@gitzone/tsrun": "^1.2.39",
+    "@gitzone/tstest": "^1.0.73",
+    "@pushrocks/qenv": "^5.0.2",
+    "@pushrocks/tapbundle": "^5.0.4",
+    "@types/node": "^18.11.7"
   },
   "dependencies": {
-    "@pushrocks/smartrequest": "^1.1.56"
+    "@pushrocks/smartdelay": "^2.0.13",
+    "@pushrocks/smartpromise": "^3.1.7",
+    "@pushrocks/smartrequest": "^2.0.10",
+    "@pushrocks/smarturl": "^3.0.5"
   },
   "browserslist": [
     "last 1 chrome versions"

test/test.nonci.ts

@@ -19,12 +19,40 @@ tap.test('should report tink as healthy', async () => {
   await expectAsync(tinkTestAccount.getTinkHealthyBoolean()).toBeTrue();
 });
 
+tap.test('should create a tink user', async (toolsArg) => {
+  await tinkTestAccount.createTinkUser('user_1234_abc');
+})
+
 tap.test('should create a valid request', async (toolsArg) => {
   const tinkuser: tink.TinkUser = await tinkTestAccount.getTinkUser('user_1234_abc');
   console.log(tinkuser);
   console.log(await tinkuser.getTinkLinkForMarket()); // defaults to 'DE';
   console.log(await tinkuser.getProviderConsents());
-  await toolsArg.delayFor(10000);
+});
+
+tap.test('allow tink link to be used', async (toolsArg) => {
+  await toolsArg.delayFor(30000);
+});
+
+tap.test('get provider consents', async () => {
+  const tinkuser: tink.TinkUser = await tinkTestAccount.getTinkUser('user_1234_abc');
+  const providerConsents = await tinkuser.getProviderConsents();
+  console.log(providerConsents);
+});
+
+tap.test('get bankaccounts', async (toolsArg) => {
+  const tinkuser: tink.TinkUser = await tinkTestAccount.getTinkUser('user_1234_abc');
+  const bankAccounts = await tinkuser.getAllBankAccounts();
+  console.log(bankAccounts.map(bankAccountArg => bankAccountArg.getNormalizedData()));
+
+  for (const bankAccount of bankAccounts) {
+    const transactions = await bankAccount.getTransactions();
+    for (const transaction of transactions) {
+      console.log(`=======================`)
+      console.log(JSON.stringify(transaction.getNormalizedData()));
+    }
+    await toolsArg.delayFor(10000);
+  } 
 });
 
 tap.test('should delete existing users', async () => {

ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@mojoio/tink',
+  version: '3.1.3',
+  description: 'an unofficial api abstraction for tink.com'
+}

ts/helpers/index.ts

@@ -0,0 +1 @@
+export * from './tinkmath.js';

ts/helpers/tinkmath.ts

@@ -0,0 +1,22 @@
+export interface ITinkScaledAmount {
+  value: {
+    unscaledValue: string;
+    scale: string;
+  };
+  currencyCode: string;
+}
+
+/**
+ * returns a normalized amount
+ * @param scaledArg
+ * @returns
+ */
+export const getNormalizedAmount = (scaledArg?: ITinkScaledAmount) => {
+  if (!scaledArg) {
+    return null;
+  }
+  return {
+    amount: parseInt(scaledArg.value.unscaledValue) * Math.pow(10, -(parseInt(scaledArg.value.scale))),
+    currency: 'EUR'
+  };
+};

ts/index.ts

@@ -1,3 +1,3 @@
 export * from './tink.classes.tinkaccount.js';
 export * from './tink.classes.tinkuser.js';
-export * from './tink.classes.tinkproviderconsent.js';
+export * from './tink.classes.tinkproviderconsent.js';

ts/tink.classes.bankaccount.ts

@@ -0,0 +1,130 @@
+import { BankTransaction } from './tink.classes.banktransaction.js';
+import { TinkUser } from './tink.classes.tinkuser.js';
+import * as plugins from './tink.plugins.js';
+
+import * as tinkHelpers from './helpers/index.js';
+
+export interface ITinkBankAccountData {
+  balances: {
+    booked: {
+      amount: {
+        currencyCode: string;
+        value: {
+          scale: string;
+          unscaledValue: string;
+        };
+      };
+    };
+    available: {
+      amount: {
+        currencyCode: string;
+        value: {
+          scale: string;
+          unscaledValue: string;
+        };
+      };
+    };
+  };
+  customerSegment: string;
+  dates: {
+    lastRefreshed: string;
+  };
+  financialInstitutionId: string;
+  id: string;
+  identifiers: {
+    iban?: {
+      bban: string;
+      iban: string;
+    };
+    pan: {
+      masked: string;
+    };
+    financialInstitution: { accountNumber: string; referenceNumbers: unknown };
+  };
+  name: string;
+  type: string;
+}
+
+export class BankAccount {
+  // STATIC
+  public static async getAccountUserAccessToken(tinkUserArg: TinkUser) {
+    const authorizationCode = await tinkUserArg.tinkAccountRef.getUserAuthorizationCode(
+      tinkUserArg.externalUserIdArg,
+      tinkUserArg.tinkAccountRef.clientId,
+      'accounts:read,balances:read,transactions:read,provider-consents:read'
+    );
+    const accessToken = await tinkUserArg.tinkAccountRef.getUserAccessToken(authorizationCode);
+    return accessToken;
+  }
+
+  public static async getBankAccountsForUser(tinkUserArg: TinkUser) {
+    const userAccessToken = await this.getAccountUserAccessToken(tinkUserArg);
+    const returnBankAccounts: BankAccount[] = [];
+    const getBankAccountRecursively = async (nextPageToken?: string) => {
+      const searchParams = new URLSearchParams();
+      searchParams.set('pageSize', '200');
+      if (nextPageToken) {
+        searchParams.set('pageToken', nextPageToken);
+      }
+      const response = await tinkUserArg.tinkAccountRef.request({
+        urlArg: `/data/v2/accounts?${searchParams.toString()}`,
+        accessToken: userAccessToken,
+        methodArg: 'GET',
+        payloadArg: null,
+      });
+      for (const account of response.accounts) {
+        returnBankAccounts.push(new BankAccount(tinkUserArg, account));
+      }
+      if (response.nextPageToken.length > 0) {
+        await getBankAccountRecursively(response.nextPageToken);
+      }
+    };
+    await getBankAccountRecursively();
+    return returnBankAccounts;
+  }
+
+  // INSTANCE
+  tinkUserRef: TinkUser;
+  data: ITinkBankAccountData;
+  constructor(tinkUserRefArg: TinkUser, dataArg: ITinkBankAccountData) {
+    this.tinkUserRef = tinkUserRefArg;
+    this.data = dataArg;
+  }
+
+  /**
+   * updates the account and tries to get the latest state from bunq
+   */
+  public async update() {
+    const bankAccounts = await BankAccount.getBankAccountsForUser(this.tinkUserRef);
+    const matchingAccount = bankAccounts.find(
+      (bankAccountArg) => bankAccountArg.data.id === this.data.id
+    );
+    if (matchingAccount) {
+      this.data = matchingAccount.data;
+    }
+  }
+
+  /**
+   * gets normalized data
+   */
+  public getNormalizedData() {
+    return {
+      id: this.data.id,
+      name: this.data.name,
+      accountNumber:
+        this.data.identifiers.iban?.iban ||
+        this.data.identifiers?.financialInstitution?.accountNumber ||
+        null,
+      bookedValue: tinkHelpers.getNormalizedAmount(this.data.balances.booked?.amount),
+      availableValue: tinkHelpers.getNormalizedAmount(this.data.balances.available?.amount),
+    };
+  }
+
+  /**
+   * gets the transactions for the bank account
+   */
+  public async getTransactions() {
+    const transactions = await BankTransaction.getBankTransactions(this);
+    return transactions;
+  }
+}

ts/tink.classes.banktransaction.ts

@@ -0,0 +1,114 @@
+import { BankAccount } from './tink.classes.bankaccount.js';
+import * as plugins from './tink.plugins.js';
+
+import * as tinkHelpers from './helpers/index.js';
+
+export interface ITinkBankTransactiondata {
+  id: string;
+  accountId:string;
+  amount: {
+    currencyCode: string;
+    value: {
+      scale: string;
+      unscaledValue: string;
+    };
+  };
+  categories: {
+    pfm: {
+      id: string;
+      name: string;
+    };
+  };
+  dates: {
+    booked: string;
+    value: string;
+  };
+  descriptions: {
+    display: string;
+    original: string;
+  };
+  identifiers: {
+    providerTransactionId: string;
+  };
+  merchantInformation: {
+    merchantCategoryCode: 'string';
+    merchantName: 'string';
+  };
+  providerMutability: string;
+  reference: string;
+  status: string;
+  types: {
+    financialInstitutionTypeCode: string;
+    type: string;
+  };
+}
+
+export class BankTransaction {
+  // STATIC
+  public static async getTransactionAccessToken(bankAccountArg: BankAccount) {
+    const authorizationCode =
+      await bankAccountArg.tinkUserRef.tinkAccountRef.getUserAuthorizationCode(
+        bankAccountArg.tinkUserRef.externalUserIdArg,
+        bankAccountArg.tinkUserRef.tinkAccountRef.clientId,
+        'accounts:read,balances:read,transactions:read,provider-consents:read'
+      );
+    const accessToken = await bankAccountArg.tinkUserRef.tinkAccountRef.getUserAccessToken(
+      authorizationCode
+    );
+    return accessToken;
+  }
+
+  public static async getBankTransactions(bankAccountArg: BankAccount) {
+    const accessToken = await this.getTransactionAccessToken(bankAccountArg);
+    const pageSize = 100;
+    const returnTransactions: BankTransaction[] = [];
+    const getTransactionsRecursively = async (nextPageToken?: string) => {
+      const searchParams = new URLSearchParams();
+      searchParams.set('accountIdIn', bankAccountArg.data.id);
+      searchParams.set('pageSize', '200');
+      if (nextPageToken) {
+        searchParams.set('pageToken', nextPageToken)
+      }
+      const response = await bankAccountArg.tinkUserRef.tinkAccountRef.request({
+        urlArg: `/data/v2/transactions?${searchParams.toString()}`,
+        accessToken: accessToken,
+        methodArg: 'GET',
+        payloadArg: null,
+      });
+      for (const transaction of response.transactions) {
+        returnTransactions.push(new BankTransaction(bankAccountArg, transaction));
+      }
+
+      if (response.nextPageToken.length > 0) {
+        await getTransactionsRecursively(response.nextPageToken);
+      }
+    };
+    await getTransactionsRecursively();
+    return returnTransactions;
+  }
+
+  // INSTANCE
+  bankAccountRef: BankAccount;
+  data: ITinkBankTransactiondata;
+
+  constructor(bankAccountRefArg: BankAccount, dataArg: ITinkBankTransactiondata) {
+    this.bankAccountRef = bankAccountRefArg;
+    this.data = dataArg;
+  }
+
+  /**
+   * gets normalized data
+   */
+  public getNormalizedData() {
+    return {
+      id: this.data.id,
+      amount: tinkHelpers.getNormalizedAmount(this.data.amount),
+      name: this.data.descriptions.display,
+      description: this.data.descriptions.original,
+      justForLooks: {
+        originalScaledAmount: this.data.amount
+      }
+    }
+
+  }
+}

ts/tink.classes.tinkproviderconsent.ts

@@ -1,30 +1,87 @@
 import * as plugins from './tink.plugins.js';
 
+export interface IProviderData {
+  credentialsId: string;
+  providerName: string;
+  status: string;
+  sessionExpiryDate: number;
+  accountIds: string[];
+  statusUpdated: number;
+}
+
 import { TinkUser } from './tink.classes.tinkuser.js';
 
 /**
  * a provider consent maps to tinks bank consents
  */
 export class TinkProviderConsent {
-  // STATIC
-  public static async getProviderConsentsForUser(tinkUserRefArg: TinkUser) {
-    const returnProviderConsents: TinkProviderConsent[] = [];
+  public static async getProviderUserAccessToken(tinkUserRefArg: TinkUser) {
     const authorizationCode = await tinkUserRefArg.tinkAccountRef.getUserAuthorizationCode(
       tinkUserRefArg.externalUserIdArg,
       tinkUserRefArg.tinkAccountRef.clientId,
       'accounts:read,balances:read,transactions:read,provider-consents:read'
     );
     const accessToken = await tinkUserRefArg.tinkAccountRef.getUserAccessToken(authorizationCode);
+    return accessToken;
+  }
+
+  // STATIC
+  public static async getProviderConsentsForUser(tinkUserRefArg: TinkUser) {
+    const returnProviderConsents: TinkProviderConsent[] = [];
+    const accessToken = await this.getProviderUserAccessToken(tinkUserRefArg);
     const responseData = await tinkUserRefArg.tinkAccountRef.request({
       urlArg: '/api/v1/provider-consents',
       accessToken,
       methodArg: 'GET',
       payloadArg: null,
     });
-    console.log(responseData);
+    // console.log(responseData); // no nextPageToken here?
+    if (responseData.providerConsents) {
+      for (const providerConsentData of responseData.providerConsents) {
+        returnProviderConsents.push(new TinkProviderConsent(tinkUserRefArg, providerConsentData));
+      }
+    }
     return returnProviderConsents;
   }
 
   // INSTANCE
-  constructor(tinkUserRefArg: TinkUser) {}
+  tinkUserRef: TinkUser;
+  data: IProviderData;
+  constructor(tinkUserRefArg: TinkUser, dataArg: IProviderData) {
+    this.tinkUserRef;
+    this.data = dataArg;
+  }
+
+  /**
+   * refresh the bank account data from origin
+   */
+  public async refresh() { 
+    const userAccessToken = await TinkProviderConsent.getProviderUserAccessToken(this.tinkUserRef);
+    const response = await this.tinkUserRef.tinkAccountRef.request({
+      accessToken: userAccessToken,
+      methodArg: 'POST',
+      urlArg: `https://api.tink.com/api/v1/credentials/${this.data.credentialsId}/refresh`,
+      payloadArg: null
+    });
+    
+    // polling as per documentation for status 'UPDATED';
+    let pollingRounds = 0;
+    let status = null;
+    while(status !== 'UPDATED' && pollingRounds < 10) {
+      await plugins.smartdelay.delayFor(2000);
+      await this.update();
+      status = this.data.status;
+      pollingRounds++;
+    }
+    // think about how to handle errors here
+  }
+
+  public async update() {
+    const providerConsents = await TinkProviderConsent.getProviderConsentsForUser(this.tinkUserRef);
+    for (const providerConsent of providerConsents) {
+      if (providerConsent.data.credentialsId === this.data.credentialsId) {
+        this.data = providerConsent.data;
+      }
+    }
+  }
 }

ts/tink.classes.tinkuser.ts

@@ -2,6 +2,7 @@ import * as plugins from './tink.plugins.js';
 
 import { TinkAccount } from './tink.classes.tinkaccount.js';
 import { TinkProviderConsent } from './tink.classes.tinkproviderconsent.js';
+import { BankAccount } from './tink.classes.bankaccount.js';
 
 export class TinkUser {
   // STATIC
@@ -109,13 +110,43 @@ export class TinkUser {
    * gets a tink link that can be used by a user to connect accounts
    * @returns
    */
-  public async getTinkLinkForMarket(countryIdArg: string = 'DE', redirectUrlArg = 'https://console.tink.com/callback'): Promise<string> {
+  public async getTinkLinkForMarket(linkOptionsArg: {
+    countryId: string;
+    redirectUrl: string;
+    /**
+     * an optional state that is transported through to the callback
+     */
+    customState: string;
+    testProviderBool?: boolean;
+  } = {
+    countryId: 'NL',
+    redirectUrl: 'https://console.tink.com/callback',
+    customState: "exampleState",
+    testProviderBool: true
+  }): Promise<string> {
+    if (typeof linkOptionsArg.testProviderBool !== 'boolean') {
+      linkOptionsArg.testProviderBool = false;
+    }
     const authorizationCode = await this.tinkAccountRef.getUserAuthorizationCode(
       this.externalUserIdArg,
       'df05e4b379934cd09963197cc855bfe9', // this is a hardcoded app id for tink link, as recommended by tink.com
       'authorization:read,authorization:grant,credentials:refresh,credentials:read,credentials:write,providers:read,user:read'
     );
-    const tinkLinkUrl = `https://link.tink.com/1.0/business-transactions/connect-accounts?client_id=${'teststate'}&redirect_uri=${redirectUrlArg}&authorization_code=${authorizationCode}&market=${countryIdArg}`;
+    const tinkUrlOptions: {[key: string]: string} = {}
+    tinkUrlOptions['client_id'] = this.tinkAccountRef.clientId;
+    tinkUrlOptions['redirect_uri']= linkOptionsArg.redirectUrl;
+    tinkUrlOptions['authorization_code'] = authorizationCode;
+    tinkUrlOptions['market'] = linkOptionsArg.countryId;
+    if (linkOptionsArg.testProviderBool) {
+      tinkUrlOptions['test'] = 'true';
+    }
+    if (linkOptionsArg.customState) {
+      tinkUrlOptions['state'] = linkOptionsArg.customState;
+    }
+    const url = plugins.smarturl.Smarturl.createFromUrl('https://link.tink.com/1.0/business-transactions/connect-accounts', {
+      searchParams: tinkUrlOptions
+    });
+    const tinkLinkUrl = url.toString();
     return tinkLinkUrl;
   }
 
@@ -124,4 +155,12 @@ export class TinkUser {
       await TinkProviderConsent.getProviderConsentsForUser(this);
     return providerConsents;
   }
+
+  /**
+   * gets all accounts
+   */
+  public async getAllBankAccounts() {
+    const bankAccounts = await BankAccount.getBankAccountsForUser(this);
+    return bankAccounts;
+  }
 }

ts/tink.plugins.ts

@@ -1,4 +1,7 @@
 // @pushrocks scope
+import * as smartdelay from '@pushrocks/smartdelay';
 import * as smartrequest from '@pushrocks/smartrequest';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smarturl from '@pushrocks/smarturl';
 
-export { smartrequest };
+export { smartdelay, smartrequest, smartpromise, smarturl };

tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "nodenext",
+    "esModuleInterop": true
+  }
+}

tslint.json

@@ -1,17 +0,0 @@
-{
-  "extends": ["tslint:latest", "tslint-config-prettier"],
-  "rules": {
-    "semicolon": [true, "always"],
-    "no-console": false,
-    "ordered-imports": false,
-    "object-literal-sort-keys": false,
-    "member-ordering": {
-      "options":{
-        "order": [
-          "static-method"
-        ]
-      }
-    }
-  },
-  "defaultSeverity": "warning"
-}