@qrvey/sms 0.0.1

package/dist/esm/azureSmsSender.client-K6MPTIU7.mjs

@@ -0,0 +1,36 @@
+import { USERNAME, PASSWORD, FROM, NotProvidedCredentialsError } from './chunk-NCQDKWNI.mjs';
+import { SmsClient } from '@azure/communication-sms';
+
+var AzureSMSSenderClient = class {
+  constructor() {
+    if (!(USERNAME && PASSWORD && FROM))
+      throw new NotProvidedCredentialsError();
+    const connectionString = `endpoint=https://${USERNAME}.communication.azure.com/;accesskey=${PASSWORD}`;
+    this.client = new SmsClient(connectionString);
+  }
+  async send(phones, message) {
+    const result = {
+      sent: [],
+      failed: []
+    };
+    const smsResults = await this.client.send({
+      from: FROM,
+      to: phones,
+      message
+    });
+    smsResults.forEach((smsResult) => {
+      if (smsResult.errorMessage)
+        result.failed.push({
+          phone: smsResult.to,
+          error: smsResult.errorMessage
+        });
+      else
+        result.sent.push({ phone: smsResult.to });
+    });
+    return result;
+  }
+};
+
+export { AzureSMSSenderClient as default };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=azureSmsSender.client-K6MPTIU7.mjs.map

package/dist/esm/azureSmsSender.client-K6MPTIU7.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/services/clients/azureSmsSender.client.ts"],"names":[],"mappings":";;;;;;;;AAIA,SAAS,iBAAiB;AAE1B,IAAqB,uBAArB,MAAgE;AAAA,EAE5D,cAAc;AACV,QAAI,EAAE,YAAY,YAAY;AAC1B,YAAM,IAAI,4BAA4B;AAC1C,UAAM,mBAAmB,oBAAoB,QAAQ,uCAAuC,QAAQ;AACpG,SAAK,SAAS,IAAI,UAAU,gBAAgB;AAAA,EAChD;AAAA,EAEA,MAAa,KAAK,QAAkB,SAAsC;AACtE,UAAM,SAAqB;AAAA,MACvB,MAAM,CAAC;AAAA,MACP,QAAQ,CAAC;AAAA,IACb;AACA,UAAM,aAAa,MAAM,KAAK,OAAO,KAAK;AAAA,MACtC,MAAM;AAAA,MACN,IAAI;AAAA,MACJ;AAAA,IACJ,CAAC;AAED,eAAW,QAAQ,CAAC,cAAc;AAC9B,UAAI,UAAU;AACV,eAAO,OAAO,KAAK;AAAA,UACf,OAAO,UAAU;AAAA,UACjB,OAAO,UAAU;AAAA,QACrB,CAAC;AAAA;AACA,eAAO,KAAK,KAAK,EAAE,OAAO,UAAU,GAAG,CAAC;AAAA,IACjD,CAAC;AAED,WAAO;AAAA,EACX;AACJ","sourcesContent":["import { NotProvidedCredentialsError } from '../../errors';\nimport { ISMSSender } from '../../interfaces';\nimport { SendResult } from '../../types';\nimport { USERNAME, PASSWORD, FROM } from '../../utils/constants';\nimport { SmsClient } from '@azure/communication-sms';\n\nexport default class AzureSMSSenderClient implements ISMSSender {\n    client: SmsClient;\n    constructor() {\n        if (!(USERNAME && PASSWORD && FROM))\n            throw new NotProvidedCredentialsError();\n        const connectionString = `endpoint=https://${USERNAME}.communication.azure.com/;accesskey=${PASSWORD}`;\n        this.client = new SmsClient(connectionString);\n    }\n\n    public async send(phones: string[], message: string): Promise<SendResult> {\n        const result: SendResult = {\n            sent: [],\n            failed: [],\n        };\n        const smsResults = await this.client.send({\n            from: FROM as string,\n            to: phones,\n            message: message,\n        });\n\n        smsResults.forEach((smsResult) => {\n            if (smsResult.errorMessage)\n                result.failed.push({\n                    phone: smsResult.to,\n                    error: smsResult.errorMessage,\n                });\n            else result.sent.push({ phone: smsResult.to });\n        });\n\n        return result;\n    }\n}\n"]}

package/dist/esm/chunk-NCQDKWNI.mjs

