unismsgateway 1.2.1 → 1.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RazakAlpha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,4 +1,3 @@
-
 # Unified Sms Gateway
 
 Most of the time a single project relies on multiple sms Gateway so it can switched if one goes off.
@@ -10,84 +9,176 @@ which means you only does one implementation in it works for all supported sms g
 you just have select or switch your sms platform and your code still works fine like nothing has changed
 
 
+## Installation
+
+```bash
+npm install unismsgateway
+```
+
+## Supported Gateways
+
+| Platform ID | Provider | Required Params |
+|-------------|----------|-----------------|
+| `route` | routeMobile | username, password, host |
+| `hubtel` | Hubtel SMS (Ghana) | clientId, clientSecret |
+| `nest` | SMSOnlineGH / smsonlinegh | apiKey |
+
 ## Usage/Examples
 
+### Initialize with Platform
+
 ```javascript
 const unisms = require('unismsgateway')
 
-const param = { clientId, // hubtel sms client Id **optional
-                clientSecret, // hubtel sms client secret ** optional
-                username, // username for route sms
-                password, // password for route sms
-                host,  // host address eg. rslr.connectbind.....
-                port} // port defaults to 8080
+// For routeMobile
+const routeGateway = unisms.init({
+    platformId: 'route',
+    param: {
+        username: 'your-username',
+        password: 'your-password',
+        host: 'rslr.connectbind.com',
+        protocol: 'http',
+        port: 8080
+    }
+})
+
+// For Hubtel
+const hubtelGateway = unisms.init({
+    platformId: 'hubtel',
+    param: {
+        clientId: 'your-client-id',
+        clientSecret: 'your-client-secret'
+    }
+})
+
+// For SMSOnlineGH (nest)
+const nestGateway = unisms.init({
+    platformId: 'nest',
+    param: {
+        apiKey: 'your-api-key',
+        // Optional: host, protocol (defaults to api.smsonlinegh.com, https)
+    }
+})
+```
+
+### Send SMS Message
+
+```javascript
+const unisms = require('unismsgateway')
 
-//init with prefered platform id. route => routemobile, hubtel => hubtel sms
-// more sms services will be added or supported in the future
-const gateway  = unisms.init({platformId:'route', param})
+// Initialize gateway
+const gateway = unisms.init({
+    platformId: 'nest',
+    param: {
+        apiKey: 'your-api-key'
+    }
+})
+
+// Send message
+async function sendSms() {
+    try {
+        const result = await gateway.quickSend({
+            From: 'SenderName',
+            To: '233XXXXXXXXX',  // recipient number
+            Content: 'Hello from unismsgateway!',
+            Type: 0  // optional, defaults to 0
+        })
+        
+        if (result.success) {
+            console.log('Message sent successfully:', result.messageId)
+        } else {
+            console.error('Failed to send:', result.error)
+        }
+    } catch (err) {
+        console.error('Error:', err)
+    }
+}
 
+sendSms()
 ```
 
-### SEND MESSAGE
-```javascript
+### With Callback
 
-const testSms = async function(){
-  try{
-    // const gateway = unisms.getSmsPlatform();
-     await gateway.quickSend({From:'xxxxx', To: xxxxxxxx, Content: 'Testing unisms', Type: 0}, (response)=>{
-      console.log(response)
-    }).then(r => {
-      console.log(r)
-    }).catch(err => {
-      console.log(err)
-    })
-  }catch(err){
-    console.log(err)
-  }
+```javascript
+gateway.quickSend({
+    From: 'SenderName',
+    To: '233XXXXXXXXX',
+    Content: 'Test message'
+}, (response) => {
+    console.log('Response:', response)
+})
+```
 
+### Check Balance (SMSOnlineGH/nest only)
 
+```javascript
+const gateway = unisms.init({
+    platformId: 'nest',
+    param: { apiKey: 'your-api-key' }
+})
+
+// Only available for nest platform
+if (gateway.getGateway) {
+    const nestGateway = gateway.getGateway()
+    const balance = await nestGateway.getBalance()
+    console.log('Balance:', balance)
 }
-
 ```
 
-### SEND PERSONALIZED MESSAGE
+### Reset Gateway Instance
+
 ```javascript
