@moovio/sdk 0.11.4 → 0.12.0

package/test/setup.ts

@@ -0,0 +1,119 @@
+import { beforeAll, afterAll } from "bun:test";
+import { Moov } from "@moovio/sdk";
+import secrets from "./.secrets.json";
+
+export let moov: Moov;
+
+const verbose = process.env.VERBOSE === "1";
+
+type Seen = {
+  accountID: string;
+  bankAccountID?: string;
+  cardID?: string;
+  representativeID?: string;
+};
+
+const idsSeen: Set<Seen> = new Set();
+
+export const ids = {
+  seen: (seen: Seen) => {
+    idsSeen.add(seen);
+  },
+  cleanup: async () => {
+    for (const seen of idsSeen) {
+      if (seen.representativeID) {
+        try {
+          console.log("🔄  Removing Representative", seen.representativeID);
+          await moov.representatives.delete({ accountID: seen.accountID, representativeID: seen.representativeID! });
+        } catch (e) {
+          // empty
+        }
+      } else if (seen.bankAccountID) {
+        try {
+          console.log("🔄  Removing Bank Account", seen.bankAccountID);
+          await moov.bankAccounts.disable({ accountID: seen.accountID, bankAccountID: seen.bankAccountID! });
+        } catch (e) {
+          // eslint-disable
+        }
+      } else if (seen.cardID) {
+        try {
+          console.log("🔄  Removing Card", seen.cardID);
+          await moov.cards.disable({ accountID: seen.accountID, cardID: seen.cardID! });
+        } catch (e) {
+          // empty
+        }
+      } else if (seen.accountID) {
+        try {
+          console.log("🔄  Removing Account", seen.accountID);
+          await moov.accounts.disconnect({ accountID: seen.accountID });
+        } catch (e) {
+          // eslint-disable
+        }
+      }
+    }
+  },
+};
+
+beforeAll(() => {
+  if (verbose) {
+    // Override global fetch to attach a logger
+    const originalFetch = global.fetch;
+    global.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = input instanceof Request ? input.url : input.toString();
+      const headers = input instanceof Request ? input.headers : "";
+      const body = input instanceof Request ? input.body : "";
+      const method = init?.method || (input instanceof Request ? input.method : "");
+
+      // Log requests
+      console.log(`↗️ API Request | ${method} | URL: ${url}`);
+      console.log(`Headers:`);
+      console.log(headers);
+      console.log(`Body:`);
+      console.log(body);
+      console.log("\n");
+
+      // Make the actual request
+      const response = await originalFetch(input, init);
+
+      // Clone the response since it can only be read once
+      const responseClone = response.clone();
+
+      // Log responses
+      console.log(`↙️ API Response | ${method} | URL: ${url}`);
+      console.log(`Status: ${response.status} ${response.statusText}`);
+      console.log(`Headers:`);
+      console.log(response.headers);
+      console.log(`Body:`);
+      try {
+        const responseBody = await responseClone.json();
+        console.log(JSON.stringify(responseBody, null, 2));
+      } catch (e) {
+        console.log("<non-JSON response>");
+      }
+      console.log("\n");
+
+      return response;
+    };
+
+    afterAll(() => {
+      global.fetch = originalFetch;
+    });
+    console.log("ℹ️  Logger setup complete\n\n");
+  }
+
+  moov = new Moov({
+    security: {
+      username: secrets.username,
+      password: secrets.password,
+    },
+    serverURL: secrets.serverURL,
+  });
+
+  console.log("ℹ️  Moov SDK setup complete\n\n");
+
+  afterAll(async () => {
+    console.log("\n\n🔄  Cleaning up after tests\n\n");
+    // Cleanup if we have the IDs available
+    await ids.cleanup();
+  });
+});

package/test/tests/accounts.test.ts

