mm-share-lib 0.0.4 → 0.0.5

package/src/lib/search-engine/typesense/typesense.module.test.ts

@@ -1,94 +1,94 @@
-/* eslint-disable max-classes-per-file */
-
-import { Module }                   from '@nestjs/common'
-import { Test }                     from '@nestjs/testing'
-
-import { TypesenseModuleOptions }   from './typesense-module.interface'
-import { TYPESENSE_MODULE_OPTIONS } from './typesense.constants'
-import { TypesenseModule }          from './typesense.module'
-
-describe('typesense', () => {
-  describe('module', () => {
-    let module
-
-    afterEach(async () => {
-      await module.close()
-    })
-
-    it(`register`, async () => {
-      module = await Test.createTestingModule({
-        imports: [
-          TypesenseModule.register({
-            apiKey: 'test',
-          }),
-        ],
-      }).compile()
-
-      expect(module.get(TYPESENSE_MODULE_OPTIONS)).toBeDefined()
-    })
-
-    it(`register async use factory`, async () => {
-      module = await Test.createTestingModule({
-        imports: [
-          TypesenseModule.registerAsync({
-            useFactory: () => ({
-              apiKey: 'test',
-            }),
-          }),
-        ],
-      }).compile()
-
-      expect(module.get(TYPESENSE_MODULE_OPTIONS)).toBeDefined()
-    })
-
-    it(`register async use class`, async () => {
-      class TestTypesenseModuleOptions {
-        createTypesenseOptions(): TypesenseModuleOptions {
-          return {
-            apiKey: 'test',
-          }
-        }
-      }
-
-      module = await Test.createTestingModule({
-        imports: [
-          TypesenseModule.registerAsync({
-            useClass: TestTypesenseModuleOptions,
-          }),
-        ],
-      }).compile()
-
-      expect(module.get(TYPESENSE_MODULE_OPTIONS)).toBeDefined()
-    })
-
-    it(`register async use exists`, async () => {
-      class TestTypesenseModuleOptions {
-        createTypesenseOptions(): TypesenseModuleOptions {
-          return {
-            apiKey: 'test',
-          }
-        }
-      }
-
-      @Module({})
-      class TestTypesenseModule {}
-
-      module = await Test.createTestingModule({
-        imports: [
-          TypesenseModule.registerAsync({
-            imports: [
-              {
-                module: TestTypesenseModule,
-                providers: [TestTypesenseModuleOptions],
-                exports: [TestTypesenseModuleOptions],
-              },
-            ],
-            useExisting: TestTypesenseModuleOptions,
-          }),
-        ],
-      }).compile()
-
-      expect(module.get(TYPESENSE_MODULE_OPTIONS)).toBeDefined()
-    })
-  })
-})
+/* eslint-disable max-classes-per-file */
+
+import { Module }                   from '@nestjs/common'
+import { Test }                     from '@nestjs/testing'
+
+import { TypesenseModuleOptions }   from './typesense-module.interface'
+import { TYPESENSE_MODULE_OPTIONS } from './typesense.constants'
+import { TypesenseModule }          from './typesense.module'
+
+describe('typesense', () => {
+  describe('module', () => {
+    let module
+
+    afterEach(async () => {
+      await module.close()
+    })
+
+    it(`register`, async () => {
+      module = await Test.createTestingModule({
+        imports: [
+          TypesenseModule.register({
+            apiKey: 'test',
+          }),
+        ],
+      }).compile()
+
+      expect(module.get(TYPESENSE_MODULE_OPTIONS)).toBeDefined()
+    })
+
+    it(`register async use factory`, async () => {
+      module = await Test.createTestingModule({
+        imports: [
+          TypesenseModule.registerAsync({
+            useFactory: () => ({
+              apiKey: 'test',
+            }),
+          }),
+        ],
+      }).compile()
+
+      expect(module.get(TYPESENSE_MODULE_OPTIONS)).toBeDefined()
+    })
+
+    it(`register async use class`, async () => {
+      class TestTypesenseModuleOptions {
+        createTypesenseOptions(): TypesenseModuleOptions {
+          return {
+            apiKey: 'test',
+          }
+        }
+      }
+
+      module = await Test.createTestingModule({
+        imports: [
+          TypesenseModule.registerAsync({
+            useClass: TestTypesenseModuleOptions,
+          }),
+        ],
+      }).compile()
+
+      expect(module.get(TYPESENSE_MODULE_OPTIONS)).toBeDefined()
+    })
+
+    it(`register async use exists`, async () => {
+      class TestTypesenseModuleOptions {
+        createTypesenseOptions(): TypesenseModuleOptions {
+          return {
+            apiKey: 'test',
+          }
+        }
+      }
+
+      @Module({})
+      class TestTypesenseModule {}
+
+      module = await Test.createTestingModule({
+        imports: [
+          TypesenseModule.registerAsync({
+            imports: [
+              {
+                module: TestTypesenseModule,
+                providers: [TestTypesenseModuleOptions],
+                exports: [TestTypesenseModuleOptions],
+              },
+            ],
+            useExisting: TestTypesenseModuleOptions,
+          }),
+        ],
+      }).compile()
+
+      expect(module.get(TYPESENSE_MODULE_OPTIONS)).toBeDefined()
+    })
+  })
+})

package/src/lib/search-engine/typesense/typesense.module.ts

@@ -1,76 +1,76 @@
-import { DynamicModule, Module, Provider } from '@nestjs/common';
-import { DiscoveryModule } from '@nestjs/core';
-import {
-  TypesenseModuleAsyncOptions,
-  TypesenseOptionsFactory,
-  TypesenseModuleOptions,
-} from './typesense-module.interface';
-import { TYPESENSE_MODULE_OPTIONS } from './typesense.constants';
-import {
-  createTypesenseExportsProvider,
-  createTypesenseOptionsProvider,
-} from './typesense.providers';
-
-@Module({
-  imports: [DiscoveryModule],
-})
-export class TypesenseModule {
-  static register(options: TypesenseModuleOptions = {}): DynamicModule {
-    const optionsProviders = createTypesenseOptionsProvider(options);
-    const exportsProviders = createTypesenseExportsProvider();
-
-    return {
-      global: true,
-      module: TypesenseModule,
-      providers: [...optionsProviders, ...exportsProviders],
-      exports: exportsProviders,
-    };
-  }
-
-  static registerAsync(options: TypesenseModuleAsyncOptions): DynamicModule {
-    const exportsProviders = createTypesenseExportsProvider();
-
-    return {
-      global: true,
-      module: TypesenseModule,
-      imports: options.imports || [],
-      providers: [...this.createAsyncProviders(options), ...exportsProviders],
-      exports: exportsProviders,
-    };
-  }
-
-  private static createAsyncProviders(
-    options: TypesenseModuleAsyncOptions,
-  ): Provider[] {
-    if (options.useExisting || options.useFactory) {
-      return [this.createAsyncOptionsProvider(options)];
-    }
-
-    return [
-      this.createAsyncOptionsProvider(options),
-      {
-        provide: options?.useClass,
-        useClass: options?.useClass,
-      },
-    ];
-  }
-
-  private static createAsyncOptionsProvider(
-    options: TypesenseModuleAsyncOptions,
-  ): Provider {
-    if (options.useFactory) {
-      return {
-        provide: TYPESENSE_MODULE_OPTIONS,
-        useFactory: options.useFactory,
-        inject: options.inject || [],
-      };
-    }
-
-    return {
-      provide: TYPESENSE_MODULE_OPTIONS,
-      useFactory: (optionsFactory: TypesenseOptionsFactory) =>
-        optionsFactory.createTypesenseOptions(),
-      inject: [options?.useExisting || options?.useClass],
-    };
-  }
-}
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+import { DiscoveryModule } from '@nestjs/core';
+import {
+  TypesenseModuleAsyncOptions,
+  TypesenseOptionsFactory,
+  TypesenseModuleOptions,
+} from './typesense-module.interface';
+import { TYPESENSE_MODULE_OPTIONS } from './typesense.constants';
+import {
+  createTypesenseExportsProvider,
+  createTypesenseOptionsProvider,
+} from './typesense.providers';
+
+@Module({
+  imports: [DiscoveryModule],
+})
+export class TypesenseModule {
+  static register(options: TypesenseModuleOptions = {}): DynamicModule {
+    const optionsProviders = createTypesenseOptionsProvider(options);
+    const exportsProviders = createTypesenseExportsProvider();
+
+    return {
+      global: true,
+      module: TypesenseModule,
+      providers: [...optionsProviders, ...exportsProviders],
+      exports: exportsProviders,
+    };
+  }
+
+  static registerAsync(options: TypesenseModuleAsyncOptions): DynamicModule {
+    const exportsProviders = createTypesenseExportsProvider();
+
+    return {
+      global: true,
+      module: TypesenseModule,
+      imports: options.imports || [],
+      providers: [...this.createAsyncProviders(options), ...exportsProviders],
+      exports: exportsProviders,
+    };
+  }
+
+  private static createAsyncProviders(
+    options: TypesenseModuleAsyncOptions,
+  ): Provider[] {
+    if (options.useExisting || options.useFactory) {
+      return [this.createAsyncOptionsProvider(options)];
+    }
+
+    return [
+      this.createAsyncOptionsProvider(options),
+      {
+        provide: options?.useClass,
+        useClass: options?.useClass,
+      },
+    ];
+  }
+
+  private static createAsyncOptionsProvider(
+    options: TypesenseModuleAsyncOptions,
+  ): Provider {
+    if (options.useFactory) {
+      return {
+        provide: TYPESENSE_MODULE_OPTIONS,
+        useFactory: options.useFactory,
+        inject: options.inject || [],
+      };
+    }
+
+    return {
+      provide: TYPESENSE_MODULE_OPTIONS,
+      useFactory: (optionsFactory: TypesenseOptionsFactory) =>
+        optionsFactory.createTypesenseOptions(),
+      inject: [options?.useExisting || options?.useClass],
+    };
+  }
+}