+// Clear the current gateway instance
+unisms.reset()
+
+// Initialize with new platform
+const newGateway = unisms.init({
+    platformId: 'hubtel',
+    param: {
+        clientId: 'new-client-id',
+        clientSecret: 'new-secret'
+    }
+})
+```
 
-const testSms = async function(){
-  try{
-    // const gateway = unisms.getSmsPlatform();
-     await gateway.sendPersonalized({From:'xxxxx', 
-                                    To: {to: 233XXXXXXXXX, values: ['Alpha', 65332]},  // [{to: 233XXXXXXXXX, values: ['Alpha', 65332]}, {to: 211XXXXXXXXX, values: ['James', 2000]}, ]
-                                    Content: 'Testing unisms', 
-                                    Type: 0}).then(r => {
-      console.log(r)
-    }).catch(err => {
-      console.log(err)
-    })
-  }catch(err){
-    console.log(err)
-  }
+## API Reference
 
+### `init(settings: IgatewaySettings): smsPlatform`
 
-}
+Initialize the SMS gateway with your platform configuration.
 
-```
+**Parameters:**
+- `platformId`: `'route'` | `'hubtel'` | `'nest'`
+- `param`: Platform-specific configuration object
 
+### `getSmsPlatform(): smsPlatform | null`
 
-## supported bulk sms gateways
+Get the current gateway instance. Returns `null` if not initialized.
 
-Hubtel bulk sms (Ghana) using hubtel-sms-extended
-routeMobile sms (India) using routemobilesms
-Nest SMS(Ghana) using nestsms
+### `reset(): void`
 
-## Roadmap
+Clear the current gateway instance.
 
-- Additional browser support
+### `quickSend(params: QuickSendParams, callback?: Function): Promise<SendResult>`
 
-- Add more third party sms integrations
+Send an SMS message.
 
+**Parameters:**
+- `From`: Sender ID/name
+- `To`: Recipient phone number (string or number)
+- `Content`: Message content
+- `Type`: Optional message type (defaults to 0)
 
-## License
+**Returns:**
+```typescript
+{
+    success: boolean;
+    messageId?: string;
+    data?: any;
+    error?: string;
+}
+```
 
