@qrvey/sms 0.0.1

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

@@ -0,0 +1,48 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import TwilioSMSSenderClient from './twilioSmsSender.client';
+import { MessageInstance } from 'twilio/lib/rest/api/v2010/account/message';
+
+jest.mock('twilio', () => {
+    const actualModule = jest.requireActual('twilio');
+    class Twilio {
+        messages = {
+            create: ({
+                from,
+                to,
+                body,
+            }: {
+                from: string;
+                to: string;
+                body: string;
+            }): Promise<MessageInstance> =>
+                Promise.resolve({ to } as MessageInstance),
+        };
+    }
+    return {
+        ...actualModule,
+        Twilio,
+    };
+});
+
+jest.mock('../../utils/constants', () => ({
+    USERNAME: 'qrvey',
+    PASSWORD: '123456',
+}));
+
+describe('TwilioSMSSender tests.', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.resetAllMocks();
+    });
+
+    test('Should response with sent messages.', async () => {
+        const smsSender = new TwilioSMSSenderClient();
+        const result = await smsSender.send(
+            ['+1234567890', '+9876543210'],
+            'Hello world',
+        );
+        expect(result).toMatchObject({
+            sent: [{ phone: '+1234567890' }, { phone: '+9876543210' }],
+        });
+    });
+});

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

@@ -0,0 +1,52 @@
+import { ISMSSender } from '../../interfaces/smsSender.interface';
+import { Twilio } from 'twilio';
+import { USERNAME, PASSWORD, FROM } from '../../utils/constants';
+import { MessageInstance } from 'twilio/lib/rest/api/v2010/account/message';
+import { SendResult } from '../../types/sendResult.type';
+import { NotProvidedCredentialsError } from '../../errors';
+
+export default class TwilioSMSSenderClient implements ISMSSender {
+    private client: Twilio;
+    constructor() {
+        if (USERNAME && PASSWORD) this.client = new Twilio(USERNAME, PASSWORD);
+        else throw new NotProvidedCredentialsError();
+    }
+
+    public async send(
+        phones: string[] = [],
+        message: string,
+    ): Promise<SendResult> {
+        const sentMessages = await Promise.all(
+            phones.map((phone) => this._send(phone, message)),
+        );
+
+        const result: SendResult = {
+            sent: [],
+            failed: [],
+        };
+        sentMessages.forEach((message) => {
+            if (message.errorMessage) {
+                result.failed.push({
+                    phone: message.to,
+                    error: message.errorMessage,
+                });
+            } else {
+                result.sent.push({
+                    phone: message.to,
+                });
+            }
+        });
+
+        return result;
+    }
+
+    private _send = (
+        phone: string,
+        message: string,
+    ): Promise<MessageInstance> =>
+        this.client.messages.create({
+            from: FROM,
+            to: phone,
+            body: message,
+        });
+}

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

@@ -0,0 +1,48 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { SMSMessages } from '@vonage/sms/dist/lib/types/SMSMessages';
+import VonageSMSSenderClient from './vonageSmsSender.client';
+
+jest.mock('@vonage/server-sdk', () => {
+    const actualModule = jest.requireActual('@vonage/server-sdk');
+    class Vonage {
+        sms = {
+            send: ({
+                from,
+                to,
+                body,
+            }: {
+                from: string;
+                to: string;
+                body: string;
+            }): Promise<SMSMessages> => Promise.resolve({} as SMSMessages),
+        };
+    }
+    return {
+        ...actualModule,
+        Vonage,
+    };
+});
+
+jest.mock('../../utils/constants', () => ({
+    FROM: '+123456789',
+    USERNAME: 'qrvey',
+    PASSWORD: '123456',
+}));
+
+describe('AwsSMSSender tests.', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.resetAllMocks();
+    });
+
+    test('Should call send method.', async () => {
+        const smsSender = new VonageSMSSenderClient();
+        const result = await smsSender.send(
+            ['+1234567890', '+9876543210'],
+            'Hello world',
+        );
+        expect(result).toMatchObject({
+            sent: [{ phone: '+1234567890' }, { phone: '+9876543210' }],
+        });
+    });
+});

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

