node-server-engine 1.1.2 → 1.1.4

package/src/entities/Redis/Redis.ts

@@ -1,71 +1,71 @@
-import { Redis as RedisClient } from 'ioredis';
-import { RedisInterface, RedisCreateOptions } from './Redis.types';
-import { validateRedisEnvironment } from './Redis.validate';
-import { EngineError } from 'entities/EngineError';
-import { LifecycleController } from 'entities/LifecycleController';
-
-export let redisClient: undefined | RedisClient;
-
-/**
- * We use a proxy to extend the Redis behavior and allow initialization of the client only when needed while keeping the same interface
- */
-export const Redis = new Proxy<RedisInterface>(
-  // Due to how we do the proxying, we are forced to ignore ts-errors, we could never create an object that respects the interface properly
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  {},
-  {
-    get: function (target, property): unknown {
-      if (property === 'init') return init;
-      if (property === 'shutdown') return shutdown;
-      // Create the redis client if it does not exist
-      if (!redisClient)
-        throw new EngineError({ message: 'Redis client was not initialized' });
-      // Call the function on the redis client
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      return redisClient[property] as unknown;
-    }
-  }
-);
-
-/**
- * On init create client anc connect
- */
-export function init(): void {
-  // Ignore if already initialized
-  if (redisClient) return;
-  redisClient = createRedisClient();
-  LifecycleController.register(Redis);
-}
-
-/**
- * On shutdown close connection and clear client
- */
-export async function shutdown(): Promise<void> {
-  if (redisClient) await redisClient.quit();
-  redisClient = undefined;
-}
-
-/**
- * Create Redis client
- */
-export function createRedisClient(
-  options: RedisCreateOptions = {}
-): RedisClient {
-  // Check that environment variables are correctly set
-  validateRedisEnvironment(options);
-  // Throw an error if there is no host initial
-  if (!process.env.REDIS_HOST)
-    throw new EngineError({
-      message: 'Host required to initialize Redis connection'
-    });
-
-  return new RedisClient({
-    port: process.env.REDIS_PORT ? parseInt(process.env.REDIS_PORT) : undefined,
-    host: process.env.REDIS_HOST,
-    username: process.env.REDIS_USERNAME,
-    password: process.env.REDIS_PASSWORD,
-    db: 0
-  });
-}
+import { Redis as RedisClient } from 'ioredis';
+import { RedisInterface, RedisCreateOptions } from './Redis.types';
+import { validateRedisEnvironment } from './Redis.validate';
+import { EngineError } from 'entities/EngineError';
+import { LifecycleController } from 'entities/LifecycleController';
+
+export let redisClient: undefined | RedisClient;
+
+/**
+ * We use a proxy to extend the Redis behavior and allow initialization of the client only when needed while keeping the same interface
+ */
+export const Redis = new Proxy<RedisInterface>(
+  // Due to how we do the proxying, we are forced to ignore ts-errors, we could never create an object that respects the interface properly
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  {},
+  {
+    get: function (target, property): unknown {
+      if (property === 'init') return init;
+      if (property === 'shutdown') return shutdown;
+      // Create the redis client if it does not exist
+      if (!redisClient)
+        throw new EngineError({ message: 'Redis client was not initialized' });
+      // Call the function on the redis client
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      return redisClient[property] as unknown;
+    }
+  }
+);
+
+/**
+ * On init create client anc connect
+ */
+export function init(): void {
+  // Ignore if already initialized
+  if (redisClient) return;
+  redisClient = createRedisClient();
+  LifecycleController.register(Redis);
+}
+
+/**
+ * On shutdown close connection and clear client
+ */
+export async function shutdown(): Promise<void> {
+  if (redisClient) await redisClient.quit();
+  redisClient = undefined;
+}
+
+/**
+ * Create Redis client
+ */
+export function createRedisClient(
+  options: RedisCreateOptions = {}
+): RedisClient {
+  // Check that environment variables are correctly set
+  validateRedisEnvironment(options);
+  // Throw an error if there is no host initial
+  if (!process.env.REDIS_HOST)
+    throw new EngineError({
+      message: 'Host required to initialize Redis connection'
+    });
+
+  return new RedisClient({
+    port: process.env.REDIS_PORT ? parseInt(process.env.REDIS_PORT) : undefined,
+    host: process.env.REDIS_HOST,
+    username: process.env.REDIS_USERNAME,
+    password: process.env.REDIS_PASSWORD,
+    db: 0
+  });
+}

