paystack-sdk 1.0.18 → 1.1.20

package/dist/subscription/subscription.d.ts

@@ -0,0 +1,18 @@
+import { Axios } from 'axios';
+import { CreateSubscription, EnableOrDisableSubscription, FetchSubscription, GenerateSubscriptionLink, ListSubscriptionQueryParams, ListSubscriptions, Response, SubscriptionCreated } from './interface';
+interface BadRequest {
+    status: boolean;
+    message: string;
+}
+export declare class Subscription {
+    http: Axios;
+    constructor(http: Axios);
+    create(data: CreateSubscription): Promise<SubscriptionCreated | BadRequest>;
+    list(queryParams?: ListSubscriptionQueryParams): Promise<ListSubscriptions | BadRequest>;
+    fetch(idOrCode: string): Promise<FetchSubscription | BadRequest>;
+    enable(data: EnableOrDisableSubscription): Promise<Response | BadRequest>;
+    disable(data: EnableOrDisableSubscription): Promise<Response | BadRequest>;
+    generateSubscriptionLink(code: string): Promise<GenerateSubscriptionLink | BadRequest>;
+    sendUpdateSubscriptionLink(code: string): Promise<Response | BadRequest>;
+}
+export {};

package/dist/subscription/subscription.js

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subscription = void 0;
+class Subscription {
+    constructor(http) {
+        this.http = http;
+    }
+    create(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.http.post('/subscription', JSON.stringify(data));
+            return response;
+        });
+    }
+    list(queryParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.get('/subscription', { params: Object.assign({}, queryParams) });
+        });
+    }
+    fetch(idOrCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.get(`/subscription/${idOrCode}`);
+        });
+    }
+    enable(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.post('/subscription/enable', JSON.stringify(data));
+        });
+    }
+    disable(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.post('/subscription/disable', JSON.stringify(data));
+        });
+    }
+    generateSubscriptionLink(code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.get(`/subscription/${code}/manage/link`);
+        });
+    }
+    sendUpdateSubscriptionLink(code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.post(`/subscription/${code}/manage/email`);
+        });
+    }
+}
+exports.Subscription = Subscription;

package/dist/transaction/interface.d.ts

@@ -1,4 +1,5 @@
 import { Authorization, Customer } from '../charge';
+import { Meta } from '../interface';
 export interface InitializeTransaction {
     /**
      * Amount should be in **kobo** if currency
@@ -72,71 +73,83 @@ export interface InitializeTransaction {
      */
     bearer?: string;
 }
