@tomei/sso 0.1.2 → 0.2.1

package/src/mail/mail.service.ts

@@ -0,0 +1,33 @@
+import { ISendNewLoginAlertOptions } from './interfaces/send-new-login-alert.interface';
+import Mail from './mail';
+
+export class MailService {
+  MailClient: Mail;
+  constructor() {
+    this.MailClient = Mail.init();
+  }
+
+  public async sendNewLoginAlertEmail(
+    options: ISendNewLoginAlertOptions,
+  ): Promise<void> {
+    try {
+      await this.MailClient.sendMail({
+        to: options.Email,
+        subject: 'New Login Alert',
+        html: `<p>Dear ${options.Name},</p>
+                <p>There was a new login to your account from ${
+                  options.IpAddress
+                } on ${options.LoginDate.toLocaleString()}.</p>
+                <p>If this was you, you can safely ignore this email.</p>
+                <p>If you suspect that someone else is trying to access your account, please contact us immediately at itd-support@tomei.com.my.</p>
+                <p>Thank you!,</p>
+                <p>
+                    Best Regards,
+                    IT Department
+                </p>`,
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+}

package/src/mail/mail.ts

@@ -0,0 +1,40 @@
+import * as nodemailer from 'nodemailer';
+import { ISendMailOptionsInterface } from './interfaces/send-mail.interface';
+
+export default class Mail {
+  private static transporter: nodemailer.Transporter;
+
+  constructor() {}
+
+  static init() {
+    if (!Mail.transporter) {
+      Mail.transporter = nodemailer.createTransport({
+        host: process.env.SMTP_HOST,
+        port: Number(process.env.SMTP_PORT),
+        secure: Number(process.env.SMTP_PORT) === 465,
+        auth: {
+          user: process.env.EMAIL_SENDER,
+          pass: process.env.EMAIL_PASSWORD,
+        },
+      });
+    }
+    return new Mail();
+  }
+
+  //SEND MAIL
+  async sendMail(options: ISendMailOptionsInterface): Promise<void> {
+    try {
+      await Mail.transporter.sendMail({
+        from: process.env.EMAIL_SENDER,
+        to: options.to,
+        cc: options.cc,
+        bcc: options.bcc,
+        subject: options.subject,
+        text: options.text,
+        html: options.html,
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+}

package/src/prisma-client/__mocks__/prisma.ts

@@ -0,0 +1,15 @@
+import { PrismaClient } from '@prisma/client';
+import { mockDeep, mockReset, DeepMockProxy } from 'jest-mock-extended';
+
+import prisma from '../client';
+
+jest.mock('../client', () => ({
+  __esModule: true,
+  default: mockDeep<PrismaClient>(),
+}));
+
+beforeEach(() => {
+  mockReset(prismaMock);
+});
+
+export const prismaMock = prisma as unknown as DeepMockProxy<PrismaClient>;

package/src/prisma-client/client.ts

@@ -0,0 +1,3 @@
+import { PrismaClient } from '@prisma/client';
+const prisma = new PrismaClient();
+export default prisma;

package/src/prisma-client/index.ts

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

package/src/redis-client/__mocks__/jest-initial-setup.ts

@@ -0,0 +1,2 @@
+import redis from './redis-mock';
+jest.mock('redis', () => redis);

package/src/redis-client/__mocks__/redis-mock.ts

@@ -0,0 +1,28 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+// redis-mock has not been updated for node-redis v4 yet, but the main changes
+// in the API are camelCase names and promises instead of callback, so we can work around it.
+// https://github.com/yeahoffline/redis-mock/issues/195
+import redis, { createClient } from 'redis-mock';
+// @ts-expect-error Work-around redis-mock types reporting incorrectly as v4 redis.
+import { RedisClient } from '@types/redis';
+import { promisify } from 'util';
+const client = createClient() as unknown as RedisClient;
+const setEx = promisify(client.setex).bind(client);
+const v4Client = {
+  connect: () => undefined,
+  get: promisify(client.get).bind(client),
+  set: promisify(client.set).bind(client),
+  del: promisify(client.del).bind(client),
+  hSet: promisify(client.hset).bind(client),
+  hGet: promisify(client.hget).bind(client),
+  hDel: promisify(client.hdel).bind(client),
+  flushAll: promisify(client.flushall).bind(client),
+  setEx: promisify(client.setex).bind(client),
+  expire: promisify(client.expire).bind(client),
+  mGet: promisify(client.mget).bind(client),
+  pSetEx: (key: string, ms: number, value: string) =>
+    setEx(key, ms / 1000, value),
+  on: () => undefined,
+  // Add additional functions as needed...
+};
+export default { ...redis, createClient: () => v4Client };

package/src/redis-client/index.ts

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

package/src/redis-client/redis.service.ts

@@ -0,0 +1,48 @@
+import { createClient } from 'redis';
+export class RedisService {
+  private static client;
+
+  private constructor() {}
+
+  static async init(): Promise<RedisService> {
+    if (!RedisService.client) {
+      // Create a new Redis client
+      RedisService.client = createClient({
+        url: process.env.REDIS_URL,
+        password: process.env.REDIS_PASSWORD,
+      });
+
+      RedisService.client.on('error', (error) => {
+        console.error('Redis error:', error);
+      });
+      RedisService.client.on('connect', () => console.log('Redis connected'));
+      RedisService.client.on('reconnecting', () =>
+        console.log('Redis reconnecting'),
+      );
+
+      await RedisService.client.connect();
+    }
+    return new RedisService();
+  }
+
+  public async set(
+    key: string,
+    value: any,
+    expire: number = 3600 * 24 * 1,
+  ): Promise<void> {
+    try {
+      const newList = typeof value === 'string' ? value : JSON.stringify(value);
+      await RedisService.client.setEx(key, expire, newList);
+    } catch (error) {
+      console.log(error);
+    }
+  }
+
+  public async get(key: string): Promise<null> {
+    try {
+      return await RedisService.client.get(key);
+    } catch (error) {
+      throw error;
+    }
+  }
+}

package/src/session/index.ts

@@ -0,0 +1,2 @@
+export * from './interfaces';
+export * from './session.service';

package/src/session/interfaces/index.ts

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

package/src/session/interfaces/session-service.interface.ts

@@ -0,0 +1,6 @@
+import { IUserSession } from '../../interfaces/user-session.interface';
+
+export interface ISessionService {
+  retrieveUserSession(userId: string): Promise<IUserSession>;
+  setUserSession(userId: string, sessionData: IUserSession): Promise<void>;
+}

package/src/session/session.service.ts

@@ -0,0 +1,45 @@
+import { RedisService } from '../redis-client/redis.service';
+import { ISessionService } from './interfaces/session-service.interface';
+import { IUserSession } from '../interfaces/user-session.interface';
+
+export class SessionService implements ISessionService {
+  private static _RedisService: RedisService;
+
+  private constructor() {}
+
+  static async init(): Promise<SessionService> {
+    const sessionService = new SessionService();
+    SessionService._RedisService = await RedisService.init();
+    return sessionService;
+  }
+
+  async setUserSession(
+    userId: string,
+    sessionData: IUserSession,
+  ): Promise<void> {
+    try {
+      const key = `tomei-sid:${userId}`;
+      await SessionService._RedisService.set(
+        key,
+        sessionData,
+        60 * 60 * 24 * 1,
+      );
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async retrieveUserSession(userId: string): Promise<IUserSession> {
+    try {
+      const key = `tomei-sid:${userId}`;
+      const stringData = await SessionService._RedisService.get(key);
+      if (!stringData)
+        return {
+          systemLogins: [],
+        };
+      return JSON.parse(stringData);
+    } catch (error) {
+      throw error;
+    }
+  }
+}

package/tsconfig.build.json

@@ -1,5 +1,6 @@
 {
     "extends": "./tsconfig.json",
-    "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+    "include": ["**/*.ts"],
+    "exclude": ["node_modules", "__test__", "dist", "**/*spec.ts"]
   }
   

package/tsconfig.json

@@ -10,13 +10,14 @@
     "target": "es6",
     "sourceMap": true,
     "outDir": "./dist",
-    "baseUrl": "./",
+    "baseUrl": "./src",
+    "rootDir": "./",
     "incremental": true,
     "skipLibCheck": true,
-    "strictNullChecks": false,
     "noImplicitAny": false,
     "strictBindCallApply": false,
     "forceConsistentCasingInFileNames": false,
     "noFallthroughCasesInSwitch": false,
-  }
-}
+    "strictNullChecks": true,
+  },
+}