-[MIT](https://choosealicense.com/licenses/mit/)
+## License
 
+[MIT](https://choosealicense.com/licenses/mit/)

package/dist/index.d.ts

@@ -1 +1 @@
-export * from './lib/lib';
+export * from './lib/lib';

package/dist/index.js

@@ -1,13 +1,13 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (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("./lib/lib"), exports);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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("./lib/lib"), exports);

package/dist/lib/lib.d.ts

@@ -1,10 +1,5 @@
-import { smsPlatform, IgatewaySettings, IQuickSendPersonalized } from './platform';
-export declare function init(settings: IgatewaySettings): smsPlatform;
-export declare function getSmsPlatform(): smsPlatform;
-export declare function quickSend(param: {
-    From: string;
-    To: number;
-    Content: string;
-    Type?: number;
-}, callback?: Function): any;
-export declare function sendPersonalized(body: IQuickSendPersonalized): any;
+import { smsPlatform, IgatewaySettings, IgatewayParam, PlatformId, QuickSendParams, SendResult, ISmsGateway } from './platform';
+export declare function init(settings: IgatewaySettings): smsPlatform;
+export declare function getSmsPlatform(): smsPlatform | null;
+export declare function reset(): void;
+export { smsPlatform, IgatewaySettings, IgatewayParam, PlatformId, QuickSendParams, SendResult, ISmsGateway };

package/dist/lib/lib.js

@@ -1,23 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendPersonalized = exports.quickSend = exports.getSmsPlatform = exports.init = void 0;
-const platform_1 = require("./platform");
-let smsplatform;
-function init(settings) {
-    const smsPlatform_ = new platform_1.smsPlatform(settings);
-    smsplatform = smsPlatform_;
-    return smsPlatform_.init();
-}
-exports.init = init;
-function getSmsPlatform() {
-    return smsplatform;
-}
-exports.getSmsPlatform = getSmsPlatform;
-function quickSend(param, callback) {
-    return smsplatform.quickSend(param, callback);
-}
-exports.quickSend = quickSend;
-function sendPersonalized(body) {
-    return smsplatform.sendPersonalized(body);
-}
-exports.sendPersonalized = sendPersonalized;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.smsPlatform = exports.reset = exports.getSmsPlatform = exports.init = void 0;
+const platform_1 = require("./platform");
+Object.defineProperty(exports, "smsPlatform", { enumerable: true, get: function () { return platform_1.smsPlatform; } });
+let smsPlatformInstance = null;
+function init(settings) {
+    smsPlatformInstance = new platform_1.smsPlatform(settings);
+    smsPlatformInstance.init();
+    return smsPlatformInstance;
+}
+exports.init = init;
+function getSmsPlatform() {
+    return smsPlatformInstance;
+}
+exports.getSmsPlatform = getSmsPlatform;
+function reset() {
+    smsPlatformInstance = null;
+}
+exports.reset = reset;

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

@@ -0,0 +1,12 @@
+import { ISmsGateway, QuickSendParams, SendResult, NestSmsConfig } from './types';
+export declare class NestSmsGateway implements ISmsGateway {
+    private config;
+    constructor(config: NestSmsConfig);
+    init(): ISmsGateway;
+    private makeRequest;
+    quickSend(params: QuickSendParams, callback?: Function): Promise<SendResult>;
+    getBalance(): Promise<{
+        balance: number;
+        model: string;
+    }>;
+}

package/dist/lib/nest-gateway.js

@@ -0,0 +1,145 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.NestSmsGateway = void 0;
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+const DEFAULT_HOST = 'api.smsonlinegh.com';
+const DEFAULT_PROTOCOL = 'https';
+class NestSmsGateway {
+    constructor(config) {
+        this.config = {
+            host: config.host || DEFAULT_HOST,
+            protocol: config.protocol || DEFAULT_PROTOCOL,
+            apiKey: config.apiKey
+        };
+    }
+    init() {
+        return this;
+    }
+    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 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,
+                    path: `/v5/${endpoint}`,
+                    method: 'POST',
+                    headers: {
+                        'Host': this.config.host || DEFAULT_HOST,
+                        'Content-Type': 'application/json',
+                        'Accept': 'application/json',
+                        'Authorization': `key ${this.config.apiKey}`,
+                        'Content-Length': Buffer.byteLength(postData)
+                    }
+                };
+                const req = httpModule.request(options, (res) => {
+                    let responseBody = '';
+                    res.on('data', (chunk) => {
+                        responseBody += chunk;
+                    });
+                    res.on('end', () => {
+                        try {
+                            if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                                const parsed = JSON.parse(responseBody);
+                                resolve(parsed);
+                            }
+                            else {
+                                reject(new Error(`HTTP ${res.statusCode}: ${responseBody}`));
+                            }
+                        }
+                        catch (error) {
+                            reject(new Error(`Failed to parse response: ${responseBody}`));
+                        }
+                    });
+                });
+                req.on('error', (error) => {
+                    reject(error);
+                });
+                req.write(postData);
+                req.end();
+            });
+        });
+    }
+    quickSend(params, callback) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = 'message/sms/send';
+            const requestBody = {
+                from: params.From,
+                to: String(params.To),
+                content: params.Content,
+                type: params.Type || 0
+            };
+            try {
+                const response = yield this.makeRequest(endpoint, requestBody);
+                const result = {
+                    success: ((_a = response.handshake) === null || _a === void 0 ? void 0 : _a.id) === 0,
+                    data: response.data,
+                    messageId: (_b = response.data) === null || _b === void 0 ? void 0 : _b.messageId
+                };
+                if (callback) {
+                    callback(result);
+                }
+                return result;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                const result = {
+                    success: false,
+                    error: errorMessage
+                };
+                if (callback) {
+                    callback(result);
+                }
+                return result;
+            }
+        });
+    }
+    getBalance() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = 'account/balance';
+            const response = yield this.makeRequest(endpoint);
+            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'
+            };
+        });
+    }
+}
+exports.NestSmsGateway = NestSmsGateway;

package/dist/lib/platform.d.ts

@@ -1,51 +1,13 @@
-export declare class smsPlatform {
-    _settings: IgatewaySettings;
-    _sms: any;
-    constructor(settings: IgatewaySettings);
-    init(): this;
-    quickSend(param: {
-        From: string;
-        To: number;
-        Content: string;
-        Type?: number;
-    }, callback?: Function): any;
-    sendPersonalized(body: IQuickSendPersonalized): any;
-}
-export interface IgatewaySettings {
-    platformId: string;
-    param: IgatewayParam;
-}
-export interface IgatewayParam {
-    host: string;
-    port?: number;
-    username?: string;
-    password?: string;
-    clientId?: string;
-    clientSecret?: string;
-    version: string;
-    authModel: AuthModel;
-}
-export interface AuthModel {
-    type: AuthTypes;
-    username?: string;
-    password?: string;
-    key?: string;
-}
-export declare enum AuthTypes {
-    factor = "factor",
-    key = "key"
-}
-export interface IQuickSendPersonalized {
-    From: string;
-    Content: string;
-    Type: MessageTypes;
-    To: IPersonalizedDestination | IPersonalizedDestination[];
-}
-export interface IPersonalizedDestination {
-    to: number;
-    values: (string | number)[];
-}
-export declare enum MessageTypes {
-    Text = 0,
-    flash = 1
-}
+import { IgatewaySettings, IgatewayParam, ISmsGateway, QuickSendParams, SendResult } from './types';
+export * from './types';
+export declare class smsPlatform implements ISmsGateway {
+    private _settings;
+    private _gateway;
+    constructor(settings: IgatewaySettings);
+    private validateSettings;
+    private createGateway;
+    init(): ISmsGateway;
+    quickSend(param: QuickSendParams, callback?: Function): Promise<SendResult>;
+    getGateway(): ISmsGateway;
+}
+export { IgatewaySettings, IgatewayParam };

