@moovio/sdk 0.11.5 → 0.12.0

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();
+    });
+  });
+});

package/test/tests/cards.test.ts

@@ -0,0 +1,168 @@
+import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { ids, moov } from "../setup";
+import { createAccount, createBankAccount, createCard } from "../utils/utils";
+import type { Card } from "../../models/components";
+
+let accountID = "a920f147-ed53-4aa1-977c-d11cc192979c"; // default account ID
+let card: Partial<Card> = {};
+let cardNumber: string;
+describe("Cards", () => {
+  beforeAll(async () => {
+    const account = await createAccount();
+    accountID = account.accountID;
+  });
+
+  describe("Card Linking", () => {
+    test("should fail when I pass incorrect params", async () => {
+      expect(
+        async () =>
+          await moov.cards.link({
+            accountID,
+            linkCard: {
+              cardNumber: "4111111111111111",
+              cardCvv: "123",
+              expiration: {
+                month: "01",
+                year: "2025", // 2025 is not a valid year, should be "25"
+              },
+              billingAddress: {
+                addressLine1: "123 Main St",
+                city: "Anytown",
+                country: "US",
+                postalCode: "12345", // stateOrProvince is missing, but required when passing anything other than just postalCode
+              },
+            },
+          }),
+      ).toThrow(
+        expect.objectContaining({
+          expiration: "year: the length must be exactly 2.",
+          billingAddress: "stateOrProvince: cannot be blank.",
+        }),
+      );
+    });
+    test("should be able to link a card successfully", async () => {
+      const { result } = await moov.cards.link({
+        accountID,
+        linkCard: {
+          cardNumber: "4111111111111111",
+          cardCvv: "123",
+          expiration: {
+            month: "01",
+            year: "45",
+          },
+          billingAddress: {
+            addressLine1: "123 Main St",
+            city: "Anytown",
+            country: "US",
+            postalCode: "12345",
+            stateOrProvince: "CA",
+          },
+        },
+      });
+      expect(result).toBeDefined();
+      expect(result.cardID).toBeDefined();
+      expect(result.cardType).toEqual("debit");
+      expect(result.brand).toEqual("Visa");
+      expect(result.lastFourCardNumber).toEqual("1111");
+      card = result;
+      ids.seen({ accountID, cardID: result.cardID });
+    });
+  });
+  describe("Card dependent tests", () => {
+    beforeEach(async () => {
+      const result = await createCard(accountID);
+      card = result.card;
+      cardNumber = result.cardNumber;
+    });
+    describe("Getting and listing cards", () => {
+      test("should be able to retrieve a card", async () => {
+        const { result } = await moov.cards.get({
+          accountID,
+          cardID: card.cardID!,
+        });
+        expect(result).toBeDefined();
+        expect(result.bin).toEqual(card.bin!);
+        expect(result.cardID).toEqual(card.cardID!);
+        expect(result.cardType).toEqual(card.cardType!);
+        expect(result.brand).toEqual(card.brand!);
+        expect(result.lastFourCardNumber).toEqual(cardNumber.slice(-4));
+      });
+
+      test("Getting a card should fail when I pass incorrect params", async () => {
+        expect(async () => await moov.cards.get({ accountID, cardID: "invalid-card-id" })).toThrowError(
+          "API error occurred: Status 404 Content-Type  Body",
+        );
+      });
+
+      test("should be able to list cards", async () => {
+        const { result } = await moov.cards.list({
+          accountID,
+        });
+        expect(result).toBeDefined();
+        expect(result.length).toBeGreaterThan(0);
+        expect(result[0].bin).toEqual(expect.any(String));
+        expect(result[0].cardID).toEqual(expect.any(String));
+        expect(result[0].cardType).toEqual(expect.any(String));
+        expect(result[0].brand).toEqual(expect.any(String));
+        expect(result[0].lastFourCardNumber).toEqual(expect.any(String));
+      });
+
+      test("listing should fail when I pass incorrect params", async () => {
+        expect(async () => await moov.cards.list({ accountID: "invalid-account-id" })).toThrowError(
+          "API error occurred: Status 403 Content-Type  Body ",
+        );
+      });
+    });
+
+    describe("Updating cards", () => {
+      test("should be able to update a card", async () => {
+        const { result } = await moov.cards.update({
+          accountID,
+          cardID: card.cardID!,
+          updateCard: {
+            expiration: {
+              month: "01",
+              year: "45",
+            },
+          },
+        });
+        expect(result).toBeDefined();
+        expect(result.cardID).toEqual(card.cardID!);
+        expect(result.expiration.month).toEqual("01");
+        expect(result.expiration.year).toEqual("45");
+      });
+
+      test("updating should fail when I pass incorrect params", async () => {
+        expect(
+          async () =>
+            await moov.cards.update({
+              accountID,
+              cardID: card.cardID!,
+              updateCard: {
+                expiration: {
+                  month: "01",
+                  year: "2045",
+                },
+              },
+            }),
+        ).toThrowError('API error occurred: {"expiration":"year: the length must be exactly 2."}');
+      });
+    });
+
+    describe("Disabling cards", () => {
+      test("should be able to disable a card", async () => {
+        const result = await moov.cards.disable({
+          accountID,
+          cardID: card.cardID!,
+        });
+        expect(result).toBeDefined();
+      });
+
+      test("disabling should fail when I pass incorrect params", async () => {
+        expect(async () => await moov.cards.disable({ accountID, cardID: "invalid-card-id" })).toThrowError(
+          "API error occurred: Status 404 Content-Type  Body",
+        );
+      });
+    });
+  });
+});

