@channelpayments/node-sdk 1.24.0

package/dist/cjs/src/runtime.js

@@ -0,0 +1,262 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Channel Payments API
+ *
+ * NOTE: This class is auto generated. Do not edit the class manually.
+ *
+ */
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextApiResponse = exports.BlobApiResponse = exports.VoidApiResponse = exports.JSONApiResponse = exports.canConsumeForm = exports.mapValues = exports.querystring = exports.removeNullUndefined = exports.exists = exports.COLLECTION_FORMATS = exports.RequiredError = exports.FetchError = exports.ResponseError = exports.BaseAPI = void 0;
+const ENVIRONMENT_URLS = {
+    prod: 'https://channelpayments-api.com',
+    sandbox: 'https://sandbox.channelpayments-api.com',
+};
+const cross_fetch_1 = __importDefault(require("cross-fetch"));
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const ulidx_1 = require("ulidx");
+/**
+ * This is the base class for all generated API classes.
+ */
+class BaseAPI {
+    constructor(apiConfig) {
+        this.apiConfig = apiConfig;
+        this.fetchApi = (url, init) => __awaiter(this, void 0, void 0, function* () {
+            let fetchParams = { url, init };
+            let response = undefined;
+            try {
+                response = yield (0, cross_fetch_1.default)(fetchParams.url, fetchParams.init);
+            }
+            catch (e) {
+                if (response === undefined) {
+                    if (e instanceof Error) {
+                        throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            return response;
+        });
+        this.keyId = apiConfig.keyId;
+        this.privateKey = apiConfig.privateKey;
+        if (apiConfig.url && apiConfig.environment) {
+            throw new Error("you must specify either 'url' or 'environment', not both");
+        }
+        if (apiConfig.url) {
+            this.url = apiConfig.url;
+        }
+        else if (apiConfig.environment) {
+            if (!ENVIRONMENT_URLS[apiConfig.environment]) {
+                throw new Error(`Unsupported environment '${apiConfig.environment}'. Valid values: 'prod | sandbox'`);
+            }
+            this.url = ENVIRONMENT_URLS[apiConfig.environment];
+        }
+        else {
+            throw new Error("Expected one of 'environment' or 'url' to be specified");
+        }
+    }
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     *   application/json
+     *   application/json; charset=UTF8
+     *   APPLICATION/JSON
+     *   application/vnd.company+json
+     * @param mime - MIME (Multipurpose Internet Mail Extensions)
+     * @return True if the given MIME is JSON, false otherwise.
+     */
+    isJsonMime(mime) {
+        if (!mime) {
+            return false;
+        }
+        return BaseAPI.jsonRegex.test(mime);
+    }
+    request(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { url, requestInit } = yield this.createFetchParams(context);
+            return yield this.fetchApi(url, requestInit);
+        });
+    }
+    createFetchParams(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            Object.keys(context.headers).forEach(key => context.headers[key] === undefined ? delete context.headers[key] : {});
+            const header = {
+                typ: 'JWT',
+                alg: 'ES512',
+                kid: this.keyId,
+            };
+            const currentTime = Math.floor(Date.now() / 1000);
+            const expirationTime = currentTime + 30; // 30 seconds from now
+            const claims = {
+                iss: 'channelpayments/node-sdk',
+                iat: currentTime,
+                exp: expirationTime,
+                jti: (0, ulidx_1.ulid)(),
+                scopes: ['*.read', '*.write'],
+            };
+            const token = jsonwebtoken_1.default.sign(claims, this.privateKey, { algorithm: 'ES512', header });
+            context.headers['Authorization'] = `Bearer ${token}`;
+            let url = this.url + context.path;
+            if (context.query !== undefined && Object.keys(context.query).length !== 0) {
+                url += '?' + querystring(context.query);
+            }
+            const requestInit = {
+                method: context.method,
+                headers: context.headers,
+                body: isFormData(context.body) ||
+                    context.body instanceof URLSearchParams ||
+                    isBlob(context.body)
+                    ? context.body
+                    : JSON.stringify(context.body),
+            };
+            return { url, requestInit };
+        });
+    }
+}
+exports.BaseAPI = BaseAPI;
+BaseAPI.jsonRegex = new RegExp('^(:?application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$', 'i');
+;
+function isBlob(value) {
+    return typeof Blob !== 'undefined' && value instanceof Blob;
+}
+function isFormData(value) {
+    return typeof FormData !== "undefined" && value instanceof FormData;
+}
+class ResponseError extends Error {
+    constructor(response, msg) {
+        super(msg);
+        this.response = response;
+        this.name = "ResponseError";
+    }
+}
+exports.ResponseError = ResponseError;
+class FetchError extends Error {
+    constructor(cause, msg) {
+        super(msg);
+        this.cause = cause;
+        this.name = "FetchError";
+    }
+}
+exports.FetchError = FetchError;
+class RequiredError extends Error {
+    constructor(field, msg) {
+        super(msg);
+        this.field = field;
+        this.name = "RequiredError";
+    }
+}
+exports.RequiredError = RequiredError;
+exports.COLLECTION_FORMATS = {
+    csv: ",",
+    ssv: " ",
+    tsv: "\t",
+    pipes: "|",
+};
+function exists(json, key) {
+    const value = json[key];
+    return value !== null && value !== undefined;
+}
+exports.exists = exists;
+const removeNullUndefined = (obj) => Object.fromEntries(Object.entries(obj).filter(([_, v]) => v != null));
+exports.removeNullUndefined = removeNullUndefined;
+function querystring(params, prefix = '') {
+    return Object.keys(params)
+        .map(key => querystringSingleKey(key, params[key], prefix))
+        .filter(part => part.length > 0)
+        .join('&');
+}
+exports.querystring = querystring;
+function querystringSingleKey(key, value, keyPrefix = '') {
+    const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+    if (value instanceof Array) {
+        const multiValue = value.map(singleValue => encodeURIComponent(String(singleValue)))
+            .join(`&${encodeURIComponent(fullKey)}=`);
+        return `${encodeURIComponent(fullKey)}=${multiValue}`;
+    }
+    if (value instanceof Set) {
+        const valueAsArray = Array.from(value);
+        return querystringSingleKey(key, valueAsArray, keyPrefix);
+    }
+    if (value instanceof Date) {
+        return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+    }
+    if (value instanceof Object) {
+        return querystring(value, fullKey);
+    }
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+function mapValues(data, fn) {
+    return Object.keys(data).reduce((acc, key) => (Object.assign(Object.assign({}, acc), { [key]: fn(data[key]) })), {});
+}
+exports.mapValues = mapValues;
+function canConsumeForm(consumes) {
+    for (const consume of consumes) {
+        if ('multipart/form-data' === consume.contentType) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.canConsumeForm = canConsumeForm;
+class JSONApiResponse {
+    constructor(raw, transformer = (jsonValue) => jsonValue) {
+        this.raw = raw;
+        this.transformer = transformer;
+    }
+    value() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.transformer(yield this.raw.json());
+        });
+    }
+}
+exports.JSONApiResponse = JSONApiResponse;
+class VoidApiResponse {
+    constructor(raw) {
+        this.raw = raw;
+    }
+    value() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return undefined;
+        });
+    }
+}
+exports.VoidApiResponse = VoidApiResponse;
+class BlobApiResponse {
+    constructor(raw) {
+        this.raw = raw;
+    }
+    value() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.raw.blob();
+        });
+    }
+    ;
+}
+exports.BlobApiResponse = BlobApiResponse;
+class TextApiResponse {
+    constructor(raw) {
+        this.raw = raw;
+    }
+    value() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.raw.text();
+        });
+    }
+    ;
+}
+exports.TextApiResponse = TextApiResponse;