@@ -0,0 +1,49 @@
+import { ISMSSender } from '../../interfaces';
+import { SendResult } from '../../types';
+import { Vonage } from '@vonage/server-sdk';
+import { Auth } from '@vonage/auth';
+import { USERNAME, PASSWORD, FROM } from '../../utils/constants';
+import { NotProvidedCredentialsError } from '../../errors';
+import { SMSMessages } from '@vonage/sms/dist/lib/types/SMSMessages';
+
+export default class VonageSMSSenderClient implements ISMSSender {
+    private client: Vonage;
+    constructor() {
+        if (!(USERNAME && PASSWORD && FROM))
+            throw new NotProvidedCredentialsError();
+        const vonageAuth = new Auth({
+            apiKey: USERNAME,
+            apiSecret: PASSWORD,
+        });
+        this.client = new Vonage(vonageAuth);
+    }
+
+    public send = async (
+        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 = (phone: string, message: string): Promise<SMSMessages> =>
+        this.client.sms.send({
+            to: phone,
+            text: message,
+            from: FROM as string,
+        });
+}

package/src/services/index.test.ts

@@ -0,0 +1,12 @@
+import { SMSSenderService } from './smsSender.service';
+import { SMSSenderFactory } from './smsSenderFactory.service';
+
+describe('Services tests.', () => {
+    test('SMSSender should be defined.', () => {
+        expect(SMSSenderService).toBeDefined();
+    });
+
+    test('SMSSenderFactory should be defined.', () => {
+        expect(SMSSenderFactory).toBeDefined();
+    });
+});

package/src/services/index.ts

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

package/src/services/smsSender.service.ts

@@ -0,0 +1,16 @@
+import { SendResult } from '../types';
+import { SMSSenderFactory } from './smsSenderFactory.service';
+
+export 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.
+     */
+    public send = async (
+        phones: string[],
+        message: string,
+    ): Promise<SendResult> =>
+        (await SMSSenderFactory.getSMSSender()).send(phones, message);
+}

package/src/services/smsSenderFactory.service.test.ts

@@ -0,0 +1,16 @@
+import { SMSSenderFactory } from './smsSenderFactory.service';
+import { UnknownProviderError } from '../errors';
+
+jest.mock('../utils/constants', () => ({
+    FROM: '+123456789',
+    USERNAME: 'qrvey',
+    PASSWORD: '123456',
+    REGION: 'us-east-1',
+}));
+describe('SMSSenderFactory tests.', () => {
+    test('Should return AwsSMSSender.', async () => {
+        await expect(SMSSenderFactory.getSMSSender()).rejects.toThrow(
+            new UnknownProviderError(),
+        );
+    });
+});

package/src/services/smsSenderFactory.service.ts

@@ -0,0 +1,24 @@
+import { UnknownProviderError } from '../errors';
+import { ISMSSender } from '../interfaces';
+import { SMSProviderModule } from '../types';
+import { SMS_PROVIDER } from '../utils/constants';
+
+export class SMSSenderFactory {
+    private static providerModules: Record<
+        string,
+        () => Promise<SMSProviderModule>
+    > = {
+        twilio: () => import('./clients/twilioSmsSender.client'),
+        aws: () => import('./clients/awsSmsSender.client'),
+        azure: () => import('./clients/azureSmsSender.client'),
+        vonage: () => import('./clients/vonageSmsSender.client'),
+    };
+
+    static async getSMSSender(): Promise<ISMSSender> {
+        const provider = SMS_PROVIDER?.toLowerCase();
+        if (!provider) throw new UnknownProviderError();
+
+        const { default: SMSSender } = await this.providerModules[provider]();
+        return new SMSSender();
+    }
+}

package/src/types/index.ts

@@ -0,0 +1,2 @@
+export * from './sendResult.type';
+export * from './smsProviderModule.type';

package/src/types/sendResult.type.ts

@@ -0,0 +1,9 @@
+export type SendResult = {
+    sent: SendMessageResult[];
+    failed: SendMessageResult[];
+};
+
+type SendMessageResult = {
+    phone: string;
+    error?: string;
+};

package/src/types/smsProviderModule.type.ts

@@ -0,0 +1,5 @@
+import { ISMSSender } from '../interfaces';
+
+export type SMSProviderModule = {
+    default: new () => ISMSSender;
+};

package/src/utils/constants.ts

@@ -0,0 +1,6 @@
+export const SMS_PROVIDER = process.env.SMS_PROVIDER;
+
+export const USERNAME = process.env.SMS_PROVIDER_USERNAME;
+export const PASSWORD = process.env.SMS_PROVIDER_PASSWORD;
+export const FROM = process.env.SMS_PROVIDER_FROM_NUMBER;
+export const REGION = process.env.SMS_PROVIDER_REGION;

package/tsconfig.cjs.json

@@ -0,0 +1,7 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "outDir": "./dist/cjs",
+        "module": "commonjs"
+    }
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "extends": "tsconfig/tsconfig.json",
+    "compilerOptions": {
+        "outDir": "./dist"
+    },
+    "include": ["src/index.ts"],
+    "exclude": [
+        "dist",
+        "build",
+        "node_modules",
+        "coverage",
+        "**/*.test.ts",
+        "**/*.test.d.ts",
+        "**/*.spec.ts",
+        "**/__tests__",
+    ]
+}

package/tsup.config.cjs.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+    entryPoints: ['./src/index.ts'],
+    format: ['cjs'],
+    treeshake: true,
+    sourcemap: true,
+    outDir: 'dist/cjs',
+});

package/tsup.config.esm.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+    entryPoints: ['./src/index.ts'],
+    format: ['esm'],
+    treeshake: true,
+    sourcemap: true,
+    dts: true,
+    outDir: 'dist/esm',
+});

package/tsup.config.types.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+    entryPoints: ['./src/index.ts'],
+    dts: {
+        only: true,
+    },
+    outDir: 'dist/types',
+});