wip

pontusab · pontusab · commit d9cd15563c3f · 2024-12-07T10:51:21.000+01:00
diff --git a/apps/engine/src/providers/pluggy/pluggy-api.ts b/apps/engine/src/providers/pluggy/pluggy-api.ts
@@ -1,6 +1,10 @@
 import { PluggyClient } from "pluggy-sdk";
-import type { ProviderParams } from "../types";
-import type { GetTransactionsParams } from "./types";
+import type {
+  GetAccountBalanceResponse,
+  GetConnectionStatusRequest,
+  ProviderParams,
+} from "../types";
+import type { GetStatusResponse, GetTransactionsParams } from "./types";
 
 export class PluggyApi {
   #client: PluggyClient;
@@ -26,35 +30,57 @@ export class PluggyApi {
   }
 
   async getAccounts(id: string) {
-    return this.#client.fetchAccounts(id);
+    const response = await this.#client.fetchAccounts(id);
+
+    return response.results;
   }
 
   async getTransactions({ accountId, latest }: GetTransactionsParams) {
     if (latest) {
-      return this.#client.fetchTransactions(accountId);
+      const response = await this.#client.fetchTransactions(accountId);
+
+      return response.results;
     }
 
-    return this.#client.fetchAllTransactions(accountId);
+    const response = await this.#client.fetchAllTransactions(accountId);
+
+    return response;
   }
 
   async getHealthCheck() {
-    // https://status.pluggy.ai/api/v2/status.json
-    // return this.#client.healthCheck();
+    try {
+      const response = await fetch(
+        "https://status.pluggy.ai/api/v2/status.json",
+      );
+
+      const data = (await response.json()) as GetStatusResponse;
+
+      return (
+        data.status.indicator === "none" ||
+        data.status.indicator === "maintenance"
+      );
+    } catch {
+      return false;
+    }
   }
 
-  async getAccountBalance({
-    accessToken,
-    accountId,
-  }: GetAccountBalanceRequest): Promise<
-    GetAccountBalanceResponse | undefined
-  > {}
+  async getAccountBalance(
+    accountId: string,
+  ): Promise<GetAccountBalanceResponse | undefined> {
+    const response = await this.#client.fetchAccount(accountId);
+
+    return {
+      currency: response.currencyCode,
+      amount: response.balance,
+    };
+  }
 
   async getInstitutions() {
     return this.#client.fetchConnectors();
   }
 
-  async getInstitutionById(id: string) {
-    return this.#client.fetchConnectorById(id);
+  async getInstitutionById(id: number) {
+    return this.#client.fetchConnector(id);
   }
 
   async getConnectionStatus({ id }: GetConnectionStatusRequest) {
diff --git a/apps/engine/src/providers/pluggy/pluggy-provider.ts b/apps/engine/src/providers/pluggy/pluggy-provider.ts
@@ -10,12 +10,7 @@ import type {
   ProviderParams,
 } from "../types";
 import { PluggyApi } from "./pluggy-api";
-import {
-  transformAccount,
-  transformAccountBalance,
-  transformInstitution,
-  transformTransaction,
-} from "./transform";
+import { transformAccount, transformTransaction } from "./transform";
 
 export class PluggyProvider implements Provider {
   #api: PluggyApi;
@@ -24,62 +19,46 @@ export class PluggyProvider implements Provider {
     this.#api = new PluggyApi(params);
   }
 
-  //   async getTransactions({
-  //     accessToken,
-  //     accountId,
-  //     accountType,
-  //     latest,
-  //   }: GetTransactionsRequest) {
-  //     if (!accessToken || !accountId) {
-  //       throw Error("accessToken or accountId is missing");
-  //     }
+  async getTransactions({ accountId, latest }: GetTransactionsRequest) {
+    if (!accountId) {
+      throw Error("accountId is missing");
+    }
 
-  //     const response = await this.#api.getTransactions({
-  //       accessToken,
-  //       accountId,
-  //       latest,
-  //     });
+    const response = await this.#api.getTransactions({
+      accountId,
+      latest,
+    });
 
-  //     return (response ?? []).map((transaction) =>
-  //       transformTransaction({
-  //         transaction,
-  //         accountType,
-  //       }),
-  //     );
-  //   }
+    return (response ?? []).map(transformTransaction);
+  }
 
-  //   async getHealthCheck() {
-  //     return this.#api.getHealthCheck();
-  //   }
+  async getHealthCheck() {
+    return this.#api.getHealthCheck();
+  }
 
-  //   async getAccounts({ accessToken, institutionId }: GetAccountsRequest) {
-  //     if (!accessToken || !institutionId) {
-  //       throw Error("accessToken or institutionId is missing");
-  //     }
+  async getAccounts({ id }: GetAccountsRequest) {
+    if (!id) {
+      throw Error("id is missing");
+    }
 
-  //     const response = await this.#api.getAccounts({
-  //       accessToken,
-  //       institutionId,
-  //     });
+    const response = await this.#api.getAccounts(id);
 
-  //     return (response ?? []).map(transformAccount);
-  //   }
+    return (response ?? []).map(transformAccount);
+  }
 
-  //   async getAccountBalance({
-  //     accessToken,
-  //     accountId,
-  //   }: GetAccountBalanceRequest) {
-  //     if (!accessToken || !accountId) {
-  //       throw Error("Missing params");
-  //     }
+  async getAccountBalance({ accountId }: GetAccountBalanceRequest) {
+    if (!accountId) {
+      throw Error("Missing params");
+    }
 
-  //     const response = await this.#api.getAccountBalance({
-  //       accessToken,
-  //       accountId,
-  //     });
+    const response = await this.#api.getAccountBalance(accountId);
 
-  //     return transformAccountBalance(response);
-  //   }
+    if (!response) {
+      throw Error("Account not found");
+    }
+
+    return response;
+  }
 
   //   async getInstitutions({ countryCode }: GetInstitutionsRequest) {
   //     const response = await this.#api.getInstitutions({
diff --git a/apps/engine/src/providers/pluggy/transform.ts b/apps/engine/src/providers/pluggy/transform.ts
@@ -0,0 +1,47 @@
+import { getType } from "@/utils/account";
+import { capitalCase } from "change-case";
+import type { Account, AccountType, Transaction } from "pluggy-sdk";
+import type {
+  Account as BaseAccount,
+  Balance as BaseBalance,
+  Transaction as BaseTransaction,
+} from "../types";
+
+export const transformTransaction = (
+  transaction: Transaction,
+): BaseTransaction => {
+  return {
+    id: transaction.id,
+    amount: transaction.amount,
+    date: transaction.date.toISOString(),
+    currency: transaction.currencyCode,
+    status: transaction.status === "POSTED" ? "posted" : "pending",
+    balance: transaction.balance,
+    category: transaction.category,
+    method: transaction.type,
+    description: null,
+    currency_rate: null,
+    currency_source: null,
+    name: capitalCase(transaction.description),
+  };
+};
+
+export const transformAccount = (account: Account): BaseAccount => {
+  return {
+    id: account.id,
+    name: account.name,
+    currency: account.currencyCode,
+    type: getType(account.type),
+    institution: {
+      id: "",
+      name: "",
+      logo: "",
+      provider: "pluggy",
+    },
+    enrollment_id: null,
+    balance: {
+      amount: account.balance,
+      currency: account.currencyCode,
+    },
+  };
+};
diff --git a/apps/engine/src/providers/pluggy/types.ts b/apps/engine/src/providers/pluggy/types.ts
@@ -2,3 +2,17 @@ export type GetTransactionsParams = {
   accountId: string;
   latest?: boolean;
 };
+
+export type GetStatusResponse = {
+  page: {
+    id: string;
+    name: string;
+    url: string;
+    time_zone: string;
+    updated_at: string;
+  };
+  status: {
+    indicator: string;
+    description: string;
+  };
+};
diff --git a/apps/engine/src/providers/types.ts b/apps/engine/src/providers/types.ts
@@ -66,7 +66,7 @@ export type GetTransactionsRequest = {
 };
 
 export type GetAccountsRequest = {
-  id?: string; // GoCardLess
+  id?: string; // GoCardLess & Pluggy
   accessToken?: string; // Teller & Plaid
   institutionId?: string; // Plaid
 };
diff --git a/apps/engine/src/utils/account.test.ts b/apps/engine/src/utils/account.test.ts
@@ -4,10 +4,12 @@ import { type AccountType, getType } from "./account";
 describe("getType function", () => {
   it("should return 'depository' for 'depository' input", () => {
     expect(getType("depository")).toBe("depository");
+    expect(getType("BANK")).toBe("depository");
   });
 
   it("should return 'credit' for 'credit' input", () => {
     expect(getType("credit")).toBe("credit");
+    expect(getType("CREDIT")).toBe("credit");
   });
 
   it("should return 'other_asset' for any other input", () => {
diff --git a/apps/engine/src/utils/account.ts b/apps/engine/src/utils/account.ts
@@ -7,8 +7,10 @@ export type AccountType =
 
 export function getType(type: string): AccountType {
   switch (type) {
+    case "BANK":
     case "depository":
       return "depository";
+    case "CREDIT":
     case "credit":
       return "credit";
     default:
