clink-typescript-sdk-test 0.0.3

package/README.md

@@ -0,0 +1,189 @@
+# ClinkPay Client SDK Guide
+
+Lightweight client for Clink billing APIs, It supports `production` and `sandbox` environments and handles authentication and errors for you.
+
+## Requirements
+- Runtime with `fetch` support (e.g., Node.js 18+).
+- Only `env` values `production` and `sandbox` are supported; any other value throws. the default value is `production`.
+
+## Import
+Choose your package management tool (such as npm, yarn, or pnpm) and import it according to your project configuration.
+
+```sh
+npm install clink-typescript-sdk
+```
+
+## Quick Start
+```ts
+import { ClinkPayClient } from 'clink-typescript-sdk';
+
+const client = new ClinkPayClient({
+  apiKey: 'YOUR_API_KEY',
+  env: 'sandbox',
+});
+
+async function main() {
+  const session = await client.createCheckoutSession({
+    originalAmount: 1999,
+    originalCurrency: 'USD',
+    successUrl: 'https://merchant.example.com/success',
+    cancelUrl: 'https://merchant.example.com/cancel',
+    allowPromotionCodes: true,
+  });
+
+  console.log(session.sessionId);
+  console.log(session.url);
+}
+
+main();
+```
+
+## API Overview
+- `createCheckoutSession(options)`: Create a checkout session and get the redirect `url`.
+- `getCheckoutSession(sessionId)`: Retrieve checkout session details.
+- `getOrder(orderId)`: Retrieve order details.
+- `getRefund(refundId)`: Retrieve refund details.
+- `getSubscription(subscriptionId)`: Retrieve subscription details.
+- `getInvoice(invoiceId)`: Retrieve subscription invoice details.
+- `customerPortalSession(options)`: Create a customer portal session and get the access link.
+
+All methods are asynchronous and throw on errors.
+
+## Error Handling
+On non-successful responses or network errors, methods throw exceptions:
+- Business errors throw `ClinkApiError`.
+- Non-business errors throw standard `Error`.
+
+Example:
+```ts
+import { ClinkPayClient } from 'clink-typescript-sdk';
+
+const client = new ClinkPayClient({ apiKey: 'YOUR_API_KEY', env: 'sandbox' });
+
+async function demo() {
+  try {
+    const order = await client.getOrder('ord_123');
+    console.log(order.status);
+  } catch (e) {
+    if (e instanceof ClinkApiError) {
+      const { code, message } = e;
+      // your code here
+    }
+    // handle other errors
+  }
+}
+
+demo();
+```
+
+## Detailed Examples
+
+### Create a Checkout Session
+```ts
+const client = new ClinkPayClient({ apiKey: 'YOUR_API_KEY', env: 'sandbox' });
+const session = await client.createCheckoutSession({
+  originalAmount: 4999,
+  originalCurrency: 'USD',
+  successUrl: 'https://merchant.example.com/success',
+  cancelUrl: 'https://merchant.example.com/cancel',
+});
+console.log(session.sessionId);
+console.log(session.url);
+```
+
+### Get Checkout Session
+```ts
+const info = await client.getCheckoutSession('sess_123');
+console.log(info.status);
+```
+
+### Get Order
+```ts
+const order = await client.getOrder('ord_123');
+console.log(order.amountTotal);
+```
+
+
+### Get Refund
+```ts
+const refund = await client.getRefund('rfd_123');
+console.log(refund.status);
+```
+
+### Get Subscription
+```ts
+const sub = await client.getSubscription('sub_123');
+console.log(sub.status);
+```
+
+### Get Invoice
+```ts
+const invoice = await client.getInvoice('inv_123');
+console.log(invoice.status);
+```
+
+### Customer Portal Session
+```ts
+const portal = await client.customerPortalSession({
+  customerId: 'cus_123',
+  returnUrl: 'https://merchant.example.com/return',
+});
+console.log(portal.url);
+```
+
+### Get Product Info
+
+```ts
+const product = await client.getProduct('prod_123');
+console.log(product);
+```
+
+### Get Product List
+```ts
+const products = await client.getProductList({
+  page: 1,
+  pageSize: 10,
+});
+console.log(products);
+```
+
+### Get Price Info
+```ts
+const price = await client.getPrice('price_123');
+console.log(price);
+```
+### Get Price List
+```ts
+const prices = await client.getPriceList({
+  page: 1,
+  pageSize: 10,
+});
+console.log(prices);
+```
+
+### Get Payment Instrument List
+```ts
+const paymentInstruments = await client.getPaymentInstrumentList({
+  customerId: 'cus_123',
+  type: 'card',
+});
+console.log(paymentInstruments);
+```
+
+
+
+## webhook
+
+### Verify and Get Webhook Event
+```ts
+import { ClinkWebhook } from 'clink-typescript-sdk';
+
+const clinkWebhook = new ClinkWebhook({ signatureKey: 'YOUR_SIGNATURE_KEY' });
+// if verify error, the verifyAndGet method will throw error
+const event = clinkWebhook.verifyAndGet({
+  timestamp: 'timestamp from request header',
+  body: 'body(jsonString) from request body',
+  headerSignature: 'signature from request header',
+});
+console.log(event);
+```