package/dist/cjs/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/test.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 });
+const fs = __importStar(require("fs"));
+const apis_1 = require("./src/apis");
+const channelPaymentsApi = new apis_1.ChannelPaymentsApi({
+    keyId: 'i6OtWffwR6A4ungdsRVSKYu5KT/NkC74gWibR5SfZuo',
+    privateKey: fs.readFileSync('/Users/andy/Downloads/sandbox-integ.pem', 'utf8'),
+    // environment: 'sandbox'
+    url: 'http://localhost:3000'
+});
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        // const merchant = await channelPaymentsApi.findMerchant();
+        // console.log(merchant);
+        // const createBuyerResponse = await channelPaymentsApi.createBuyer({
+        //     givenName: 'Test',
+        //     familyName: 'Test last name',
+        //     email: 'foo@bar.com',
+        //     address: {
+        //         city: 'city',
+        //         countryCode: 'US',
+        //         postalCode: '12345',
+        //         subdivision: 'AZ',
+        //         streetAddress: 'street',
+        //     }
+        // });
+        // console.log(createBuyerResponse);
+        const searchBuyersResponse = yield channelPaymentsApi.searchBuyers({
+            merchantId: ''
+        });
+        // const captureResponse = await channelPaymentsApi.createTransaction({
+        //     amount: 1000,
+        //     currency: 'USD',
+        //     paymentMethod: {
+        //         method: 'CARD',
+        //         number: '4111111111111111',
+        //         expirationDate: '12/29',
+        //         securityCode: '123'
+        //     }
+        // });
+        // console.log(captureResponse)
+    }
+    catch (_error) {
+        const error = _error;
+        console.error(`Error: ${error.message}`, error);
+    }
+}))();
+// const requestId = rawResponse.headers.get('requestId');
+//             error.requestId = requestId