@@ -0,0 +1,26 @@
+// src/errors/notProvidedCredentials.error.ts
+var NotProvidedCredentialsError = class extends Error {
+  constructor() {
+    super("SMS sender credentials not provided.");
+    this.name = "NotProvidedCredentialsError";
+  }
+};
+
+// src/errors/unknownProvider.error.ts
+var UnknownProviderError = class extends Error {
+  constructor() {
+    super("Unknown provider. Set PROVIDER env variable");
+    this.name = "UnknownProviderError";
+  }
+};
+
+// src/utils/constants.ts
+var SMS_PROVIDER = process.env.SMS_PROVIDER;
+var USERNAME = process.env.SMS_PROVIDER_USERNAME;
+var PASSWORD = process.env.SMS_PROVIDER_PASSWORD;
+var FROM = process.env.SMS_PROVIDER_FROM_NUMBER;
+var REGION = process.env.SMS_PROVIDER_REGION;
+
+export { FROM, NotProvidedCredentialsError, PASSWORD, REGION, SMS_PROVIDER, USERNAME, UnknownProviderError };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=chunk-NCQDKWNI.mjs.map

package/dist/esm/chunk-NCQDKWNI.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/errors/notProvidedCredentials.error.ts","../../src/errors/unknownProvider.error.ts","../../src/utils/constants.ts"],"names":[],"mappings":";AAAO,IAAM,8BAAN,cAA0C,MAAM;AAAA,EACnD,cAAc;AACV,UAAM,sCAAsC;AAC5C,SAAK,OAAO;AAAA,EAChB;AACJ;;;ACLO,IAAM,uBAAN,cAAmC,MAAM;AAAA,EAC5C,cAAc;AACV,UAAM,6CAA6C;AACnD,SAAK,OAAO;AAAA,EAChB;AACJ;;;ACLO,IAAM,eAAe,QAAQ,IAAI;AAEjC,IAAM,WAAW,QAAQ,IAAI;AAC7B,IAAM,WAAW,QAAQ,IAAI;AAC7B,IAAM,OAAO,QAAQ,IAAI;AACzB,IAAM,SAAS,QAAQ,IAAI","sourcesContent":["export class NotProvidedCredentialsError extends Error {\n    constructor() {\n        super('SMS sender credentials not provided.');\n        this.name = 'NotProvidedCredentialsError';\n    }\n}\n","export class UnknownProviderError extends Error {\n    constructor() {\n        super('Unknown provider. Set PROVIDER env variable');\n        this.name = 'UnknownProviderError';\n    }\n}\n","export const SMS_PROVIDER = process.env.SMS_PROVIDER;\n\nexport const USERNAME = process.env.SMS_PROVIDER_USERNAME;\nexport const PASSWORD = process.env.SMS_PROVIDER_PASSWORD;\nexport const FROM = process.env.SMS_PROVIDER_FROM_NUMBER;\nexport const REGION = process.env.SMS_PROVIDER_REGION;\n"]}

package/dist/esm/index.d.mts

@@ -0,0 +1,20 @@
+type SendResult = {
+    sent: SendMessageResult[];
+    failed: SendMessageResult[];
+};
+type SendMessageResult = {
+    phone: string;
+    error?: string;
+};
+
+declare class SMSSenderService {
+    /**
+     * Send a message to one or more phones.
+     * @param phones - phone numbers to send to
+     * @param message - message to send
+     * @returns {Promise<SendResult>} Send result.
+     */
+    send: (phones: string[], message: string) => Promise<SendResult>;
+}
+
+export { SMSSenderService, SendResult };

package/dist/esm/index.mjs

@@ -0,0 +1,36 @@
+import { SMS_PROVIDER, UnknownProviderError } from './chunk-NCQDKWNI.mjs';
+
+// src/services/smsSenderFactory.service.ts
+var SMSSenderFactory = class {
+  static async getSMSSender() {
+    var _a;
+    const provider = (_a = SMS_PROVIDER) == null ? void 0 : _a.toLowerCase();
+    if (!provider)
+      throw new UnknownProviderError();
+    const { default: SMSSender } = await this.providerModules[provider]();
+    return new SMSSender();
+  }
+};
+SMSSenderFactory.providerModules = {
+  twilio: () => import('./twilioSmsSender.client-2Z4R25US.mjs'),
+  aws: () => import('./awsSmsSender.client-DGZ2JYIG.mjs'),
+  azure: () => import('./azureSmsSender.client-K6MPTIU7.mjs'),
+  vonage: () => import('./vonageSmsSender.client-23U65FBQ.mjs')
+};
+
+// src/services/smsSender.service.ts
+var SMSSenderService = class {
+  constructor() {
+    /**
+     * Send a message to one or more phones.
+     * @param phones - phone numbers to send to
+     * @param message - message to send
+     * @returns {Promise<SendResult>} Send result.
+     */
+    this.send = async (phones, message) => (await SMSSenderFactory.getSMSSender()).send(phones, message);
+  }
+};
+
+export { SMSSenderService };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.mjs.map