@@ -0,0 +1,127 @@
+import { expect, test, describe, beforeAll } from "bun:test";
+import { Chance } from "chance";
+import { moov } from "../setup";
+import { createAccount } from "../utils/utils";
+import type { Account, AccountType } from "../../models/components";
+const chance = new Chance();
+
+let account: Account;
+
+describe("Accounts", () => {
+  describe("Account creation", () => {
+    test("should create an account", async () => {
+      const legalBusinessName = `${chance.company()} ${new Date().getTime()}`;
+      const acc = await createAccount({
+        profile: {
+          business: {
+            legalBusinessName,
+          },
+        },
+      });
+
+      expect(acc).toBeDefined();
+      expect(acc.accountID).toBeDefined();
+      expect(acc.displayName).toEqual(legalBusinessName);
+      account = acc;
+    });
+    describe("Failure cases", () => {
+      test("should fail if the account type is not supported", async () => {
+        await expect(() =>
+          createAccount({
+            accountType: "not-a-valid-account-type" as AccountType,
+          }),
+        ).toThrowError();
+      });
+    });
+
+    test("should fail if we pass an empty business profile", async () => {
+      await expect(() =>
+        createAccount({
+          profile: {},
+        }),
+      ).toThrow();
+      // @TODO: Once error hanling is 100% consistent, we should be able to narrow this assertion
+      // Right now it's throwing a Zod validation error, but it should be a custom error instead
+      // ).toThrowError('API error occurred: {"error":{"profile":"business profile is required for business account"}}');
+    });
+  });
+
+  describe("Account-dependent tests", () => {
+    beforeAll(async () => {
+      if (!account) {
+        account = await createAccount();
+      }
+    });
+
+    describe("Account listing", () => {
+      test("should be able to list accounts", async () => {
+        const { result } = await moov.accounts.list({
+          name: account.displayName,
+        });
+        expect(result).toBeDefined();
+        expect(result.length).toBeGreaterThan(0);
+        expect(result[0].accountID).toEqual(account.accountID);
+      });
+
+      test("Should be able to filter accounts by type and status", async () => {
+        const { result } = await moov.accounts.list({
+          type: "business",
+          capabilityStatus: "pending",
+        });
+        expect(result).toBeDefined();
+        expect(result.length).toBeGreaterThan(0);
+        const { result: result2 } = await moov.accounts.list({
+          type: "individual",
+          capabilityStatus: "enabled",
+        });
+        expect(result2).toBeDefined();
+        expect(result2.length).toBeGreaterThan(0);
+      });
+
+      test("should be able to filter accounts by capability", async () => {
+        const { result } = await moov.accounts.list({
+          capability: "transfers",
+        });
+        expect(result).toBeDefined();
+        expect(result.length).toBeGreaterThan(0);
+        const { result: result2 } = await moov.accounts.list({
+          capability: "collect-funds",
+        });
+        expect(result2).toBeDefined();
+        expect(result2.length).toBeGreaterThan(0);
+      });
+    });
+
+    test("should be able to get an account", async () => {
+      const { result } = await moov.accounts.get({ accountID: account.accountID });
+      expect(result).toBeDefined();
+      expect(result.accountID).toEqual(account.accountID);
+    });
+
+    test("should be able to update an account", async () => {
+      const legalBusinessName = chance.company();
+      const { result } = await moov.accounts.update({
+        accountID: account.accountID,
+        createAccountUpdate: { profile: { business: { legalBusinessName } } },
+      });
+      expect(result).toBeDefined();
+      expect(result.accountID).toEqual(account.accountID);
+      expect(result.profile?.business?.legalBusinessName).toEqual(legalBusinessName);
+    });
+
+    test("should be able to get the terms of service token for an account", async () => {
+      const { result } = await moov.accounts.getTermsOfServiceToken({
+        origin: "https://example.com",
+        referer: "https://example.com",
+      });
+      expect(result).toBeDefined();
+      expect(result.token).toEqual(expect.any(String));
+    });
+
+    test("should be able to disconnect an account", async () => {
+      const response = await moov.accounts.disconnect({ accountID: account.accountID });
+      const headers = response?.headers;
+      expect(headers).toBeDefined();
+    });
+  });
+});