package/test/tests/paymentMethods.test.ts

@@ -0,0 +1,55 @@
+import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { ids, moov } from "../setup";
+import { createAccount, createBankAccount, createCard } from "../utils/utils";
+import type { BankAccount, Card } from "../../models/components";
+
+let accountID = "a920f147-ed53-4aa1-977c-d11cc192979c"; // default account ID
+let card: Partial<Card> = {};
+let bankAccount: Partial<BankAccount> = {};
+let cardNumber: string;
+describe("PaymentMethods", () => {
+  beforeAll(async () => {
+    const account = await createAccount();
+    accountID = account.accountID;
+    const result = await createCard(accountID);
+    card = result.card;
+    cardNumber = result.cardNumber;
+    const bankAccountResult = await createBankAccount(accountID);
+    bankAccount = bankAccountResult.bankAccount;
+  });
+
+  describe("Listing", () => {
+    test("should be able to list payment methods", async () => {
+      const { result } = await moov.paymentMethods.list({ accountID });
+      expect(result).toBeDefined();
+      expect(result.length).toBeGreaterThan(0);
+    });
+    test("listing should fail if accountID is not provided", async () => {
+      expect(() => moov.paymentMethods.list({ accountID: "" })).toThrowError(
+        "API error occurred: Status 403 Content-Type  Body",
+      );
+    });
+  });
+
+  describe("Getting PaymentMethods", () => {
+    test("should be able to get a payment method", async () => {
+      const { result: listResult } = await moov.paymentMethods.list({ accountID });
+      const { result } = await moov.paymentMethods.get({
+        accountID: accountID,
+        paymentMethodID: listResult[0].paymentMethodID,
+      });
+      expect(result).toBeDefined();
+      expect(result.paymentMethodID).toBe(listResult[0].paymentMethodID);
+    });
+    test("getting should fail if accountID and paymentMethodID are not correct", async () => {
+      expect(() => moov.paymentMethods.get({ accountID: "@#$@#$@$", paymentMethodID: "@#$@#$@#$@" })).toThrowError(
+        "API error occurred: Status 403 Content-Type  Body",
+      );
+    });
+    test("getting should fail if paymentMethodID is not provided", async () => {
+      expect(() => moov.paymentMethods.get({ accountID: accountID, paymentMethodID: "" })).toThrowError(
+        "API error occurred: Status 403 Content-Type  Body",
+      );
+    });
+  });
+});