liqpay-nestjs 0.2.17 → 0.3.0

package/dist/core/clients/liqpay.client.d.ts

@@ -3,5 +3,10 @@ import { WebhooksClient } from './webhooks.client';
 export declare class LiqPayClient {
     payments: PaymentsClient;
     webhooks: WebhooksClient;
-    constructor(publicKey: string, privateKey: string, resultUrl: string, serverUrl: string);
+    constructor(options: {
+        publicKey: string;
+        privateKey: string;
+        resultUrl?: string;
+        serverUrl?: string;
+    });
 }

package/dist/core/clients/liqpay.client.js

@@ -7,8 +7,9 @@ const webhooks_client_1 = require("./webhooks.client");
 class LiqPayClient {
     payments;
     webhooks;
-    constructor(publicKey, privateKey, resultUrl, serverUrl) {
-        const utils = new utils_client_1.UtilsClient(publicKey, privateKey, resultUrl, serverUrl);
+    constructor(options) {
+        const { publicKey, privateKey, resultUrl, serverUrl } = options;
+        const utils = new utils_client_1.UtilsClient(publicKey, privateKey, resultUrl ?? '', serverUrl ?? '');
         this.payments = new payments_client_1.PaymentsClient(utils);
         this.webhooks = new webhooks_client_1.WebhooksClient(utils);
     }

package/dist/core/clients/payments.client.d.ts

@@ -1,16 +1,21 @@
 import { Result } from '../types/base';
-import { type CheckoutRequest } from '../types/checkout';
+import { CheckoutInput, type CheckoutRequest } from '../types/checkout';
 import { PaymentStatusResponse } from '../types/payment-status';
 import { UtilsClient } from './utils.client';
 export declare class PaymentsClient {
     private readonly utils;
     constructor(utils: UtilsClient);
-    private fulfillPayload;
-    private prepareCheckout;
-    getCheckoutUrl(payload: CheckoutRequest): string;
-    create(payload: CheckoutRequest): CheckoutRequest & {
-        checkoutUrl: string;
+    private prepare;
+    private buildUrl;
+    pay(payload: CheckoutInput): CheckoutRequest & {
+        url: string;
     };
-    getCheckoutFormButton(payload: CheckoutRequest, buttonText?: string, buttonColor?: string): string;
+    hold(payload: CheckoutInput): CheckoutRequest & {
+        url: string;
+    };
+    subscribe(payload: CheckoutInput): CheckoutRequest & {
+        url: string;
+    };
+    getPayButton(payload: CheckoutInput, buttonText?: string, buttonColor?: string): string;
     getStatus(orderId: string): Promise<Result<PaymentStatusResponse>>;
 }

package/dist/core/clients/payments.client.js

@@ -9,30 +9,36 @@ class PaymentsClient {
     constructor(utils) {
         this.utils = utils;
     }
-    fulfillPayload(payload) {
-        return {
+    prepare(payload, action) {
+        const fullfilled = {
             ...payload,
+            action,
             version: 7,
+            publicKey: this.utils.publicKey,
             resultUrl: payload.resultUrl ?? this.utils.resultUrl,
             serverUrl: payload.serverUrl ?? this.utils.serverUrl,
         };
-    }
-    prepareCheckout(payload) {
-        const fullfilled = this.fulfillPayload(payload);
         const raw = checkout_1.RawCheckoutRequestSchema.parse(fullfilled);
-        const { data, signature } = this.utils.getCredentials(raw);
+        const { data, signature } = this.utils.toEnvelope(raw);
         return { fullfilled, data, signature };
     }
-    getCheckoutUrl(payload) {
-        const { data, signature } = this.prepareCheckout(payload);
+    buildUrl(data, signature) {
         return `${url_type_1.CHECKOUT_URL}?data=${data}&signature=${signature}`;
     }
-    create(payload) {
-        const fullfilled = this.fulfillPayload(payload);
-        return { ...fullfilled, checkoutUrl: this.getCheckoutUrl(fullfilled) };
+    pay(payload) {
+        const { fullfilled, data, signature } = this.prepare(payload, 'pay');
+        return { ...fullfilled, url: this.buildUrl(data, signature) };
+    }
+    hold(payload) {
+        const { fullfilled, data, signature } = this.prepare(payload, 'hold');
+        return { ...fullfilled, url: this.buildUrl(data, signature) };
+    }
+    subscribe(payload) {
+        const { fullfilled, data, signature } = this.prepare(payload, 'subscribe');
+        return { ...fullfilled, url: this.buildUrl(data, signature) };
     }
-    getCheckoutFormButton(payload, buttonText = 'Pay', buttonColor = '#77CC5D') {
-        const { data, signature } = this.prepareCheckout(payload);
+    getPayButton(payload, buttonText = 'Pay', buttonColor = '#77CC5D') {
+        const { data, signature } = this.prepare(payload, 'pay');
         return `
       <form method="POST" action="${url_type_1.CHECKOUT_URL}" accept-charset="utf-8">
         <input type="hidden" name="data" value="${data}" />

package/dist/core/clients/utils.client.d.ts

@@ -10,7 +10,7 @@ export declare class UtilsClient {
     encodeData(data: LiqPayRawRequest): string;
     decodeData(encodedData: string): unknown;
     createSignature(encodedData: string): string;
-    getCredentials(data: LiqPayRawRequest): LiqPayEnvelope;
+    toEnvelope(data: LiqPayRawRequest): LiqPayEnvelope;
     isValidSignature(envelope: LiqPayEnvelope): boolean;
     createError(code: LiqPayError['code'], description: string): Result<never>;
     parseData<T>(schema: z.ZodType<T>, data: unknown): Result<T>;

package/dist/core/clients/utils.client.js

@@ -24,13 +24,8 @@ class UtilsClient {
         const signatureString = `${this.privateKey}${encodedData}${this.privateKey}`;
         return (0, node_crypto_1.createHash)('sha3-256').update(signatureString).digest('base64');
     }
-    getCredentials(data) {
-        const payload = {
-            ...data,
-            version: 7,
-            public_key: this.publicKey,
-        };
-        const encoded = this.encodeData(payload);
+    toEnvelope(data) {
+        const encoded = this.encodeData(data);
         const signature = this.createSignature(encoded);
         return { data: encoded, signature };
     }
@@ -77,7 +72,7 @@ class UtilsClient {
     }
     async call(payload, rawSchema, responseSchema, url) {
         const raw = rawSchema.parse(payload);
-        const envelope = this.getCredentials(raw);
+        const envelope = this.toEnvelope(raw);
         const response = await fetch(url, {
             method: 'POST',
             headers: { 'Content-Type': 'application/x-www-form-urlencoded' },

package/dist/core/types/checkout/checkout-request.d.ts

@@ -0,0 +1,225 @@
+import z from 'zod';
+import { Action, LiqPayVersion } from '../common/enums';
+/**
+ * Public layer - what library user provides
+ * These are the fields user can actually fill
+ */
+export declare const CheckoutInputSchema: z.ZodObject<{
+    amount: z.ZodNumber;
+    cardToken: z.ZodOptional<z.ZodString>;
+    currency: z.ZodEnum<{
+        USD: "USD";
+        EUR: "EUR";
+        UAH: "UAH";
+    }>;
+    description: z.ZodString;
+    ip: z.ZodOptional<z.ZodString>;
+    orderId: z.ZodString;
+    fiscalData: z.ZodOptional<z.ZodObject<{
+        items: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            amount: z.ZodNumber;
+            cost: z.ZodNumber;
+            id: z.ZodNumber;
+            price: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            amount: z.ZodNumber;
+            cost: z.ZodNumber;
+            price: z.ZodNumber;
+            categoryname: z.ZodString;
+            name: z.ZodString;
+            unitcode: z.ZodEnum<typeof import("../common/enums").UnitEnum>;
+            barcode: z.ZodOptional<z.ZodString>;
+            codifier: z.ZodOptional<z.ZodString>;
+            vndcode: z.ZodOptional<z.ZodString>;
+            taxs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                letter: z.ZodString;
+                name: z.ZodString;
+                type: z.ZodNumber;
+                prc: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>]>>>;
+        delivery_emails: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    expiredDate: z.ZodOptional<z.ZodDate>;
+    language: z.ZodOptional<z.ZodEnum<{
+        uk: "uk";
+        en: "en";
+    }>>;
+    paytypes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        apay: "apay";
+        gpay: "gpay";
+        card: "card";
+        privat24: "privat24";
+        masterpass: "masterpass";
+        moment_part: "moment_part";
+        paypart: "paypart";
+        cash: "cash";
+        invoice: "invoice";
+        qr: "qr";
+    }>>>;
+    resultUrl: z.ZodOptional<z.ZodString>;
+    serverUrl: z.ZodOptional<z.ZodString>;
+    verifyCode: z.ZodOptional<z.ZodBoolean>;
+    splitRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        public_key: z.ZodString;
+        amount: z.ZodNumber;
+        commission_payer: z.ZodEnum<{
+            sender: "sender";
+            receiver: "receiver";
+        }>;
+        server_url: z.ZodString;
+        rro_info: z.ZodOptional<z.ZodObject<{
+            items: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                amount: z.ZodNumber;
+                cost: z.ZodNumber;
+                id: z.ZodNumber;
+                price: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                amount: z.ZodNumber;
+                cost: z.ZodNumber;
+                price: z.ZodNumber;
+                categoryname: z.ZodString;
+                name: z.ZodString;
+                unitcode: z.ZodEnum<typeof import("../common/enums").UnitEnum>;
+                barcode: z.ZodOptional<z.ZodString>;
+                codifier: z.ZodOptional<z.ZodString>;
+                vndcode: z.ZodOptional<z.ZodString>;
+                taxs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    letter: z.ZodString;
+                    name: z.ZodString;
+                    type: z.ZodNumber;
+                    prc: z.ZodNumber;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>]>>>;
+            delivery_emails: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    senderAddress: z.ZodOptional<z.ZodString>;
+    senderCity: z.ZodOptional<z.ZodString>;
+    senderCountryCode: z.ZodOptional<z.ZodString>;
+    senderFirstName: z.ZodOptional<z.ZodString>;
+    senderLastName: z.ZodOptional<z.ZodString>;
+    senderPostalCode: z.ZodOptional<z.ZodString>;
+    subscribe: z.ZodOptional<z.ZodBoolean>;
+    subscribeDateStart: z.ZodOptional<z.ZodDate>;
+    subscribePeriodicity: z.ZodOptional<z.ZodEnum<{
+        day: "day";
+        week: "week";
+        month: "month";
+        year: "year";
+    }>>;
+    customer: z.ZodOptional<z.ZodString>;
+    recurringByToken: z.ZodOptional<z.ZodBoolean>;
+    customerUserId: z.ZodOptional<z.ZodString>;
+    detailAddenda: z.ZodOptional<z.ZodObject<{
+        airLine: z.ZodString;
+        ticketNumber: z.ZodString;
+        passengerName: z.ZodString;
+        flightNumber: z.ZodString;
+        originCity: z.ZodString;
+        destinationCity: z.ZodString;
+        departureDate: z.ZodString;
+    }, z.core.$strip>>;
+    info: z.ZodOptional<z.ZodString>;
+    productCategory: z.ZodOptional<z.ZodString>;
+    productDescription: z.ZodOptional<z.ZodString>;
+    productName: z.ZodOptional<z.ZodString>;
+    productUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Contract of data that is passed when forming a payment request as `base64` encoded string data when calling the LiqPay API
+ */
+export type CheckoutInput = z.infer<typeof CheckoutInputSchema>;
+/**
+ * Internal layer - full object inside the library
+ * Includes version, publicKey, action — set internally
+ *
+ *
+ * Contract of data that is passed when forming a payment request as `base64` encoded string data when calling the LiqPay API
+ */
+export type CheckoutRequest = CheckoutInput & {
+    /**
+     * API version. Current version: `7`
+     */
+    version: LiqPayVersion;
+    /**
+     * Public API key: ID of created company. Example: `i00000000`
+     *
+     * You can get the key in the store settings.
+     */
+    publicKey: string;
+    /**
+     * Operation type. Possible values:
+     * - `pay` - payment
+     * - `hold` - blocking of funds on sender's account
+     * - `subscribe` - regular payment
+     * - `paydonate` - donation
+     */
+    action: Action;
+};
+/**
+ * Raw layer - what is actually sent to LiqPay API
+ * snake_case, bool/date/string transformations
+ */
+export declare const RawCheckoutRequestSchema: z.ZodPipe<z.ZodCustom<CheckoutRequest, CheckoutRequest>, z.ZodTransform<Partial<{
+    rro_info: {
+        items?: ({
+            amount: number;
+            cost: number;
+            id: number;
+            price: number;
+        } | {
+            amount: number;
+            cost: number;
+            price: number;
+            categoryname: string;
+            name: string;
+            unitcode: import("../common/enums").UnitEnum;
+            barcode?: string | undefined;
+            codifier?: string | undefined;
+            vndcode?: string | undefined;
+            taxs?: {
+                letter: string;
+                name: string;
+                type: number;
+                prc: number;
+            }[] | undefined;
+        })[] | undefined;
+        delivery_emails?: string[] | undefined;
+    } | undefined;
+    expired_date: string | undefined;
+    paytypes: string | undefined;
+    verifycode: "Y" | undefined;
+    split_rules: string | undefined;
+    subscribe: "1" | undefined;
+    subscribe_date_start: string | undefined;
+    recurringbytoken: "1" | undefined;
+    dae: string | undefined;
+    amount: number;
+    currency: "USD" | "EUR" | "UAH";
+    description: string;
+    order_id: string;
+    card_token?: string | undefined;
+    ip?: string | undefined;
+    language?: "uk" | "en" | undefined;
+    result_url?: string | undefined;
+    server_url?: string | undefined;
+    sender_address?: string | undefined;
+    sender_city?: string | undefined;
+    sender_country_code?: string | undefined;
+    sender_first_name?: string | undefined;
+    sender_last_name?: string | undefined;
+    sender_postal_code?: string | undefined;
+    subscribe_periodicity?: "day" | "week" | "month" | "year" | undefined;
+    customer?: string | undefined;
+    customer_user_id?: string | undefined;
+    info?: string | undefined;
+    product_category?: string | undefined;
+    product_description?: string | undefined;
+    product_name?: string | undefined;
+    product_url?: string | undefined;
+    version: LiqPayVersion;
+    public_key: string;
+    action: Action;
+}>, CheckoutRequest>>;
+export type RawCheckoutRequest = z.infer<typeof RawCheckoutRequestSchema>;

package/dist/core/types/checkout/checkout-request.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawCheckoutRequestSchema = exports.CheckoutInputSchema = void 0;
+const ts_case_convert_1 = require("ts-case-convert");
+const zod_1 = __importDefault(require("zod"));
+const utils_1 = require("../../utils");
+const common_1 = require("../common");
+const enums_1 = require("../common/enums");
+/**
+ * Public layer - what library user provides
+ * These are the fields user can actually fill
+ */
+exports.CheckoutInputSchema = zod_1.default.object({
+    /**
+     * Payment amount. For example: `5`, `7.34`
+     */
+    amount: zod_1.default.number().positive(),
+    cardToken: zod_1.default.string().optional(),
+    /**
+     * Payment currency. Possible values: `USD`, `EUR`, `UAH`
+     */
+    currency: enums_1.CurrencySchema,
+    /**
+     * Payment purpose
+     */
+    description: zod_1.default.string(),
+    ip: zod_1.default.string().optional(),
+    /**
+     * Unique purchase ID in your store. Maximum length __255__ characters
+     */
+    orderId: zod_1.default.string().max(255),
+    /**
+     * Data for fiscalization (rro_info)
+     */
+    fiscalData: common_1.FiscalDataSchema.optional(),
+    /**
+     * The time by which the customer can pay the invoice in `UTC`. Transmitted in the format `2016-04-24 00:00:00`
+     */
+    expiredDate: zod_1.default.date().optional(),
+    /**
+     * Client language: `uk`, `en`
+     */
+    language: enums_1.LanguageSchema.optional(),
+    /**
+     * Parameter that transmits payment methods to be displayed at checkout.
+     * If the parameter is not provided, the store settings are applied. Possible values:
+     * - `apay` - Apple Pay
+     * - `gpay` - Google Pay
+     * - `card` - card payment
+     * - `privat24` - via Privat24 account
+     * - `moment_part` - installments
+     * - `paypart` - payment in parts
+     * - `cash` - cash
+     * - `invoice` - invoice to e-mail
+     * - `qr` - scanning a QR code
+     */
+    paytypes: zod_1.default.array(enums_1.PaytypeSchema).optional(),
+    /**
+     * The URL in your store to which the buyer will be redirected after completing the purchase. Maximum length __510__ characters
+     */
+    resultUrl: zod_1.default.string().max(510).optional(),
+    /**
+     * API URL in your store for notifications about payment status changes (`server -> server`). Maximum length __510__ characters.
+     */
+    serverUrl: zod_1.default.string().max(510).optional(),
+    /**
+     * Possible value `Y`. Dynamic verification code, generated and returned in `Callback`. Similarly, the generated code will be passed in the verification transaction to be displayed in the client's card statement. Works for `action = auth` (verifycode)
+     */
+    verifyCode: zod_1.default.boolean().optional(),
+    /**
+     * Payment with splitting the amount into several recipients. This parameter specifies a `JSON` array with payment splitting rules.
+     * One debit is made from the client and several credits are made to the recipients. If you need to transfer your purpose for each amount, use the `description` parameter.
+     * If you need to fiscalize payments for each recipient, add the `rro_info` object. The acquiring fee is charged for each recipient.
+     */
+    splitRules: zod_1.default.array(common_1.SplitRuleSchema).optional(),
+    /**
+     * Sender address
+     */
+    senderAddress: zod_1.default.string().optional(),
+    /**
+     * Sender city
+     */
+    senderCity: zod_1.default.string().optional(),
+    /**
+     * Sender country code. Numeric __ISO 3166-1__ code
+     */
+    senderCountryCode: zod_1.default.string().optional(),
+    /**
+     * Sender first name
+     */
+    senderFirstName: zod_1.default.string().optional(),
+    /**
+     * Sender's last name
+     */
+    senderLastName: zod_1.default.string().optional(),
+    /**
+     * Sender's postal code
+     */
+    senderPostalCode: zod_1.default.string().optional(),
+    /**
+     * Regular payment. Possible values: `1`
+     */
+    subscribe: zod_1.default.boolean().optional(),
+    /**
+     * Date of first payment. The time must be specified in the format `2015-03-31 00:00:00` in `UTC`. If the date is past, the subscription will be activated from the current date of receipt of the request
+     */
+    subscribeDateStart: zod_1.default.date().optional(),
+    /**
+     * The frequency of funds write-off. Possible values:
+     * - `day` - daily
+     * - `week` - weekly
+     * - `month` - once a month
+     * - `year` - once a year, раз
+     */
+    subscribePeriodicity: enums_1.SubscribePeriodicitySchema.optional(),
+    /**
+     * Unique client identifier on the merchant's website. When transmitting the parameter, LiqPay remembers the client's payment details and his identifier - further payment can be made in 1 click. Maximum length __100__ characters. (When using the parameter for __Masterpass 1 click__, a valid payer's phone number is transmitted in this field)
+     */
+    customer: zod_1.default.string().max(100).optional(),
+    /**
+     * Allows you to generate a `card_token` of the payer, which you will receive in a callback request to `server_url`. `card_token` allows you to make payments without entering the payer's card details, using the token payment API - that is, in 1 click. To receive `card_token`, you must pass the value: `1` in the request (recurringbytoken)
+     */
+    recurringByToken: zod_1.default.boolean().optional(),
+    /**
+     * User ID in the merchant system, transmitted with each user payment (must not match `customer`, used for payment using the __Masterpass 1 click__ wallet)
+     */
+    customerUserId: zod_1.default.string().optional(),
+    /**
+     * Long Detail Addenda entry. __Required for merchants with MCC 4511__.
+     *
+     * The `dae` parameter is a `JSON` string to which `base64` has been applied.
+     * It can contain the parameters given in the example below. (dae)
+     */
+    detailAddenda: common_1.DetailAddendaSchema.optional(),
+    /**
+     * Information to add data to the payment. For example: `"External information for payments"`
+     */
+    info: zod_1.default.string().optional(),
+    /**
+     * Product category. Maximum length `25` characters
+     */
+    productCategory: zod_1.default.string().max(25).optional(),
+    /**
+     * Product description. Maximum length `500` characters.
+     */
+    productDescription: zod_1.default.string().max(500).optional(),
+    /**
+     * Product name. Maximum length `100` characters.
+     */
+    productName: zod_1.default.string().max(100).optional(),
+    /**
+     * Product page address. Maximum length `510` characters
+     */
+    productUrl: zod_1.default.string().max(510).optional(),
+});
+/**
+ * Raw layer - what is actually sent to LiqPay API
+ * snake_case, bool/date/string transformations
+ */
+exports.RawCheckoutRequestSchema = zod_1.default
+    .custom()
+    .transform(req => {
+    const { fiscalData, verifyCode, recurringByToken, detailAddenda, ...rest } = req;
+    const snakelized = (0, ts_case_convert_1.objectToSnake)(rest);
+    const transformed = {
+        ...snakelized,
+        rro_info: fiscalData,
+        expired_date: (0, utils_1.dateToIso)(snakelized.expired_date),
+        paytypes: (0, utils_1.join)(snakelized.paytypes),
+        verifycode: (0, utils_1.boolTo)(verifyCode, 'Y'),
+        split_rules: (0, utils_1.stringify)(snakelized.split_rules),
+        subscribe: (0, utils_1.boolTo)(snakelized.subscribe, '1'),
+        subscribe_date_start: (0, utils_1.dateToIso)(snakelized.subscribe_date_start),
+        recurringbytoken: (0, utils_1.boolTo)(recurringByToken, '1'),
+        dae: (0, utils_1.stringify)(detailAddenda),
+    };
+    return (0, utils_1.removeUndefined)(transformed);
+});

package/dist/core/types/checkout/index.d.ts

@@ -1,2 +1,2 @@
 export * from './checkout-callback.schema';
-export * from './checkout-request.schema';
+export * from './checkout-request';

package/dist/core/types/checkout/index.js

@@ -15,4 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./checkout-callback.schema"), exports);
-__exportStar(require("./checkout-request.schema"), exports);
+__exportStar(require("./checkout-request"), exports);

package/dist/nest/liqpay.service.js

@@ -23,8 +23,7 @@ let LiqpayService = class LiqpayService {
     webhooks;
     constructor(options) {
         this.options = options;
-        const { privateKey, publicKey, resultUrl, serverUrl } = options;
-        const client = new clients_1.LiqPayClient(publicKey, privateKey, resultUrl ?? '', serverUrl ?? '');
+        const client = new clients_1.LiqPayClient(options);
         this.payments = new services_1.PaymentsService(client);
         this.webhooks = new services_1.WebhooksService(client);
     }