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.12",
+  "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

@@ -27,14 +27,13 @@ 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');
-const tinkLinkUrl = await tinkUser.getTinkLink();
+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.
 
@@ -47,9 +46,11 @@ for (const providerConsent of tinkProviderConsents) {
   }
 }
 
+// additional stuff
+const existingTinkUser = await tinkAccount.getUser('<YourOwnUniqueUserId/externalUserId>');
+await existingTinkuser.delete(); // delete the user on the tink platform
 ```
 
-
 ## Contribution
 
 We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)

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"
-}