@channelpayments/node-sdk 1.24.0

package/dist/mjs/src/models/index.js

@@ -0,0 +1,58 @@
+/* tslint:disable */
+/* eslint-disable */
+export * from './AddressDto';
+export * from './AddressEntity';
+export * from './BuyerAddressEntity';
+export * from './BuyerEntity';
+export * from './BuyerEntity1';
+export * from './BuyerEntityAddress';
+export * from './BuyersSearchEntity';
+export * from './CFeeDto';
+export * from './CFeeEntity';
+export * from './CaptureTransactionDto';
+export * from './CardDetails';
+export * from './CreateBuyerDto';
+export * from './CreateBuyerDtoAddress';
+export * from './CreateMerchantAccountDto';
+export * from './CreateMerchantAccountDtoCfee';
+export * from './CreateMerchantAccountDtoGateways';
+export * from './CreateMerchantAccountsDto';
+export * from './CreateMerchantAddressDto';
+export * from './CreateMerchantCredentialsDto';
+export * from './CreateMerchantDto';
+export * from './CreateMerchantDtoAddress';
+export * from './CreateMerchantGateway';
+export * from './CreatePaymentMethodDto';
+export * from './CreateTransactionDto';
+export * from './CreateTransactionDtoPaymentMethod';
+export * from './ErrorEntity';
+export * from './MerchantAccountEntity';
+export * from './MerchantAccountEntityCfee';
+export * from './MerchantAddressEntity';
+export * from './MerchantCredentialsEntity';
+export * from './MerchantEntity';
+export * from './MerchantEntityAddress';
+export * from './MerchantGatewayEntity';
+export * from './PaymentMethodDto';
+export * from './PaymentMethodEntity';
+export * from './PaymentMethodEntity1';
+export * from './PaymentMethodEntityBuyer';
+export * from './PaymentMethodEntityDetails';
+export * from './PaymentMethodsSearchEntity';
+export * from './PaymentsBuyerEntity';
+export * from './RefundTransactionDto';
+export * from './TransactionEntity';
+export * from './TransactionRefundEntity';
+export * from './TransactionRefundsSearchEntity';
+export * from './TransactionsSearchEntity';
+export * from './UpdateAddressDto';
+export * from './UpdateBuyerDto';
+export * from './UpdateBuyerDtoAddress';
+export * from './UpdateCFeeDto';
+export * from './UpdateMerchantAccountDto';
+export * from './UpdateMerchantAccountDtoCfee';
+export * from './UpdateMerchantAddressDto';
+export * from './UpdateMerchantCredentialsDto';
+export * from './UpdateMerchantDto';
+export * from './UpdateMerchantDtoAddress';
+export * from './ValidateMerchantCredentialsDto';

