@moovio/sdk 0.11.4 → 0.12.0

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

package/test/tests/representatives.test.ts

@@ -0,0 +1,83 @@
+import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { createAccount, createAccountWithWallet, createRepresentative } from "../utils/utils";
+import type { Account, Representative } from "../../models/components";
+import { moov } from "../setup";
+
+let account: Account;
+let representative: Representative;
+describe("Representative", () => {
+  beforeAll(async () => {
+    account = await createAccount();
+  });
+  describe("Creating a representative", () => {
+    test("should create a representative", async () => {
+      const representativeCreated = await createRepresentative(account.accountID);
+      expect(representativeCreated).toBeDefined();
+      representative = representativeCreated;
+    });
+  });
+  describe("Representative-dependent tests", () => {
+    beforeEach(async () => {
+      if (!representative) {
+        representative = await createRepresentative(account.accountID);
+      }
+    });
+    describe("Listing and getting representatives", () => {
+      test("should list representatives", async () => {
+        const { result } = await moov.representatives.list({ accountID: account.accountID });
+        expect(result).toBeDefined();
+        expect(result.length).toBeGreaterThan(0);
+        expect(result.some((r) => r.representativeID === representative.representativeID)).toBe(true);
+      });
+      test("should be able to get a representative", async () => {
+        const { result } = await moov.representatives.get({
+          accountID: account.accountID,
+          representativeID: representative.representativeID,
+        });
+        expect(result).toBeDefined();
+        expect(result.representativeID).toBe(representative.representativeID);
+        expect(result.email).toBe(representative.email!);
+      });
+      test("listing representatives should fail if the account is not found", async () => {
+        expect(() => moov.representatives.list({ accountID: "not-a-valid-account-id" })).toThrowError(
+          "API error occurred: Status 403 Content-Type  Body ",
+        );
+      });
+      test("getting a representative should fail if the account is not found", async () => {
+        expect(() =>
+          moov.representatives.get({
+            accountID: "not-a-valid-account-id",
+            representativeID: representative.representativeID,
+          }),
+        ).toThrowError("API error occurred: Status 403 Content-Type  Body ");
+      });
+    });
+    describe("Updating a representative", () => {
+      beforeEach(async () => {
+        representative = await createRepresentative(account.accountID);
+      });
+      test("should be able to update a representative", async () => {
+        const { result } = await moov.representatives.update({
+          accountID: account.accountID,
+          representativeID: representative.representativeID,
+          updateRepresentative: {
+            email: "mia.wallece@bigkahunaburger.com",
+          },
+        });
+        expect(result).toBeDefined();
+        expect(result.email).toBe("mia.wallece@bigkahunaburger.com");
+      });
+      test("updating a representative should fail if the account is not found", async () => {
+        expect(() =>
+          moov.representatives.update({
+            accountID: "not-a-valid-account-id",
+            representativeID: representative.representativeID,
+            updateRepresentative: {
+              email: "mia.wallece@bigkahunaburger.com",
+            },
+          }),
+        ).toThrowError("API error occurred: Status 403 Content-Type  Body ");
+      });
+    });
+  });
+});

package/test/tests/transfers.test.ts

