@litepos/payment 1.0.16 → 1.0.19

package/dist/client.d.ts

@@ -2,13 +2,13 @@ import type { CancelResponse, PaymentRequest, PaymentResponse, RefundResponse, V
 import { PaymentStatus } from './types/status';
 export declare function validateConfig(method: string, config: unknown): void;
 export declare class LitePosPayment {
+    private getRoute;
     charge(request: PaymentRequest): Promise<PaymentResponse>;
     queryPayment(method: string, transactionId: string, config: Record<string, unknown>): Promise<PaymentResponse>;
     cancelPayment(method: string, transactionId: string, config: Record<string, unknown>): Promise<CancelResponse>;
-    refund(method: string, transactionId: string, config: Record<string, unknown>, amount?: number): Promise<RefundResponse>;
+    refund(method: string, transactionId: string, config: Record<string, unknown>, amount?: number, refundRequestNo?: string): Promise<RefundResponse>;
     voidPayment(method: string, transactionId: string, config: Record<string, unknown>): Promise<VoidResponse>;
     queryRefund(method: string, refundId: string, config: Record<string, unknown>): Promise<RefundResponse>;
     simulateCharge(request: PaymentRequest): PaymentResponse;
-    simulateQuery(transactionId: string, status: PaymentStatus, amount?: number, currency?: string): PaymentResponse;
-    private getGatewayName;
+    simulateQuery(method: string, transactionId: string, status: PaymentStatus, amount?: number, currency?: string): PaymentResponse;
 }

package/dist/client.js

@@ -1,248 +1,176 @@
-import { cancelPayment as cancelFiuuPayment, chargeCard, chargeQrCode, queryPayment, refund, validateConfig as validateFiuuConfig, voidPayment as voidFiuuPayment } from '@litepos/payment-fiuu';
+import { cancelPayment as cancelFiuuPayment, chargeCard, chargeQrCode, simulateCharge as fiuuSimulateCharge, simulateQuery as fiuuSimulateQuery, queryPayment, refund, validateConfig as validateFiuuConfig, voidPayment as voidFiuuPayment, } from '@litepos/payment-fiuu';
+import { cancelPayment as sqbCancelPayment, 
+// chargeAlipay as sqbChargeAlipay, // ALPH disabled
+chargeCard as sqbChargeCard, 
+// chargeWechat as sqbChargeWechat, // WCPH disabled
+queryPayment as sqbQueryPayment, refund as sqbRefund, simulateCharge as sqbSimulateCharge, simulateQuery as sqbSimulateQuery, validateConfig as validateSqbConfig, } from '@litepos/payment-shouqianba';
 import { ValidationError } from './types/error';
-import { PaymentStatus } from './types/status';
+import { CancelStatus, PaymentStatus, RefundStatus, VoidStatus } from './types/status';
 import { logError, logInfo } from './utils/logger';
-// Fixed payment method routing
-const CHARGE_ROUTING = {
-    'FIUU': chargeCard,
-    'fiuu-qrcode': chargeQrCode,
+const ROUTING = {
+    'FIUU': {
+        charge: chargeCard,
+        query: queryPayment,
+        refund: refund,
+        refundQuery: queryPayment,
+        cancel: cancelFiuuPayment,
+        void: voidFiuuPayment,
+        simulateCharge: fiuuSimulateCharge,
+        simulateQuery: fiuuSimulateQuery,
+        validate: validateFiuuConfig,
+        name: 'Fiuu',
+    },
+    'fiuu-qrcode': {
+        charge: chargeQrCode,
+        query: queryPayment,
+        refund: refund,
+        refundQuery: queryPayment,
+        cancel: cancelFiuuPayment,
+        void: voidFiuuPayment,
+        simulateCharge: fiuuSimulateCharge,
+        simulateQuery: fiuuSimulateQuery,
+        validate: validateFiuuConfig,
+        name: 'Fiuu',
+    },
+    'SQBP': {
+        charge: sqbChargeCard,
+        query: sqbQueryPayment,
+        refund: sqbRefund,
+        refundQuery: sqbQueryPayment,
+        cancel: sqbCancelPayment,
+        simulateCharge: sqbSimulateCharge,
+        simulateQuery: (txId, s, a, c) => sqbSimulateQuery(txId, s, a, c, 'SQBP'),
+        validate: validateSqbConfig,
+        name: 'Shouqianba',
+    },
+    // 'WCPH': { charge: sqbChargeWechat, ... }, // WeChat Pay C扫B - disabled
+    // 'ALPH': { charge: sqbChargeAlipay, ... }, // Alipay C扫B - disabled
 };
-const QUERY_ROUTING = {
-    'FIUU': queryPayment,
-    'fiuu-qrcode': queryPayment,
-};
-const REFUND_ROUTING = {
-    'FIUU': refund,
-    'fiuu-qrcode': refund,
-};
-const REFUND_QUERY_ROUTING = {
-    'FIUU': queryPayment,
-    'fiuu-qrcode': queryPayment,
-};
-const CANCEL_ROUTING = {
-    'FIUU': cancelFiuuPayment,
-    'fiuu-qrcode': cancelFiuuPayment,
-};
-const VOID_ROUTING = {
-    'FIUU': voidFiuuPayment,
-    'fiuu-qrcode': voidFiuuPayment,
-};
-// Config validation routing
-const VALIDATE_ROUTING = {
-    'FIUU': validateFiuuConfig,
-    'fiuu-qrcode': validateFiuuConfig,
-};
-// Validate payment method configuration
 export function validateConfig(method, config) {
-    const validator = VALIDATE_ROUTING[method];
-    if (!validator)
+    const route = ROUTING[method];
+    if (!route)
         throw new ValidationError(`Payment method not supported: ${method}`, method);
-    validator(config);
+    route.validate(config);
 }
 export class LitePosPayment {
+    getRoute(method) {
+        const route = ROUTING[method];
+        if (!route)
+            throw new ValidationError(`Payment method not supported: ${method}`, method);
+        return route;
+    }
     async charge(request) {
-        const handler = CHARGE_ROUTING[request.method];
-        if (!handler)
-            throw new ValidationError(`Payment method not supported: ${request.method}`, request.method);
+        const route = this.getRoute(request.method);
+        if (!route.charge)
+            throw new ValidationError(`Charge not supported for method: ${request.method}`, request.method);
         try {
-            const response = await handler(request);
-            logInfo(`${this.getGatewayName(request.method)}: Charge payment, Order ID ${request.orderId}, Transaction ID ${response.transactionId}, Status ${response.status}`, { request, response });
+            const response = await route.charge(request);
+            if (response.status === PaymentStatus.Failed)
+                logError(`${route.name}: Charge payment failed, Order ID ${request.orderId}`, { request, response });
+            else
+                logInfo(`${route.name}: Charge payment, Order ID ${request.orderId}, Transaction ID ${response.transactionId}, Status ${response.status}`, { request, response });
             return response;
         }
         catch (error) {
-            logError(`${this.getGatewayName(request.method)}: Charge payment failed, Order ID ${request.orderId}`, { request, error });
+            logError(`${route.name}: Charge payment error, Order ID ${request.orderId}`, { request, error });
             throw error;
         }
     }
     async queryPayment(method, transactionId, config) {
-        const handler = QUERY_ROUTING[method];
-        if (!handler)
-            throw new ValidationError(`Payment method not supported: ${method}`, method);
+        const route = this.getRoute(method);
+        if (!route.query)
+            throw new ValidationError(`Query not supported for method: ${method}`, method);
         try {
-            const response = await handler(transactionId, config);
-            logInfo(`${this.getGatewayName(method)}: Query payment, Transaction ID ${transactionId}, Status ${response.status}`, { transactionId, response });
+            const response = await route.query(transactionId, config);
+            if (response.status === PaymentStatus.Failed)
+                logError(`${route.name}: Query payment - payment failed, Transaction ID ${transactionId}`, { transactionId, response });
+            else
+                logInfo(`${route.name}: Query payment, Transaction ID ${transactionId}, Status ${response.status}`, { transactionId, response });
             return response;
         }
         catch (error) {
-            logError(`${this.getGatewayName(method)}: Query payment failed, Transaction ID ${transactionId}`, { transactionId, error });
+            logError(`${route.name}: Query payment error, Transaction ID ${transactionId}`, { transactionId, error });
             throw error;
         }
     }
     async cancelPayment(method, transactionId, config) {
-        const handler = CANCEL_ROUTING[method];
-        if (!handler)
-            throw new ValidationError(`Payment method not supported: ${method}`, method);
+        const route = this.getRoute(method);
+        if (!route.cancel)
+            throw new ValidationError(`Cancel not supported for method: ${method}`, method);
         try {
-            const response = await handler(transactionId, config);
-            logInfo(`${this.getGatewayName(method)}: Cancel payment, Transaction ID ${transactionId}, Status ${response.status}`, { transactionId, response });
+            const response = await route.cancel(transactionId, config);
+            if (response.status === CancelStatus.Failed)
+                logError(`${route.name}: Cancel payment failed, Transaction ID ${transactionId}`, { transactionId, response });
+            else
+                logInfo(`${route.name}: Cancel payment, Transaction ID ${transactionId}, Status ${response.status}`, { transactionId, response });
             return response;
         }
         catch (error) {
-            logError(`${this.getGatewayName(method)}: Cancel payment failed, Transaction ID ${transactionId}`, { transactionId, error });
+            logError(`${route.name}: Cancel payment error, Transaction ID ${transactionId}`, { transactionId, error });
             throw error;
         }
     }
-    async refund(method, transactionId, config, amount) {
-        const handler = REFUND_ROUTING[method];
-        if (!handler)
-            throw new ValidationError(`Payment method not supported: ${method}`, method);
+    async refund(method, transactionId, config, amount, refundRequestNo) {
+        const route = this.getRoute(method);
+        if (!route.refund)
+            throw new ValidationError(`Refund not supported for method: ${method}`, method);
         try {
-            const response = await handler(transactionId, config, amount);
-            logInfo(`${this.getGatewayName(method)}: Refund payment, Transaction ID ${transactionId}, Refund ID ${response.refundId}, Status ${response.status}`, { transactionId, amount, response });
+            const response = await route.refund(transactionId, config, amount, refundRequestNo);
+            if (response.status === RefundStatus.Failed)
+                logError(`${route.name}: Refund failed, Transaction ID ${transactionId}`, { transactionId, amount, response });
+            else
+                logInfo(`${route.name}: Refund payment, Transaction ID ${transactionId}, Refund ID ${response.refundId}, Status ${response.status}`, { transactionId, amount, response });
             return response;
         }
         catch (error) {
-            logError(`${this.getGatewayName(method)}: Refund payment failed, Transaction ID ${transactionId}`, { transactionId, amount, error });
+            logError(`${route.name}: Refund error, Transaction ID ${transactionId}`, { transactionId, amount, error });
             throw error;
         }
     }
     async voidPayment(method, transactionId, config) {
-        const handler = VOID_ROUTING[method];
-        if (!handler)
-            throw new ValidationError(`Payment method not supported: ${method}`, method);
+        const route = this.getRoute(method);
+        if (!route.void)
+            throw new ValidationError(`Void not supported for method: ${method}`, method);
         try {
-            const response = await handler(transactionId, config);
-            logInfo(`${this.getGatewayName(method)}: Void payment, Transaction ID ${transactionId}, Void ID ${response.voidId}, Status ${response.status}`, { transactionId, response });
+            const response = await route.void(transactionId, config);
+            if (response.status === VoidStatus.Failed)
+                logError(`${route.name}: Void failed, Transaction ID ${transactionId}`, { transactionId, response });
+            else
+                logInfo(`${route.name}: Void payment, Transaction ID ${transactionId}, Void ID ${response.voidId}, Status ${response.status}`, { transactionId, response });
             return response;
         }
         catch (error) {
-            logError(`${this.getGatewayName(method)}: Void payment failed, Transaction ID ${transactionId}`, { transactionId, error });
+            logError(`${route.name}: Void error, Transaction ID ${transactionId}`, { transactionId, error });
             throw error;
         }
     }
     async queryRefund(method, refundId, config) {
-        const handler = REFUND_QUERY_ROUTING[method];
-        if (!handler)
-            throw new ValidationError(`Payment method not supported: ${method}`, method);
+        const route = this.getRoute(method);
+        if (!route.refundQuery)
+            throw new ValidationError(`Refund query not supported for method: ${method}`, method);
         try {
-            const response = await handler(refundId, config);
-            logInfo(`${this.getGatewayName(method)}: Query refund, Refund ID ${refundId}, Status ${response.status}`, { refundId, response });
+            const response = await route.refundQuery(refundId, config);
+            if (response.status === RefundStatus.Failed)
+                logError(`${route.name}: Query refund failed, Refund ID ${refundId}`, { refundId, response });
+            else
+                logInfo(`${route.name}: Query refund, Refund ID ${refundId}, Status ${response.status}`, { refundId, response });
             return response;
         }
         catch (error) {
-            logError(`${this.getGatewayName(method)}: Query refund failed, Refund ID ${refundId}`, { refundId, error });
+            logError(`${route.name}: Query refund error, Refund ID ${refundId}`, { refundId, error });
             throw error;
         }
     }
-    // Simulation methods (for testing, returns mock data without calling adapters)
     simulateCharge(request) {
-        const transactionId = `SIM-${Date.now()}`;
-        const isQrCode = request.method.includes('qrcode');
-        const paymentChannel = isQrCode ? (request.metadata?.paymentChannel || 'tng') : 'Mastercard';
-        const cardLabel = isQrCode ? '' : 'Mastercard';
-        const cardNo = isQrCode ? '' : '************2066';
-        const now = new Date();
-        const invNo = now.toISOString().replace(/[-:T]/g, '').slice(0, 14);
-        return {
-            transactionId,
-            status: PaymentStatus.Pending,
-            amount: request.amount,
-            currency: request.currency,
-            qrCodeData: isQrCode ? `QR_${request.orderId}` : undefined,
-            payment_source_method: cardLabel || paymentChannel,
-            payment_source_last4: isQrCode ? '' : '2066',
-            payment_source_charge_ref: transactionId,
-            metadata: {
-                responseCode: '00',
-                responseText: 'Approved',
-                paymentChannel,
-                invNo,
-                tid: '00000001',
-                mid: '000000000000001',
-                cardNo,
-                entryMode: 'contactless',
-                cardLabel,
-            },
-            raw: {
-                transType: 'sale',
-                posId: 'SIM_POS_ID',
-                deviceId: 'SIM_DEVICE_ID',
-                referenceLabel: request.orderId.slice(0, 10),
-                apiVersion: 'v1',
-                statusCode: '00',
-                responseCode: '00',
-                responseText: 'Approved',
-                terminalSn: 'SIM_TERMINAL',
-                softwareVersion: 'Version 1.0.0',
-                transData: {
-                    cardNo,
-                    entryMode: 'contactless',
-                    rrn: '000000000001',
-                    tvr: '0000008001',
-                    appCrypt: 'simulated',
-                    aid: 'A0000000041010',
-                    cvmType: '00',
-                    cardLabel,
-                    paymentChannel,
-                    transAmt: request.amount.toFixed(2),
-                    transDateTime: now.toISOString().slice(0, 19),
-                    transId: transactionId,
-                    invNo,
-                    batchNo: '',
-                    tid: '00000001',
-                    mid: '000000000000001',
-                    currency: request.currency,
-                    apprCode: '000001',
-                },
-                referenceId: `SIM-${Date.now()}`,
-                signature: 'simulated',
-            },
-        };
-    }
-    simulateQuery(transactionId, status, amount = 0, currency = 'SGD') {
-        const now = new Date();
-        const invNo = now.toISOString().replace(/[-:T]/g, '').slice(0, 14);
-        return {
-            transactionId,
-            status,
-            amount,
-            currency,
-            payment_source_method: 'Mastercard',
-            payment_source_last4: '2066',
-            payment_source_charge_ref: transactionId,
-            metadata: {
-                responseCode: '00',
-                responseText: 'Approved',
-                paymentChannel: 'Mastercard',
-                invNo,
-                tid: '00000001',
-                mid: '000000000000001',
-                cardNo: '************2066',
-                entryMode: 'contactless',
-                cardLabel: 'Mastercard',
-            },
-            raw: {
-                transType: 'sale',
-                posId: 'SIM_POS_ID',
-                deviceId: 'SIM_DEVICE_ID',
-                apiVersion: 'v1',
-                statusCode: '00',
-                responseCode: '00',
-                responseText: 'Approved',
-                terminalSn: 'SIM_TERMINAL',
-                softwareVersion: 'Version 1.0.0',
-                transData: {
-                    cardNo: '************2066',
-                    entryMode: 'contactless',
-                    rrn: '000000000001',
-                    cardLabel: 'Mastercard',
-                    paymentChannel: 'Mastercard',
-                    transAmt: amount.toFixed(2),
-                    transDateTime: now.toISOString().slice(0, 19),
-                    transId: transactionId,
-                    invNo,
-                    tid: '00000001',
-                    mid: '000000000000001',
-                    currency,
-                },
-                referenceId: `SIM-${Date.now()}`,
-                signature: 'simulated',
-            },
-        };
+        const route = this.getRoute(request.method);
+        if (!route.simulateCharge)
+            throw new ValidationError(`Simulate charge not supported for method: ${request.method}`, request.method);
+        return route.simulateCharge(request);
     }
-    getGatewayName(method) {
-        if (method === 'FIUU' || method === 'fiuu-qrcode')
-            return 'Fiuu';
-        return method;
+    simulateQuery(method, transactionId, status, amount = 0, currency = 'SGD') {
+        const route = this.getRoute(method);
+        if (!route.simulateQuery)
+            throw new ValidationError(`Simulate query not supported for method: ${method}`, method);
+        return route.simulateQuery(transactionId, status, amount, currency);
     }
 }

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 export { LitePosPayment, validateConfig } from './client';
 export { CancelResponse, PaymentRequest, PaymentResponse, RefundResponse, ValidationResult, VoidResponse, } from './interfaces';
-export { Simulator } from './simulator';
 export type { PaymentConfig } from './types/config';
 export { PaymentError, ValidationError } from './types/error';
 export { CancelStatus, PaymentStatus, RefundStatus, VoidStatus } from './types/status';

package/dist/index.js

@@ -1,6 +1,5 @@
 // Main exports
 export { LitePosPayment, validateConfig } from './client';
-export { Simulator } from './simulator';
 export { PaymentError, ValidationError } from './types/error';
 // Type exports
 export { CancelStatus, PaymentStatus, RefundStatus, VoidStatus } from './types/status';

package/dist/sqb.d.ts

@@ -0,0 +1 @@
+export { sqbCheckin } from '@litepos/payment-shouqianba/tools';

package/dist/sqb.js

@@ -0,0 +1 @@
+export { sqbCheckin } from '@litepos/payment-shouqianba/tools';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@litepos/payment",
   "type": "module",
-  "version": "1.0.16",
+  "version": "1.0.19",
   "description": "LitePOS payment gateway SDK - Core package",
   "author": "",
   "license": "MIT",
@@ -16,6 +16,11 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./sqb": {
+      "types": "./dist/sqb.d.ts",
+      "import": "./dist/sqb.js",
+      "default": "./dist/sqb.js"
     }
   },
   "main": "dist/index.js",
@@ -25,7 +30,8 @@
     "dist"
   ],
   "dependencies": {
-    "@litepos/payment-fiuu": "1.0.16"
+    "@litepos/payment-fiuu": "1.0.19",
+    "@litepos/payment-shouqianba": "1.0.19"
   },
   "devDependencies": {
     "typescript": "^5.9.2",

package/dist/simulator.d.ts

@@ -1,7 +0,0 @@
-import type { PaymentRequest, PaymentResponse } from './interfaces';
-import { PaymentStatus } from './types/status';
-export declare class Simulator {
-    private generateTransactionId;
-    simulateCharge(request: PaymentRequest): PaymentResponse;
-    simulateQuery(transactionId: string, status: PaymentStatus): PaymentResponse;
-}

package/dist/simulator.js

@@ -1,30 +0,0 @@
-import { PaymentStatus } from './types/status';
-// Payment simulator for testing
-export class Simulator {
-    // Generate transaction ID
-    generateTransactionId() {
-        return `txn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    }
-    // Simulate charge payment
-    simulateCharge(request) {
-        return {
-            transactionId: this.generateTransactionId(),
-            status: PaymentStatus.Pending,
-            amount: request.amount,
-            currency: request.currency,
-            qrCodeData: request.method.includes('qrcode') ? `QR_${request.orderId}` : undefined,
-            metadata: request.metadata,
-            raw: { simulated: true, request },
-        };
-    }
-    // Simulate query payment
-    simulateQuery(transactionId, status) {
-        return {
-            transactionId,
-            status,
-            amount: 0,
-            currency: 'MYR',
-            raw: { simulated: true },
-        };
-    }
-}