unismsgateway 1.3.2 → 1.3.3

package/dist/src/lib/hubtel-gateway.d.ts

@@ -2,12 +2,15 @@ import { ISmsGatewayDelegate, QuickSendParams, SendResult } from './types';
 export interface HubtelSmsGatewayConfig {
     clientId: string;
     clientSecret: string;
+    debug?: boolean;
 }
 /**
  * Wraps hubtel-sms-extended and maps API responses to {@link SendResult}.
  */
 export declare class HubtelSmsGateway implements ISmsGatewayDelegate {
     private _client;
+    private _debug;
     constructor(config: HubtelSmsGatewayConfig);
+    private log;
     quickSend(params: QuickSendParams, callback?: Function): Promise<SendResult>;
 }

package/dist/src/lib/hubtel-gateway.js

@@ -16,41 +16,55 @@ const hubtel_sms_extended_1 = require("hubtel-sms-extended");
  */
 class HubtelSmsGateway {
     constructor(config) {
+        this._debug = config.debug || false;
         this._client = new hubtel_sms_extended_1.HubtelSms({
             clientId: config.clientId,
             clientSecret: config.clientSecret
         });
     }
+    log(...args) {
+        if (this._debug) {
+            console.log('[unismsgateway:hubtel]', ...args);
+        }
+    }
     quickSend(params, callback) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            this.log('quickSend params:', JSON.stringify(params));
+            let result;
             try {
                 const raw = yield this._client.quickSend({
                     From: params.From,
                     To: String(params.To),
                     Content: params.Content
                 });
-                const ok = Number(raw.Status) === 0;
-                const result = {
+                this.log('quickSend raw response:', JSON.stringify(raw));
+                const ok = Number(raw === null || raw === void 0 ? void 0 : raw.Status) === 0;
+                result = {
                     success: ok,
-                    messageId: String(raw.MessageId),
+                    messageId: (raw === null || raw === void 0 ? void 0 : raw.MessageId) != null ? String(raw.MessageId) : undefined,
                     data: raw,
-                    error: ok ? undefined : `Hubtel Status=${raw.Status}`
+                    error: ok
+                        ? undefined
+                        : `Hubtel API Error: Status=${raw === null || raw === void 0 ? void 0 : raw.Status}, NetworkId=${(_a = raw === null || raw === void 0 ? void 0 : raw.NetworkId) !== null && _a !== void 0 ? _a : 'n/a'}`
                 };
-                if (callback) {
-                    callback(result);
-                }
-                return result;
             }
             catch (error) {
-                const result = {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.log('quickSend error:', errorMessage);
+                result = {
                     success: false,
-                    error: error instanceof Error ? error.message : String(error)
+                    error: errorMessage,
+                    data: error instanceof Error && error.response
+                        ? error.response
+                        : null
                 };
-                if (callback) {
-                    callback(result);
-                }
-                return result;
             }
+            this.log('quickSend result:', JSON.stringify(result));
+            if (callback) {
+                callback(result);
+            }
+            return result;
         });
     }
 }

package/dist/src/lib/nest-gateway.d.ts