package/dist/mjs/src/runtime.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Channel Payments API
+ *
+ * NOTE: This class is auto generated. Do not edit the class manually.
+ *
+ */
+interface BaseApiConfig {
+    keyId: string;
+    privateKey: string;
+}
+interface ApiConfigWithEnvironment extends BaseApiConfig {
+    environment?: 'prod' | 'sandbox';
+    url?: never;
+}
+interface ApiConfigWithUrl extends BaseApiConfig {
+    environment?: never;
+    url?: string;
+}
+export type ApiConfig = ApiConfigWithEnvironment | ApiConfigWithUrl;
+/**
+ * This is the base class for all generated API classes.
+ */
+export declare class BaseAPI {
+    protected apiConfig: ApiConfig;
+    private static readonly jsonRegex;
+    private keyId;
+    private privateKey;
+    private url;
+    constructor(apiConfig: ApiConfig);
+    /**
+     * 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.
+     */
+    protected isJsonMime(mime: string | null | undefined): boolean;
+    protected request(context: RequestOpts): Promise<Response>;
+    private createFetchParams;
+    private fetchApi;
+}
+export declare class ResponseError extends Error {
+    response: Response;
+    name: "ResponseError";
+    constructor(response: Response, msg?: string);
+}
+export declare class FetchError extends Error {
+    cause: Error;
+    name: "FetchError";
+    constructor(cause: Error, msg?: string);
+}
+export declare class RequiredError extends Error {
+    field: string;
+    name: "RequiredError";
+    constructor(field: string, msg?: string);
+}
+export declare const COLLECTION_FORMATS: {
+    csv: string;
+    ssv: string;
+    tsv: string;
+    pipes: string;
+};
+export type Json = any;
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+export type HTTPHeaders = {
+    [key: string]: string;
+};
+export type HTTPQuery = {
+    [key: string]: string | number | null | boolean | Array<string | number | null | boolean> | Set<string | number | null | boolean> | HTTPQuery;
+};
+export type HTTPBody = Json | FormData | URLSearchParams;
+export interface RequestOpts {
+    path: string;
+    method: HTTPMethod;
+    headers: HTTPHeaders;
+    query?: HTTPQuery;
+    body?: HTTPBody;
+}
+export declare function exists(json: any, key: string): boolean;
+export declare const removeNullUndefined: <T extends Record<string, any>>(obj: T) => { [K in keyof T as T[K] extends null | undefined ? never : K]: T[K]; };
+export declare function querystring(params: HTTPQuery, prefix?: string): string;
+export declare function mapValues(data: any, fn: (item: any) => any): {};
+export declare function canConsumeForm(consumes: Consume[]): boolean;
+export interface Consume {
+    contentType: string;
+}
+export interface ApiResponse<T> {
+    raw: Response;
+    value(): Promise<T>;
+}
+export interface ResponseTransformer<T> {
+    (json: any): T;
+}
+export declare class JSONApiResponse<T> {
+    raw: Response;
+    private transformer;
+    constructor(raw: Response, transformer?: ResponseTransformer<T>);
+    value(): Promise<T>;
+}
+export declare class VoidApiResponse {
+    raw: Response;
+    constructor(raw: Response);
+    value(): Promise<void>;
+}
+export declare class BlobApiResponse {
+    raw: Response;
+    constructor(raw: Response);
+    value(): Promise<Blob>;
+}
+export declare class TextApiResponse {
+    raw: Response;
+    constructor(raw: Response);
+    value(): Promise<string>;
+}
+export {};

package/dist/mjs/src/runtime.js