package/dist/client/index.d.ts

@@ -0,0 +1,89 @@
+import { ClinkPayClientConstructorOptions, CreateCheckoutSessionRequest, CreateCheckoutSessionResponse, CustomerPortalSessionRequest, CustomerPortalSessionResponse, GetInvoiceResponse, GetOrderResponse, GetPriceRequest, GetPriceResponse, GetProductResponse, GetSessionResponse, GetSubscriptionResponse, ListResult, PageQuery, PaymentInstrumentRequest, PaymentInstrumentResponse, RefundResponse } from './model';
+export declare class ClinkPayClient {
+    private apiKey;
+    private baseUrl;
+    private requestClient;
+    constructor(options: ClinkPayClientConstructorOptions);
+    /**
+     * create checkout session
+     *
+     * @param options CreateCheckoutSessionRequest
+     * @returns sessionResponse
+     */
+    createCheckoutSession(options: CreateCheckoutSessionRequest): Promise<CreateCheckoutSessionResponse>;
+    /**
+     * get checkout session
+     *
+     * @param sessionId checkout session id
+     * @returns checkout session response
+     */
+    getCheckoutSession(sessionId: string): Promise<GetSessionResponse.SessionInfo>;
+    /**
+     * get order info
+     *
+     * @param orderId order id
+     * @returns order info response
+     */
+    getOrder(orderId: string): Promise<GetOrderResponse>;
+    /**
+     * get refund info
+     *
+     * @param refundId refund id
+     * @returns refund info response
+     */
+    getRefund(refundId: string): Promise<RefundResponse>;
+    /**
+     * get subscription info
+     *
+     * @param subscriptionId subscription id
+     * @returns subscription info response
+     */
+    getSubscription(subscriptionId: string): Promise<GetSubscriptionResponse.Data>;
+    /**
+     * get invoice info
+     *
+     * @param invoiceId invoice id
+     * @returns invoice info response
+     */
+    getInvoice(invoiceId: string): Promise<GetInvoiceResponse.Data>;
+    /**
+     * create customer portal session
+     *
+     * @param options CustomerPortalSessionRequest
+     * @returns customer portal session response
+     */
+    customerPortalSession(options: CustomerPortalSessionRequest): Promise<CustomerPortalSessionResponse>;
+    /**
+     * get product info
+     *
+     * @param productId product id
+     * @returns product info response
+     */
+    getProduct(productId: string): Promise<GetProductResponse>;
+    /**
+     * get products list
+     *
+     * @returns list of product info response
+     */
+    getProductList(params?: PageQuery): Promise<ListResult<GetProductResponse>>;
+    /**
+     * get price info
+     *
+     * @param priceId price id
+     * @returns price info response
+     */
+    getPrice(priceId: string): Promise<GetPriceResponse>;
+    /**
+     * get all prices
+     *
+     * @returns list of price info response
+     */
+    getPriceList(params: GetPriceRequest): Promise<ListResult<GetPriceResponse>>;
+    /**
+     * get payment instrument list
+     *
+     * @param params PaymentInstrumentRequest
+     * @returns list of payment instrument response. if not found, return empty list
+     */
+    getPaymentInstrumentList(params: PaymentInstrumentRequest): Promise<PaymentInstrumentResponse[]>;
+}

package/dist/client/index.js