package/dist/lib/platform.js

@@ -1,93 +1,85 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageTypes = exports.AuthTypes = exports.smsPlatform = void 0;
-// const routesms = require('routesms')
-const hubtel_sms_extended_1 = require("hubtel-sms-extended");
-const routemobilesms_1 = require("routemobilesms");
-const nestsms = __importStar(require("nestsms"));
-// routeSms.engine
-class smsPlatform {
-    constructor(settings) {
-        this._settings = settings;
-    }
-    init() {
-        if (this._settings.platformId === 'route') {
-            // this._sms = routesms;
-            this._sms = new routemobilesms_1.routeSms({
-                host: this._settings.param.host,
-                username: this._settings.param.username,
-                password: this._settings.param.password,
-                protocol: 'http',
-                port: 8080
-            });
-            // this._sms = routeSms;
-            // console.log(this._sms, this._sms.connection)  
-            // this._sms.connection = this._settings.param;
-        }
-        else if (this._settings.platformId === 'hubtel') {
-            // console.log(this._settings)
-            this._sms = new hubtel_sms_extended_1.HubtelSms({ clientId: this._settings.param.clientId, clientSecret: this._settings.param.clientSecret });
-        }
-        else if (this._settings.platformId === 'nest') {
-            // console.log(this._settings)
-            this._sms = nestsms.init({
-                host: this._settings.param.host,
-                version: this._settings.param.version,
-                authModel: this._settings.param.authModel
-            });
-        }
-        // console.log({sms: this._sms})
-        return this;
-    }
-    quickSend(param, callback) {
-        if (this._settings.platformId === 'route') {
-            return this._sms.sendAsync({ From: param.From, To: param.To, Content: param.Content });
-            // return this._sms.send(callback);
-        }
-        else if (this._settings.platformId === 'hubtel') {
-            return this._sms.quickSend(param);
-        }
-        else if (this._settings.platformId === 'nest') {
-            return this._sms.quickSend(param);
-        }
-        else {
-            throw new Error("Platform ID not recognised");
-        }
-    }
-    sendPersonalized(body) {
-        if (this._settings.platformId !== 'nest') {
-            throw new Error("Specified platform does not support personalisation");
-        }
-        return this._sms.sendPersonalized(body);
-    }
-}
-exports.smsPlatform = smsPlatform;
-var AuthTypes;
-(function (AuthTypes) {
-    AuthTypes["factor"] = "factor";
-    AuthTypes["key"] = "key";
-})(AuthTypes = exports.AuthTypes || (exports.AuthTypes = {}));
-var MessageTypes;
-(function (MessageTypes) {
-    MessageTypes[MessageTypes["Text"] = 0] = "Text";
-    MessageTypes[MessageTypes["flash"] = 1] = "flash";
-})(MessageTypes = exports.MessageTypes || (exports.MessageTypes = {}));
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 });
+exports.smsPlatform = void 0;
+const hubtel_sms_extended_1 = require("hubtel-sms-extended");
+const routemobilesms_1 = require("routemobilesms");
+const nest_gateway_1 = require("./nest-gateway");
+__exportStar(require("./types"), exports);
+const GATEWAY_CONFIGS = {
+    route: { requiresUsernamePassword: true },
+    hubtel: { requiresClientCredentials: true },
+    nest: { requiresApiKey: true }
+};
+class smsPlatform {
+    constructor(settings) {
+        this.validateSettings(settings);
+        this._settings = settings;
+        this._gateway = this.createGateway();
+    }
+    validateSettings(settings) {
+        const validPlatforms = ['route', 'hubtel', 'nest'];
+        if (!validPlatforms.includes(settings.platformId)) {
+            throw new Error(`Invalid platform ID. Supported platforms: ${validPlatforms.join(', ')}`);
+        }
+        const config = GATEWAY_CONFIGS[settings.platformId];
+        const param = settings.param;
+        if (config.requiresApiKey && !param.apiKey) {
+            throw new Error(`Platform '${settings.platformId}' requires 'apiKey' in param`);
+        }
+        if (config.requiresClientCredentials && (!param.clientId || !param.clientSecret)) {
+            throw new Error(`Platform '${settings.platformId}' requires 'clientId' and 'clientSecret' in param`);
+        }
+        if (config.requiresUsernamePassword && (!param.username || !param.password)) {
+            throw new Error(`Platform '${settings.platformId}' requires 'username' and 'password' in param`);
+        }
+    }
+    createGateway() {
+        const { platformId, param } = this._settings;
+        switch (platformId) {
+            case 'route':
+                return new routemobilesms_1.routeSms({
+                    host: param.host || 'rslr.connectbind.com',
+                    username: param.username,
+                    password: param.password,
+                    protocol: param.protocol || 'http',
+                    port: param.port || 8080
+                });
+            case 'hubtel':
+                return new hubtel_sms_extended_1.HubtelSms({
+                    clientId: param.clientId,
+                    clientSecret: param.clientSecret
+                });
+            case 'nest':
+                return new nest_gateway_1.NestSmsGateway({
+                    apiKey: param.apiKey,
+                    host: param.host,
+                    protocol: param.protocol
+                });
+            default:
+                throw new Error(`Unsupported platform: ${platformId}`);
+        }
+    }
+    init() {
+        return this;
+    }
+    quickSend(param, callback) {
+        if (!this._gateway) {
+            throw new Error('Gateway not initialized. Call init() first.');
+        }
+        return this._gateway.quickSend(param, callback);
+    }
+    getGateway() {
+        return this._gateway;
+    }
+}
+exports.smsPlatform = smsPlatform;