@@ -3,6 +3,7 @@ export declare class NestSmsGateway implements ISmsGateway {
     private config;
     constructor(config: NestSmsConfig);
     init(): ISmsGateway;
+    private log;
     private makeRequest;
     quickSend(params: QuickSendParams, callback?: Function): Promise<SendResult>;
     getBalance(): Promise<{

package/dist/src/lib/nest-gateway.js

@@ -38,59 +38,80 @@ class NestSmsGateway {
         this.config = {
             host: config.host || DEFAULT_HOST,
             protocol: config.protocol || DEFAULT_PROTOCOL,
-            apiKey: config.apiKey
+            apiKey: config.apiKey,
+            debug: config.debug || false
         };
     }
     init() {
         return this;
     }
+    log(...args) {
+        if (this.config.debug) {
+            console.log('[unismsgateway:nest]', ...args);
+        }
+    }
     makeRequest(endpoint, data) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
-                var _a;
                 const postData = data ? JSON.stringify(data) : '';
                 const protocol = this.config.protocol || DEFAULT_PROTOCOL;
                 const httpModule = protocol === 'https' ? https : http;
                 const defaultPort = protocol === 'https' ? 443 : 80;
+                const host = this.config.host || DEFAULT_HOST;
+                const hostname = host.includes(':') ? host.split(':')[0] : host;
+                const port = host.includes(':')
+                    ? parseInt(host.split(':')[1], 10)
+                    : defaultPort;
                 const options = {
-                    hostname: this.config.host || DEFAULT_HOST,
-                    port: ((_a = this.config.host) === null || _a === void 0 ? void 0 : _a.includes(':'))
-                        ? parseInt(this.config.host.split(':')[1])
-                        : defaultPort,
+                    hostname,
+                    port,
                     path: `/v5/${endpoint}`,
                     method: 'POST',
                     headers: {
-                        'Host': this.config.host || DEFAULT_HOST,
+                        'Host': hostname,
                         'Content-Type': 'application/json',
                         'Accept': 'application/json',
                         'Authorization': `key ${this.config.apiKey}`,
                         'Content-Length': Buffer.byteLength(postData)
                     }
                 };
+                this.log(`POST /v5/${endpoint}`, data ? JSON.stringify(data) : '(no body)');
                 const req = httpModule.request(options, (res) => {
                     let responseBody = '';
                     res.on('data', (chunk) => {
                         responseBody += chunk;
                     });
                     res.on('end', () => {
+                        var _a;
+                        const statusCode = (_a = res.statusCode) !== null && _a !== void 0 ? _a : 0;
+                        this.log(`HTTP ${statusCode} response:`, responseBody);
                         try {
-                            if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-                                const parsed = JSON.parse(responseBody);
-                                resolve(parsed);
+                            const parsed = JSON.parse(responseBody);
+                            if (statusCode >= 200 && statusCode < 300) {
+                                resolve({ statusCode, body: parsed });
                             }
                             else {
-                                reject(new Error(`HTTP ${res.statusCode}: ${responseBody}`));
+                                const err = new Error(`HTTP ${statusCode}: ${responseBody}`);
+                                err.statusCode = statusCode;
+                                err.rawBody = responseBody;
+                                reject(err);
                             }
                         }
-                        catch (error) {
-                            reject(new Error(`Failed to parse response: ${responseBody}`));
+                        catch (_b) {
+                            const err = new Error(`Failed to parse gateway response (HTTP ${statusCode}): ${responseBody}`);
+                            err.statusCode = statusCode;
+                            err.rawBody = responseBody;
+                            reject(err);
                         }
                     });
                 });
                 req.on('error', (error) => {
+                    this.log('Network error:', error.message);
                     reject(error);
                 });
-                req.write(postData);
+                if (postData) {
+                    req.write(postData);
+                }
                 req.end();
             });
         });