@@ -0,0 +1,171 @@
+"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.ClinkPayClient = void 0;
+const request_1 = require("./request");
+const supportedEnvs = ['production', 'sandbox'];
+class ClinkPayClient {
+    constructor(options) {
+        this.baseUrl = '';
+        const { apiKey, env = 'production' } = options;
+        if (!supportedEnvs.includes(env)) {
+            throw new Error(`env ${env} is not supported. supported envs are ${supportedEnvs}`);
+        }
+        this.apiKey = apiKey;
+        switch (env) {
+            case 'production': {
+                this.baseUrl = 'https://api.clinkbill.com/api';
+                break;
+            }
+            case 'sandbox': {
+                this.baseUrl = 'https://uat-api.clinkbill.com/api';
+                break;
+            }
+        }
+        this.requestClient = (0, request_1.createRequestClient)(this.baseUrl, this.apiKey);
+    }
+    /**
+     * create checkout session
+     *
+     * @param options CreateCheckoutSessionRequest
+     * @returns sessionResponse
+     */
+    createCheckoutSession(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.requestClient.Post('/checkout/session', options);
+        });
+    }
+    /**
+     * get checkout session
+     *
+     * @param sessionId checkout session id
+     * @returns checkout session response
+     */
+    getCheckoutSession(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.requestClient.Get(`/checkout/session/${sessionId}`);
+        });
+    }
+    /**
+     * get order info
+     *
+     * @param orderId order id
+     * @returns order info response
+     */
+    getOrder(orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.requestClient.Get(`/order/${orderId}`);
+        });
+    }
+    /**
+     * get refund info
+     *
+     * @param refundId refund id
+     * @returns refund info response
+     */
+    getRefund(refundId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.requestClient.Get(`/refund/${refundId}`);
+        });
+    }
+    /**
+     * get subscription info
+     *
+     * @param subscriptionId subscription id
+     * @returns subscription info response
+     */
+    getSubscription(subscriptionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.requestClient.Get(`/subscription/${subscriptionId}`);
+        });
+    }
+    /**
+     * get invoice info
+     *
+     * @param invoiceId invoice id
+     * @returns invoice info response
+     */
+    getInvoice(invoiceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.requestClient.Get(`/subscription/invoice/${invoiceId}`);
+        });
+    }
+    /**
+     * create customer portal session
+     *
+     * @param options CustomerPortalSessionRequest
+     * @returns customer portal session response
+     */
+    customerPortalSession(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.requestClient.Post('/billing/session', options);
+        });
+    }
+    /**
+     * get product info
+     *
+     * @param productId product id
+     * @returns product info response
+     */
+    getProduct(productId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.requestClient.Get(`/product/${productId}`);
+        });
+    }
+    /**
+     * get products list
+     *
+     * @returns list of product info response
+     */
+    getProductList(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.requestClient.Get(`/product`, {
+                params,
+            });
+        });
+    }
+    /**
+     * get price info
+     *
+     * @param priceId price id
+     * @returns price info response
+     */
+    getPrice(priceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.requestClient.Get(`/price/${priceId}`);
+        });
+    }
+    /**
+     * get all prices
+     *
+     * @returns list of price info response
+     */
+    getPriceList(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.requestClient.Get(`/price`, {
+                params,
+            });
+        });
+    }
+    /**
+     * get payment instrument list
+     *
+     * @param params PaymentInstrumentRequest
+     * @returns list of payment instrument response. if not found, return empty list
+     */
+    getPaymentInstrumentList(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { customerId, type } = params;
+            return this.requestClient.Get(`/payment_instrument/list?customerId=${customerId}&type=${type}`);
+        });
+    }
+}
+exports.ClinkPayClient = ClinkPayClient;

package/dist/client/model.d.ts

