3.1.0

.gitlab-ci.yml

@@ -100,10 +100,9 @@ codequality:
   only:
     - tags
   script:
-    - npmci command npm install -g tslint typescript
+    - npmci command npm install -g typescript
     - npmci npm prepare
     - npmci npm install
-    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
   tags:
     - lossless
     - docker

package.json

@@ -1,10 +1,11 @@
 {
   "name": "@mojoio/tink",
-  "version": "1.0.10",
+  "version": "3.1.0",
   "private": false,
   "description": "an unofficial api abstraction for tink.com",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
+  "type": "module",
   "author": "Lossless GmbH",
   "license": "MIT",
   "scripts": {
@@ -12,17 +13,19 @@
     "build": "(tsbuild --web)"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.25",
-    "@gitzone/tsbundle": "^1.0.78",
-    "@gitzone/tstest": "^1.0.64",
-    "@pushrocks/qenv": "^4.0.10",
-    "@pushrocks/tapbundle": "^4.0.7",
-    "@types/node": "^17.0.18",
+    "@gitzone/tsbuild": "^2.1.65",
+    "@gitzone/tsbundle": "^2.0.7",
+    "@gitzone/tstest": "^1.0.73",
+    "@pushrocks/qenv": "^5.0.2",
+    "@pushrocks/tapbundle": "^5.0.4",
+    "@types/node": "^18.7.8",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.15.0"
   },
   "dependencies": {
-    "@pushrocks/smartrequest": "^1.1.56"
+    "@pushrocks/smartdelay": "^2.0.13",
+    "@pushrocks/smartrequest": "^2.0.10",
+    "@pushrocks/smarturl": "^3.0.5"
   },
   "browserslist": [
     "last 1 chrome versions"

readme.md

@@ -28,8 +28,28 @@ Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20W
 Use TypeScript for best inclass intellisense
 
 ```typescript
+// this example assumes toplevel await
 import * as tink from '@mojoio/tink';
 
+const tinkAccount = new TinkAccount('<clientId>', '<clientSecret>');
+const tinkUser = await tinkAccount.createTinkUser('<YourOwnUniqueUserId/externalUserId>');
+const tinkLinkUrl = await tinkUser.getTinkLink('<marketCode like DE>');
+
+// present the link to your user to connect their bank accounts to the tink platform.
+
+const tinkProviderConsents = await tinkUser.getProviderConsents();
+
+for (const providerConsent of tinkProviderConsents) {
+  const bankAccounts = await providerConsent.getBankAccounts();
+  for (const bankAccount of bankAccounts) {
+    const transactions = bankAccount.getTransactions();
+  }
+}
+
+// additional stuff
+const existingTinkUser = await tinkAccount.getUser('<YourOwnUniqueUserId/externalUserId>');
+await existingTinkuser.delete(); // delete the user on the tink platform
+```
 
 ## Contribution
 

test/test.nonci.ts

@@ -3,7 +3,7 @@ import * as qenv from '@pushrocks/qenv';
 
 const testQenv = new qenv.Qenv('./', './.nogit/');
 
-import * as tink from '../ts/index';
+import * as tink from '../ts/index.js';
 
 let tinkTestAccount: tink.TinkAccount;
 
@@ -19,19 +19,43 @@ tap.test('should report tink as healthy', async () => {
   await expectAsync(tinkTestAccount.getTinkHealthyBoolean()).toBeTrue();
 });
 
-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('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());
+});
+
+tap.test('allow tink link to be used', async (toolsArg) => {
+  await toolsArg.delayFor(60000);
+});
+
+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);
+
+  for (const bankAccount of bankAccounts) {
+    const transactions = await bankAccount.getTransactions();
+    console.log(transactions);
+    await toolsArg.delayFor(10000);
+  } 
+});
+
 tap.test('should delete existing users', async () => {
-  process.exit(0);
   expect(tinkTestAccount).toBeInstanceOf(tink.TinkAccount);
   const tinkUser = new tink.TinkUser(tinkTestAccount, null, 'user_1234_abc');
   await tinkUser.delete();
-})
+});
 
 tap.start();

ts/00_commitinfo_data.ts

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

ts/index.ts

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

ts/tink.classes.bankaccount.ts