@@ -0,0 +1,234 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Channel Payments API
+ *
+ * NOTE: This class is auto generated. Do not edit the class manually.
+ *
+ */
+const ENVIRONMENT_URLS = {
+    prod: 'https://channelpayments-api.com',
+    sandbox: 'https://sandbox.channelpayments-api.com',
+};
+import fetch from 'cross-fetch';
+import jwt from 'jsonwebtoken';
+import { ulid } from 'ulidx';
+/**
+ * This is the base class for all generated API classes.
+ */
+export class BaseAPI {
+    apiConfig;
+    static jsonRegex = new RegExp('^(:?application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$', 'i');
+    keyId;
+    privateKey;
+    url;
+    constructor(apiConfig) {
+        this.apiConfig = apiConfig;
+        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);
+    }
+    async request(context) {
+        const { url, requestInit } = await this.createFetchParams(context);
+        return await this.fetchApi(url, requestInit);
+    }
+    async createFetchParams(context) {
+        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: ulid(),
+            scopes: ['*.read', '*.write'],
+        };
+        const token = jwt.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 };
+    }
+    fetchApi = async (url, init) => {
+        let fetchParams = { url, init };
+        let response = undefined;
+        try {
+            response = await fetch(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;
+    };
+}
+;
+function isBlob(value) {
+    return typeof Blob !== 'undefined' && value instanceof Blob;
+}
+function isFormData(value) {
+    return typeof FormData !== "undefined" && value instanceof FormData;
+}
+export class ResponseError extends Error {
+    response;
+    name = "ResponseError";
+    constructor(response, msg) {
+        super(msg);
+        this.response = response;
+    }
+}
+export class FetchError extends Error {
+    cause;
+    name = "FetchError";
+    constructor(cause, msg) {
+        super(msg);
+        this.cause = cause;
+    }
+}
+export class RequiredError extends Error {
+    field;
+    name = "RequiredError";
+    constructor(field, msg) {
+        super(msg);
+        this.field = field;
+    }
+}
+export const COLLECTION_FORMATS = {
+    csv: ",",
+    ssv: " ",
+    tsv: "\t",
+    pipes: "|",
+};
+export function exists(json, key) {
+    const value = json[key];
+    return value !== null && value !== undefined;
+}
+export const removeNullUndefined = (obj) => Object.fromEntries(Object.entries(obj).filter(([_, v]) => v != null));
+export function querystring(params, prefix = '') {
+    return Object.keys(params)
+        .map(key => querystringSingleKey(key, params[key], prefix))
+        .filter(part => part.length > 0)
+        .join('&');
+}
+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))}`;
+}
+export function mapValues(data, fn) {
+    return Object.keys(data).reduce((acc, key) => ({ ...acc, [key]: fn(data[key]) }), {});
+}
+export function canConsumeForm(consumes) {
+    for (const consume of consumes) {
+        if ('multipart/form-data' === consume.contentType) {
+            return true;
+        }
+    }
+    return false;
+}
+export class JSONApiResponse {
+    raw;
+    transformer;
+    constructor(raw, transformer = (jsonValue) => jsonValue) {
+        this.raw = raw;
+        this.transformer = transformer;
+    }
+    async value() {
+        return this.transformer(await this.raw.json());
+    }
+}
+export class VoidApiResponse {
+    raw;
+    constructor(raw) {
+        this.raw = raw;
+    }
+    async value() {
+        return undefined;
+    }
+}
+export class BlobApiResponse {
+    raw;
+    constructor(raw) {
+        this.raw = raw;
+    }
+    async value() {
+        return await this.raw.blob();
+    }
+    ;
+}
+export class TextApiResponse {
+    raw;
+    constructor(raw) {
+        this.raw = raw;
+    }
+    async value() {
+        return await this.raw.text();
+    }
+    ;
+}

package/dist/mjs/test.d.ts

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

package/dist/mjs/test.js

@@ -0,0 +1,47 @@
+import * as fs from 'fs';
+import { ChannelPaymentsApi } from './src/apis';
+const channelPaymentsApi = new ChannelPaymentsApi({
+    keyId: 'i6OtWffwR6A4ungdsRVSKYu5KT/NkC74gWibR5SfZuo',
+    privateKey: fs.readFileSync('/Users/andy/Downloads/sandbox-integ.pem', 'utf8'),
+    // environment: 'sandbox'
+    url: 'http://localhost:3000'
+});
+(async () => {
+    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 = await 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/package.json

@@ -0,0 +1,32 @@
+{
+	"name": "@channelpayments/node-sdk",
+	"description": "Channel Payments nodejs sdk",
+	"version": "v1.24.0",
+	"author": "Channel Payments",
+	"license": "ISC",
+	"main": "dist/cjs/index.js",
+	"module": "dist/mjs/index.js",
+	"exports": {
+		".": {
+			"import": "./dist/mjs/index.js",
+			"require": "./dist/cjs/index.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "./build.sh"
+	},
+	"dependencies": {
+		"cross-fetch": "^3.1.6",
+		"jsonwebtoken": "^9.0.0",
+		"ulidx": "^2.0.0"
+	},
+	"devDependencies": {
+		"@types/jsonwebtoken": "^9.0.2",
+		"@types/node": "^20.3.1",
+		"ts-node": "^10.9.1",
+		"typescript": "^5.1.3"
+	}
+}