package/dist/esm/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/services/smsSenderFactory.service.ts","../../src/services/smsSender.service.ts"],"names":[],"mappings":";;;;;;AAKO,IAAM,mBAAN,MAAuB;AAAA,EAW1B,aAAa,eAAoC;AAhBrD;AAiBQ,UAAM,YAAW,yCAAc;AAC/B,QAAI,CAAC;AAAU,YAAM,IAAI,qBAAqB;AAE9C,UAAM,EAAE,SAAS,UAAU,IAAI,MAAM,KAAK,gBAAgB,QAAQ,EAAE;AACpE,WAAO,IAAI,UAAU;AAAA,EACzB;AACJ;AAlBa,iBACM,kBAGX;AAAA,EACA,QAAQ,MAAM,OAAO,uCAAkC;AAAA,EACvD,KAAK,MAAM,OAAO,oCAA+B;AAAA,EACjD,OAAO,MAAM,OAAO,sCAAiC;AAAA,EACrD,QAAQ,MAAM,OAAO,uCAAkC;AAC3D;;;ACXG,IAAM,mBAAN,MAAuB;AAAA,EAAvB;AAOH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,SAAO,OAAO,OACV,QACA,aAEC,MAAM,iBAAiB,aAAa,GAAG,KAAK,QAAQ,OAAO;AAAA;AACpE","sourcesContent":["import { UnknownProviderError } from '../errors';\nimport { ISMSSender } from '../interfaces';\nimport { SMSProviderModule } from '../types';\nimport { SMS_PROVIDER } from '../utils/constants';\n\nexport class SMSSenderFactory {\n    private static providerModules: Record<\n        string,\n        () => Promise<SMSProviderModule>\n    > = {\n        twilio: () => import('./clients/twilioSmsSender.client'),\n        aws: () => import('./clients/awsSmsSender.client'),\n        azure: () => import('./clients/azureSmsSender.client'),\n        vonage: () => import('./clients/vonageSmsSender.client'),\n    };\n\n    static async getSMSSender(): Promise<ISMSSender> {\n        const provider = SMS_PROVIDER?.toLowerCase();\n        if (!provider) throw new UnknownProviderError();\n\n        const { default: SMSSender } = await this.providerModules[provider]();\n        return new SMSSender();\n    }\n}\n","import { SendResult } from '../types';\nimport { SMSSenderFactory } from './smsSenderFactory.service';\n\nexport class SMSSenderService {\n    /**\n     * Send a message to one or more phones.\n     * @param phones - phone numbers to send to\n     * @param message - message to send\n     * @returns {Promise<SendResult>} Send result.\n     */\n    public send = async (\n        phones: string[],\n        message: string,\n    ): Promise<SendResult> =>\n        (await SMSSenderFactory.getSMSSender()).send(phones, message);\n}\n"]}

package/dist/esm/twilioSmsSender.client-2Z4R25US.mjs

@@ -0,0 +1,42 @@
+import { FROM, USERNAME, PASSWORD, NotProvidedCredentialsError } from './chunk-NCQDKWNI.mjs';
+import { Twilio } from 'twilio';
+
+var TwilioSMSSenderClient = class {
+  constructor() {
+    this._send = (phone, message) => this.client.messages.create({
+      from: FROM,
+      to: phone,
+      body: message
+    });
+    if (USERNAME && PASSWORD)
+      this.client = new Twilio(USERNAME, PASSWORD);
+    else
+      throw new NotProvidedCredentialsError();
+  }
+  async send(phones = [], message) {
+    const sentMessages = await Promise.all(
+      phones.map((phone) => this._send(phone, message))
+    );
+    const result = {
+      sent: [],
+      failed: []
+    };
+    sentMessages.forEach((message2) => {
+      if (message2.errorMessage) {
+        result.failed.push({
+          phone: message2.to,
+          error: message2.errorMessage
+        });
+      } else {
+        result.sent.push({
+          phone: message2.to
+        });
+      }
+    });
+    return result;
+  }
+};
+
+export { TwilioSMSSenderClient as default };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=twilioSmsSender.client-2Z4R25US.mjs.map