@@ -0,0 +1,399 @@
+export type ClinkEnv = 'sandbox' | 'production';
+export interface ClinkPayClientConstructorOptions {
+    apiKey: string;
+    /**
+     * default to production
+     */
+    env?: ClinkEnv;
+}
+export interface CommonResponse<T = any> {
+    code: number;
+    msg: string;
+    data: T;
+}
+export interface CustomerPortalSessionRequest {
+    /**
+     * Existing customer's unique identifier
+     */
+    customerId: string;
+    /**
+     * Redirect URL when customer click on 'Return to Merchant'
+     */
+    returnUrl?: string;
+}
+export interface CustomerPortalSessionResponse {
+    /**
+     * The magic link for customer to access the portal
+     */
+    url: string;
+    /**
+     * Link expiry time
+     */
+    expiresAt: number;
+}
+export interface SessionProduct {
+    /**
+     * Display name of the product shown to customers during checkout
+     */
+    name: string;
+    /**
+     * Price per unit in the specified currency (must be greater than 0)
+     */
+    unitAmount: number;
+    /**
+     * Number of units to be purchased (minimum 1)
+     */
+    quantity?: number;
+    /**
+     * Three-letter ISO currency code for the price (e.g., USD, EUR, GBP)
+     */
+    currency?: string;
+    /**
+     * URL of the product image to display during checkout
+     */
+    imageUrl?: string;
+}
+export interface CreateCheckoutSessionRequest {
+    /**
+     * Total transaction amount in the specified currency (must be greater than 0)
+     */
+    originalAmount: number;
+    /**
+     * Three-letter ISO currency code for the transaction (e.g., USD, EUR, GBP)
+     */
+    originalCurrency: string;
+    /**
+     * Existing customer's unique identifier (required if customerEmail is not provided)
+     */
+    customerId?: string;
+    /**
+     * Customer's email address. A new customer account will be created if the email is not associated with an existing customer
+     */
+    customerEmail?: string;
+    /**
+     * Your internal reference ID for tracking (non-unique identifier, does not guarantee idempotency)
+     */
+    merchantReferenceId?: string;
+    /**
+     * Unique identifier of the predefined price configuration from your dashboard
+     */
+    priceId?: string;
+    /**
+     * Unique identifier of the product configured in your dashboard
+     */
+    productId?: string;
+    /**
+     * URL where customers will be redirected after successful payment completion
+     */
+    successUrl?: string;
+    /**
+     * URL where customers will be redirected if they cancel the checkout process
+     */
+    cancelUrl?: string;
+    /**
+     * List of product pricing details for one-time purchases. Use this when creating transactions without pre-configured products
+     */
+    priceDataList?: SessionProduct[];
+    /**
+     * Whether to allow promotion codes to be applied to the transaction (default: false)
+     */
+    allowPromotionCodes?: boolean;
+}
+export interface CreateCheckoutSessionResponse {
+    /**
+     * Unique identifier for the created checkout session
+     */
+    sessionId: string;
+    /**
+     * Token value required for payment processing. This token is used to verify the payment status and complete the transaction
+     */
+    tokenValue: string;
+    /**
+     * Customer's unique identifier associated with the checkout session
+     */
+    customerId: string;
+    /**
+     * Original transaction amount in the specified currency
+     */
+    originalAmount: number;
+    /**
+     * Three-letter ISO currency code for the transaction (e.g., USD, EUR, GBP)
+     */
+    originalCurrency: string;
+    /**
+     * Symbol of the currency (e.g., $, €, £)
+     */
+    originalCurrencySymbol: string;
+    /**
+     * checkout url
+     */
+    url: string;
+    merchantReferenceId: string;
+    /**
+     * Expiration time
+     */
+    expireTime: string;
+}
+export declare namespace GetSessionResponse {
+    interface PriceList {
+        amount: number;
+        currency: string;
+        exchangeRate: number;
+    }
+    interface Recurring {
+        freeTrialDays: number;
+        interval: string;
+    }
+    interface Price {
+        priceId: string;
+        priceList: PriceList[];
+        recurring: Recurring;
+    }
+    interface Customer {
+        customerId: string;
+        email: string;
+    }
+    interface Product {
+        productId: string;
+        productName: string;
+    }
+    interface SessionInfo {
+        sessionId: string;
+        token: string;
+        status: string;
+        paymentStatus: string;
+        amountSubtotal: number;
+        amountTotal?: number;
+        originalCurrency: string;
+        paymentCurrency?: string;
+        subscriptionId?: string;
+        invoiceId?: string;
+        orderId?: string;
+        price: Price;
+        merchantReferenceId?: string;
+        customer: Customer;
+        locale: string;
+        cancelUrl?: string;
+        successUrl?: string;
+        created: string;
+        expire: string;
+        product: Product;
+        priceDataList?: SessionProduct[];
+    }
+}
+export interface GetOrderResponse {
+    orderId: string;
+    merchantReferenceId?: string;
+    invoiceId: string;
+    customerId: string;
+    productId: string;
+    priceId: string;
+    priceDataList?: SessionProduct[];
+    paymentMethod: {
+        paymentMethodType: string;
+        paymentInstrumentId: string;
+    };
+    amountSubtotal: number;
+    amountTotal: number;
+    paymentCurrency: string;
+    originalCurrency: string;
+    status: string;
+}
+export declare namespace GetSubscriptionResponse {
+    interface Recurring {
+        interval: string;
+        trialPeriodDays: number;
+        pricingModel: string;
+        tiersMode?: any;
+    }
+    interface Price {
+        productId: string;
+        productName: string;
+        priceId: string;
+        priceSnapshotId: string;
+        unitAmount: string;
+        quantity: number;
+        recurring: Recurring;
+    }
+    interface RecurringInvoiceItem {
+        invoiceItemId: string;
+        amount: string;
+        currency: string;
+        description: string;
+        periodStart: number;
+        periodEnd: number;
+        proration?: number;
+        price: Price;
+    }
+    interface Data {
+        merchantReference?: any;
+        subscriptionId: string;
+        customerId: string;
+        productId: string;
+        priceId: string;
+        priceSnapshotId: string;
+        createTime: number;
+        quantity: number;
+        paymentMethodType: string;
+        paymentInstrumentId: string;
+        trialStart?: string;
+        trialEnd?: string;
+        currentPeriodStart: number;
+        currentPeriodEnd: number;
+        cancelAt?: string;
+        cancelAtPeriodEnd?: string;
+        canceledAt?: string;
+        cancelReason?: string;
+        status: string;
+        billing: string;
+        currency: string;
+        recurringInvoiceItem: RecurringInvoiceItem;
+        upcomingInvoiceItem?: RecurringInvoiceItem;
+    }
+}
+export declare namespace GetInvoiceResponse {
+    interface Recurring {
+        interval: string;
+        trialPeriodDays: number;
+        pricingModel: string;
+        tiersMode?: any;
+    }
+    interface Price {
+        productId: string;
+        productName: string;
+        priceId: string;
+        priceSnapshotId: string;
+        unitAmount: string;
+        quantity: number;
+        recurring: Recurring;
+    }
+    interface Item {
+        invoiceItemId: string;
+        amount: string;
+        currency: string;
+        description: string;
+        periodStart: number;
+        periodEnd: number;
+        proration?: any;
+        price: Price;
+    }
+    interface Data {
+        invoiceId: string;
+        subscriptionId: string;
+        orderId: string;
+        customerId: string;
+        merchantId: string;
+        status: string;
+        createTime: number;
+        currentPeriodStart: number;
+        currentPeriodEnd: number;
+        originalAmount: string;
+        paymentAmount: string;
+        originalCurrency: string;
+        billing: string;
+        items: Item[];
+        discount?: number;
+    }
+}
+export interface RefundResponse {
+    createTime: number;
+    refundId: string;
+    orderId: string;
+    customerId: string;
+    refundAmount: number;
+    refundCurrency: string;
+    status: string;
+    refundReason: string;
+    paymentInstrumentId: string;
+    metadata?: string;
+}
+export interface ListResult<T> {
+    total: number;
+    rows: T[];
+}
+export interface PageQuery {
+    /**
+     * Page number
+     */
+    page?: number;
+    /**
+     * Number of items per page
+     */
+    pageSize?: number;
+}
+export interface GetProductResponse {
+    productId: string;
+    name: string;
+    active: boolean;
+    description: string;
+    defaultPrice: string;
+    image: string;
+    taxCategory: string;
+    createTime: number;
+    updateTime?: string;
+}
+export interface GetPriceRequest extends PageQuery {
+    /**
+     * Product ID
+     */
+    productId: string;
+    /**
+     * Is it available for purchase
+     * @requires active
+     */
+    active: boolean;
+}
+export interface GetPriceResponse {
+    priceId: string;
+    productId: string;
+    currency: string;
+    unitAmount: number;
+    priceType: string;
+    recurring: {
+        interval: string;
+        tiers?: any;
+        interval_count?: any;
+        trial_period_days: number;
+        pricing_model: string;
+        tiers_mode?: any;
+        transform_quantity?: any;
+        [key: string]: any;
+    };
+    active: boolean;
+    createTime: number;
+}
+export type PaymentType = 'CARD' | 'CASHAPP' | 'KAKAO' | 'WECHAT' | string;
+export interface PaymentInstrumentRequest {
+    customerId: string;
+    type: PaymentType;
+}
+export interface PaymentInstrumentResponse {
+    id: string;
+    customerId: string;
+    type: string;
+    card?: Card;
+    wallet?: Wallet;
+    created: number;
+}
+export interface Wallet {
+    accountTag: string;
+}
+export interface BillingAddress {
+    city?: string;
+    country: string;
+    line1?: string;
+    line2?: string;
+    postalCode?: string;
+    state?: string;
+}
+export interface Card {
+    last4: string;
+    name: string;
+    expiryYear: string;
+    expiryMonth: string;
+    scheme: string;
+    funding: string;
+    issuerRegion: string;
+    issuerBank: string;
+    billingAddress: BillingAddress;
+}

