@tomei/sso 0.60.4-staging.1 → 0.61.0

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

@@ -1,75 +1,75 @@
-import { createClient } from 'redis';
-export class RedisService {
-  private static client;
-
-  private constructor() {}
-
-  static async init(client?: any): Promise<RedisService> {
-    if (!client) {
-      if (!RedisService.client) {
-        // Create a new Redis client
-        const host = process.env.REDIS_HOST;
-        const password = process.env.REDIS_PASS;
-        const port = process.env.REDIS_PORT;
-        const isProduction = process.env.REDIS_HOST.includes('windows.net');
-        const redis = isProduction ? 'rediss' : 'redis';
-        const pass = password ? `:${password}@` : '';
-        console.log(`${redis}://${pass}${host}:${port}`);
-        RedisService.client = client = createClient({
-          url: `${redis}://${pass}${host}:${port}`,
-          password: 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();
-      }
-    } else {
-      RedisService.client = client;
-    }
-    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;
-    }
-  }
-
-  public async del(key: string): Promise<void> {
-    try {
-      await RedisService.client.del(key);
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  public static async close(): Promise<void> {
-    try {
-      await RedisService.client.disconnect();
-    } catch (error) {
-      throw error;
-    }
-  }
-}
+import { createClient } from 'redis';
+export class RedisService {
+  private static client;
+
+  private constructor() {}
+
+  static async init(client?: any): Promise<RedisService> {
+    if (!client) {
+      if (!RedisService.client) {
+        // Create a new Redis client
+        const host = process.env.REDIS_HOST;
+        const password = process.env.REDIS_PASS;
+        const port = process.env.REDIS_PORT;
+        const isProduction = process.env.REDIS_HOST.includes('windows.net');
+        const redis = isProduction ? 'rediss' : 'redis';
+        const pass = password ? `:${password}@` : '';
+        console.log(`${redis}://${pass}${host}:${port}`);
+        RedisService.client = client = createClient({
+          url: `${redis}://${pass}${host}:${port}`,
+          password: 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();
+      }
+    } else {
+      RedisService.client = client;
+    }
+    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;
+    }
+  }
+
+  public async del(key: string): Promise<void> {
+    try {
+      await RedisService.client.del(key);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public static async close(): Promise<void> {
+    try {
+      await RedisService.client.disconnect();
+    } catch (error) {
+      throw error;
+    }
+  }
+}

package/src/session/index.ts

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

package/src/session/interfaces/index.ts

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

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

@@ -1,26 +1,26 @@
-import { IUserSession } from '../../interfaces/user-session.interface';
-
-export interface ISessionService {
-  retrieveUserSession(
-    userId: string,
-    sessionName: string,
-  ): Promise<IUserSession>;
-  setUserSession(
-    userId: string,
-    sessionData: IUserSession,
-    sessionName: string,
-    duration?: number,
-  ): Promise<void>;
-  refreshDuration(
-    userId: string,
-    sessionName: string,
-    duration?: number,
-  ): Promise<void>;
-  setAuthorizationCode(
-    token: string,
-    value: string,
-    expire: number,
-  ): Promise<void>;
-  retrieveAuthorizationCode(token: string): Promise<string>;
-  deleteAuthorizationCode(token: string): Promise<void>;
-}
+import { IUserSession } from '../../interfaces/user-session.interface';
+
+export interface ISessionService {
+  retrieveUserSession(
+    userId: string,
+    sessionName: string,
+  ): Promise<IUserSession>;
+  setUserSession(
+    userId: string,
+    sessionData: IUserSession,
+    sessionName: string,
+    duration?: number,
+  ): Promise<void>;
+  refreshDuration(
+    userId: string,
+    sessionName: string,
+    duration?: number,
+  ): Promise<void>;
+  setAuthorizationCode(
+    token: string,
+    value: string,
+    expire: number,
+  ): Promise<void>;
+  retrieveAuthorizationCode(token: string): Promise<string>;
+  deleteAuthorizationCode(token: string): Promise<void>;
+}

package/src/session/session.service.ts

@@ -1,96 +1,96 @@
-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 environment: string = '';
-
-  private constructor() {}
-
-  static async init(redisClient?: any): Promise<SessionService> {
-    const sessionService = new SessionService();
-    SessionService._RedisService = await RedisService.init(redisClient);
-    if (process.env.NODE_ENV == 'test') {
-      sessionService.environment = 'test:';
-    } else if (process.env.NODE_ENV == 'staging') {
-      sessionService.environment = 'staging:';
-    }
-    return sessionService;
-  }
-
-  async setUserSession(
-    userId: string,
-    sessionData: IUserSession,
-    sessionName: string = 'tomei-sid',
-    duration: number = 60 * 60, //1 hour
-  ): Promise<void> {
-    try {
-      const key = `${this.environment}${sessionName}:${userId}`;
-      await SessionService._RedisService.set(key, sessionData, duration);
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  async retrieveUserSession(
-    userId: string,
-    sessionName: string = 'tomei-sid',
-  ): Promise<IUserSession> {
-    try {
-      const key = `${this.environment}${sessionName}:${userId}`;
-      const stringData = await SessionService._RedisService.get(key);
-      if (!stringData)
-        return {
-          systemLogins: [],
-        };
-      return JSON.parse(stringData);
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  async refreshDuration(
-    userid: string,
-    sessionName: string = 'tomei-sid',
-    duration: number = 60 * 60,
-  ): Promise<void> {
-    try {
-      const userSession = await this.retrieveUserSession(userid, sessionName);
-      await this.setUserSession(userid, userSession, sessionName, duration);
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  async setAuthorizationCode(
-    token: string,
-    value: string,
-    expire: number,
-  ): Promise<void> {
-    try {
-      const key = `${this.environment}tomei-auth-code:${token}`;
-      await SessionService._RedisService.set(key, value, expire);
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  async retrieveAuthorizationCode(token: string): Promise<string> {
-    try {
-      const key = `${this.environment}tomei-auth-code:${token}`;
-      return await SessionService._RedisService.get(key);
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  async deleteAuthorizationCode(token: string): Promise<void> {
-    try {
-      const key = `${this.environment}tomei-auth-code:${token}`;
-      await SessionService._RedisService.del(key);
-    } catch (error) {
-      throw error;
-    }
-  }
-}
+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 environment: string = '';
+
+  private constructor() {}
+
+  static async init(redisClient?: any): Promise<SessionService> {
+    const sessionService = new SessionService();
+    SessionService._RedisService = await RedisService.init(redisClient);
+    if (process.env.NODE_ENV == 'test') {
+      sessionService.environment = 'test:';
+    } else if (process.env.NODE_ENV == 'staging') {
+      sessionService.environment = 'staging:';
+    }
+    return sessionService;
+  }
+
+  async setUserSession(
+    userId: string,
+    sessionData: IUserSession,
+    sessionName: string = 'tomei-sid',
+    duration: number = 60 * 60, //1 hour
+  ): Promise<void> {
+    try {
+      const key = `${this.environment}${sessionName}:${userId}`;
+      await SessionService._RedisService.set(key, sessionData, duration);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async retrieveUserSession(
+    userId: string,
+    sessionName: string = 'tomei-sid',
+  ): Promise<IUserSession> {
+    try {
+      const key = `${this.environment}${sessionName}:${userId}`;
+      const stringData = await SessionService._RedisService.get(key);
+      if (!stringData)
+        return {
+          systemLogins: [],
+        };
+      return JSON.parse(stringData);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async refreshDuration(
+    userid: string,
+    sessionName: string = 'tomei-sid',
+    duration: number = 60 * 60,
+  ): Promise<void> {
+    try {
+      const userSession = await this.retrieveUserSession(userid, sessionName);
+      await this.setUserSession(userid, userSession, sessionName, duration);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async setAuthorizationCode(
+    token: string,
+    value: string,
+    expire: number,
+  ): Promise<void> {
+    try {
+      const key = `${this.environment}tomei-auth-code:${token}`;
+      await SessionService._RedisService.set(key, value, expire);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async retrieveAuthorizationCode(token: string): Promise<string> {
+    try {
+      const key = `${this.environment}tomei-auth-code:${token}`;
+      return await SessionService._RedisService.get(key);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async deleteAuthorizationCode(token: string): Promise<void> {
+    try {
+      const key = `${this.environment}tomei-auth-code:${token}`;
+      await SessionService._RedisService.del(key);
+    } catch (error) {
+      throw error;
+    }
+  }
+}

package/src/types/auth-context.ts

@@ -1,10 +1,10 @@
-import { IAPIKeyAttr } from '../interfaces/api-key-attr.interface';
-import { LoginUser } from '../components/login-user/login-user';
-
-export type AuthContext =
-  | {
-      loginUser: LoginUser;
-    }
-  | {
-      apiKey: IAPIKeyAttr;
-    };
+import { IAPIKeyAttr } from '../interfaces/api-key-attr.interface';
+import { LoginUser } from '../components/login-user/login-user';
+
+export type AuthContext =
+  | {
+      loginUser: LoginUser;
+    }
+  | {
+      apiKey: IAPIKeyAttr;
+    };

package/src/types/index.ts

@@ -1 +1 @@
-export * from './auth-context';
+export * from './auth-context';

package/tsconfig.build.json

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

package/tsconfig.json

@@ -1,24 +1,24 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "declaration": true,
-    "removeComments": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "allowSyntheticDefaultImports": true,
-    "moduleResolution": "node",
-    "target": "es6",
-    "sourceMap": true,
-    "outDir": "./dist",
-    "baseUrl": "./src",
-    "rootDir": "./",
-    "incremental": true,
-    "skipLibCheck": true,
-    "noImplicitAny": false,
-    "strictBindCallApply": false,
-    "forceConsistentCasingInFileNames": false,
-    "noFallthroughCasesInSwitch": false,
-    "strictNullChecks": false,
-  },
-  "exclude": ["node_modules", "dist"]
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "moduleResolution": "node",
+    "target": "es6",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./src",
+    "rootDir": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false,
+    "strictNullChecks": false,
+  },
+  "exclude": ["node_modules", "dist"]
 }