mm-share-lib 0.0.4 → 0.0.6

package/src/lib/typesense/decorator/field.decorator.ts

@@ -0,0 +1,44 @@
+import { SetMetadata } from '@nestjs/common';
+import { applyDecorators } from '@nestjs/common';
+
+export interface FieldMetadata {
+  name?: string;
+  facet?: boolean;
+  index?: boolean;
+  optional?: boolean;
+}
+
+export type FieldType =
+  | 'string'
+  | 'int32'
+  | 'int64'
+  | 'float'
+  | 'bool'
+  | 'geopoint'
+  | 'geopoint[]'
+  | 'string[]'
+  | 'int32[]'
+  | 'int64[]'
+  | 'float[]'
+  | 'bool[]'
+  | 'object'
+  | 'object[]'
+  | 'auto'
+  | 'string*';
+
+export const FIELD_METADATA = '__fieldMetadata__';
+
+export const Field = (type: FieldType, options: FieldMetadata = {}) =>
+  applyDecorators((target: object, key?: any, descriptor?: any) => {
+    const exists =
+      Reflect.getMetadata(FIELD_METADATA, target.constructor) || [];
+
+    return SetMetadata(FIELD_METADATA, [
+      ...exists,
+      {
+        ...options,
+        type,
+        name: options.name || key,
+      },
+    ])(target.constructor, key, descriptor);
+  });

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

@@ -0,0 +1,2 @@
+export * from './field.decorator';
+export * from './schema.decorator';

package/src/lib/typesense/decorator/schema.decorator.ts

@@ -0,0 +1,23 @@
+import decamelize from 'decamelize';
+import { SetMetadata, applyDecorators } from '@nestjs/common';
+
+export interface Schema {
+  name?: string;
+  defaultSortingField?: string;
+  auto?: boolean;
+}
+
+export const SCHEMA_METADATA = '__schemaMetadata__';
+
+export const Schema = (options: Schema = {}): ClassDecorator =>
+  applyDecorators((target: object, key?: any, descriptor?: any) =>
+    SetMetadata(SCHEMA_METADATA, {
+      name:
+        options.name ||
+        decamelize((target as any).name, {
+          separator: '-',
+          preserveConsecutiveUppercase: false,
+        }),
+      defaultSortingField: options.defaultSortingField,
+    })(target, key, descriptor),
+  );

package/src/lib/typesense/document/base.document.ts

@@ -0,0 +1,3 @@
+export class BaseDocument {
+  id?: string;
+}

package/src/lib/typesense/index.ts

@@ -0,0 +1,6 @@
+export * from './client';
+// export * from './collection';
+// export * from './decorator';
+export * from './document';
+export * from './metadata';
+export * from './module';

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

@@ -0,0 +1,4 @@
+export * from './schema.metadata';
+export * from './typesense.metadata-accessor';
+export * from './typesense.metadata-explorer';
+export * from './typesense.metadata-registry';

package/src/lib/typesense/metadata/schema.metadata.ts

@@ -0,0 +1,21 @@
+import type { FieldType } from '../decorator/field.decorator';
+
+export interface SchemaField {
+  name: string;
+  type: FieldType;
+  optional?: boolean;
+  facet?: boolean;
+  index?: boolean;
+  sort?: boolean;
+  locale?: string;
+  infix?: boolean;
+  num_dim?: number;
+  [t: string]: unknown;
+}
+
+export interface Schema {
+  name: string;
+  fields: Array<SchemaField>;
+  enable_nested_fields?: boolean;
+  defaultSortingField?: string;
+}

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

@@ -0,0 +1,37 @@
+import { Injectable } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+
+import { SCHEMA_METADATA } from '../decorator';
+import { FIELD_METADATA } from '../decorator';
+import { Schema } from './schema.metadata';
+
+@Injectable()
+export class TypesenseMetadataAccessor {
+  constructor(private readonly reflector: Reflector) {}
+
+  getTypesenseMetadata(target): Schema | undefined {
+    if (target.constructor) {
+      const schema = this.reflector.get(SCHEMA_METADATA, target.constructor);
+      const fields = this.reflector.get(FIELD_METADATA, target.constructor);
+
+      if (!schema) {
+        return undefined;
+      }
+
+      if (!(fields || schema.auto)) {
+        return undefined;
+      }
+
+      return {
+        name: schema.name,
+        defaultSortingField: schema.defaultSortingField,
+        fields: [
+          ...(schema.auto ? [{ name: '.*', type: 'auto' }] : []),
+          ...(fields || []),
+        ],
+      };
+    }
+
+    return undefined;
+  }
+}

package/src/lib/typesense/metadata/typesense.metadata-explorer.spec.ts

@@ -0,0 +1,56 @@
+/* eslint-disable max-classes-per-file */
+
+import 'reflect-metadata';
+
+import { Module } from '@nestjs/common';
+import { DiscoveryModule } from '@nestjs/core';
+import { Test } from '@nestjs/testing';
+
+import { Schema } from '../decorators';
+import { Field } from '../decorators';
+import { TypesenseMetadataAccessor } from './typesense.metadata-accessor';
+import { TypesenseMetadataExplorer } from './typesense.metadata-explorer';
+import { TypesenseMetadataRegistry } from './typesense.metadata-registry';
+
+describe('typesense', () => {
+  describe('metadata', () => {
+    describe('explorer', () => {
+      let module;
+
+      @Module({
+        imports: [DiscoveryModule],
+        providers: [
+          TypesenseMetadataAccessor,
+          TypesenseMetadataExplorer,
+          TypesenseMetadataRegistry,
+        ],
+      })
+      class TestMetadataModule {}
+
+      @Schema()
+      class TestSchema {
+        @Field('string')
+        field!: string;
+      }
+
+      beforeEach(async () => {
+        module = await Test.createTestingModule({
+          imports: [TestMetadataModule],
+          providers: [TestSchema],
+        }).compile();
+
+        await module.init();
+      });
+
+      afterEach(async () => {
+        await module.close();
+      });
+
+      it('should store schema metadata', () => {
+        expect(
+          module.get(TypesenseMetadataRegistry).getSchemaByTarget(TestSchema),
+        ).toBeDefined();
+      });
+    });
+  });
+});

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