package/dist/client/model.js

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

package/dist/client/request.d.ts

@@ -0,0 +1,2 @@
+export declare function createRequestClient(baseURL: string, apiKey: string): import("alova").Alova<import("alova").AlovaGenerics<any, any, import("alova/fetch").FetchRequestInit, Response, Headers, import("alova").AlovaDefaultCacheAdapter, import("alova").AlovaDefaultCacheAdapter, import("alova").StatesExport<any>>>;
+export type RequestClient = ReturnType<typeof createRequestClient>;

package/dist/client/request.js

@@ -0,0 +1,83 @@
+"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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRequestClient = createRequestClient;
+const alova_1 = require("alova");
+const fetch_1 = __importDefault(require("alova/fetch"));
+const exceptions_1 = require("../exceptions");
+/**
+ * Success code for API requests
+ */
+const SUCCESS_CODE = 200;
+function createRequestClient(baseURL, apiKey) {
+    const alovaInstance = (0, alova_1.createAlova)({
+        baseURL,
+        requestAdapter: (0, fetch_1.default)(),
+        responded: {
+            onError: (error) => {
+                throw error;
+            },
+            onSuccess: (response) => __awaiter(this, void 0, void 0, function* () {
+                // Most likely due to network issues causing errors
+                if (response.status >= 400) {
+                    try {
+                        const json = (yield response.json());
+                        throw new exceptions_1.ClinkApiError(json.code, json.msg);
+                    }
+                    catch (e) {
+                        if (e instanceof exceptions_1.ClinkApiError) {
+                            throw e;
+                        }
+                        // throw if response.json failed
+                        throw new Error(response.statusText);
+                    }
+                }
+                const json = (yield response.json());
+                if (json.code !== SUCCESS_CODE) {
+                    throw new exceptions_1.ClinkApiError(json.code, json.msg);
+                }
+                const { code, msg, data } = json, rest = __rest(json, ["code", "msg", "data"]);
+                // Compatible with non-standard return formats for lists
+                if (data !== undefined) {
+                    return data;
+                }
+                return rest;
+            }),
+        },
+        beforeRequest(method) {
+            method.config.headers['Content-Type'] = 'application/json';
+            // locale en
+            method.config.headers['Accept-Language'] = 'en_US';
+            method.config.headers['Content-Language'] = 'en_US';
+            // add secret key to header
+            method.config.headers['X-API-Key'] = apiKey;
+            method.config.headers['X-TIMESTAMP'] = Date.now().toString();
+        },
+        cacheFor: null,
+        shareRequest: false,
+        timeout: 10000,
+    });
+    return alovaInstance;
+}

