feat: Chargebacks (#371)

* implementation of Chargebacks

* create test

---------

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

Author: axshani

resources/chargeback.ts

@@ -0,0 +1,45 @@
+import { Customer, Account, Transaction } from "../types"
+import { Chargeback, ChargebackListParams, CreateChargebackRequest } from "../types/chargeback"
+import { Include, UnitConfig, UnitResponse } from "../types/common"
+import {BaseResource} from "./baseResource"
+
+type ChargebackIncluded = Customer[] | Account[] | Transaction[]
+
+export class Chargebacks extends BaseResource {
+
+    constructor(token: string, basePath: string, config?: UnitConfig) {
+        super(token, basePath + "/chargebacks", config)
+    }
+
+    public async create(request: CreateChargebackRequest): Promise<UnitResponse<Chargeback>> {
+        return this.httpPost<UnitResponse<Chargeback>>("", {data: request})
+    }
+
+    /**
+     * Include is Optional. Related resource available to include: customer, account, transaction. See [Getting Related Resources](https://developers.unit.co/#intro-getting-related-resources)
+     * @param chargebackId
+     * @param include
+     */
+    public async get(chargebackId: string, include = ""): Promise<UnitResponse<Chargeback> & Include<ChargebackIncluded>> {
+        return this.httpGet<UnitResponse<Chargeback> & Include<ChargebackIncluded>>(`/${chargebackId}`, {params: {include}})
+    }
+
+    public async list(params?: ChargebackListParams): Promise<UnitResponse<Chargeback[]> & Include<ChargebackIncluded>> {
+        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?.tags && {"filter[tags]": params.tags}),
+            ...(params?.include && {"include": params.include}),
+            ...(params?.sort && {"sort": params.sort})
+        }
+
+        return this.httpGet<UnitResponse<Chargeback[]> & Include<ChargebackIncluded>>("", {params: parameters})
+    }
+    
+
+
+}

resources/index.ts

@@ -29,3 +29,4 @@ export * from "./simulations"
 export * from "./statements"
 export * from "./transactions"
 export * from "./webhooks"
+export * from "./chargeback"

tests/chargebacks.spec.ts

@@ -0,0 +1,60 @@
+import { Chargeback, CreateChargebackRequest, Unit } from "../unit"
+
+import dotenv from "dotenv"
+import { createIndividualAccount } from "./testHelpers"
+import { createRelationship } from "../helpers"
+dotenv.config()
+const unit = new Unit(process.env.UNIT_TOKEN || "test", process.env.UNIT_API_URL || "test")
+
+describe("Chargebacks List", () => {
+    test("Get Chargebacks List", async () => {
+        const res = await unit.chargebacks.list()
+        res.data.forEach(element => {
+            expect(element.type).toBe("chargeback")
+        })
+    })
+
+    test("Get Chargebacks list with included customer", async () => {
+        const res = await unit.chargebacks.list()
+        res.data.forEach(async (element: Chargeback) => {
+            expect(element.type).toBe("chargeback")
+
+            const chargeback: Chargeback = (await unit.chargebacks.get(element.id)).data
+            expect(chargeback.id).toBe(element.id)
+            expect(chargeback.type).toBe(element.type)
+            expect(chargeback.attributes.amount).toBe(element.attributes.amount)
+        })
+    })
+
+    test("Get Chargebacks list with included customer", async () => {
+        const res = await unit.chargebacks.list({include: "customer"})
+        res.data.forEach(async (element: Chargeback) => {
+            expect(element.type).toBe("chargeback")
+        })
+
+        
+        // expect(res.included).not.toBeUndefined()
+    })
+})
+
+describe("Test Create Chargeback", () => {
+    test("Create Chargeback", async () => {
+        const accountId = (await createIndividualAccount(unit)).data.id
+        const counterpartyId = (await createIndividualAccount(unit)).data.id
+
+        const req: CreateChargebackRequest = {
+            type: "chargeback",
+            attributes: {
+                amount: 50,
+                description: "Chargeback for test"
+            },
+            relationships: {
+                account: createRelationship("account", accountId),
+                counterpartyAccount: createRelationship("depositAccount", counterpartyId)
+            }
+        }
+
+        const res = await unit.chargebacks.create(req)
+        expect(res.data.type).toBe("chargeback")
+    })
+})

types/chargeback.ts

