feat: Check Payments (#368)

* implement StopPayments

* init Stop and Check Payments

* added createCheckPaymentSimulation and e2e-test

* implemented checkPayments

* stopPayments refactoring

* lint-fix

* lint-fix

* update unit client and added a test for checkPayments

* lint-fix

---------

Co-authored-by: Ilya Merman <[email protected]>

Author: axshani

resources/baseResource.ts

@@ -42,6 +42,11 @@ export class BaseResource {
             .catch(error => { throw extractUnitError(error) })
     }
 
+    protected async httpGetWithInclude<T>(path: string, include?: string): Promise<T> {
+        const params = {...(include && { include })}
+        return this.httpGet<T>(path,  { params })
+    }
+
     protected async httpPatch<T>(path: string, data: DataPayload | { data: DataPayload; }, config?: { headers?: object; params?: object; }): Promise<T> {
         return this.httpPatchFullPath<T>(this.resourcePath + path, data, config)
     }

resources/checkPayments.ts

@@ -0,0 +1,66 @@
+import { Include, Meta, UnitConfig, UnitResponse } from "../types/common"
+import { CheckPayment, CheckPaymentStatus, ApproveCheckPaymentRequest, ReturnCheckPaymentRequest, BaseCheckPaymentListParams } from "../types/checkPayment"
+import { BaseResource } from "./baseResource"
+import { Account, Customer, Transaction } from "../types"
+import {responseEncoding, ResponseType} from "axios"
+
+export class CheckPayments extends BaseResource {
+    constructor(token: string, basePath: string, config?: UnitConfig) {
+        super(token, basePath + "/check-payments", config)
+    }
+
+    public async get(id: string, include?: string): Promise<UnitResponse<CheckPayment>> {
+        return this.httpGetWithInclude<UnitResponse<CheckPayment> & Include<Account[] | Customer[] | Transaction[]> >(`/${id}`, include)
+    }
+
+    public async return(request: ReturnCheckPaymentRequest): Promise<UnitResponse<CheckPayment>> {
+        return this.httpPost<UnitResponse<CheckPayment>>(`/${request.id}/return`, {data: request.data})
+    }
+
+    public async approve(request: ApproveCheckPaymentRequest): Promise<UnitResponse<CheckPayment>> {
+        return this.httpPost<UnitResponse<CheckPayment>>(`/${request.id}/approve`, {data: request.data})
+    }
+
+    public async getImage(id: string, front = true, responseEncoding: responseEncoding = "binary", responseType: ResponseType = "blob"): Promise<string> {
+        const p = front ? "front" : "back"
+        return this.httpGet<string>(`/${id}/${p}`, {responseEncoding, responseType})
+    }
+
+    
+    public async list(params?: CheckPaymentListParams): Promise<UnitResponse<CheckPayment[]> & Meta> {
+        const parameters: any = {
+            "page[limit]": (params?.limit ? params.limit : 100),
+            "page[offset]": (params?.offset ? params.offset : 0),
+            ...(params?.accountId && { "filter[accountId]": params.accountId }),
+            ...(params?.customerId && { "filter[customerId]": params.customerId }),
+            ...(params?.since && { "filter[since]": params.since }),
+            ...(params?.until && { "filter[until]": params.until }),
+            ...(params?.fromAmount && { "filter[fromAmount]": params.fromAmount }),
+            ...(params?.toAmount && { "filter[toAmount]": params.toAmount }),
+            ...(params?.checkNumber && { "filter[checkNumber]": params.checkNumber }),
+            ...(params?.tags && { "tags": params.tags }),
+            ...(params?.sort && { "sort": params.sort }),
+            ...(params?.include && { "sort": params.include })
+        }
+
+        if (params?.status)
+            params.status.forEach((s, idx) => {
+                parameters[`filter[status][${idx}]`] = s
+            })
+        
+        return this.httpGet<UnitResponse<CheckPayment[]> & Meta>("", { params: parameters })
+    }
+}
+
+export interface CheckPaymentListParams extends BaseCheckPaymentListParams {
+    /**
+     * Optional. Filter by status (Processed, PendingReview, MarkedForReturn or Returned). Usage example: filter[status][0]=Processed
+     */
+    status?: CheckPaymentStatus[]
+    
+    /**
+     * Optional. A comma-separated list of related resources to include in the response. Related resources include: customer, account, transaction.
+     * See [Getting Related Resources](https://docs.unit.co/about-jsonapi/#intro-getting-related-resources)
+     */
+    include?: string
+}

resources/index.ts

@@ -21,6 +21,8 @@ export * from "./payments"
 export * from "./repayments"
 export * from "./receivedPayments"
 export * from "./recurringPayments"
+export * from "./checkPayments"
+export * from "./stopPayments"
 export * from "./returns"
 export * from "./rewards"
 export * from "./simulations"

resources/simulations.ts

@@ -1,5 +1,5 @@
 import { BaseResource } from "."
-import { UnitConfig, UnitResponse } from "../types"
+import { CheckPayment, CreateCheckPaymentSimulation, UnitConfig, UnitResponse } from "../types"
 import { AchReceivedPayment, Application, ApplicationDocument, AchPayment } from "../types"
 import {
     ApproveApplicationSimulation,
@@ -93,6 +93,10 @@ export class Simulations extends BaseResource {
         )
     }
 
+    public async createCheckPayment(request: CreateCheckPaymentSimulation): Promise<UnitResponse<CheckPayment>> {
+        return this.httpPost<UnitResponse<CheckPayment>>("/check-payments", { data: request} )
+    }
+    
     public async createCardPurchase(
         request: CreateCardPurchaseSimulation
     ): Promise<UnitResponse<CardTransaction>> {

resources/stopPayments.ts

@@ -0,0 +1,51 @@
+import { Meta, UnitConfig, UnitResponse } from "../types/common"
+import { BaseCheckPaymentListParams, CreateStopPaymentRequest, StopPayment, StopPaymentStatus } from "../types/checkPayment"
+import { BaseResource } from "./baseResource"
+
+export class StopPayments extends BaseResource {
+    constructor(token: string, basePath: string, config?: UnitConfig) {
+        super(token, basePath + "/stop-payments", config)
+    }
+
+    public async create(request: CreateStopPaymentRequest): Promise<UnitResponse<StopPayment>> {
+        return this.httpPost<UnitResponse<StopPayment>>("", { data: request} )
+    }
+
+    public async get(id: string): Promise<UnitResponse<StopPayment>> {
+        return this.httpGet<UnitResponse<StopPayment>>(`/${id}`)
+    }
+
+    public async disable(id: string): Promise<UnitResponse<StopPayment>> {
+        return this.httpPost<UnitResponse<StopPayment>>(`/${id}/disable`)
+    }
+    
+    public async list(params?: StopPaymentListParams): Promise<UnitResponse<StopPayment[]> & Meta> {
+        const parameters: any = {
+            "page[limit]": (params?.limit ? params.limit : 100),
+            "page[offset]": (params?.offset ? params.offset : 0),
+            ...(params?.accountId && { "filter[accountId]": params.accountId }),
+            ...(params?.customerId && { "filter[customerId]": params.customerId }),
+            ...(params?.since && { "filter[since]": params.since }),
+            ...(params?.until && { "filter[until]": params.until }),
+            ...(params?.fromAmount && { "filter[fromAmount]": params.fromAmount }),
+            ...(params?.toAmount && { "filter[toAmount]": params.toAmount }),
+            ...(params?.checkNumber && { "filter[checkNumber]": params.checkNumber }),
+            ...(params?.tags && { "tags": params.tags }),
+            ...(params?.sort && { "sort": params.sort })
+        }
+
+        if (params?.status)
+            params.status.forEach((s, idx) => {
+                parameters[`filter[status][${idx}]`] = s
+            })
+        
+        return this.httpGet<UnitResponse<StopPayment[]> & Meta>("", { params: parameters })
+    }
+}
+
+export interface StopPaymentListParams extends BaseCheckPaymentListParams {
+    /**
+     * Optional. Filter by status (Active or Disabled). Usage example: filter[status][0]=Active
+     */
+    status?: StopPaymentStatus[]
+}

tests/checkPayments.spec.ts

@@ -0,0 +1,42 @@
+import { Unit } from "../unit"
+
+import dotenv from "dotenv"
+dotenv.config()
+const unit = new Unit(process.env.UNIT_TOKEN || "test", process.env.UNIT_API_URL || "test")
+
+describe("Test Check Payments", () => {
+    test("Get Check Payments List", async () => {
+        const checkPayments = (await unit.checkPayments.list()).data
+       
+        checkPayments.forEach(async cp => {
+            expect(cp.type).toBe("checkPayment")
+            expect(cp.attributes.checkNumber).not.toBe("")
+            expect(cp.attributes.createdAt).not.toBe("")
+            expect(cp.attributes.updatedAt).not.toBe("")
+            expect(cp.attributes.description).not.toBe("")
+            expect(cp.attributes.additionalVerificationStatus).not.toBe("")
+            expect(cp.attributes.amount).not.toBe(undefined)
+            expect(cp.attributes.counterpartyRoutingNumber).not.toBe("")
+        })
+    })
+
+    test("Get Check Payment", async () => {
+        const checkPayments = (await unit.checkPayments.list()).data
+       
+        checkPayments.forEach(async cp => {
+            expect(cp.type).toBe("checkPayment")
+
+            const res = (await unit.checkPayments.get(cp.id)).data
+
+            expect(cp.type).toBe(res.type)
+            expect(cp.attributes.checkNumber).toBe(res.attributes.checkNumber)
+            expect(cp.attributes.createdAt).toBe(res.attributes.createdAt)
+            expect(cp.attributes.updatedAt).toBe(res.attributes.updatedAt)
+            expect(cp.attributes.description).toBe(res.attributes.description)
+            expect(cp.attributes.additionalVerificationStatus).toBe(res.attributes.additionalVerificationStatus)
+            expect(cp.attributes.amount).toBe(res.attributes.amount)
+            expect(cp.attributes.counterpartyRoutingNumber).toBe(res.attributes.counterpartyRoutingNumber)
+
+        })
+    })
+})

tests/stopPayments.spec.ts

@@ -0,0 +1,58 @@
+import { createRelationship } from "../helpers"
+import { Unit } from "../unit"
+
+import dotenv from "dotenv"
+import { createIndividualAccount } from "./testHelpers"
+dotenv.config()
+const unit = new Unit(process.env.UNIT_TOKEN || "test", process.env.UNIT_API_URL || "test")
+
+describe("E2E Test", () => {
+    test("Create Check and Stop Payments", async () => {
+        const accountId = (await createIndividualAccount(unit)).data.id
+        const checkNumber = "12345"
+        const relationships = {account: createRelationship("depositAccount", accountId)}
+        const amount = 1000
+        
+        const checkPayment = (await unit.simulations.createCheckPayment({
+            type: "checkPayment",
+            attributes: {
+                amount,
+                checkNumber
+            },
+            relationships
+        })).data
+
+        expect(checkPayment.type).toBe("checkPayment")
+
+        const response = await unit.stopPayments.create({
+            type: "stopPayment",
+            attributes: {
+                amount: amount/2,
+                checkNumber,
+                tags: {"test": "test"}
+            },
+            relationships
+        })
+
+        expect(response.data.type).toBe("stopPayment")
+    })
+
+    test("Get Stop Payments List", async () => {
+        const stopPayments = (await unit.stopPayments.list()).data
+       
+        stopPayments.forEach(async sp => {
+            expect(sp.type).toBe("stopPayment")
+
+            const res = (await unit.stopPayments.get(sp.id)).data
+
+            expect(res.type).toBe("stopPayment")
+            expect(res.id).toBe(sp.id)
+            expect(res.attributes.createdAt).toBe(sp.attributes.createdAt)
+            expect(res.attributes.updatedAt).toBe(sp.attributes.updatedAt)
+            expect(res.attributes.amount).toBe(sp.attributes.amount)
+            expect(res.attributes.checkNumber).toBe(sp.attributes.checkNumber)
+            expect(res.attributes.status).toBe(sp.attributes.status)
+
+        })
+    })
+})