package/dist/mjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/dist/mjs/src/apis/ChannelPaymentsApi.d.ts

@@ -0,0 +1,281 @@
+/**
+ * Channel Payments API
+ *
+ * NOTE: This class is auto generated. Do not edit the class manually.
+ *
+ */
+import * as runtime from '../runtime';
+import type { BuyerEntity, BuyersSearchEntity, CaptureTransactionDto, CreateBuyerDto, CreatePaymentMethodDto, CreateTransactionDto, MerchantEntity, PaymentMethodEntity, PaymentMethodsSearchEntity, RefundTransactionDto, TransactionEntity, TransactionRefundEntity, TransactionRefundsSearchEntity, TransactionsSearchEntity, UpdateBuyerDto } from '../models';
+export interface DeleteBuyerRequest {
+    buyerId: string;
+}
+export interface DeletePaymentMethodRequest {
+    paymentMethodId: any;
+}
+export interface GetBuyerRequest {
+    buyerId: string;
+}
+export interface GetPaymentMethodRequest {
+    paymentMethodId: any;
+}
+export interface GetRefundRequest {
+    refundId: string;
+}
+export interface GetTransactionRequest {
+    transactionId: string;
+}
+export interface SearchBuyersRequest {
+    merchantId?: string;
+    buyerId?: string;
+    externalBuyerId?: string;
+    startDate?: Date;
+    endDate?: Date;
+    givenName?: string;
+    familyName?: string;
+    email?: string;
+    cursor?: string;
+    limit?: string;
+    order?: SearchBuyersOrderEnum;
+}
+export interface SearchPaymentMethodsRequest {
+    merchantId: string;
+    paymentMethodId?: string;
+    buyerId?: string;
+    externalBuyerId?: string;
+    startDate?: Date;
+    endDate?: Date;
+    method?: SearchPaymentMethodsMethodEnum;
+    currency?: SearchPaymentMethodsCurrencyEnum;
+    cursor?: string;
+    limit?: string;
+    order?: SearchPaymentMethodsOrderEnum;
+}
+export interface SearchRefundsRequest {
+    merchantId: string;
+    transactionId?: string;
+    status?: Array<SearchRefundsStatusEnum>;
+    startDate?: Date;
+    endDate?: Date;
+    currency?: SearchRefundsCurrencyEnum;
+    cursor?: string;
+    limit?: string;
+    order?: SearchRefundsOrderEnum;
+}
+export interface SearchTransactionsRequest {
+    merchantId: string;
+    status?: Array<SearchTransactionsStatusEnum>;
+    intent?: SearchTransactionsIntentEnum;
+    buyerId?: string;
+    externalBuyerId?: string;
+    startDate?: Date;
+    endDate?: Date;
+    currency?: SearchTransactionsCurrencyEnum;
+    hasRefunds?: string;
+    capturedAt?: Date;
+    authorizedAt?: Date;
+    voidedAt?: Date;
+    cursor?: string;
+    limit?: string;
+    order?: SearchTransactionsOrderEnum;
+}
+export interface VoidTransactionRequest {
+    transactionId: string;
+}
+/**
+ *
+ */
+export declare class ChannelPaymentsApi extends runtime.BaseAPI {
+    /**
+     * Attempts to capture an authorized transaction
+     * Capture transaction
+    */
+    captureTransaction(requestParameters: CaptureTransactionDto): Promise<TransactionEntity>;
+    /**
+     * Creates a new buyer.
+     * Create buyer.
+    */
+    createBuyer(requestParameters: CreateBuyerDto): Promise<BuyerEntity>;
+    /**
+     * Attempts to create a new transaction by specified intent for a given payment method
+     * Create transaction
+    */
+    createTransaction(requestParameters: CreateTransactionDto): Promise<TransactionEntity>;
+    /**
+     * Removes a buyer ID.
+     * Remove buyer.
+    */
+    deleteBuyer(requestParameters: DeleteBuyerRequest): Promise<BuyerEntity>;
+    /**
+     * Delete payment method by paymentMethodId
+     * Delete payment method
+    */
+    deletePaymentMethod(requestParameters: DeletePaymentMethodRequest): Promise<PaymentMethodEntity>;
+    /**
+     * Find a buyer by buyer ID.
+     * Find buyer.
+    */
+    getBuyer(requestParameters: GetBuyerRequest): Promise<BuyerEntity>;
+    /**
+     * Retrieve all child merchants of the merchant associated with the user making the request.
+     * Find child merchants
+    */
+    getChildMerchants(): Promise<MerchantEntity>;
+    /**
+     * Retrieve the merchant associated with the user making the request.
+     * Find merchant
+    */
+    getMerchant(): Promise<MerchantEntity>;
+    /**
+     * Find payment method by paymentMethodId
+     * Find by payment method
+    */
+    getPaymentMethod(requestParameters: GetPaymentMethodRequest): Promise<PaymentMethodEntity>;
+    /**
+     * Attempts to find refund by transaction ID and refund ID
+     * Find refund
+    */
+    getRefund(requestParameters: GetRefundRequest): Promise<TransactionRefundEntity>;
+    /**
+     * Attempts to find a transaction by ID
+     * Find transaction
+    */
+    getTransaction(requestParameters: GetTransactionRequest): Promise<TransactionEntity>;
+    /**
+     * Attempts to refund a captured transaction
+     * Refund a transaction
+    */
+    refundTransaction(requestParameters: RefundTransactionDto): Promise<TransactionRefundEntity>;
+    /**
+     * Search a buyer by query param
+     * Search a buyer
+    */
+    searchBuyers(requestParameters: SearchBuyersRequest): Promise<BuyersSearchEntity>;
+    /**
+     * Search a payment methods by query params
+     * Search payment methods
+    */
+    searchPaymentMethods(requestParameters: SearchPaymentMethodsRequest): Promise<PaymentMethodsSearchEntity>;
+    /**
+     * Attempts to search refunds by query parameters
+     * Search refunds
+    */
+    searchRefunds(requestParameters: SearchRefundsRequest): Promise<TransactionRefundsSearchEntity>;
+    /**
+     * Search a transactions by query params
+     * Search transactions
+    */
+    searchTransactions(requestParameters: SearchTransactionsRequest): Promise<TransactionsSearchEntity>;
+    /**
+     * Store a card payment method
+     * Store payment method
+    */
+    storePaymentMethod(requestParameters: CreatePaymentMethodDto): Promise<PaymentMethodEntity>;
+    /**
+     * Updates an existing buyer.
+     * Update buyer.
+    */
+    updateBuyer(requestParameters: UpdateBuyerDto): Promise<BuyerEntity>;
+    /**
+     * Attempts to void an authorized transaction
+     * Void a transaction
+    */
+    voidTransaction(requestParameters: VoidTransactionRequest): Promise<TransactionEntity>;
+}
+/**
+ * @export
+ */
+export declare const SearchBuyersOrderEnum: {
+    readonly Asc: "asc";
+    readonly Desc: "desc";
+};
+export type SearchBuyersOrderEnum = typeof SearchBuyersOrderEnum[keyof typeof SearchBuyersOrderEnum];
+/**
+ * @export
+ */
+export declare const SearchPaymentMethodsMethodEnum: {
+    readonly Card: "card";
+};
+export type SearchPaymentMethodsMethodEnum = typeof SearchPaymentMethodsMethodEnum[keyof typeof SearchPaymentMethodsMethodEnum];
+/**
+ * @export
+ */
+export declare const SearchPaymentMethodsCurrencyEnum: {
+    readonly Usd: "USD";
+};
+export type SearchPaymentMethodsCurrencyEnum = typeof SearchPaymentMethodsCurrencyEnum[keyof typeof SearchPaymentMethodsCurrencyEnum];
+/**
+ * @export
+ */
+export declare const SearchPaymentMethodsOrderEnum: {
+    readonly Asc: "asc";
+    readonly Desc: "desc";
+};
+export type SearchPaymentMethodsOrderEnum = typeof SearchPaymentMethodsOrderEnum[keyof typeof SearchPaymentMethodsOrderEnum];
+/**
+ * @export
+ */
+export declare const SearchRefundsStatusEnum: {
+    readonly Processing: "processing";
+    readonly Succeeded: "succeeded";
+    readonly Declined: "declined";
+    readonly Failed: "failed";
+    readonly Voided: "voided";
+};
+export type SearchRefundsStatusEnum = typeof SearchRefundsStatusEnum[keyof typeof SearchRefundsStatusEnum];
+/**
+ * @export
+ */
+export declare const SearchRefundsCurrencyEnum: {
+    readonly Usd: "USD";
+    readonly Cad: "CAD";
+    readonly Aud: "AUD";
+};
+export type SearchRefundsCurrencyEnum = typeof SearchRefundsCurrencyEnum[keyof typeof SearchRefundsCurrencyEnum];
+/**
+ * @export
+ */
+export declare const SearchRefundsOrderEnum: {
+    readonly Asc: "asc";
+    readonly Desc: "desc";
+};
+export type SearchRefundsOrderEnum = typeof SearchRefundsOrderEnum[keyof typeof SearchRefundsOrderEnum];
+/**
+ * @export
+ */
+export declare const SearchTransactionsStatusEnum: {
+    readonly Processing: "processing";
+    readonly BuyerApprovalPending: "buyerApprovalPending";
+    readonly Authorized: "authorized";
+    readonly AuthorizationFailed: "authorizationFailed";
+    readonly Declined: "declined";
+    readonly CapturePending: "capturePending";
+    readonly Captured: "captured";
+    readonly VoidPending: "voidPending";
+    readonly Voided: "voided";
+};
+export type SearchTransactionsStatusEnum = typeof SearchTransactionsStatusEnum[keyof typeof SearchTransactionsStatusEnum];
+/**
+ * @export
+ */
+export declare const SearchTransactionsIntentEnum: {
+    readonly Capture: "capture";
+    readonly Authorize: "authorize";
+};
+export type SearchTransactionsIntentEnum = typeof SearchTransactionsIntentEnum[keyof typeof SearchTransactionsIntentEnum];
+/**
+ * @export
+ */
+export declare const SearchTransactionsCurrencyEnum: {
+    readonly Usd: "USD";
+    readonly Cad: "CAD";
+    readonly Aud: "AUD";
+};
+export type SearchTransactionsCurrencyEnum = typeof SearchTransactionsCurrencyEnum[keyof typeof SearchTransactionsCurrencyEnum];
+/**
+ * @export
+ */
+export declare const SearchTransactionsOrderEnum: {
+    readonly Asc: "asc";
+    readonly Desc: "desc";
+};
+export type SearchTransactionsOrderEnum = typeof SearchTransactionsOrderEnum[keyof typeof SearchTransactionsOrderEnum];