@tomei/sso 0.61.0 → 0.61.1

package/src/models/user.entity.ts

@@ -1,193 +1,193 @@
-import {
-  BelongsTo,
-  BelongsToMany,
-  Column,
-  CreatedAt,
-  DataType,
-  ForeignKey,
-  HasMany,
-  HasOne,
-  Model,
-  Table,
-  UpdatedAt,
-} from 'sequelize-typescript';
-import Staff from './staff.entity';
-import { YN } from '../enum/yn.enum';
-import { UserStatus } from '../enum/user-status.enum';
-import UserSystemAccessModel from './user-system-access.entity';
-import UserPrivilegeModel from './user-privilege.entity';
-import UserGroupModel from './user-group.entity';
-import UserObjectPrivilegeModel from './user-object-privilege.entity';
-
-@Table({
-  tableName: 'sso_User',
-  timestamps: true,
-  createdAt: 'CreatedAt',
-  updatedAt: 'UpdatedAt',
-})
-export default class User extends Model {
-  @Column({
-    primaryKey: true,
-    allowNull: false,
-    autoIncrement: true,
-    type: DataType.INTEGER,
-  })
-  UserId: number;
-
-  @Column({
-    allowNull: true,
-    type: DataType.STRING,
-  })
-  UserName: string;
-
-  @Column({
-    allowNull: false,
-    type: DataType.STRING,
-  })
-  Email: string;
-
-  @Column({
-    allowNull: false,
-    type: DataType.STRING,
-  })
-  Password: string;
-
-  @Column({
-    allowNull: true,
-    type: DataType.STRING,
-  })
-  FullName: string;
-
-  @Column({
-    allowNull: true,
-    type: DataType.STRING,
-  })
-  IdNo: string;
-
-  @Column({
-    allowNull: true,
-    type: DataType.STRING,
-  })
-  IdType: string;
-
-  @Column({
-    allowNull: true,
-    type: DataType.STRING,
-  })
-  ContactNo: string;
-
-  @Column({
-    allowNull: false,
-    type: DataType.STRING,
-  })
-  Status: UserStatus;
-
-  @Column({
-    allowNull: false,
-    type: DataType.CHAR(1),
-  })
-  DefaultPasswordChangedYN: YN;
-
-  @Column({
-    type: DataType.DATE,
-  })
-  FirstLoginAt: Date;
-
-  @Column({
-    type: DataType.DATE,
-  })
-  LastLoginAt: Date;
-
-  @Column({
-    type: DataType.TINYINT,
-  })
-  MFAEnabled: number;
-
-  @Column({
-    type: DataType.TEXT,
-  })
-  MFAConfig: string;
-
-  @Column({
-    type: DataType.STRING,
-  })
-  RecoveryEmail: string;
-
-  @Column({
-    allowNull: false,
-    type: DataType.INTEGER,
-  })
-  FailedLoginAttemptCount: number;
-
-  @Column({
-    type: DataType.DATE,
-  })
-  LastFailedLoginAt: Date;
-
-  @Column({
-    type: DataType.DATE,
-  })
-  LastPasswordChangedAt: Date;
-
-  @Column({
-    allowNull: false,
-    type: DataType.CHAR(1),
-  })
-  NeedToChangePasswordYN: YN;
-
-  @Column({
-    allowNull: true,
-    type: DataType.STRING,
-  })
-  PasscodeHash: string;
-
-  @Column({
-    type: DataType.DATE,
-  })
-  PasscodeUpdatedAt: Date;
-
-  @ForeignKey(() => User)
-  @Column({
-    type: DataType.INTEGER,
-  })
-  CreatedById: number;
-
-  @CreatedAt
-  CreatedAt: Date;
-
-  @ForeignKey(() => User)
-  @Column({
-    type: DataType.INTEGER,
-  })
-  UpdatedById: number;
-
-  @UpdatedAt
-  UpdatedAt: Date;
-
-  @HasOne(() => Staff, 'UserId')
-  Staff: Staff;
-
-  @HasMany(() => UserGroupModel, 'UserId')
-  UserGroups: UserGroupModel[];
-
-  @HasMany(() => UserSystemAccessModel)
-  UserSystemAccesses: UserSystemAccessModel[];
-
-  @HasMany(() => UserPrivilegeModel)
-  UserPrivileges: UserPrivilegeModel[];
-
-  @HasMany(() => UserObjectPrivilegeModel)
-  UserObjectPrivileges: UserObjectPrivilegeModel[];
-
-  @BelongsTo(() => User, {
-    as: 'CreatedBy',
-    foreignKey: 'CreatedById',
-  })
-  CreatedBy: User;
-
-  @BelongsTo(() => User, {
-    as: 'UpdatedBy',
-    foreignKey: 'UpdatedById',
-  })
-  UpdatedBy: User;
-}
+import {
+  BelongsTo,
+  BelongsToMany,
+  Column,
+  CreatedAt,
+  DataType,
+  ForeignKey,
+  HasMany,
+  HasOne,
+  Model,
+  Table,
+  UpdatedAt,
+} from 'sequelize-typescript';
+import Staff from './staff.entity';
+import { YN } from '../enum/yn.enum';
+import { UserStatus } from '../enum/user-status.enum';
+import UserSystemAccessModel from './user-system-access.entity';
+import UserPrivilegeModel from './user-privilege.entity';
+import UserGroupModel from './user-group.entity';
+import UserObjectPrivilegeModel from './user-object-privilege.entity';
+
+@Table({
+  tableName: 'sso_User',
+  timestamps: true,
+  createdAt: 'CreatedAt',
+  updatedAt: 'UpdatedAt',
+})
+export default class User extends Model {
+  @Column({
+    primaryKey: true,
+    allowNull: false,
+    autoIncrement: true,
+    type: DataType.INTEGER,
+  })
+  UserId: number;
+
+  @Column({
+    allowNull: true,
+    type: DataType.STRING,
+  })
+  UserName: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING,
+  })
+  Email: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING,
+  })
+  Password: string;
+
+  @Column({
+    allowNull: true,
+    type: DataType.STRING,
+  })
+  FullName: string;
+
+  @Column({
+    allowNull: true,
+    type: DataType.STRING,
+  })
+  IdNo: string;
+
+  @Column({
+    allowNull: true,
+    type: DataType.STRING,
+  })
+  IdType: string;
+
+  @Column({
+    allowNull: true,
+    type: DataType.STRING,
+  })
+  ContactNo: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING,
+  })
+  Status: UserStatus;
+
+  @Column({
+    allowNull: false,
+    type: DataType.CHAR(1),
+  })
+  DefaultPasswordChangedYN: YN;
+
+  @Column({
+    type: DataType.DATE,
+  })
+  FirstLoginAt: Date;
+
+  @Column({
+    type: DataType.DATE,
+  })
+  LastLoginAt: Date;
+
+  @Column({
+    type: DataType.TINYINT,
+  })
+  MFAEnabled: number;
+
+  @Column({
+    type: DataType.TEXT,
+  })
+  MFAConfig: string;
+
+  @Column({
+    type: DataType.STRING,
+  })
+  RecoveryEmail: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.INTEGER,
+  })
+  FailedLoginAttemptCount: number;
+
+  @Column({
+    type: DataType.DATE,
+  })
+  LastFailedLoginAt: Date;
+
+  @Column({
+    type: DataType.DATE,
+  })
+  LastPasswordChangedAt: Date;
+
+  @Column({
+    allowNull: false,
+    type: DataType.CHAR(1),
+  })
+  NeedToChangePasswordYN: YN;
+
+  @Column({
+    allowNull: true,
+    type: DataType.STRING,
+  })
+  PasscodeHash: string;
+
+  @Column({
+    type: DataType.DATE,
+  })
+  PasscodeUpdatedAt: Date;
+
+  @ForeignKey(() => User)
+  @Column({
+    type: DataType.INTEGER,
+  })
+  CreatedById: number;
+
+  @CreatedAt
+  CreatedAt: Date;
+
+  @ForeignKey(() => User)
+  @Column({
+    type: DataType.INTEGER,
+  })
+  UpdatedById: number;
+
+  @UpdatedAt
+  UpdatedAt: Date;
+
+  @HasOne(() => Staff, 'UserId')
+  Staff: Staff;
+
+  @HasMany(() => UserGroupModel, 'UserId')
+  UserGroups: UserGroupModel[];
+
+  @HasMany(() => UserSystemAccessModel)
+  UserSystemAccesses: UserSystemAccessModel[];
+
+  @HasMany(() => UserPrivilegeModel)
+  UserPrivileges: UserPrivilegeModel[];
+
+  @HasMany(() => UserObjectPrivilegeModel)
+  UserObjectPrivileges: UserObjectPrivilegeModel[];
+
+  @BelongsTo(() => User, {
+    as: 'CreatedBy',
+    foreignKey: 'CreatedById',
+  })
+  CreatedBy: User;
+
+  @BelongsTo(() => User, {
+    as: 'UpdatedBy',
+    foreignKey: 'UpdatedById',
+  })
+  UpdatedBy: User;
+}

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

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

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

@@ -1,28 +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 };
+/* 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

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

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>;
+}