package/src/entities/Redis/Redis.types.ts

@@ -1,19 +1,19 @@
-import { Redis as IoRedis, Cluster, RedisOptions } from 'ioredis';
-
-export type RedisInterface = IoRedis &
-  Cluster & {
-    /** Start the redis service */
-    init: () => void;
-    /** Stop the redis service */
-    shutdown: () => Promise<void>;
-  };
-
-/** Options to initialize a Redis client */
-export interface RedisCreateOptions {
-  /** Redis client settings */
-  redis?: RedisOptions;
-  /** Should the client perform readiness check when establishing the connection */
-  enableReadyCheck?: boolean;
-  /** Cluster mode read operation settings, can make reads on masters, slaves, or both */
-  scaleReads?: string;
-}
+import { Redis as IoRedis, Cluster, RedisOptions } from 'ioredis';
+
+export type RedisInterface = IoRedis &
+  Cluster & {
+    /** Start the redis service */
+    init: () => void;
+    /** Stop the redis service */
+    shutdown: () => Promise<void>;
+  };
+
+/** Options to initialize a Redis client */
+export interface RedisCreateOptions {
+  /** Redis client settings */
+  redis?: RedisOptions;
+  /** Should the client perform readiness check when establishing the connection */
+  enableReadyCheck?: boolean;
+  /** Cluster mode read operation settings, can make reads on masters, slaves, or both */
+  scaleReads?: string;
+}

package/src/entities/Redis/Redis.validate.ts

@@ -1,17 +1,17 @@
-import { RedisCreateOptions } from './Redis.types';
-import { EngineError } from 'entities/EngineError';
-
-/**
- * Verify that the environment variables to connect to a Redis server are properly set
- */
-export function validateRedisEnvironment(options: RedisCreateOptions): void {
-  const host = process.env.REDIS_HOST ?? options.redis?.host;
-  if (typeof host !== 'string')
-    throw new EngineError({ message: 'No host specified for Redis instance' });
-
-  const port = process.env.REDIS_PORT
-    ? parseInt(process.env.REDIS_PORT)
-    : options.redis?.port;
-  if (typeof port !== 'number')
-    throw new EngineError({ message: 'No port specified for Redis instance' });
-}
+import { RedisCreateOptions } from './Redis.types';
+import { EngineError } from 'entities/EngineError';
+
+/**
+ * Verify that the environment variables to connect to a Redis server are properly set
+ */
+export function validateRedisEnvironment(options: RedisCreateOptions): void {
+  const host = process.env.REDIS_HOST ?? options.redis?.host;
+  if (typeof host !== 'string')
+    throw new EngineError({ message: 'No host specified for Redis instance' });
+
+  const port = process.env.REDIS_PORT
+    ? parseInt(process.env.REDIS_PORT)
+    : options.redis?.port;
+  if (typeof port !== 'number')
+    throw new EngineError({ message: 'No port specified for Redis instance' });
+}

package/src/entities/Redis/index.ts

@@ -1,2 +1,2 @@
-export { Redis, createRedisClient } from './Redis';
-export * from './Redis.types';
+export { Redis, createRedisClient } from './Redis';
+export * from './Redis.types';

package/src/entities/Sequelize/Sequelize.config.ts

