mm-share-lib 0.0.6 → 0.0.7

package/src/lib/typesense/metadata/typesense.metadata-registry.ts

@@ -1,28 +1,28 @@
-import { Injectable, Logger } from '@nestjs/common';
-
-import { Schema } from './schema.metadata';
-
-type Constructor = new (...args: any[]) => unknown;
-
-@Injectable()
-export class TypesenseMetadataRegistry {
-  private logger = new Logger(TypesenseMetadataRegistry.name);
-
-  private schemas: Map<Constructor, Schema> = new Map();
-
-  addSchema(target: Constructor, schema: Schema) {
-    if (this.schemas.has(target)) {
-      this.logger.warn(`Schema ${target} already exists`);
-    }
-
-    this.schemas.set(target, schema);
-  }
-
-  getSchemaByTarget(target: Constructor) {
-    return this.schemas.get(target);
-  }
-
-  getTargets() {
-    return this.schemas.keys();
-  }
-}
+import { Injectable, Logger } from '@nestjs/common';
+
+import { Schema } from './schema.metadata';
+
+type Constructor = new (...args: any[]) => unknown;
+
+@Injectable()
+export class TypesenseMetadataRegistry {
+  private logger = new Logger(TypesenseMetadataRegistry.name);
+
+  private schemas: Map<Constructor, Schema> = new Map();
+
+  addSchema(target: Constructor, schema: Schema) {
+    if (this.schemas.has(target)) {
+      this.logger.warn(`Schema ${target} already exists`);
+    }
+
+    this.schemas.set(target, schema);
+  }
+
+  getSchemaByTarget(target: Constructor) {
+    return this.schemas.get(target);
+  }
+
+  getTargets() {
+    return this.schemas.keys();
+  }
+}

package/src/lib/typesense/module/index.ts

@@ -1,4 +1,4 @@
-export * from './interface.module';
-export * from './typesense.module';
-export * from './typesense.constant';
-export * from './typesense.provider';
+export * from './interface.module';
+export * from './typesense.module';
+export * from './typesense.constant';
+export * from './typesense.provider';

package/src/lib/typesense/module/interface.module.ts

@@ -3,10 +3,12 @@ import { Type } from '@nestjs/common/interfaces';
 
 export interface TypesenseNodeOptions {
   host: string;
-  port: string;
+  port: number;
   protocol: string;
 }
 