@@ -0,0 +1,122 @@
+import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { ids, moov } from "../setup";
+import {
+  crateAccountAndGetTransferOptions,
+  createAccount,
+  createAccountWithWallet,
+  createBankAccount,
+  createCard,
+  SOURCE_ACCOUNT_ID,
+  UUID_REGEX,
+  waitFor,
+} from "../utils/utils";
+import type { CreateTransferOptions, PaymentMethod, TransferResponse } from "../../models/components";
+import { sleep } from "bun";
+import type { CreateTransferRequest } from "../../models/operations";
+
+let destinationAccountID: string;
+let sourcePaymentMethodID: string;
+let destinationPaymentMethodID: string;
+let transfer: TransferResponse;
+describe("Transfers", () => {
+  // Setup accounts and payment methods
+
+  describe("Transfer Creation", () => {
+    beforeAll(async () => {
+      const availablePaymentMethods = await crateAccountAndGetTransferOptions();
+      sourcePaymentMethodID = availablePaymentMethods.sourceOptions![0].paymentMethodID!;
+      destinationPaymentMethodID = availablePaymentMethods.destinationOptions![0].paymentMethodID!;
+    });
+    test("should be able to create a simple ASYNC transfer between accounts", async () => {
+      const transferRequest: CreateTransferRequest = {
+        xIdempotencyKey: crypto.randomUUID(),
+        accountID: SOURCE_ACCOUNT_ID,
+        createTransfer: {
+          source: {
+            paymentMethodID: sourcePaymentMethodID,
+          },
+          destination: {
+            paymentMethodID: destinationPaymentMethodID,
+          },
+          amount: {
+            currency: "USD",
+            value: 1,
+          },
+        },
+      };
+
+      const { result } = await moov.transfers.create(transferRequest);
+      expect(result).toBeDefined();
+      expect(result.transferID).toBeDefined();
+      expect(result.createdOn).toBeDefined();
+      expect(result.transferID).toMatch(UUID_REGEX);
+      transfer = result;
+    });
+
+    test("Should be able to create a simple SYNC transfer between accounts", async () => {
+      const transferRequest: CreateTransferRequest = {
+        xIdempotencyKey: crypto.randomUUID(),
+        xWaitFor: "rail-response",
+        accountID: SOURCE_ACCOUNT_ID,
+        createTransfer: {
+          source: {
+            paymentMethodID: sourcePaymentMethodID,
+          },
+          destination: {
+            paymentMethodID: destinationPaymentMethodID,
+          },
+          amount: {
+            currency: "USD",
+            value: 1,
+          },
+        },
+      };
+
+      const { result } = await moov.transfers.create(transferRequest);
+      expect(result).toBeDefined();
+      expect(result.transferID).toBeDefined();
+      expect(result.createdOn).toBeDefined();
+      expect(result.transferID).toMatch(UUID_REGEX);
+      transfer = result;
+    });
+
+    test("should fail to create transfer with invalid amount", async () => {
+      const transferRequest: CreateTransferRequest = {
+        xIdempotencyKey: crypto.randomUUID(),
+        accountID: SOURCE_ACCOUNT_ID,
+        createTransfer: {
+          source: {
+            paymentMethodID: sourcePaymentMethodID,
+          },
+          destination: {
+            paymentMethodID: destinationPaymentMethodID,
+          },
+          amount: {
+            currency: "USD",
+            value: 0,
+          },
+        },
+      };
+
+      await expect(() => moov.transfers.create(transferRequest)).toThrowError(
+        'API error occurred: {"amount":"amount value must be greater than or equal to 0.01"}',
+      );
+    });
+  });
+
+  describe.todo("Transfer Management", () => {
+    beforeEach(async () => {});
+
+    test("should list transfers", async () => {});
+
+    test("should get transfer details", async () => {});
+
+    test("should update transfer metadata", async () => {});
+
+    test("should list transfer refunds", async () => {});
+  });
+
+  describe.todo("Transfer Options", () => {
+    test("should generate transfer options", async () => {});
+  });
+});

package/test/tests/wallets.test.ts

@@ -0,0 +1,31 @@
+import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { ids, moov } from "../setup";
+import { createAccount, createAccountWithWallet } from "../utils/utils";
+
+let accountID = "a920f147-ed53-4aa1-977c-d11cc192979c"; // default account ID
+describe("Wallets", () => {
+  beforeAll(async () => {
+    const account = await createAccountWithWallet();
+    accountID = account.accountID;
+  });
+
+  describe("Listing", () => {
+    test("should be able to list wallets", async () => {
+      const { result } = await moov.wallets.list({ accountID });
+      expect(result).toBeDefined();
+      expect(result.length).toEqual(1);
+      expect(result[0].availableBalance).toEqual({
+        currency: "USD",
+        value: 0,
+        valueDecimal: "0",
+      });
+    });
+    test("listing should fail if accountID is not provided", async () => {
+      expect(() => moov.wallets.list({ accountID: "" })).toThrowError(
+        "API error occurred: Status 403 Content-Type  Body",
+      );
+    });
+  });
+
+  describe.todo("Getting Wallets", () => {});
+});

package/test/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false,
+
+    // Add Bun types
+    "types": ["bun-types"]
+  }
+}