package/dist/exceptions/index.d.ts

@@ -0,0 +1,7 @@
+export declare class ClinkApiError extends Error {
+    code: number;
+    constructor(code: number, message: string);
+}
+export declare class ClinkWebhookSignatureError extends Error {
+    constructor(message: string);
+}

package/dist/exceptions/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClinkWebhookSignatureError = exports.ClinkApiError = void 0;
+class ClinkApiError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.ClinkApiError = ClinkApiError;
+class ClinkWebhookSignatureError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.ClinkWebhookSignatureError = ClinkWebhookSignatureError;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './client';
+export * from './exceptions';
+export * from './webhook';

package/dist/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./exceptions"), exports);
+__exportStar(require("./webhook"), exports);

package/dist/webhook/index.d.ts

@@ -0,0 +1,31 @@
+import { ClinkWebhookConstructorOptions, ClinkWebhookEvent, ClinkWebhookSignatureOptions, WithHeaderSignature } from './model';
+export declare class ClinkWebhook {
+    private signatureKey;
+    constructor(options: ClinkWebhookConstructorOptions);
+    /**
+     * generate webhook signature
+     *
+     * @param options { timestamp: string, body: string }
+     * @returns string
+     */
+    signature(options: ClinkWebhookSignatureOptions): string;
+    /**
+     * verify webhook signature
+     *
+     * @param options { timestamp: string, body: string, headerSignature: string }
+     * @returns boolean
+     */
+    verifySignature(options: WithHeaderSignature): boolean;
+    /**
+     * verify webhook signature and return event data
+     *
+     * @param options { timestamp: string, body: string, headerSignature: string }
+     * @throws ClinkWebhookSignatureError when signature verify failed
+     * @returns ClinkWebhookEvent<T>
+     */
+    verifyAndGet<T = any>(options: {
+        timestamp: string;
+        body: string;
+        headerSignature: string;
+    }): ClinkWebhookEvent<T>;
+}