package/dist/esm/twilioSmsSender.client-2Z4R25US.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/services/clients/twilioSmsSender.client.ts"],"names":["message"],"mappings":";;;;;;;;AACA,SAAS,cAAc;AAMvB,IAAqB,wBAArB,MAAiE;AAAA,EAE7D,cAAc;AAiCd,SAAQ,QAAQ,CACZ,OACA,YAEA,KAAK,OAAO,SAAS,OAAO;AAAA,MACxB,MAAM;AAAA,MACN,IAAI;AAAA,MACJ,MAAM;AAAA,IACV,CAAC;AAxCD,QAAI,YAAY;AAAU,WAAK,SAAS,IAAI,OAAO,UAAU,QAAQ;AAAA;AAChE,YAAM,IAAI,4BAA4B;AAAA,EAC/C;AAAA,EAEA,MAAa,KACT,SAAmB,CAAC,GACpB,SACmB;AACnB,UAAM,eAAe,MAAM,QAAQ;AAAA,MAC/B,OAAO,IAAI,CAAC,UAAU,KAAK,MAAM,OAAO,OAAO,CAAC;AAAA,IACpD;AAEA,UAAM,SAAqB;AAAA,MACvB,MAAM,CAAC;AAAA,MACP,QAAQ,CAAC;AAAA,IACb;AACA,iBAAa,QAAQ,CAACA,aAAY;AAC9B,UAAIA,SAAQ,cAAc;AACtB,eAAO,OAAO,KAAK;AAAA,UACf,OAAOA,SAAQ;AAAA,UACf,OAAOA,SAAQ;AAAA,QACnB,CAAC;AAAA,MACL,OAAO;AACH,eAAO,KAAK,KAAK;AAAA,UACb,OAAOA,SAAQ;AAAA,QACnB,CAAC;AAAA,MACL;AAAA,IACJ,CAAC;AAED,WAAO;AAAA,EACX;AAWJ","sourcesContent":["import { ISMSSender } from '../../interfaces/smsSender.interface';\nimport { Twilio } from 'twilio';\nimport { USERNAME, PASSWORD, FROM } from '../../utils/constants';\nimport { MessageInstance } from 'twilio/lib/rest/api/v2010/account/message';\nimport { SendResult } from '../../types/sendResult.type';\nimport { NotProvidedCredentialsError } from '../../errors';\n\nexport default class TwilioSMSSenderClient implements ISMSSender {\n    private client: Twilio;\n    constructor() {\n        if (USERNAME && PASSWORD) this.client = new Twilio(USERNAME, PASSWORD);\n        else throw new NotProvidedCredentialsError();\n    }\n\n    public async send(\n        phones: string[] = [],\n        message: string,\n    ): Promise<SendResult> {\n        const sentMessages = await Promise.all(\n            phones.map((phone) => this._send(phone, message)),\n        );\n\n        const result: SendResult = {\n            sent: [],\n            failed: [],\n        };\n        sentMessages.forEach((message) => {\n            if (message.errorMessage) {\n                result.failed.push({\n                    phone: message.to,\n                    error: message.errorMessage,\n                });\n            } else {\n                result.sent.push({\n                    phone: message.to,\n                });\n            }\n        });\n\n        return result;\n    }\n\n    private _send = (\n        phone: string,\n        message: string,\n    ): Promise<MessageInstance> =>\n        this.client.messages.create({\n            from: FROM,\n            to: phone,\n            body: message,\n        });\n}\n"]}

package/dist/esm/vonageSmsSender.client-23U65FBQ.mjs

@@ -0,0 +1,38 @@
+import { FROM, USERNAME, PASSWORD, NotProvidedCredentialsError } from './chunk-NCQDKWNI.mjs';
+import { Vonage } from '@vonage/server-sdk';
+import { Auth } from '@vonage/auth';
+
+var VonageSMSSenderClient = class {
+  constructor() {
+    this.send = async (phones, message) => {
+      const result = {
+        sent: [],
+        failed: []
+      };
+      await Promise.all(
+        phones.map(
+          (phone) => this._send(phone, message).then(() => result.sent.push({ phone })).catch(
+            (error) => result.failed.push({ phone, error: error.message })
+          )
+        )
+      );
+      return result;
+    };
+    this._send = (phone, message) => this.client.sms.send({
+      to: phone,
+      text: message,
+      from: FROM
+    });
+    if (!(USERNAME && PASSWORD && FROM))
+      throw new NotProvidedCredentialsError();
+    const vonageAuth = new Auth({
+      apiKey: USERNAME,
+      apiSecret: PASSWORD
+    });
+    this.client = new Vonage(vonageAuth);
+  }
+};
+
+export { VonageSMSSenderClient as default };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=vonageSmsSender.client-23U65FBQ.mjs.map