package/test/tests/bankAccounts.test.ts

@@ -0,0 +1,171 @@
+import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { ids, moov } from "../setup";
+import { createAccount, createBankAccount } from "../utils/utils";
+import type { BankAccount } from "../../models/components";
+import { sleep } from "bun";
+
+let accountID = "a920f147-ed53-4aa1-977c-d11cc192979c"; // default account ID
+let bankAccount: Partial<BankAccount> = {};
+let accountNumber = "1234567890";
+
+describe("Bank Accounts", () => {
+  beforeAll(async () => {
+    const account = await createAccount();
+    accountID = account.accountID;
+  });
+
+  test("should be able to link a bank account", async () => {
+    const { result } = await moov.bankAccounts.link({
+      accountID,
+      linkBankAccount: {
+        account: {
+          holderName: "Marcellus Wallace",
+          holderType: "individual",
+          accountNumber,
+          bankAccountType: "checking",
+          routingNumber: "121000248",
+        },
+      },
+    });
+    expect(result).toBeDefined();
+    expect(result.bankAccountID).toBeDefined();
+    expect(result.bankAccountType).toEqual("checking");
+    bankAccount = result;
+    ids.seen({ accountID, bankAccountID: result.bankAccountID });
+  });
+  describe("Bank-account dependent tests", () => {
+    describe("Getting and listing bank accounts", () => {
+      // Create a bank account if it doesn't exist yet
+      beforeAll(async () => {
+        if (!bankAccount.bankAccountID) {
+          const result = await createBankAccount(accountID);
+          bankAccount = result.bankAccount;
+          accountNumber = result.accountNumber;
+        }
+      });
+      test("should be able to retrieve a bank account", async () => {
+        const { result } = await moov.bankAccounts.get({
+          accountID,
+          bankAccountID: bankAccount.bankAccountID!,
+        });
+        expect(result).toBeDefined();
+        expect(result.bankAccountID).toEqual(bankAccount.bankAccountID!);
+        expect(result.bankAccountType).toEqual(bankAccount.bankAccountType!);
+        expect(result.holderName).toEqual(bankAccount.holderName!);
+        expect(result.holderType).toEqual(bankAccount.holderType!);
+        expect(result.routingNumber).toEqual(bankAccount.routingNumber!);
+        expect(result.lastFourAccountNumber).toEqual(accountNumber.slice(-4));
+      });
+
+      test("should be able to list bank accounts", async () => {
+        const { result } = await moov.bankAccounts.list({
+          accountID,
+        });
+        expect(result).toBeDefined();
+        expect(result.length).toBeGreaterThan(0);
+        expect(result[0].bankAccountID).toEqual(bankAccount.bankAccountID!);
+        expect(result[0].bankAccountType).toEqual(bankAccount.bankAccountType!);
+        expect(result[0].holderName).toEqual(bankAccount.holderName!);
+        expect(result[0].holderType).toEqual(bankAccount.holderType!);
+        expect(result[0].routingNumber).toEqual(bankAccount.routingNumber!);
+        expect(result[0].lastFourAccountNumber).toEqual(accountNumber.slice(-4));
+      });
+    });
+
+    describe("Bank account verification", () => {
+      beforeEach(async () => {
+        const result = await createBankAccount(accountID);
+        bankAccount = result.bankAccount;
+        accountNumber = result.accountNumber;
+      });
+      describe("RTP verification", () => {
+        test("should be able to initiate bank account verification and complete it, and get a 409 error when I try to verify an already-verified bank account", async () => {
+          const { result } = await moov.bankAccounts.initiateVerification({
+            accountID,
+            bankAccountID: bankAccount.bankAccountID!,
+            xWaitFor: "rail-response",
+          });
+          expect(result).toBeDefined();
+          expect(result.status).toEqual("sent-credit");
+          const { result: result2 } = await moov.bankAccounts.completeVerification({
+            accountID,
+            bankAccountID: bankAccount.bankAccountID!,
+            completeBankAccountVerification: {
+              code: "0001",
+            },
+          });
+          expect(result2).toBeDefined();
+          expect(result2.status).toEqual("successful");
+          expect(
+            async () =>
+              await moov.bankAccounts.initiateVerification({
+                accountID,
+                bankAccountID: bankAccount.bankAccountID!,
+              }),
+          ).toThrowError(
+            expect.objectContaining({ error: "unacceptable bank account status verified for verification" }),
+          );
+        });
+        test("should be able to get the bank account verification status", async () => {
+          const { result } = await moov.bankAccounts.initiateVerification({
+            accountID,
+            bankAccountID: bankAccount.bankAccountID!,
+          });
+          expect(result).toBeDefined();
+          expect(result.status).toEqual("new");
+          await sleep(2000);
+          const { result: result2 } = await moov.bankAccounts.getVerification({
+            accountID,
+            bankAccountID: bankAccount.bankAccountID!,
+          });
+          expect(result2).toBeDefined();
+          expect(result2.status).toEqual("sent-credit");
+        });
+      });
+
+      describe("Micro deposits", () => {
+        beforeEach(async () => {
+          const result = await createBankAccount(accountID);
+          bankAccount = result.bankAccount;
+          accountNumber = result.accountNumber;
+        });
+        test("should be able to initiate micro deposits and complete them and should get a 409 error when we try to complete micro deposits for an already-completed bank account", async () => {
+          const result = await moov.bankAccounts.initiateMicroDeposits({
+            accountID,
+            bankAccountID: bankAccount.bankAccountID!,
+          });
+          expect(result).toBeDefined();
+          await sleep(2000);
+          const { result: result2 } = await moov.bankAccounts.completeMicroDeposits({
+            accountID,
+            bankAccountID: bankAccount.bankAccountID!,
+            completeMicroDeposits: {
+              amounts: [0, 0],
+            },
+          });
+          expect(result2).toBeDefined();
+          expect(result2.status).toEqual("verified");
+          expect(
+            async () =>
+              await moov.bankAccounts.initiateMicroDeposits({
+                accountID,
+                bankAccountID: bankAccount.bankAccountID!,
+              }),
+          ).toThrowError(
+            expect.objectContaining({
+              error: "unexpected account status: expected 'new' or 'verificationFailed', found 'verified'",
+            }),
+          );
+        });
+      });
+    });
+
+    test("should be able to disable a bank account", async () => {
+      const result = await moov.bankAccounts.disable({
+        accountID,
+        bankAccountID: bankAccount.bankAccountID!,
+      });
+      expect(result).toBeDefined();
+    });
+  });
+});