@@ -1,29 +1,59 @@
-import { Options, Dialect } from 'sequelize';
-import { validateSequelizeEnvironment } from './Sequelize.validate';
-
-// Check that environment variables are correctly set
-validateSequelizeEnvironment();
-
-const config: Options = {
-  username: process.env.SQL_USER,
-  password: process.env.SQL_PASSWORD,
-  database: process.env.SQL_DB,
-  host: process.env.SQL_HOST,
-  port: process.env.SQL_PORT ? parseInt(process.env.SQL_PORT) : 5432,
-  dialect: (process.env.SQL_TYPE ?? 'postgres') as Dialect,
-  logging: false,
-  define: {
-    freezeTableName: false,
-    charset: 'utf8mb4',
-    collate: 'utf8mb4_unicode_ci'
-  },
-  retry: {
-    max: 5
-  }
-};
-
-export const development = config;
-export const staging = config;
-export const production = config;
-export const test = config;
-export default config;
+import { Options, Dialect } from 'sequelize';
+import { validateSequelizeEnvironment } from './Sequelize.validate';
+
+// Check that environment variables are correctly set
+validateSequelizeEnvironment();
+
+const config: Options = {
+  username: process.env.SQL_USER,
+  password: process.env.SQL_PASSWORD,
+  database: process.env.SQL_DB,
+  host: process.env.SQL_HOST,
+  port: process.env.SQL_PORT ? parseInt(process.env.SQL_PORT) : 5432, // Default port for PostgreSQL
+  dialect: (process.env.SQL_TYPE ?? 'postgres') as Dialect, // Dynamically set the dialect (postgres, mysql, mssql)
+  logging: false, // Set to true for debugging SQL queries
+  define: {
+    freezeTableName: false, // Prevent automatic pluralization of table names
+    charset: 'utf8mb4', // Set character set for MySQL/MariaDB
+    collate: 'utf8mb4_unicode_ci' // Set collation for MySQL/MariaDB
+  },
+  retry: {
+    max: 5 // Maximum retry attempts for failed queries
+  },
+  dialectOptions: {},
+  pool: {
+    max: 5,
+    min: 0,
+    acquire: 30000, // Maximum time to wait for a connection
+    idle: 10000 // Maximum idle time for connections
+  },
+};
+
+// Additional configurations for MSSQL
+if (config.dialect === 'mssql') {
+  config.dialectOptions = {
+    requestTimeout: 30000, // Increase request timeout for MSSQL
+    connectTimeout: 30000, // Increase connection timeout for MSSQL
+    encrypt: true, // Use encryption for MSSQL (set to false if not needed)
+    trustServerCertificate: true, // Set to true if using self-signed certificates
+  };
+}
+
+// Add specific dialect configurations if necessary for MySQL/PostgreSQL
+if (config.dialect === 'mysql') {
+  config.dialectOptions = {
+    timezone: 'Z', // Set timezone for MySQL
+  };
+}
+
+if (config.dialect === 'postgres') {
+  config.dialectOptions = {
+    ssl: process.env.PG_SSL === 'true' ? { rejectUnauthorized: false } : false, // SSL options for PostgreSQL (if required)
+  };
+}
+
+export const development = config;
+export const staging = config;
+export const production = config;
+export const test = config;
+export default config;

package/src/entities/Sequelize/Sequelize.test.ts

@@ -1,21 +1,21 @@
-import { expect } from 'chai';
-import { validateSequelizeEnvironment } from './Sequelize.validate';
-
-describe('Entity - Sequelize', () => {
-  it('Should validate process env if needed', () => {
-    process.env.SQL_HOST = '127.0.0.1';
-    process.env.SQL_PORT = '5423';
-    process.env.SQL_PASSWORD = 'password';
-    process.env.SQL_DB = 'db';
-    process.env.SQL_USER = 'sql';
-    expect(validateSequelizeEnvironment).not.to.throw();
-  });
-
-  it('Should allow only required variables', () => {
-    process.env.SQL_HOST = '127.0.0.1';
-    process.env.SQL_PASSWORD = 'password';
-    process.env.SQL_DB = 'db';
-    process.env.SQL_USER = 'sql';
-    expect(validateSequelizeEnvironment).not.to.throw();
-  });
-});
+import { expect } from 'chai';
+import { validateSequelizeEnvironment } from './Sequelize.validate';
+
+describe('Entity - Sequelize', () => {
+  it('Should validate process env if needed', () => {
+    process.env.SQL_HOST = '127.0.0.1';
+    process.env.SQL_PORT = '5423';
+    process.env.SQL_PASSWORD = 'password';
+    process.env.SQL_DB = 'db';
+    process.env.SQL_USER = 'sql';
+    expect(validateSequelizeEnvironment).not.to.throw();
+  });
+
+  it('Should allow only required variables', () => {
+    process.env.SQL_HOST = '127.0.0.1';
+    process.env.SQL_PASSWORD = 'password';
+    process.env.SQL_DB = 'db';
+    process.env.SQL_USER = 'sql';
+    expect(validateSequelizeEnvironment).not.to.throw();
+  });
+});