@@ -98,57 +119,73 @@ class NestSmsGateway {
     quickSend(params, callback) {
         var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
-            const endpoint = 'message/sms/send';
-            // SMSOnlineGH v5 expects: text, sender, destinations[] (see API docs — not from/to/content).
             const requestBody = {
                 text: params.Content,
-                type: params.Type || 0,
+                type: (_a = params.Type) !== null && _a !== void 0 ? _a : 0,
                 sender: params.From,
                 destinations: [String(params.To)]
             };
+            this.log('quickSend params:', JSON.stringify(params));
+            let result;
             try {
-                const response = yield this.makeRequest(endpoint, requestBody);
-                const handshakeOk = Number((_a = response.handshake) === null || _a === void 0 ? void 0 : _a.id) === 0;
-                const data = (_b = response.data) !== null && _b !== void 0 ? _b : null;
-                const batchId = data && typeof data === 'object' ? data.batch : undefined;
-                const firstDest = data && typeof data === 'object'
-                    ? (_c = data.destinations) === null || _c === void 0 ? void 0 : _c[0]
+                const { statusCode, body: response } = yield this.makeRequest('message/sms/send', requestBody);
+                const handshakeId = (_b = response.handshake) === null || _b === void 0 ? void 0 : _b.id;
+                const handshakeLabel = (_c = response.handshake) === null || _c === void 0 ? void 0 : _c.label;
+                const handshakeOk = Number(handshakeId) === 0;
+                const responseData = (_d = response.data) !== null && _d !== void 0 ? _d : null;
+                const batchId = responseData && typeof responseData === 'object'
+                    ? responseData.batch
+                    : undefined;
+                const firstDest = responseData && typeof responseData === 'object'
+                    ? (_e = responseData.destinations) === null || _e === void 0 ? void 0 : _e[0]
                     : undefined;
-                const result = {
+                let errorMsg;
+                if (!handshakeOk) {
+                    if (handshakeLabel) {
+                        errorMsg = `API Error [code ${handshakeId}]: ${handshakeLabel}`;
+                    }
+                    else if (handshakeId !== undefined && handshakeId !== null) {
+                        errorMsg = `API Error: handshake code=${handshakeId}`;
+                    }
+                    else {
+                        errorMsg = `Unexpected API response: ${JSON.stringify(response)}`;
+                    }
+                }
+                result = {
                     success: handshakeOk,
-                    data,
                     messageId: batchId || (firstDest === null || firstDest === void 0 ? void 0 : firstDest.id),
-                    error: handshakeOk
-                        ? undefined
-                        : (((_d = response.handshake) === null || _d === void 0 ? void 0 : _d.label)
-                            || `handshake id ${String((_e = response.handshake) === null || _e === void 0 ? void 0 : _e.id)}`)
+                    // On failure, expose the full raw response so callers can inspect it.
+                    data: handshakeOk ? responseData : response,
+                    error: errorMsg,
+                    statusCode
                 };
-                if (callback) {
-                    callback(result);
-                }
-                return result;
             }
             catch (error) {
+                const httpErr = error;
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                const result = {
+                result = {
                     success: false,
-                    error: errorMessage
+                    error: errorMessage,
+                    statusCode: httpErr.statusCode,
+                    // Preserve whatever raw body we got for inspection.
+                    data: httpErr.rawBody !== undefined ? httpErr.rawBody : null
                 };
-                if (callback) {
-                    callback(result);
-                }
-                return result;
             }
+            this.log('quickSend result:', JSON.stringify(result));
+            if (callback) {
+                callback(result);
+            }
+            return result;
         });
     }
     getBalance() {
-        var _a, _b;
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
-            const endpoint = 'account/balance';
-            const response = yield this.makeRequest(endpoint);
+            this.log('getBalance called');
+            const { body: response } = yield this.makeRequest('account/balance');
             return {
-                balance: ((_a = response.data) === null || _a === void 0 ? void 0 : _a.balance) || 0,
-                model: ((_b = response.data) === null || _b === void 0 ? void 0 : _b.model) || 'quantity'
+                balance: (_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.balance) !== null && _b !== void 0 ? _b : 0,
+                model: (_d = (_c = response.data) === null || _c === void 0 ? void 0 : _c.model) !== null && _d !== void 0 ? _d : 'quantity'
             };
         });
     }

package/dist/src/lib/platform.js

@@ -52,18 +52,21 @@ class smsPlatform {
                     username: param.username,
                     password: param.password,
                     protocol: param.protocol || 'http',
-                    port: param.port || 8080
+                    port: param.port || 8080,
+                    debug: param.debug
                 });
             case 'hubtel':
                 return new hubtel_gateway_1.HubtelSmsGateway({
                     clientId: param.clientId,
-                    clientSecret: param.clientSecret
+                    clientSecret: param.clientSecret,
+                    debug: param.debug
                 });
             case 'nest':
                 return new nest_gateway_1.NestSmsGateway({
                     apiKey: param.apiKey,
                     host: param.host,
-                    protocol: param.protocol
+                    protocol: param.protocol,
+                    debug: param.debug
                 });
             default:
                 throw new Error(`Unsupported platform: ${platformId}`);

package/dist/src/lib/route-gateway.d.ts

@@ -5,8 +5,18 @@ export interface RouteSmsGatewayConfig {
     password: string;
     protocol: 'http' | 'https';
     port: number;
+    debug?: boolean;
 }
+/**
+ * Adapts routemobilesms to {@link ISmsGatewayDelegate}.
+ *
+ * NOTE: routemobilesms stores config in module-level state via the constructor,
+ * then exposes `routeSms.sendAsync` as a static-style call. The instance is
+ * intentionally discarded after construction.
+ */
 export declare class RouteSmsGateway implements ISmsGatewayDelegate {
+    private _debug;
     constructor(config: RouteSmsGatewayConfig);
+    private log;
     quickSend(params: QuickSendParams, callback?: Function): Promise<SendResult>;
 }

package/dist/src/lib/route-gateway.js

@@ -11,9 +11,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouteSmsGateway = void 0;
 const routemobilesms_1 = require("routemobilesms");