package/dist/esm/vonageSmsSender.client-23U65FBQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/services/clients/vonageSmsSender.client.ts"],"names":[],"mappings":";;;;;;;;AAEA,SAAS,cAAc;AACvB,SAAS,YAAY;AAKrB,IAAqB,wBAArB,MAAiE;AAAA,EAE7D,cAAc;AAUd,SAAO,OAAO,OACV,QACA,YACsB;AACtB,YAAM,SAAqB;AAAA,QACvB,MAAM,CAAC;AAAA,QACP,QAAQ,CAAC;AAAA,MACb;AAEA,YAAM,QAAQ;AAAA,QACV,OAAO;AAAA,UAAI,CAAC,UACR,KAAK,MAAM,OAAO,OAAO,EACpB,KAAK,MAAM,OAAO,KAAK,KAAK,EAAE,MAAM,CAAC,CAAC,EACtC;AAAA,YAAM,CAAC,UACJ,OAAO,OAAO,KAAK,EAAE,OAAO,OAAO,MAAM,QAAQ,CAAC;AAAA,UACtD;AAAA,QACR;AAAA,MACJ;AAEA,aAAO;AAAA,IACX;AAEA,SAAQ,QAAQ,CAAC,OAAe,YAC5B,KAAK,OAAO,IAAI,KAAK;AAAA,MACjB,IAAI;AAAA,MACJ,MAAM;AAAA,MACN,MAAM;AAAA,IACV,CAAC;AApCD,QAAI,EAAE,YAAY,YAAY;AAC1B,YAAM,IAAI,4BAA4B;AAC1C,UAAM,aAAa,IAAI,KAAK;AAAA,MACxB,QAAQ;AAAA,MACR,WAAW;AAAA,IACf,CAAC;AACD,SAAK,SAAS,IAAI,OAAO,UAAU;AAAA,EACvC;AA8BJ","sourcesContent":["import { ISMSSender } from '../../interfaces';\nimport { SendResult } from '../../types';\nimport { Vonage } from '@vonage/server-sdk';\nimport { Auth } from '@vonage/auth';\nimport { USERNAME, PASSWORD, FROM } from '../../utils/constants';\nimport { NotProvidedCredentialsError } from '../../errors';\nimport { SMSMessages } from '@vonage/sms/dist/lib/types/SMSMessages';\n\nexport default class VonageSMSSenderClient implements ISMSSender {\n    private client: Vonage;\n    constructor() {\n        if (!(USERNAME && PASSWORD && FROM))\n            throw new NotProvidedCredentialsError();\n        const vonageAuth = new Auth({\n            apiKey: USERNAME,\n            apiSecret: PASSWORD,\n        });\n        this.client = new Vonage(vonageAuth);\n    }\n\n    public send = async (\n        phones: string[],\n        message: string,\n    ): Promise<SendResult> => {\n        const result: SendResult = {\n            sent: [],\n            failed: [],\n        };\n\n        await Promise.all(\n            phones.map((phone) =>\n                this._send(phone, message)\n                    .then(() => result.sent.push({ phone }))\n                    .catch((error) =>\n                        result.failed.push({ phone, error: error.message }),\n                    ),\n            ),\n        );\n\n        return result;\n    };\n\n    private _send = (phone: string, message: string): Promise<SMSMessages> =>\n        this.client.sms.send({\n            to: phone,\n            text: message,\n            from: FROM as string,\n        });\n}\n"]}

package/dist/types/index.d.ts

@@ -0,0 +1,20 @@
+type SendResult = {
+    sent: SendMessageResult[];
+    failed: SendMessageResult[];
+};
+type SendMessageResult = {
+    phone: string;
+    error?: string;
+};
+
+declare class SMSSenderService {
+    /**
+     * Send a message to one or more phones.
+     * @param phones - phone numbers to send to
+     * @param message - message to send
+     * @returns {Promise<SendResult>} Send result.
+     */
+    send: (phones: string[], message: string) => Promise<SendResult>;
+}
+
+export { SMSSenderService, SendResult };

package/jest.config.ts