package/dist/webhook/index.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClinkWebhook = void 0;
+const crypto_js_1 = __importDefault(require("crypto-js"));
+const exceptions_1 = require("../exceptions");
+class ClinkWebhook {
+    constructor(options) {
+        const { signatureKey } = options;
+        this.signatureKey = signatureKey;
+    }
+    /**
+     * generate webhook signature
+     *
+     * @param options { timestamp: string, body: string }
+     * @returns string
+     */
+    signature(options) {
+        const { timestamp, body } = options;
+        const payload = `${timestamp}.${body}`;
+        const hash = crypto_js_1.default.HmacSHA256(payload, this.signatureKey);
+        return crypto_js_1.default.enc.Hex.stringify(hash);
+    }
+    /**
+     * verify webhook signature
+     *
+     * @param options { timestamp: string, body: string, headerSignature: string }
+     * @returns boolean
+     */
+    verifySignature(options) {
+        const { timestamp, body, headerSignature } = options;
+        const payload = `${timestamp}.${body}`;
+        const hash = crypto_js_1.default.HmacSHA256(payload, this.signatureKey);
+        const computedSignature = crypto_js_1.default.enc.Hex.stringify(hash);
+        return computedSignature === headerSignature;
+    }
+    /**
+     * verify webhook signature and return event data
+     *
+     * @param options { timestamp: string, body: string, headerSignature: string }
+     * @throws ClinkWebhookSignatureError when signature verify failed
+     * @returns ClinkWebhookEvent<T>
+     */
+    verifyAndGet(options) {
+        const { timestamp, body, headerSignature } = options;
+        const isSignatureValid = this.verifySignature({
+            timestamp,
+            body,
+            headerSignature,
+        });
+        if (!isSignatureValid) {
+            throw new exceptions_1.ClinkWebhookSignatureError('webhook signature verify failed');
+        }
+        return JSON.parse(body);
+    }
+}
+exports.ClinkWebhook = ClinkWebhook;

package/dist/webhook/model.d.ts

@@ -0,0 +1,34 @@
+export interface ClinkWebhookConstructorOptions {
+    /**
+     * you can get signatureKey from dashboard -> Developers -> webhook
+     */
+    signatureKey: string;
+}
+/**
+ * common webhook event
+ */
+export interface ClinkWebhookEvent<T = any> {
+    id: string;
+    type: string;
+    object: string;
+    created: string;
+    data: {
+        object: T;
+    };
+}
+export interface ClinkWebhookSignatureOptions {
+    /**
+     * timestamp from header X-Clink-Timestamp
+     */
+    timestamp: string;
+    /**
+     * body from request body
+     */
+    body: string;
+}
+export interface WithHeaderSignature extends ClinkWebhookSignatureOptions {
+    /**
+     * signature from header X-Clink-Signature
+     */
+    headerSignature: string;
+}

package/dist/webhook/model.js

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

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "clink-typescript-sdk-test",
+  "version": "0.0.3",
+  "author": {
+    "name": "Clink-test",
+    "email": "support@clinkbill.com",
+    "url": "https://www.clinkbill.com/"
+  },
+  "description": "npm package for clinkbill",
+  "keywords": [
+    "clinkbill",
+    "clinkpay"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test:api": "vitest test/api.test.ts",
+    "test:webhook": "vitest test/webhook.test.ts",
+    "test": "vitest */*.test.ts",
+    "clean-dist": "rm -rf ./dist"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "alova": "3.3.4",
+    "crypto-js": "4.2.0"
+  },
+  "devDependencies": {
+    "@types/crypto-js": "^4.2.2",
+    "@types/node": "24.10.1",
+    "prettier": "3.6.2",
+    "typescript": "^5",
+    "vitest": "4.0.13"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}