-/**
- * Adapts routemobilesms static `sendAsync` API to {@link ISmsGatewayDelegate}.
- */
 function toRouteDestination(to) {
     if (typeof to === 'number') {
         return to;
@@ -22,8 +19,18 @@ function toRouteDestination(to) {
     const n = Number(digits);
     return Number.isNaN(n) ? 0 : n;
 }
+/**
+ * Adapts routemobilesms to {@link ISmsGatewayDelegate}.
+ *
+ * NOTE: routemobilesms stores config in module-level state via the constructor,
+ * then exposes `routeSms.sendAsync` as a static-style call. The instance is
+ * intentionally discarded after construction.
+ */
 class RouteSmsGateway {
     constructor(config) {
+        this._debug = config.debug || false;
+        // routemobilesms configures itself through its constructor and exposes
+        // sendAsync as a static method — the returned instance is not needed.
         new routemobilesms_1.routeSms({
             host: config.host,
             username: config.username,
@@ -32,8 +39,15 @@ class RouteSmsGateway {
             port: config.port
         });
     }
+    log(...args) {
+        if (this._debug) {
+            console.log('[unismsgateway:route]', ...args);
+        }
+    }
     quickSend(params, callback) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
+            this.log('quickSend params:', JSON.stringify(params));
             const sendParams = {
                 From: params.From,
                 To: toRouteDestination(params.To),
@@ -42,24 +56,47 @@ class RouteSmsGateway {
             if (params.Type !== undefined) {
                 sendParams.config = { type: params.Type, dlr: 0 };
             }
-            const raw = yield routemobilesms_1.routeSms.sendAsync(sendParams);
             let result;
-            if (raw === undefined || raw === null) {
-                result = { success: false, error: 'No response from route SMS gateway' };
+            try {
+                const raw = yield routemobilesms_1.routeSms.sendAsync(sendParams);
+                this.log('quickSend raw response:', JSON.stringify(raw));
+                if (raw === undefined || raw === null) {
+                    result = {
+                        success: false,
+                        error: 'No response received from Route SMS gateway',
+                        data: null
+                    };
+                }
+                else if (Array.isArray(raw) && raw.length > 0) {
+                    const first = raw[0];
+                    const ok = first.status === 'successful';
+                    result = {
+                        success: ok,
+                        messageId: first.id,
+                        data: raw,
+                        error: ok
+                            ? undefined
+                            : `Route SMS Error [${(_a = first.code) !== null && _a !== void 0 ? _a : 'unknown'}]: ${(_b = first.message) !== null && _b !== void 0 ? _b : 'Send failed'}`
+                    };
+                }
+                else {
+                    result = {
+                        success: false,
+                        error: 'Unexpected response format from Route SMS gateway',
+                        data: raw
+                    };
+                }
             }
-            else if (Array.isArray(raw) && raw.length > 0) {
-                const first = raw[0];
-                const ok = first.status === 'successful';
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.log('quickSend error:', errorMessage);
                 result = {
-                    success: ok,
-                    messageId: first.id,
-                    data: raw,
-                    error: ok ? undefined : (first.message || first.code || 'Send failed')
+                    success: false,
+                    error: errorMessage,
+                    data: null
                 };
             }
-            else {
-                result = { success: false, error: 'Unexpected response from route SMS gateway', data: raw };
-            }
+            this.log('quickSend result:', JSON.stringify(result));
             if (callback) {
                 callback(result);
             }

package/dist/src/lib/types.d.ts

@@ -10,6 +10,8 @@ export interface SendResult {
     messageId?: string;
     data?: any;
     error?: string;
+    /** HTTP status code returned by the gateway (when available). */
+    statusCode?: number;
 }
 export interface IgatewayParam {
     host?: string;
@@ -20,6 +22,8 @@ export interface IgatewayParam {
     clientSecret?: string;
     apiKey?: string;
     protocol?: 'http' | 'https';
+    /** Set to true to print request/response details to console for debugging. */
+    debug?: boolean;
 }
 export interface IgatewaySettings {
     platformId: PlatformId;
@@ -37,6 +41,7 @@ export interface NestSmsConfig {
     apiKey: string;
     host?: string;
     protocol?: 'http' | 'https';
+    debug?: boolean;
 }
 export interface NestSendResponse {
     handshake: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unismsgateway",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "A unified SMS gateway library that brings access to multiple SMS gateways under a single API",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",