+type LogLevelNames = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+
 export interface TypesenseModuleOptions {
   nodes?: Array<TypesenseNodeOptions>;
   numRetries?: number;
@@ -14,7 +16,7 @@ export interface TypesenseModuleOptions {
   connectionTimeoutSeconds?: number;
   retryIntervalSeconds?: number;
   healthcheckIntervalSeconds?: number;
-  logLevel?: string;
+  logLevel?: LogLevelNames;
 }
 
 export interface TypesenseOptionsFactory {

package/src/lib/typesense/module/typesense.constant.ts

@@ -1 +1 @@
-export const TYPESENSE_MODULE_OPTIONS = 'TYPESENSE_MODULE_OPTIONS';
+export const TYPESENSE_MODULE_OPTIONS = 'TYPESENSE_MODULE_OPTIONS';

package/src/lib/typesense/module/typesense.module.spec.ts

@@ -1,94 +1,94 @@
-/* eslint-disable max-classes-per-file */
-
-import { Module } from '@nestjs/common';
-import { Test } from '@nestjs/testing';
-
-import { TypesenseModuleOptions } from './interface.module';
-import { TYPESENSE_MODULE_OPTIONS } from './typesense.constant';
-import { TypesenseModule } from './';
-
-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 './interface.module';
+import { TYPESENSE_MODULE_OPTIONS } from './typesense.constant';
+import { TypesenseModule } from './';
+
+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/typesense/module/typesense.module.ts

@@ -1,87 +1,87 @@
-import { DynamicModule, Provider, Module } from '@nestjs/common';
-import { DiscoveryModule } from '@nestjs/core';
-
-import {
-  TypesenseModuleAsyncOptions,
-  TypesenseOptionsFactory,
-  TypesenseModuleOptions,
-} from './interface.module';
-import { TYPESENSE_MODULE_OPTIONS } from './typesense.constant';
-import {
-  createTypesenseExportsProvider,
-  createTypesenseProvider,
-  createTypesenseOptionsProvider,
-} from './typesense.provider';
-
-@Module({
-  imports: [DiscoveryModule],
-})
-export class TypesenseModule {
-  static register(options: TypesenseModuleOptions = {}): DynamicModule {
-    const optionsProviders = createTypesenseOptionsProvider(options);
-    const exportsProviders = createTypesenseExportsProvider();
-    const providers = createTypesenseProvider();
-
-    return {
-      global: true,
-      module: TypesenseModule,
-      providers: [...optionsProviders, ...providers, ...exportsProviders],
-      exports: exportsProviders,
-    };
-  }
-
-  static registerAsync(options: TypesenseModuleAsyncOptions): DynamicModule {
-    const exportsProviders = createTypesenseExportsProvider();
-    const providers = createTypesenseProvider();
-
-    return {
-      global: true,
-      module: TypesenseModule,
-      imports: options.imports || [],
-      providers: [
-        ...this.createAsyncProviders(options),
-        ...providers,
-        ...exportsProviders,
-      ],
-      exports: exportsProviders,
-    };
-  }
-
-  private static createAsyncProviders(
-    options: TypesenseModuleAsyncOptions,
-  ): Provider[] {
-    if (options.useExisting || options.useFactory) {
-      return [this.createAsyncOptionsProvider(options)];
-    }
-
-    return [
-      this.createAsyncOptionsProvider(options),
-      {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        provide: options.useClass!,
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        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(),
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      inject: [options.useExisting! || options.useClass!],
-    };
-  }
-}
+import { DynamicModule, Provider, Module } from '@nestjs/common';
+import { DiscoveryModule } from '@nestjs/core';
+
+import {
+  TypesenseModuleAsyncOptions,
+  TypesenseOptionsFactory,
+  TypesenseModuleOptions,
+} from './interface.module';
+import { TYPESENSE_MODULE_OPTIONS } from './typesense.constant';
+import {
+  createTypesenseExportsProvider,
+  createTypesenseProvider,
+  createTypesenseOptionsProvider,
+} from './typesense.provider';
+
+@Module({
+  imports: [DiscoveryModule],
+})
+export class TypesenseModule {
+  static register(options: TypesenseModuleOptions = {}): DynamicModule {
+    const optionsProviders = createTypesenseOptionsProvider(options);
+    const exportsProviders = createTypesenseExportsProvider();
+    const providers = createTypesenseProvider();
+
+    return {
+      global: true,
+      module: TypesenseModule,
+      providers: [...optionsProviders, ...providers, ...exportsProviders],
+      exports: exportsProviders,
+    };
+  }
+
+  static registerAsync(options: TypesenseModuleAsyncOptions): DynamicModule {
+    const exportsProviders = createTypesenseExportsProvider();
+    const providers = createTypesenseProvider();
+
+    return {
+      global: true,
+      module: TypesenseModule,
+      imports: options.imports || [],
+      providers: [
+        ...this.createAsyncProviders(options),
+        ...providers,
+        ...exportsProviders,
+      ],
+      exports: exportsProviders,
+    };
+  }
+
+  private static createAsyncProviders(
+    options: TypesenseModuleAsyncOptions,
+  ): Provider[] {
+    if (options.useExisting || options.useFactory) {
+      return [this.createAsyncOptionsProvider(options)];
+    }
+
+    return [
+      this.createAsyncOptionsProvider(options),
+      {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        provide: options.useClass!,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        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(),
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      inject: [options.useExisting! || options.useClass!],
+    };
+  }
+}

package/src/lib/typesense/module/typesense.provider.ts

@@ -1,13 +1,13 @@
-import { Provider } from '@nestjs/common';
-
 import { Client } from 'typesense';
-
-import { TypesenseCollectionsCreator } from '../collections';
-import { TypesenseMetadataAccessor } from '../metadata';
-import { TypesenseMetadataExplorer } from '../metadata';
-import { TypesenseMetadataRegistry } from '../metadata';
-import { TypesenseModuleOptions } from './typesense-module.interface';
-import { TYPESENSE_MODULE_OPTIONS } from './typesense.constants';
+import { Provider } from '@nestjs/common';
+import { TypesenseCollectionsCreator } from '../collection';
+import {
+  TypesenseMetadataAccessor,
+  TypesenseMetadataRegistry,
+  TypesenseMetadataExplorer,
+} from '../metadata';
+import { TypesenseModuleOptions } from './interface.module';
+import { TYPESENSE_MODULE_OPTIONS } from './typesense.constant';
 
 export const createTypesenseOptionsProvider = (
   options: TypesenseModuleOptions = {},

package/src/setup/index.ts

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

package/src/setup/microservice.setup.ts

@@ -1,29 +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',
-  );
-}
+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

@@ -1,18 +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);
-    });
-  };
-}
+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);
+    });
+  };
+}