-export interface TransactionResponse {
+export interface Response {
     status: boolean;
     message: string;
-    data: TransactionInitializedOk | TransactionData | Transactions | Timeline | ExportTransaction;
-    meta?: Meta;
 }
-interface TransactionInitializedOk {
-    authorization_url: string;
-    access_code: string;
-    reference: string;
+export interface TransactionInitialized extends Response {
+    data: {
+        authorization_url: string;
+        access_code: string;
+        reference: string;
+    };
 }
-export interface TransactionData {
-    amount: number;
-    currency: string;
-    transaction_date: Date;
-    status: string;
-    reference: string;
-    domain: string;
-    metadata: number;
-    gateway_response: string;
-    message?: any;
-    channel: string;
-    ip_address: string;
-    log: {
+export interface TransactionData extends Response {
+    data: {
+        amount: number;
+        currency: string;
+        transaction_date: Date;
+        status: string;
+        reference: string;
+        domain: string;
+        metadata: number;
+        gateway_response: string;
+        message?: string;
+        channel: string;
+        ip_address: string;
+        log: [
+            {
+                time_spent: number;
+                attempt: number;
+                authentication: any;
+                errors: number;
+                success: boolean;
+                mobile: boolean;
+                input: [];
+                channel: string;
+                history: [
+                    {
+                        type: string;
+                        message: string;
+                        time: number;
+                    }
+                ];
+            }
+        ];
+        fees: number;
+        authorization: Authorization;
+        customer: Customer;
+        pin: string;
+        required_amount: number;
+    };
+}
+export interface ListTransactions extends Response {
+    data: TransactionData[];
+    meta: Meta;
+}
+export interface Timeline extends Response {
+    data: {
         time_spent: number;
-        attempt: number;
+        attempts: number;
         authentication: any;
         errors: number;
         success: boolean;
         mobile: boolean;
         input: [];
-        channel: any;
-        history: {
-            type: string;
-            message: string;
-            time: number;
-        }[];
+        channel: string;
+        history: [
+            {
+                type: string;
+                message: string;
+                time: number;
+            }
+        ];
     };
-    fees: any;
-    authorization: Authorization;
-    customer: Customer;
-    pin: string;
-    required_amount: number;
 }
-interface Transactions extends TransactionData {
-}
-interface Timeline {
-    time_spent: number;
-    attempts: number;
-    authentication: any;
-    errors: number;
-    success: boolean;
-    mobile: boolean;
-    input: [];
-    channel: string;
-    history: [
-        {
-            type: string;
-            message: string;
-            time: number;
-        }
-    ];
-}
-interface ExportTransaction {
-    path: string;
+export interface ExportTransaction extends Response {
+    data: {
+        path: string;
+    };
 }
 export interface ListTransactionQueryParams {
     /**
@@ -176,13 +189,6 @@ export interface ListTransactionQueryParams {
      */
     amount?: number;
 }
-export interface Meta {
-    total: number;
-    skipped: number;
-    perPage: number;
-    page: number;
-    pageCount: number;
-}
 export interface ChargeAuthorization {
     /**
      * Amount should be in kobo if currency is `NGN`, *pesewas*,
@@ -292,6 +298,12 @@ export interface PartialDebit {
      */
     at_least: string;
 }
-export interface Subscription {
+export interface PartialDebitResponse extends Response {
+    data: Record<string, any>;
+}
+export interface CheckAuthorizationResponse extends Response {
+    data: {
+        amount: string;
+        currency: string;
+    };
 }
-export {};

package/dist/transaction/interface.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-[];

package/dist/transaction/transaction.d.ts

@@ -1,5 +1,6 @@
 import { Axios } from 'axios';
-import { ChargeAuthorization, CheckAuthorization, InitializeTransaction, ListTransactionQueryParams, PartialDebit, TransactionResponse } from './interface';
+import { CheckAuthorizationResponse, ExportTransaction, ListTransactions, PartialDebitResponse, Timeline, TransactionData } from './interface';
+import { ChargeAuthorization, CheckAuthorization, InitializeTransaction, ListTransactionQueryParams, PartialDebit, TransactionInitialized } from './interface';
 interface BadRequest {
     status: boolean;
     message: string;
@@ -17,15 +18,15 @@ export declare class Transaction {
      * Initialize a transaction
      * @param {InitializeTransaction} data **Body Param**
      */
-    initialize(data: InitializeTransaction): Promise<TransactionResponse | BadRequest>;
-    verify(reference: string): Promise<TransactionResponse | BadRequest>;
-    list(queryParams: ListTransactionQueryParams): Promise<TransactionResponse | BadRequest>;
-    fetch(id: string): Promise<TransactionResponse | BadRequest>;
-    chargeAuthorization(data: ChargeAuthorization): Promise<TransactionResponse | BadRequest>;
-    checkAuthorization(data: CheckAuthorization): Promise<TransactionResponse | BadRequest>;
-    viewTimeline(id: string): Promise<TransactionResponse | BadRequest>;
-    totals(queryParams: ListTransactionQueryParams): Promise<TransactionResponse | BadRequest>;
-    export(queryParams: ListTransactionQueryParams): Promise<TransactionResponse | BadRequest>;
-    partialDebit(data: PartialDebit): Promise<TransactionResponse | BadRequest>;
+    initialize(data: InitializeTransaction): Promise<TransactionInitialized | BadRequest>;
+    verify(reference: string): Promise<TransactionData | BadRequest>;
+    list(queryParams?: ListTransactionQueryParams): Promise<ListTransactions | BadRequest>;
+    fetch(id: string): Promise<TransactionData | BadRequest>;
+    chargeAuthorization(data: ChargeAuthorization): Promise<TransactionData | BadRequest>;
+    checkAuthorization(data: CheckAuthorization): Promise<CheckAuthorizationResponse | BadRequest>;
+    viewTimeline(id: string): Promise<Timeline | BadRequest>;
+    total(queryParams: ListTransactionQueryParams): Promise<ListTransactions | BadRequest>;
+    export(queryParams: ListTransactionQueryParams): Promise<ExportTransaction | BadRequest>;
+    partialDebit(data: PartialDebit): Promise<PartialDebitResponse | BadRequest>;
 }
 export {};

package/dist/transaction/transaction.js

@@ -26,7 +26,7 @@ class Transaction {
     initialize(data) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.http.post('/transaction/initialize', JSON.stringify(data));
-            return JSON.parse(response.data);
+            return response;
         });
     }
     verify(reference) {
@@ -34,7 +34,7 @@ class Transaction {
             const response = yield this.http.get('/transaction/verify', {
                 params: { reference },
             });
-            return JSON.parse(response.data);
+            return response;
         });
     }
     list(queryParams) {
@@ -42,47 +42,44 @@ class Transaction {
             const response = yield this.http.get('/transaction', {
                 params: Object.assign({}, queryParams),
             });
-            return JSON.parse(response.data);
+            return response;
         });
     }
     fetch(id) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.http.get(`/transaction/:${id}`);
-            return JSON.parse(response.data);
+            return response;
         });
     }
     chargeAuthorization(data) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.http.post('/transaction/charge_authorization', JSON.stringify(data));