@@ -0,0 +1,15 @@
+export default {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    collectCoverageFrom: [
+        'src/**/*.ts',
+        '!src/**/*.test.ts',
+        '!src/**/*.spec.ts',
+        '!src/types/**/*',
+        '!src/interfaces/**/*',
+    ],
+    testPathIgnorePatterns: [
+        '<rootDir>/node_modules/',
+        '<rootDir>/__tests__/__mocks__/',
+    ],
+};

package/package.json

@@ -0,0 +1,80 @@
+{
+    "name": "@qrvey/sms",
+    "version": "0.0.1",
+    "types": "dist/types/index.d.ts",
+    "main": "dist/cjs/index.js",
+    "exports": {
+        ".": {
+            "import": "./dist/esm/index.mjs",
+            "require": "./dist/cjs/index.js",
+            "default": "./dist/cjs/index.js"
+        }
+    },
+    "scripts": {
+        "test": "jest",
+        "test:cov": "jest --coverage && chmod +x ./coverageReader.sh && sh ./coverageReader.sh",
+        "build:clean": "rm -rf dist",
+        "build:compile:original": "tsc -b ./tsconfig.cjs.json ./tsconfig.esm.json ./tsconfig.types.json",
+        "build:compile:cjs:original": "tsup --config ./tsup.config.cjs.ts",
+        "build:compile:cjs": "tsc -b ./tsconfig.cjs.json",
+        "build:compile:esm": "tsup --config ./tsup.config.esm.ts",
+        "build:compile:types": "tsup --config ./tsup.config.types.ts",
+        "build:compile": "yarn build:compile:cjs && yarn build:compile:esm && yarn build:compile:types",
+        "build": "yarn test:cov && yarn build:clean && yarn build:compile",
+        "prepare-publish": "yarn install && yarn build",
+        "publish-package": "yarn prepare-publish && npm publish"
+    },
+    "keywords": [
+        "sms",
+        "client",
+        "qrvey"
+    ],
+    "author": "Qrvey",
+    "license": "MIT",
+    "description": "",
+    "devDependencies": {
+        "@aws-sdk/client-sns": "3.682.0",
+        "@azure/communication-sms": "1.2.0-beta.1",
+        "@types/jest": "29.5.5",
+        "@types/twilio": "3.19.3",
+        "@vonage/auth": "1.12.0",
+        "@vonage/server-sdk": "3.19.1",
+        "auto-version-js": "0.3.10",
+        "eslint-config-custom": "*",
+        "jest": "29.7.0",
+        "ts-jest": "29.1.1",
+        "tsc": "2.0.4",
+        "tsconfig": "*",
+        "tsup": "7.2.0",
+        "twilio": "5.3.5",
+        "typescript": "5.2.2"
+    },
+    "peerDependencies": {
+        "@aws-sdk/client-sns": "3.682.0",
+        "@azure/communication-sms": "1.2.0-beta.1",
+        "@vonage/auth": "1.12.0",
+        "@vonage/server-sdk": "3.19.1",
+        "twilio": "5.3.5"
+    },
+    "peerDependenciesMeta": {
+        "@aws-sdk/client-sns": {
+            "optional": true
+        },
+        "@azure/communication-sms": {
+            "optional": true
+        },
+        "@vonage/auth": {
+            "optional": true
+        },
+        "@vonage/server-sdk": {
+            "optional": true
+        },
+        "twilio": {
+            "optional": true
+        }
+    },
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org"
+    }
+}

package/src/errors/index.test.ts

@@ -0,0 +1,13 @@
+import { UnknownProviderError, NotProvidedCredentialsError } from './index';
+
+describe('Error tests.', () => {
+    test('UnknownProviderError should be defined.', () => {
+        expect(UnknownProviderError).toBeDefined();
+        expect(new UnknownProviderError()).toBeInstanceOf(Error);
+    });
+
+    test('NotProvidedCredentialsError should be defined.', () => {
+        expect(NotProvidedCredentialsError).toBeDefined();
+        expect(new NotProvidedCredentialsError()).toBeInstanceOf(Error);
+    });
+});

package/src/errors/index.ts

@@ -0,0 +1,2 @@
+export * from './unknownProvider.error';
+export * from './notProvidedCredentials.error';

package/src/errors/notProvidedCredentials.error.ts

@@ -0,0 +1,6 @@
+export class NotProvidedCredentialsError extends Error {
+    constructor() {
+        super('SMS sender credentials not provided.');
+        this.name = 'NotProvidedCredentialsError';
+    }
+}