@@ -0,0 +1,41 @@
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
+import { DiscoveryService } from '@nestjs/core';
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+
+import { TypesenseMetadataAccessor } from './typesense.metadata-accessor';
+import { TypesenseMetadataRegistry } from './typesense.metadata-registry';
+
+@Injectable()
+export class TypesenseMetadataExplorer implements OnModuleInit {
+  private readonly logger = new Logger(TypesenseMetadataExplorer.name);
+
+  constructor(
+    private readonly discoveryService: DiscoveryService,
+    private readonly metadataAccessor: TypesenseMetadataAccessor,
+    private readonly metadataRegistry: TypesenseMetadataRegistry,
+  ) {}
+
+  onModuleInit() {
+    this.explore();
+  }
+
+  explore() {
+    this.discoveryService.getProviders().forEach((wrapper: InstanceWrapper) => {
+      const { instance } = wrapper;
+
+      if (!instance || !Object.getPrototypeOf(instance)) {
+        return;
+      }
+
+      this.lookupSchema(instance);
+    });
+  }
+
+  lookupSchema(instance) {
+    const metadata = this.metadataAccessor.getTypesenseMetadata(instance);
+
+    if (metadata) {
+      this.metadataRegistry.addSchema(instance.constructor, metadata);
+    }
+  }
+}

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

@@ -0,0 +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();
+  }
+}

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

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

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

@@ -0,0 +1,34 @@
+import { ModuleMetadata } from '@nestjs/common/interfaces';
+import { Type } from '@nestjs/common/interfaces';
+
+export interface TypesenseNodeOptions {
+  host: string;
+  port: string;
+  protocol: string;
+}
+
+export interface TypesenseModuleOptions {
+  nodes?: Array<TypesenseNodeOptions>;
+  numRetries?: number;
+  apiKey?: string;
+  connectionTimeoutSeconds?: number;
+  retryIntervalSeconds?: number;
+  healthcheckIntervalSeconds?: number;
+  logLevel?: string;
+}
+
+export interface TypesenseOptionsFactory {
+  createTypesenseOptions():
+    | Promise<TypesenseModuleOptions>
+    | TypesenseModuleOptions;
+}
+
+export interface TypesenseModuleAsyncOptions
+  extends Pick<ModuleMetadata, 'imports'> {
+  useExisting?: Type<TypesenseOptionsFactory>;
+  useClass?: Type<TypesenseOptionsFactory>;
+  useFactory?: (
+    ...args: any[]
+  ) => Promise<TypesenseModuleOptions> | TypesenseModuleOptions;
+  inject?: any[];
+}

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

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

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

@@ -0,0 +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();
+    });
+  });
+});

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

@@ -0,0 +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!],
+    };
+  }
+}

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

@@ -0,0 +1,54 @@
+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';
+
+export const createTypesenseOptionsProvider = (
+  options: TypesenseModuleOptions = {},
+): Provider[] => [
+  {
+    provide: TYPESENSE_MODULE_OPTIONS,
+    useValue: options,
+  },
+];
+
+export const createTypesenseProvider = (): Provider[] => [
+  TypesenseMetadataAccessor,
+  TypesenseMetadataExplorer,
+  TypesenseMetadataRegistry,
+  TypesenseCollectionsCreator,
+];
+
+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/base-entity.response.ts

@@ -0,0 +1,8 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+
+export class BaseEntityResponse {
+  @ApiPropertyOptional()
+  @Type(() => Number)
+  id?: number;
+}

package/src/response/index.ts

@@ -1 +1,2 @@
+export * from './base-entity.response';
 export * from './pagination.response';

package/src/response/pagination.response.ts

@@ -1,12 +1,27 @@
-export class PaginationResponse<T> {
-  data: T[];
-  total?: number;
-  offset?: number;
-  limit?: number;
-  hasNext?: boolean;
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+export class PaginationResponse<TData> {
+  @ApiPropertyOptional()
+  data: TData[];
+
+  @ApiPropertyOptional()
+  @Type(() => Number)
+  total?: number = 0;
+
+  @ApiPropertyOptional()
+  @Type(() => Number)
+  offset?: number = 0;
+
+  @ApiPropertyOptional()
+  @Type(() => Number)
+  limit?: number = 25;
+
+  @ApiPropertyOptional()
+  @Type(() => Boolean)
+  hasNext?: boolean = false;
 
   constructor(
-    data: T[],
+    data: TData[],
     total: number = data?.length || 0,
     limit?: number,
     offset?: number,
@@ -29,7 +44,7 @@ export class PaginationResponse<T> {
     };
   }
 
-  promise(): Promise<PaginationResponse<T>> {
+  promise(): Promise<PaginationResponse<TData>> {
     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/index.ts

@@ -1,2 +1,4 @@
 export * from './date.util';
 export * from './generator.util';
+export * from './app.utils';
+export * from './validate-config';