package/dist/lib/types.d.ts

@@ -0,0 +1,44 @@
+export declare type PlatformId = 'route' | 'hubtel' | 'nest';
+export interface QuickSendParams {
+    From: string;
+    To: string | number;
+    Content: string;
+    Type?: number;
+}
+export interface SendResult {
+    success: boolean;
+    messageId?: string;
+    data?: any;
+    error?: string;
+}
+export interface IgatewayParam {
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    clientId?: string;
+    clientSecret?: string;
+    apiKey?: string;
+    protocol?: 'http' | 'https';
+}
+export interface IgatewaySettings {
+    platformId: PlatformId;
+    param: IgatewayParam;
+}
+export interface ISmsGateway {
+    init(): ISmsGateway;
+    quickSend(params: QuickSendParams, callback?: Function): Promise<SendResult>;
+    getBalance?(): Promise<any>;
+}
+export interface NestSmsConfig {
+    apiKey: string;
+    host?: string;
+    protocol?: 'http' | 'https';
+}
+export interface NestSendResponse {
+    handshake: {
+        id: number;
+        label: string;
+    };
+    data?: any;
+}

package/dist/lib/types.js

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

package/package.json

@@ -1,32 +1,48 @@
 {
   "name": "unismsgateway",
-  "version": "1.2.1",
-  "description": "A unified sms gateway library that brings access to multiple sms gateways under a single API",
+  "version": "1.3.0",
+  "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",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/RazakAlpha/unismsgateway"
-  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "tsc",
-    "prepublish": "npm run build",
-    "publish": "git push --tags && npm publish"
+    "prepublish": "npm run build"
   },
   "files": [
     "dist/**/*"
   ],
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
+  "keywords": [
+    "sms",
+    "gateway",
+    "unified",
+    "hubtel",
+    "routemobile",
+    "smsonlinegh",
+    "messaging",
+    "sms-api",
+    "ghana",
+    "telecommunications"
+  ],
+  "author": "RazakAlpha",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/RazakAlpha/unismsgateway.git"
+  },
+  "bugs": {
+    "url": "https://github.com/RazakAlpha/unismsgateway/issues"
+  },
+  "homepage": "https://github.com/RazakAlpha/unismsgateway#readme",
+  "engines": {
+    "node": ">=12.0.0"
+  },
   "devDependencies": {
     "@types/node": "^17.0.4",
     "typescript": "^4.5.4"
   },
   "dependencies": {
     "hubtel-sms-extended": "^1.0.2",
-    "nestsms": "^1.2.1",
     "routemobilesms": "^1.0.4"
   }
 }