package/test/tests/capabilities.test.ts

@@ -0,0 +1,147 @@
+import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { createAccount, createRepresentative } from "../utils/utils";
+import type { Account, CapabilityID } from "../../models/components";
+import { moov } from "../setup";
+import { sleep } from "bun";
+
+let account: Account;
+
+describe("Capabilities", () => {
+  beforeAll(async () => {
+    account = await createAccount({ capabilities: ["collect-funds"] });
+  });
+
+  describe("Listing capabilities", () => {
+    test("should list capabilities for an account", async () => {
+      const { result } = await moov.capabilities.list({
+        accountID: account.accountID,
+      });
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+      // Capabilities should include some standard capabilities
+      expect(result.some((cap) => cap.capability === "transfers")).toBe(true);
+    });
+
+    test("listing capabilities should fail if the account is not found", async () => {
+      expect(() =>
+        moov.capabilities.list({
+          accountID: "not-a-valid-account-id",
+        }),
+      ).toThrowError("API error occurred: Status 403 Content-Type  Body ");
+    });
+  });
+
+  describe("Getting specific capabilities", () => {
+    test("should get details of a specific capability", async () => {
+      const { result } = await moov.capabilities.get({
+        accountID: account.accountID,
+        capabilityID: "transfers",
+      });
+      expect(result).toBeDefined();
+      expect(result.capability).toBe("transfers");
+      expect(result.status).toEqual("enabled");
+    });
+
+    test("should contain currentlyDue for pending capabilities", async () => {
+      const { result } = await moov.capabilities.get({
+        accountID: account.accountID,
+        capabilityID: "collect-funds",
+      });
+      expect(result).toBeDefined();
+      expect(result.requirements?.currentlyDue?.length).toBeGreaterThan(0);
+      // somee of the requirements should be business.ein
+      expect(result.requirements?.currentlyDue?.some((req) => req === "business.ein")).toBe(true);
+    });
+
+    test.todo("should contain errors for collect-funds capability", async () => {
+      await createRepresentative(account.accountID, {
+        birthDate: {
+          day: 1,
+          month: 1,
+          year: 1900, // will fail automatic verification
+        },
+        email: "a@a.com",
+      });
+      await sleep(1000);
+      const { result } = await moov.capabilities.get({
+        accountID: account.accountID,
+        capabilityID: "collect-funds",
+      });
+      expect(result).toBeDefined();
+      expect(result.requirements?.errors?.length).toBeGreaterThan(0);
+      // some of the errors should be business.ein
+      expect(result.requirements?.errors?.some((err) => err.errorCode === "failed-automatic-verification")).toBe(true);
+    });
+
+    test("getting a capability should fail if the account is not found", async () => {
+      expect(() =>
+        moov.capabilities.get({
+          accountID: "not-a-valid-account-id",
+          capabilityID: "transfers",
+        }),
+      ).toThrowError("API error occurred: Status 403 Content-Type  Body ");
+    });
+
+    test("getting a capability should fail if the capability does not exist", async () => {
+      expect(() =>
+        moov.capabilities.get({
+          accountID: account.accountID,
+          capabilityID: "not-a-valid-capability" as CapabilityID,
+        }),
+      ).toThrowError();
+    });
+  });
+
+  describe("Requesting capabilities", () => {
+    test("should request new capabilities", async () => {
+      const { result } = await moov.capabilities.request({
+        accountID: account.accountID,
+        addCapabilities: {
+          capabilities: ["transfers", "send-funds", "collect-funds"],
+        },
+      });
+      expect(result).toBeDefined();
+      expect(result[0].capability).toBe("collect-funds");
+      expect(result[0].status).toBeDefined();
+    });
+
+    test("requesting capabilities should fail if the account is not found", async () => {
+      expect(() =>
+        moov.capabilities.request({
+          accountID: "not-a-valid-account-id",
+          addCapabilities: {
+            capabilities: ["transfers"],
+          },
+        }),
+      ).toThrowError("API error occurred: Status 403 Content-Type  Body ");
+    });
+
+    test("requesting capabilities should fail if the capability is invalid", async () => {
+      expect(() =>
+        moov.capabilities.request({
+          accountID: account.accountID,
+          addCapabilities: {
+            capabilities: ["not-a-valid-capability" as CapabilityID],
+          },
+        }),
+      ).toThrowError();
+    });
+
+    test("requesting capabilities should NOT fail if we request the same capability twice", async () => {
+      const { result } = await moov.capabilities.request({
+        accountID: account.accountID,
+        addCapabilities: { capabilities: ["transfers"] },
+      });
+      expect(result).toBeDefined();
+      // capability array should containe "transfers"
+      expect(result.some((cap) => cap.capability === "transfers")).toBe(true);
+      expect(result[0].status).toBeDefined();
+      expect(() =>
+        moov.capabilities.request({
+          accountID: account.accountID,
+          addCapabilities: { capabilities: ["transfers"] },
+        }),
+      ).not.toThrowError();
+    });
+  });
+});