-            return JSON.parse(response.data);
+            return response;
         });
     }
     checkAuthorization(data) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.http.post('/transaction/check_authorization', JSON.stringify(data));
-            return JSON.parse(response.data);
+            return response;
         });
     }
     viewTimeline(id) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.http.get(`/transaction/timeline/${id}`);
-            return JSON.parse(response.data);
+            return yield this.http.get(`/transaction/timeline/${id}`);
         });
     }
-    totals(queryParams) {
+    total(queryParams) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.http.get('/transaction/totals', {
+            return yield this.http.get('/transaction/totals', {
                 params: Object.assign({}, queryParams),
             });
-            return JSON.parse(response.data);
         });
     }
     export(queryParams) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.http.get('/transaction/export', {
+            return yield this.http.get('/transaction/export', {
                 params: Object.assign({}, queryParams),
             });
-            return JSON.parse(response.data);
         });
     }
     partialDebit(data) {

package/dist/transfer/interface.d.ts

@@ -0,0 +1,105 @@
+export interface InitiateTransfer {
+    /**
+     * Where should we transfer from? Only `balance` for now
+     */
+    source: string;
+    /** Amount to transfer in *kobo* if currency is `NGN`
+     * and *pesewas* if currency is `GHS`.
+     */
+    amount: number;
+    /**
+     * Code for transfer recipient
+     */
+    recipient: string;
+    /**
+     * The reason for the transfer
+     */
+    reason?: string;
+    /**
+     * Specify the currency of the transfer. Defaults to NGN
+     */
+    currency?: string;
+    /** If specified, the field should be a unique identifier (in lowercase)
+     * for the object. Only `-`,`_` and alphanumeric characters allowed.
+     */
+    reference?: string;
+}
+export interface Response {
+    status: boolean;
+    message: string;
+}
+export interface FinalizeTransfer extends Response {
+    data: Transfer;
+}
+export interface TransferInitiated extends Response {
+    data: Transfer;
+}
+export interface InitiateBulkTransfer {
+    /**
+     * Where should we transfer from? Only `balance` for now
+     */
+    source: string;
+    /**
+     * A list of transfer object. Each object should contain `amount`, `recipient`, and `reference`
+     */
+    transfers: {
+        amount: number;
+        recipient: string;
+        reference: string;
+    }[];
+}
+export interface BulkTransferInitiated extends Response {
+    data: Transfer[];
+}
+export interface ListTransfers extends Response {
+    data: Transfer[];
+}
+export interface FetchTransfer extends Response {
+    data: Transfer;
+}
+export interface VerifyTransfer extends Response {
+    data: Transfer;
+}
+export interface ListTransferQueryParams {
+    /**
+     * Specify how many records you want to retrieve per page.
+     * If not specify we use a default value of 50.
+     */
+    perPage?: number;
+    /**
+     * Specify exactly what page you want to retrieve.
+     * If not specify we use a default value of 1.
+     */
+    page?: number;
+    /**
+     * Specify an ID for the customer whose transactions
+     * you want to retrieve
+     */
+    customer?: number;
+    /**
+     * A timestamp from which to start listing transaction
+     * e.g `2021-10-25T00.00.05.000z`, `2021-12-25`
+     */
+    from?: Date;
+    /**
+     * A timestamp from which to stop listing transaction
+     * e.g `2021-10-25T00.00.05.000z`, `2021-12-25`
+     */
+    to?: Date;
+}
+interface Transfer {
+    integration: number;
+    domain: string;
+    amount: number;
+    source: string;
+    source_details: string;
+    reason: string;
+    recipient: number | string | Record<string, unknown>;
+    status: string;
+    failures: unknown;
+    transfer_code: string;
+    id: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export {};

package/dist/transfer/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/transfer/transfer.d.ts

@@ -0,0 +1,26 @@
+import { Axios } from 'axios';
+import { BulkTransferInitiated, FetchTransfer, FinalizeTransfer, InitiateBulkTransfer, InitiateTransfer, ListTransferQueryParams, ListTransfers, TransferInitiated, VerifyTransfer } from './interface';
+interface BadRequest {
+    status: boolean;
+    message: string;
+}
+export declare class Transfer {
+    http: Axios;
+    constructor(http: Axios);
+    /**
+     * # Initiate Transfer
+     * Status of transfer object returned will be `pending` if OTP is disabled.
+     * In the event that an OTP is required, status will read `otp`.
+     */
+    initiate(data: InitiateTransfer): Promise<TransferInitiated | BadRequest>;
+    /**
+     * # Finalize Transfer
+     * Finalize an initiated transfer
+     */
+    finalize(transferCode: string, otp: string): Promise<FinalizeTransfer | BadRequest>;
+    bulk(data: InitiateBulkTransfer): Promise<BulkTransferInitiated | BadRequest>;
+    list(queryParams?: ListTransferQueryParams): Promise<ListTransfers | BadRequest>;
+    fetch(idOrCode: string): Promise<FetchTransfer | BadRequest>;
+    verify(reference: string): Promise<VerifyTransfer | BadRequest>;
+}
+export {};

package/dist/transfer/transfer.js

@@ -0,0 +1,59 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transfer = void 0;
+class Transfer {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * # Initiate Transfer
+     * Status of transfer object returned will be `pending` if OTP is disabled.
+     * In the event that an OTP is required, status will read `otp`.
+     */
+    initiate(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.post('/transfer', JSON.stringify(data));
+        });
+    }
+    /**
+     * # Finalize Transfer
+     * Finalize an initiated transfer
+     */
+    finalize(transferCode, otp) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.post('/transfer/finalize_transfer', JSON.stringify({ transfer_code: transferCode, otp }));
+        });
+    }
+    bulk(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.post('/transfer/bulk', JSON.stringify(data));
+        });
+    }
+    list(queryParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.get('/transfer', {
+                params: Object.assign({}, queryParams),
+            });
+        });
+    }
+    fetch(idOrCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.get(`/transfer/${idOrCode}`);
+        });
+    }
+    verify(reference) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.http.get(`transfer/verify/${reference}`);
+        });
+    }
+}
+exports.Transfer = Transfer;

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "paystack-sdk",
-  "version": "1.0.18",
+  "version": "1.1.20",
   "description": "Paystack SDK written in Typescript",
   "main": "dist/index.js",