package/src/lib/search-engine/typesense/typesense.providers.ts

@@ -1,42 +1,42 @@
-import { Provider } from '@nestjs/common';
-import { Client } from 'typesense';
-import { TypesenseMetadataRegistry } from './metadata';
-import { TypesenseModuleOptions } from './typesense-module.interface';
-import { TYPESENSE_MODULE_OPTIONS } from './typesense.constants';
-
-export const createTypesenseOptionsProvider = (
-  options: TypesenseModuleOptions = {},
-): Provider[] => [
-  {
-    provide: TYPESENSE_MODULE_OPTIONS,
-    useValue: options,
-  },
-];
-
-export const createTypesenseExportsProvider = (): Provider[] => [
-  TypesenseMetadataRegistry,
-  {
-    provide: Client,
-    useFactory: (options: TypesenseModuleOptions) =>
-      new Client({
-        nodes: options.nodes || [
-          {
-            host:
-              process.env.TYPESENSE_HOST ||
-              process.env.NODE_ENV === 'production'
-                ? 'ts.typesense.svc.cluster.local'
-                : 'localhost',
-            port: 8108,
-            protocol: 'http',
-          },
-        ],
-        numRetries: options.numRetries || 10,
-        apiKey: options.apiKey || process.env.TYPESENSE_API_KEY,
-        connectionTimeoutSeconds: options.connectionTimeoutSeconds || 10,
-        retryIntervalSeconds: options.retryIntervalSeconds || 0.1,
-        healthcheckIntervalSeconds: options.healthcheckIntervalSeconds || 2,
-        logLevel: options.logLevel || 'info',
-      }),
-    inject: [TYPESENSE_MODULE_OPTIONS],
-  },
-];
+import { Provider } from '@nestjs/common';
+import { Client } from 'typesense';
+import { TypesenseMetadataRegistry } from './metadata';
+import { TypesenseModuleOptions } from './typesense-module.interface';
+import { TYPESENSE_MODULE_OPTIONS } from './typesense.constants';
+
+export const createTypesenseOptionsProvider = (
+  options: TypesenseModuleOptions = {},
+): Provider[] => [
+  {
+    provide: TYPESENSE_MODULE_OPTIONS,
+    useValue: options,
+  },
+];
+
+export const createTypesenseExportsProvider = (): Provider[] => [
+  TypesenseMetadataRegistry,
+  {
+    provide: Client,
+    useFactory: (options: TypesenseModuleOptions) =>
+      new Client({
+        nodes: options.nodes || [
+          {
+            host:
+              process.env.TYPESENSE_HOST ||
+              process.env.NODE_ENV === 'production'
+                ? 'ts.typesense.svc.cluster.local'
+                : 'localhost',
+            port: 8108,
+            protocol: 'http',
+          },
+        ],
+        numRetries: options.numRetries || 10,
+        apiKey: options.apiKey || process.env.TYPESENSE_API_KEY,
+        connectionTimeoutSeconds: options.connectionTimeoutSeconds || 10,
+        retryIntervalSeconds: options.retryIntervalSeconds || 0.1,
+        healthcheckIntervalSeconds: options.healthcheckIntervalSeconds || 2,
+        logLevel: options.logLevel || 'info',
+      }),
+    inject: [TYPESENSE_MODULE_OPTIONS],
+  },
+];