package/src/entities/Sequelize/Sequelize.ts

@@ -1,75 +1,75 @@
-import { Sequelize, ModelCtor } from 'sequelize-typescript';
-import dbConfig from './Sequelize.config';
-import { Sequelize as SequelizeInterface } from './Sequelize.types';
-import { validateSequelizeEnvironment } from './Sequelize.validate';
-import { EngineError } from 'entities/EngineError';
-import { LifecycleController } from 'entities/LifecycleController';
-
-export let sequelizeClient: undefined | Sequelize;
-
-/**
- * We use a proxy to extend the Sequelize behavior and allow initialization of the client only when needed while keeping the same interface
- */
-export const sequelize = new Proxy<SequelizeInterface>(
-  // Due to how we do the proxying, we are forced to ignore ts-errors, we could never create an object that respects the interface properly
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  {},
-  {
-    get: function (target, property): unknown {
-      if (property === 'init') return init;
-      if (property === 'shutdown') return shutdown;
-      if (property === 'addModels') return addModels;
-      // Create the sequelize client if it does not exist
-      if (!sequelizeClient)
-        throw new EngineError({
-          message: 'Sequelize client was not initialized'
-        });
-      // Call the function on the sequelize client
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      return sequelizeClient[property] as unknown;
-    }
-  }
-);
-
-/** On init create client and connect */
-export function init(): void {
-  // Ignore if already initialized
-  if (sequelizeClient) return;
-  sequelizeClient = createSequelizeClient();
-  sequelizeClient
-    .authenticate()
-    .then(() => console.log('Connected to MySQL database.'))
-    .catch((err: Error) =>
-      console.error('Unable to connect to the database:', err)
-    );
-  LifecycleController.register(sequelize);
-}
-
-/** On shutdown close connection and clear client */
-export async function shutdown(): Promise<void> {
-  if (sequelizeClient) await sequelizeClient.close();
-  sequelizeClient = undefined;
-}
-
-export function addModels(models: Array<ModelCtor>): void {
-  if (!sequelizeClient)
-    throw new EngineError({
-      message: 'Sequelize client was not initialized'
-    });
-  sequelizeClient.addModels(models);
-  sequelizeClient.sync();
-}
-
-/** Create Sequelize client */
-export function createSequelizeClient(): Sequelize {
-  // Throw an error if there is no host initial
-  validateSequelizeEnvironment();
-  return new Sequelize(
-    process.env.SQL_DB as string,
-    process.env.SQL_USER as string,
-    process.env.SQL_PASSWORD as string,
-    dbConfig
-  );
-}
+import { Sequelize, ModelCtor } from 'sequelize-typescript';
+import dbConfig from './Sequelize.config';
+import { Sequelize as SequelizeInterface } from './Sequelize.types';
+import { validateSequelizeEnvironment } from './Sequelize.validate';
+import { EngineError } from 'entities/EngineError';
+import { LifecycleController } from 'entities/LifecycleController';
+
+export let sequelizeClient: undefined | Sequelize;
+
+/**
+ * We use a proxy to extend the Sequelize behavior and allow initialization of the client only when needed while keeping the same interface
+ */
+export const sequelize = new Proxy<SequelizeInterface>(
+  // Due to how we do the proxying, we are forced to ignore ts-errors, we could never create an object that respects the interface properly
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  {},
+  {
+    get: function (target, property): unknown {
+      if (property === 'init') return init;
+      if (property === 'shutdown') return shutdown;
+      if (property === 'addModels') return addModels;
+      // Create the sequelize client if it does not exist
+      if (!sequelizeClient)
+        throw new EngineError({
+          message: 'Sequelize client was not initialized'
+        });
+      // Call the function on the sequelize client
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      return sequelizeClient[property] as unknown;
+    }
+  }
+);
+
+/** On init create client and connect */
+export function init(): void {
+  // Ignore if already initialized
+  if (sequelizeClient) return;
+  sequelizeClient = createSequelizeClient();
+  sequelizeClient
+    .authenticate()
+    .then(() => console.log('Connected to database.'))
+    .catch((err: Error) =>
+      console.error('Unable to connect to the database:', err)
+    );
+  LifecycleController.register(sequelize);
+}
+
+/** On shutdown close connection and clear client */
+export async function shutdown(): Promise<void> {
+  if (sequelizeClient) await sequelizeClient.close();
+  sequelizeClient = undefined;
+}
+
+export function addModels(models: Array<ModelCtor>): void {
+  if (!sequelizeClient)
+    throw new EngineError({
+      message: 'Sequelize client was not initialized'
+    });
+  sequelizeClient.addModels(models);
+  sequelizeClient.sync();
+}
+
+/** Create Sequelize client */
+export function createSequelizeClient(): Sequelize {
+  // Throw an error if there is no host initial
+  validateSequelizeEnvironment();
+  return new Sequelize(
+    process.env.SQL_DB as string,
+    process.env.SQL_USER as string,
+    process.env.SQL_PASSWORD as string,
+    dbConfig
+  );
+}