package/src/errors/unknownProvider.error.ts

@@ -0,0 +1,6 @@
+export class UnknownProviderError extends Error {
+    constructor() {
+        super('Unknown provider. Set PROVIDER env variable');
+        this.name = 'UnknownProviderError';
+    }
+}

package/src/index.test.ts

@@ -0,0 +1,7 @@
+import { SMSSenderService } from './index';
+
+describe('index.ts', () => {
+    test('SMSSender should be defined.', () => {
+        expect(SMSSenderService).toBeDefined();
+    });
+});

package/src/index.ts

@@ -0,0 +1,2 @@
+export { SMSSenderService } from './services';
+export type { SendResult } from './types';

package/src/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './smsSender.interface';

package/src/interfaces/smsSender.interface.ts

@@ -0,0 +1,5 @@
+import { SendResult } from '../types';
+
+export interface ISMSSender {
+    send: (phones: string[], message: string) => Promise<SendResult>;
+}

package/src/services/clients/awsSmsSender.client.test.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { SNSClient, PublishCommandOutput } from '@aws-sdk/client-sns';
+import AwsSMSSenderClient from './awsSmsSender.client';
+
+jest.mock('@aws-sdk/client-sns', () => {
+    const actualModule = jest.requireActual('@aws-sdk/client-sns');
+    class SNSClient {
+        send(
+            phones: string[] = [],
+            message: string,
+        ): Promise<PublishCommandOutput> {
+            return Promise.resolve({} as PublishCommandOutput);
+        }
+    }
+    return {
+        ...actualModule,
+        SNSClient,
+    };
+});
+
+jest.mock('../../utils/constants', () => ({
+    REGION: 'us-east-1',
+    USERNAME: 'qrvey',
+    PASSWORD: '123456',
+}));
+
+describe('AwsSMSSender tests.', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.resetAllMocks();
+    });
+
+    test('Should call send method.', async () => {
+        const smsSender = new AwsSMSSenderClient();
+        const clientSend = jest.spyOn(SNSClient.prototype, 'send');
+        await smsSender.send(['+1234567890', '+9876543210'], 'Hello world');
+        expect(clientSend).toHaveBeenCalledTimes(2);
+    });
+});

package/src/services/clients/awsSmsSender.client.ts

@@ -0,0 +1,57 @@
+import { NotProvidedCredentialsError } from '../../errors';
+import { ISMSSender } from '../../interfaces';
+import { SendResult } from '../../types';
+import { PASSWORD, REGION, USERNAME } from '../../utils/constants';
+import {
+    PublishCommand,
+    PublishCommandOutput,
+    SNSClient,
+} from '@aws-sdk/client-sns';
+
+export default class AwsSMSSenderClient implements ISMSSender {
+    private client: SNSClient;
+    constructor() {
+        if (!(USERNAME && PASSWORD)) throw new NotProvidedCredentialsError();
+        this.client = new SNSClient({
+            region: REGION,
+            credentials: {
+                accessKeyId: USERNAME,
+                secretAccessKey: PASSWORD,
+            },
+        });
+    }
+
+    public async send(
+        phones: string[] = [],
+        message: string,
+    ): Promise<SendResult> {
+        const result: SendResult = {
+            sent: [],
+            failed: [],
+        };
+
+        await Promise.all(
+            phones.map((phone) =>
+                this._send(phone, message)
+                    .then(() => result.sent.push({ phone }))
+                    .catch((error) =>
+                        result.failed.push({ phone, error: error.message }),
+                    ),
+            ),
+        );
+
+        return result;
+    }
+
+    private _send = async (
+        phone: string,
+        message: string,
+    ): Promise<PublishCommandOutput> => {
+        const command = new PublishCommand({
+            Message: message,
+            PhoneNumber: phone,
+        });
+
+        return await this.client.send(command);
+    };
+}

package/src/services/clients/azureSmsSender.client.test.ts