package/src/response/index.ts

@@ -1 +1 @@
-export * from './pagination.response';
+export * from './pagination.response';

package/src/response/pagination.response.ts

@@ -1,37 +1,37 @@
-export class PaginationResponse<T> {
-  data: T[];
-  total?: number;
-  offset?: number;
-  limit?: number;
-  hasNext?: boolean;
-
-  constructor(
-    data: T[],
-    total: number = data?.length || 0,
-    limit?: number,
-    offset?: number,
-  ) {
-    this.data = data;
-    this.total = total;
-    this.offset = offset;
-    this.limit = limit;
-    this.hasNext = this.offset + this.limit < this.total;
-  }
-
-  toJSON() {
-    return {
-      data: this.data,
-      total: this.total,
-      count: this.data.length,
-      offset: this.offset,
-      limit: this.limit,
-      hasNext: this.hasNext,
-    };
-  }
-
-  promise(): Promise<PaginationResponse<T>> {
-    return new Promise((resolve, reject) => {
-      resolve(this);
-    });
-  }
-}
+export class PaginationResponse<T> {
+  data: T[];
+  total?: number;
+  offset?: number;
+  limit?: number;
+  hasNext?: boolean;
+
+  constructor(
+    data: T[],
+    total: number = data?.length || 0,
+    limit?: number,
+    offset?: number,
+  ) {
+    this.data = data;
+    this.total = total;
+    this.offset = offset;
+    this.limit = limit;
+    this.hasNext = this.offset + this.limit < this.total;
+  }
+
+  toJSON() {
+    return {
+      data: this.data,
+      total: this.total,
+      count: this.data.length,
+      offset: this.offset,
+      limit: this.limit,
+      hasNext: this.hasNext,
+    };
+  }
+
+  promise(): Promise<PaginationResponse<T>> {
+    return new Promise((resolve, reject) => {
+      resolve(this);
+    });
+  }
+}

package/src/setup/index.ts

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

package/src/setup/microservice.setup.ts