@@ -0,0 +1,136 @@
+import { BaseCreateRequestAttributes, BaseListParams, Relationship, Sort, Tags } from "./common"
+
+export interface Chargeback {
+    /**
+     * Identifier of the chargeback resource.
+     */
+    id: string
+
+    /**
+     * Type of the chargeback resource. The value is always chargeback.
+     */
+    type: "chargeback"
+
+    /**
+     * JSON object representing the chargeback data.
+     */
+    attributes: {
+        /**
+         * The date the chargeback was created.
+         * RFC3339 format. For more information: https://en.wikipedia.org/wiki/ISO_8601#RFCs
+         */
+        createdAt: string
+
+        /**
+         * The amount (in cents) of the chargeback.
+         */
+        amount: number
+
+        /**
+         * 	Description of the chargeback.
+         */
+        description: string
+
+        /**
+         * See [Tags](https://developers.unit.co/#tags).
+         */
+        tags?: object
+    }
+
+    /**
+     * Describes relationships between the chargeback resource and other resources (accounts, transaction, customer).
+     */
+    relationships: {
+        /**
+         * The [Deposit Account](https://docs.unit.co/deposit-accounts/) the funds will be debited from.
+         */
+        account: Relationship
+
+        /**
+         * The [Customer](https://developers.unit.co/customers/) the deposit account belongs to.
+         */
+        customer: Relationship
+
+        /**
+         * The account that will receive the funds.
+         */
+        counterpartyAccount: Relationship
+
+        /**
+         * The Chargeback [Transaction](https://docs.unit.co/resources/#transaction-chargeback) generated by this chargeback.
+         */
+        transaction: Relationship
+    }
+}
+
+export interface ChargebackListParams extends BaseListParams {
+    /**
+     * Optional. Filters the results by the specified account id.
+     * default: empty
+     */
+    accountId?: string
+
+    /**
+     * Optional. Filters the results by the specified customer id.
+     * default: empty
+     */
+    customerId?: string
+
+    /**
+     * Optional. Filter Chargebacks by [Tags](https://docs.unit.co/#tags).
+     * default: empty
+     */
+    tags?: Tags
+
+    /**
+     * Optional. Filters the Chargebacks that occurred after the specified date. e.g. 2020-01-13T16:01:19.346Z
+     */
+    since?: string
+
+    /**
+     * Optional. Filters the Chargebacks that occurred before the specified date. e.g. 2020-01-02T20:06:23.486Z
+     */
+    until?: string
+
+    /**
+     * Optional. Leave empty or provide sort=createdAt for ascending order. Provide sort=-createdAt (leading minus sign) for descending order.
+     * default: sort=-createdAt
+     */
+    sort?: Sort
+
+    /**
+     * 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
+}
+
+export interface CreateChargebackRequest {
+    /**
+     * Type of the resource to be created, the value is always chargeback.
+     */
+    type: "chargeback"
+    
+    attributes: {
+        /**
+         * The amount (in cents) to charge the account and credit the counterparty.
+         */
+        amount: number
+
+        /**
+         * Description of the chargeback (maximum of 50 characters).
+         */
+        description: string
+    } & BaseCreateRequestAttributes
+
+    relationships: {
+        /**
+         * The Deposit Account the funds will be debited from.
+         */
+        account: Relationship
+
+        /**
+         * The account that will receive the funds.
+         */
+        counterpartyAccount: Relationship
+    }
+}

types/index.ts

@@ -27,3 +27,4 @@ export * from "./rewards"
 export * from "./simulations"
 export * from "./transactions"
 export * from "./webhooks"
+export * from "./chargeback"

unit.ts

@@ -29,6 +29,7 @@ import { Simulations } from "./resources/simulations"
 import { Disputes } from "./resources/dispute"
 import { Repayments } from "./resources/repayments"
 import { StopPayments } from "./resources/stopPayments"
+import { Chargebacks } from "./resources/chargeback"
 
 export class Unit {
     public applications: Applications
@@ -63,6 +64,7 @@ export class Unit {
     public repayments: Repayments
     public stopPayments: StopPayments
     public checkPayments: CheckPayments
+    public chargebacks: Chargebacks
 
     constructor(token: string, basePath: string, config?: UnitConfig) {
         // remove all trailing slashes from user-provided basePath
@@ -99,6 +101,7 @@ export class Unit {
         this.repayments = new Repayments(token, basePath, config)
         this.stopPayments = new StopPayments(token, basePath, config)
         this.checkPayments = new CheckPayments(token, basePath, config)
+        this.chargebacks = new Chargebacks(token, basePath, config)
         this.helpers = helpers
     }