-  "author": "Koderant",
+  "author": "Tech Priest",
   "license": "MIT",
   "private": false,
   "scripts": {
     "build": "tsc",
     "format": "prettier --write \"src/**/*.ts\"",
     "lint": "tslint -p tsconfig.json",
-    "test": "jest --config jestconfig.json",
     "prepare": "npm run build",
     "prepublishOnly": "npm run lint",
     "preversion": "npm run lint",
@@ -18,14 +17,16 @@
     "postversion": "git push && git push --tags"
   },
   "devDependencies": {
-    "@types/jest": "^27.0.3",
-    "@types/node": "^16.11.11",
-    "jest": "^27.4.3",
-    "prettier": "^2.5.1",
-    "ts-jest": "^27.0.7",
-    "tslint": "^6.1.3",
-    "tslint-config-prettier": "^1.18.0",
-    "typescript": "^4.5.2"
+    "@types/node": "16.11.11",
+    "@typescript-eslint/eslint-plugin": "^5.10.0",
+    "@typescript-eslint/parser": "^5.10.0",
+    "eslint": "8.6.0",
+    "prettier": "2.5.1",
+    "ts-node": "10.4.0",
+    "tslint": "6.1.3",
+    "tslint-config-prettier": "1.18.0",
+    "typescript": "4.5.2",
+    "typescript-eslint": "0.0.1-alpha.0"
   },
   "dependencies": {
     "axios": "^0.24.0"
@@ -35,7 +36,9 @@
   ],
   "keywords": [
     "Paystack",
-    "Typescript"
+    "Typescript",
+    "payment",
+    "node"
   ],
   "repository": {
     "type": "git",