package/src/entities/Sequelize/Sequelize.types.ts

@@ -1,10 +1,10 @@
-import { Sequelize as SequelizeClass, ModelCtor } from 'sequelize-typescript';
-
-export type Sequelize = SequelizeClass & {
-  /** Start the sequelize service */
-  init: () => void;
-  /** Stop the sequelize service */
-  shutdown: () => Promise<void>;
-  /** Register a model with sequelize */
-  addModels: (models: Array<ModelCtor>) => void;
-};
+import { Sequelize as SequelizeClass, ModelCtor } from 'sequelize-typescript';
+
+export type Sequelize = SequelizeClass & {
+  /** Start the sequelize service */
+  init: () => void;
+  /** Stop the sequelize service */
+  shutdown: () => Promise<void>;
+  /** Register a model with sequelize */
+  addModels: (models: Array<ModelCtor>) => void;
+};

package/src/entities/Sequelize/Sequelize.validate.ts

@@ -1,15 +1,15 @@
-import { assertEnvironment } from 'utils/checkEnvironment';
-import { envAssert } from 'utils/envAssert';
-
-/**
- * Verify that the environment variables to connect to a SQL server are properly set
- */
-export function validateSequelizeEnvironment(): void {
-  // We only check if there is at least the host specified
-  if (process.env.SQL_HOST) assertEnvironment({ SQL_HOST: envAssert.isHost() });
-  if (process.env.SQL_PASSWORD)
-    assertEnvironment({ SQL_PASSWORD: envAssert.isString() });
-  if (process.env.SQL_DB) assertEnvironment({ SQL_DB: envAssert.isString() });
-  if (process.env.SQL_USER)
-    assertEnvironment({ SQL_USER: envAssert.isString() });
-}
+import { assertEnvironment } from 'utils/checkEnvironment';
+import { envAssert } from 'utils/envAssert';
+
+/**
+ * Verify that the environment variables to connect to a SQL server are properly set
+ */
+export function validateSequelizeEnvironment(): void {
+  // We only check if there is at least the host specified
+  if (process.env.SQL_HOST) assertEnvironment({ SQL_HOST: envAssert.isHost() });
+  if (process.env.SQL_PASSWORD)
+    assertEnvironment({ SQL_PASSWORD: envAssert.isString() });
+  if (process.env.SQL_DB) assertEnvironment({ SQL_DB: envAssert.isString() });
+  if (process.env.SQL_USER)
+    assertEnvironment({ SQL_USER: envAssert.isString() });
+}

package/src/entities/Sequelize/index.ts

@@ -1,2 +1,2 @@
-export { sequelize } from './Sequelize';
-export * from './Sequelize.types';
+export { sequelize } from './Sequelize';
+export * from './Sequelize.types';