@@ -0,0 +1,29 @@
+import type { INestApplication } from '@nestjs/common';
+import { Logger } from '@nestjs/common';
+import { Transport } from '@nestjs/microservices';
+
+import { AppUtils } from '../util';
+
+export async function microserviceSetup(
+  app: INestApplication,
+  serviceName: string,
+) {
+  AppUtils.killAppWithGrace(app);
+  const protoBasePath = process.cwd() + '/libs/proto-schema/src/proto';
+  const host = process.env['GRPC_HOST'];
+  const port = process.env['GRPC_PORT'];
+  const options = {
+    transport: Transport.GRPC,
+    options: {
+      url: `${host}:${port}`,
+      protoPath: `${protoBasePath}/${serviceName}.proto`,
+      package: `${serviceName}`,
+    },
+  };
+  app.connectMicroservice(options);
+  await app.startAllMicroservices();
+  Logger.log(
+    `GRPC ${serviceName} running on ${options.options.url}`,
+    'Bootstrap',
+  );
+}

package/src/util/app.utils.ts

@@ -0,0 +1,18 @@
+import type { INestApplication } from '@nestjs/common';
+
+export class AppUtils {
+  public static killAppWithGrace = (app: INestApplication) => {
+    process.on('SIGINT', async () => {
+      setTimeout(() => process.exit(1), 5000);
+      await app.close();
+      process.exit(0);
+    });
+
+    // kill -15
+    process.on('SIGTERM', async () => {
+      setTimeout(() => process.exit(1), 5000);
+      await app.close();
+      process.exit(0);
+    });
+  };
+}

package/src/util/date.util.spec.ts

@@ -1,49 +1,49 @@
-import dayjs from 'dayjs';
-import { addSecond, isExpired } from './date.util';
-
-describe('Utility Functions', () => {
-  test('addSecond should return a Date object with the specified duration added', () => {
-    // Arrange
-    const duration = 10;
-
-    // Act
-    const result = addSecond(duration);
-
-    // Assert
-    const expectedDate = dayjs().add(duration, 'seconds').toDate();
-    expect(result).toEqual(expectedDate);
-  });
-
-  test('isExpired should return true for a past date', () => {
-    // Arrange
-    const pastDate = dayjs().subtract(1, 'day').toDate();
-
-    // Act
-    const result = isExpired(pastDate);
-
-    // Assert
-    expect(result).toBe(true);
-  });
-
-  test('isExpired should return false for a future date', () => {
-    // Arrange
-    const futureDate = dayjs().add(1, 'day').toDate();
-
-    // Act
-    const result = isExpired(futureDate);
-
-    // Assert
-    expect(result).toBe(false);
-  });
-
-  test('isExpired should return false for the current date', () => {
-    // Arrange
-    const currentDate = dayjs().toDate();
-
-    // Act
-    const result = isExpired(currentDate);
-
-    // Assert
-    expect(result).toBe(false);
-  });
-});
+import dayjs from 'dayjs';
+import { addSecond, isExpired } from './date.util';
+
+describe('Utility Functions', () => {
+  test('addSecond should return a Date object with the specified duration added', () => {
+    // Arrange
+    const duration = 10;
+
+    // Act
+    const result = addSecond(duration);
+
+    // Assert
+    const expectedDate = dayjs().add(duration, 'seconds').toDate();
+    expect(result).toEqual(expectedDate);
+  });
+
+  test('isExpired should return true for a past date', () => {
+    // Arrange
+    const pastDate = dayjs().subtract(1, 'day').toDate();
+
+    // Act
+    const result = isExpired(pastDate);
+
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  test('isExpired should return false for a future date', () => {
+    // Arrange
+    const futureDate = dayjs().add(1, 'day').toDate();
+
+    // Act
+    const result = isExpired(futureDate);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test('isExpired should return false for the current date', () => {
+    // Arrange
+    const currentDate = dayjs().toDate();
+
+    // Act
+    const result = isExpired(currentDate);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+});