@@ -0,0 +1,89 @@
+import { BankTransaction } from './tink.classes.banktransaction.js';
+import { TinkUser } from './tink.classes.tinkuser.js';
+import * as plugins from './tink.plugins.js';
+
+export interface IBankAccountData {
+  "balances": {
+    "booked": {
+      "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
+    }
+  },
+  "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: IBankAccountData;
+  constructor(tinkUserRefArg: TinkUser, dataArg: IBankAccountData) {
+    this.tinkUserRef = tinkUserRefArg;
+    this.data = dataArg;
+  }
+
+  /**
+   * 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,96 @@
+import { BankAccount } from './tink.classes.bankaccount.js';
+import * as plugins from './tink.plugins.js';
+
+export interface IBankTransactiondata {
+  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;
+  };
+  id: 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: IBankTransactiondata;
+
+  constructor(bankAccountRefArg: BankAccount, dataArg: IBankTransactiondata) {
+    this.bankAccountRef = bankAccountRefArg;
+    this.data = dataArg;
+  }
+}

ts/tink.classes.tinkaccount.ts

@@ -1,16 +1,16 @@
-import * as plugins from './tink.plugins';
+import * as plugins from './tink.plugins.js';
 
-import { TinkUser } from './tink.classes.tinkuser';
+import { TinkUser } from './tink.classes.tinkuser.js';
 
 export class TinkAccount {
   public clientId: string;
-  private clientSecret: string;
+  private _clientSecret: string;
 
-  private apiBaseUrl: string = 'https://api.tink.com';
+  private _apiBaseUrl: string = 'https://api.tink.com';
 
   constructor(clientIdArg: string, clientSecretArg: string) {
     this.clientId = clientIdArg;
-    this.clientSecret = clientSecretArg;
+    this._clientSecret = clientSecretArg;
   }
 
   public async getTinkHealthyBoolean(): Promise<boolean> {
@@ -26,7 +26,7 @@ export class TinkAccount {
   public async getClientAccessTokenForScope(scopeArg: string): Promise<string> {
     // lets get an accessToken for the request
     const response = await plugins.smartrequest.postFormDataUrlEncoded(
-      `${this.apiBaseUrl}/api/v1/oauth/token`,
+      `${this._apiBaseUrl}/api/v1/oauth/token`,
       {
         keepAlive: false,
       },
@@ -37,7 +37,7 @@ export class TinkAccount {
         },
         {
           key: 'client_secret',
-          content: this.clientSecret,
+          content: this._clientSecret,
         },
         {
           key: 'grant_type',
@@ -65,7 +65,7 @@ export class TinkAccount {
   ) {
     const accessToken = await this.getClientAccessTokenForScope('authorization:grant');
     const response = await plugins.smartrequest.postFormDataUrlEncoded(
-      `${this.apiBaseUrl}/api/v1/oauth/authorization-grant/delegate`,
+      `${this._apiBaseUrl}/api/v1/oauth/authorization-grant/delegate`,
       {
         keepAlive: false,
         headers: {
@@ -107,7 +107,7 @@ export class TinkAccount {
   public async getUserAccessToken(authorizationCode: string): Promise<string> {
     const accessToken = await this.getClientAccessTokenForScope('authorization:grant');
     const response = await plugins.smartrequest.postFormDataUrlEncoded(
-      `${this.apiBaseUrl}/api/v1/oauth/token`,
+      `${this._apiBaseUrl}/api/v1/oauth/token`,
       {
         keepAlive: false,
       },
@@ -122,7 +122,7 @@ export class TinkAccount {
         },
         {
           key: 'client_secret',
-          content: this.clientSecret,
+          content: this._clientSecret,
         },
         {
           key: 'grant_type',
@@ -153,7 +153,7 @@ export class TinkAccount {
     } else {
       console.log('tink is healthy, continuing...');
     }
-    const response = await plugins.smartrequest.request(`${this.apiBaseUrl}${optionsArg.urlArg}`, {
+    const response = await plugins.smartrequest.request(`${this._apiBaseUrl}${optionsArg.urlArg}`, {
       keepAlive: false,
       headers: {
         Authorization: `Bearer ${optionsArg.accessToken}`,

ts/tink.classes.tinkproviderconsent.ts

@@ -1,30 +1,87 @@
-import * as plugins from './tink.plugins';
+import * as plugins from './tink.plugins.js';
 
-import { TinkUser } from './tink.classes.tinkuser';
+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);
+      payloadArg: null,
+    });
+    // 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

@@ -1,7 +1,8 @@
-import * as plugins from './tink.plugins';
+import * as plugins from './tink.plugins.js';
 
-import { TinkAccount } from './tink.classes.tinkaccount';
-import { TinkProviderConsent } from './tink.classes.tinkproviderconsent';
+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
@@ -80,8 +81,6 @@ export class TinkUser {
   public tinkUserId: string;
   public externalUserIdArg: string;
 
-  public authorizationToken: string;
-
   constructor(tinkAccountrefArg: TinkAccount, tinkUserIdArg: string, externalUserIdArg: string) {
     this.tinkAccountRef = tinkAccountrefArg;
     this.tinkUserId = tinkUserIdArg;
@@ -111,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'): 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: 'DE',
+    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=https://console.tink.com/callback&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;
   }
 
@@ -126,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,6 +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"
-}