@@ -0,0 +1,46 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { SmsClient, SmsSendResult } from '@azure/communication-sms';
+import AzureSMSSenderClient from './azureSmsSender.client';
+
+jest.mock('@azure/communication-sms', () => {
+    const actualModule = jest.requireActual('@azure/communication-sms');
+    class SmsClient {
+        send({
+            from,
+            to,
+            message,
+        }: {
+            from: string;
+            to: string[];
+            message: string;
+        }): Promise<SmsSendResult[]> {
+            return Promise.resolve(
+                to.map((phone) => ({ to: phone })) as SmsSendResult[],
+            );
+        }
+    }
+    return {
+        ...actualModule,
+        SmsClient,
+    };
+});
+
+jest.mock('../../utils/constants', () => ({
+    FROM: '+123456789',
+    USERNAME: 'qrvey',
+    PASSWORD: '123456',
+}));
+
+describe('AzureSMSSender tests.', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.resetAllMocks();
+    });
+
+    test('Should call send method.', async () => {
+        const smsSender = new AzureSMSSenderClient();
+        const clientSend = jest.spyOn(SmsClient.prototype, 'send');
+        await smsSender.send(['+1234567890', '+9876543210'], 'Hello world');
+        expect(clientSend).toHaveBeenCalledTimes(1);
+    });
+});

package/src/services/clients/azureSmsSender.client.ts

@@ -0,0 +1,38 @@
+import { NotProvidedCredentialsError } from '../../errors';
+import { ISMSSender } from '../../interfaces';
+import { SendResult } from '../../types';
+import { USERNAME, PASSWORD, FROM } from '../../utils/constants';
+import { SmsClient } from '@azure/communication-sms';
+
+export default class AzureSMSSenderClient implements ISMSSender {
+    client: SmsClient;
+    constructor() {
+        if (!(USERNAME && PASSWORD && FROM))
+            throw new NotProvidedCredentialsError();
+        const connectionString = `endpoint=https://${USERNAME}.communication.azure.com/;accesskey=${PASSWORD}`;
+        this.client = new SmsClient(connectionString);
+    }
+
+    public async send(phones: string[], message: string): Promise<SendResult> {
+        const result: SendResult = {
+            sent: [],
+            failed: [],
+        };
+        const smsResults = await this.client.send({
+            from: FROM as string,
+            to: phones,
+            message: message,
+        });
+
+        smsResults.forEach((smsResult) => {
+            if (smsResult.errorMessage)
+                result.failed.push({
+                    phone: smsResult.to,
+                    error: smsResult.errorMessage,
+                });
+            else result.sent.push({ phone: smsResult.to });
+        });
+
+        return result;
+    }
+}

package/src/services/clients/index.test.ts

@@ -0,0 +1,50 @@
+import { NotProvidedCredentialsError } from '../../errors';
+import {
+    AwsSMSSenderClient,
+    AzureSMSSenderClient,
+    TwilioSMSSenderClient,
+    VonageSMSSenderClient,
+} from './index';
+import { SMSSender } from '../../../__tests__/__mocks__/SMSSender.mock';
+
+describe('Client tests.', () => {
+    test('AwsSMSSender should be defined.', () => {
+        expect(AwsSMSSenderClient.default).toBeDefined();
+    });
+
+    test('AzureSMSSender should be defined.', () => {
+        expect(AzureSMSSenderClient.default).toBeDefined();
+    });
+
+    test('TwilioSMSSender should be defined.', () => {
+        expect(TwilioSMSSenderClient.default).toBeDefined();
+    });
+
+    test('VonageSMSSender should be defined.', () => {
+        expect(VonageSMSSenderClient.default).toBeDefined();
+    });
+
+    test('SMSSender must implement ISMSSender interface.', async () => {
+        const smsSender = new SMSSender();
+        const results = await smsSender.send(['+1234567890'], 'Hello world');
+        expect('send' in smsSender).toBe(true);
+        expect(smsSender.send).toBeInstanceOf(Function);
+
+        expect(results.sent).toBeInstanceOf(Array);
+    });
+
+    test('Should return NotProvidedCredentialsError.', () => {
+        expect(() => new AwsSMSSenderClient.default()).toThrow(
+            new NotProvidedCredentialsError(),
+        );
+        expect(() => new TwilioSMSSenderClient.default()).toThrow(
+            new NotProvidedCredentialsError(),
+        );
+        expect(() => new VonageSMSSenderClient.default()).toThrow(
+            new NotProvidedCredentialsError(),
+        );
+        expect(() => new AzureSMSSenderClient.default()).toThrow(
+            new NotProvidedCredentialsError(),
+        );
+    });
+});

package/src/services/clients/index.ts

@@ -0,0 +1,4 @@
+export * as AwsSMSSenderClient from './awsSmsSender.client';
+export * as TwilioSMSSenderClient from './twilioSmsSender.client';
+export * as AzureSMSSenderClient from './azureSmsSender.client';
+export * as VonageSMSSenderClient from './vonageSmsSender.client';