mm-share-lib 0.0.4 → 0.0.6

package/src/exception/bad-request-error.exception.spec.ts

@@ -0,0 +1,24 @@
+import { HttpStatus } from '@nestjs/common';
+import { BadRequestException } from './bad-request-error.exception';
+
+describe('BadRequestException', () => {
+  it('should set default message and status code if no parameters are provided', () => {
+    const error = new BadRequestException();
+
+    expect(error.message).toBe('BadRequestException');
+    expect(error.statusCode).toBe(HttpStatus.BAD_REQUEST);
+    expect(error.parameters).toBeUndefined();
+  });
+
+  it('should set custom message, status code, and parameters if provided', () => {
+    const customMessage = 'Custom message';
+    const customStatusCode = HttpStatus.BAD_REQUEST;
+    const customParameters = { key: 'value' };
+    const error = new BadRequestException(customMessage, customParameters);
+
+    expect(error.message).toBe(customMessage);
+    expect(error.statusCode).toBe(customStatusCode);
+    expect(error.parameters).toEqual(customParameters);
+    console.log(error);
+  });
+});

package/src/exception/bad-request-error.exception.ts

@@ -0,0 +1,8 @@
+import { HttpStatus } from '@nestjs/common';
+import { BaseException, ParametersType } from './base.exception';
+
+export class BadRequestException extends BaseException {
+  constructor(message?: string, parameters?: ParametersType) {
+    super(message ?? 'BadRequestException', HttpStatus.BAD_REQUEST, parameters);
+  }
+}

package/src/exception/base.exception.ts

@@ -0,0 +1,36 @@
+import { HttpException, HttpStatus } from '@nestjs/common';
+
+export type ErrorModel = {
+  error: {
+    code: string | number;
+    traceid: string;
+    message: string;
+    timestamp: string;
+    path: string;
+  };
+};
+
+export type ParametersType = { [key: string]: unknown };
+
+export class BaseException extends HttpException {
+  traceid: string;
+  readonly context: string;
+  readonly statusCode: number;
+  readonly code?: string;
+  readonly parameters: ParametersType;
+
+  constructor(
+    message: string,
+    status: HttpStatus,
+    parameters?: ParametersType,
+  ) {
+    super(message, status);
+
+    if (parameters) {
+      this.parameters = parameters;
+    }
+
+    this.statusCode = super.getStatus();
+    Error.captureStackTrace(this);
+  }
+}

package/src/exception/conflict-error.exception.spec.ts

@@ -0,0 +1,23 @@
+import { HttpStatus } from '@nestjs/common';
+import { ConflictException } from './conflict-error.exception';
+
+describe('ConflictException', () => {
+  it('should set default message and status code if no parameters are provided', () => {
+    const error = new ConflictException();
+
+    expect(error.message).toBe('ConflictException');
+    expect(error.statusCode).toBe(HttpStatus.CONFLICT);
+    expect(error.parameters).toBeUndefined();
+  });
+
+  it('should set custom message, status code, and parameters if provided', () => {
+    const customMessage = 'Custom message';
+    const customStatusCode = HttpStatus.CONFLICT;
+    const customParameters = { key: 'value' };
+    const error = new ConflictException(customMessage, customParameters);
+
+    expect(error.message).toBe(customMessage);
+    expect(error.statusCode).toBe(customStatusCode);
+    expect(error.parameters).toEqual(customParameters);
+  });
+});

package/src/exception/conflict-error.exception.ts

@@ -0,0 +1,8 @@
+import { HttpStatus } from '@nestjs/common';
+import { BaseException, ParametersType } from './base.exception';
+
+export class ConflictException extends BaseException {
+  constructor(message?: string, parameters?: ParametersType) {
+    super(message ?? 'ConflictException', HttpStatus.CONFLICT, parameters);
+  }
+}

package/src/exception/forbidden-error.exception.spec.ts

@@ -0,0 +1,23 @@
+import { ForbiddenException } from './forbidden-error.exception';
+import { HttpStatus } from '@nestjs/common';
+
+describe('ForbiddenException', () => {
+  it('should set default message and status code if no parameters are provided', () => {
+    const error = new ForbiddenException();
+
+    expect(error.message).toBe('BadRequestException');
+    expect(error.statusCode).toBe(HttpStatus.FORBIDDEN);
+    expect(error.parameters).toBeUndefined();
+  });
+
+  it('should set custom message, status code, and parameters if provided', () => {
+    const customMessage = 'Custom message';
+    const customStatusCode = HttpStatus.FORBIDDEN;
+    const customParameters = { key: 'value' };
+    const error = new ForbiddenException(customMessage, customParameters);
+
+    expect(error.message).toBe(customMessage);
+    expect(error.statusCode).toBe(customStatusCode);
+    expect(error.parameters).toEqual(customParameters);
+  });
+});

package/src/exception/forbidden-error.exception.ts

@@ -0,0 +1,8 @@
+import { HttpStatus } from '@nestjs/common';
+import { BaseException, ParametersType } from './base.exception';
+
+export class ForbiddenException extends BaseException {
+  constructor(message?: string, parameters?: ParametersType) {
+    super(message ?? 'BadRequestException', HttpStatus.FORBIDDEN, parameters);
+  }
+}

package/src/exception/index.ts

@@ -0,0 +1,7 @@
+export * from './base.exception';
+export * from './conflict-error.exception';
+export * from './not-found-error.exception';
+export * from './forbidden-error.exception';
+export * from './bad-request-error.exception';
+export * from './unauthorized-error.exception';
+export * from './internal-server-error.exception';

package/src/exception/internal-server-error.exception.spec.ts

@@ -0,0 +1,23 @@
+import { InternalServerException } from './internal-server-error.exception';
+import { HttpStatus } from '@nestjs/common';
+
+describe('InternalServerException', () => {
+  it('should set default message and status code if no parameters are provided', () => {
+    const error = new InternalServerException();
+
+    expect(error.message).toBe('InternalServerException');
+    expect(error.statusCode).toBe(HttpStatus.INTERNAL_SERVER_ERROR);
+    expect(error.parameters).toBeUndefined();
+  });
+
+  it('should set custom message, status code, and parameters if provided', () => {
+    const customMessage = 'Custom message';
+    const customStatusCode = HttpStatus.INTERNAL_SERVER_ERROR;
+    const customParameters = { key: 'value' };
+    const error = new InternalServerException(customMessage, customParameters);
+
+    expect(error.message).toBe(customMessage);
+    expect(error.statusCode).toBe(customStatusCode);
+    expect(error.parameters).toEqual(customParameters);
+  });
+});

package/src/exception/internal-server-error.exception.ts

@@ -0,0 +1,12 @@
+import { HttpStatus } from '@nestjs/common';
+import { BaseException, ParametersType } from './base.exception';
+
+export class InternalServerException extends BaseException {
+  constructor(message?: string, parameters?: ParametersType) {
+    super(
+      message ?? 'InternalServerException',
+      HttpStatus.INTERNAL_SERVER_ERROR,
+      parameters,
+    );
+  }
+}

package/src/exception/not-found-error.exception.spec.ts

@@ -0,0 +1,23 @@
+import { NotFoundException } from './not-found-error.exception';
+import { HttpStatus } from '@nestjs/common';
+
+describe('NotFoundException', () => {
+  it('should set default message and status code if no parameters are provided', () => {
+    const error = new NotFoundException();
+
+    expect(error.message).toBe('NotFoundException');
+    expect(error.statusCode).toBe(HttpStatus.NOT_FOUND);
+    expect(error.parameters).toBeUndefined();
+  });
+
+  it('should set custom message, status code, and parameters if provided', () => {
+    const customMessage = 'Custom message';
+    const customStatusCode = HttpStatus.INTERNAL_SERVER_ERROR;
+    const customParameters = { key: 'value' };
+    const error = new NotFoundException(customMessage, customParameters);
+
+    expect(error.message).toBe(customMessage);
+    expect(error.statusCode).toBe(customStatusCode);
+    expect(error.parameters).toEqual(customParameters);
+  });
+});

package/src/exception/not-found-error.exception.ts

@@ -0,0 +1,8 @@
+import { HttpStatus } from '@nestjs/common';
+import { BaseException, ParametersType } from './base.exception';
+
+export class NotFoundException extends BaseException {
+  constructor(message?: string, parameters?: ParametersType) {
+    super(message ?? 'NotFoundException', HttpStatus.NOT_FOUND, parameters);
+  }
+}

package/src/exception/unauthorized-error.exception.spec.ts

@@ -0,0 +1,23 @@
+import { UnauthorizedException } from './unauthorized-error.exception';
+import { HttpStatus } from '@nestjs/common';
+
+describe('UnauthorizedException', () => {
+  it('should set default message and status code if no parameters are provided', () => {
+    const error = new UnauthorizedException();
+
+    expect(error.message).toBe('UnauthorizedException');
+    expect(error.statusCode).toBe(HttpStatus.UNAUTHORIZED);
+    expect(error.parameters).toBeUndefined();
+  });
+
+  it('should set custom message, status code, and parameters if provided', () => {
+    const customMessage = 'Custom message';
+    const customStatusCode = HttpStatus.UNAUTHORIZED;
+    const customParameters = { key: 'value' };
+    const error = new UnauthorizedException(customMessage, customParameters);
+
+    expect(error.message).toBe(customMessage);
+    expect(error.statusCode).toBe(customStatusCode);
+    expect(error.parameters).toEqual(customParameters);
+  });
+});

package/src/exception/unauthorized-error.exception.ts

@@ -0,0 +1,12 @@
+import { HttpStatus } from '@nestjs/common';
+import { BaseException, ParametersType } from './base.exception';
+
+export class UnauthorizedException extends BaseException {
+  constructor(message?: string, parameters?: ParametersType) {
+    super(
+      message ?? 'UnauthorizedException',
+      HttpStatus.UNAUTHORIZED,
+      parameters,
+    );
+  }
+}

package/src/filter/http-exception.filter.ts

@@ -0,0 +1,23 @@
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+} from '@nestjs/common';
+import { Request, Response } from 'express';
+
+@Catch(HttpException)
+export class HttpExceptionFilter implements ExceptionFilter {
+  catch(exception: HttpException, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const request = ctx.getRequest<Request>();
+    const status = exception.getStatus();
+
+    response.status(status).json({
+      statusCode: status,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+    });
+  }
+}

package/src/filter/index.ts

@@ -0,0 +1 @@
+export * from './http-exception.filter';

package/src/filter/rpc-exception.filter.ts

@@ -0,0 +1,15 @@
+import { Catch } from '@nestjs/common';
+import { RpcException } from '@nestjs/microservices';
+import type { RpcExceptionFilter as NestRpcExceptionFilter } from '@nestjs/common';
+import { throwError } from 'rxjs';
+import type { Observable } from 'rxjs';
+
+@Catch(RpcException)
+export class RpcExceptionFilter
+  implements NestRpcExceptionFilter<RpcException>
+{
+  catch(exception: RpcException): Observable<any> {
+    // TODO: handle grpc error here instead of throwing it inside each service
+    return throwError(() => exception.getError());
+  }
+}

package/src/index.ts

@@ -1,6 +1,9 @@
+export * from './auth';
 export * from './generic';
 export * from './constant';
 export * from './dto';
 export * from './lib';
 export * from './response';
 export * from './util';
+export * from './filter';
+export * from './exception';

package/src/interface/index.ts

@@ -0,0 +1 @@
+export * from './social.interface';

package/src/interface/social.interface.ts

@@ -0,0 +1,6 @@
+export interface SocialInterface {
+  id: string;
+  firstName?: string;
+  lastName?: string;
+  email?: string;
+}

package/src/lib/index.ts

@@ -1 +1,3 @@
 export * from './search-engine';
+export * from './mailer';
+export * from './typesense';

package/src/lib/mailer/config/index.ts

@@ -0,0 +1 @@
+export * from './mailer.config';

package/src/lib/mailer/config/mailer.config.ts

@@ -0,0 +1,62 @@
+import { registerAs } from '@nestjs/config';
+import {
+  IsString,
+  IsInt,
+  Min,
+  Max,
+  IsOptional,
+  IsBoolean,
+  IsEmail,
+} from 'class-validator';
+import { validateConfig } from '../../../util';
+import { MailConfig } from '../../../config';
+
+class EnvironmentVariablesValidator {
+  @IsInt()
+  @Min(0)
+  @Max(65535)
+  @IsOptional()
+  MAIL_PORT: number;
+
+  @IsString()
+  MAIL_HOST: string;
+
+  @IsString()
+  @IsOptional()
+  MAIL_USER: string;
+
+  @IsString()
+  @IsOptional()
+  MAIL_PASSWORD: string;
+
+  @IsEmail()
+  MAIL_DEFAULT_EMAIL: string;
+
+  @IsString()
+  MAIL_DEFAULT_NAME: string;
+
+  @IsBoolean()
+  MAIL_IGNORE_TLS: boolean;
+
+  @IsBoolean()
+  MAIL_SECURE: boolean;
+
+  @IsBoolean()
+  MAIL_REQUIRE_TLS: boolean;
+}
+
+export default registerAs<MailConfig>('mail', () => {
+  validateConfig(process.env, EnvironmentVariablesValidator);
+
+  return {
+    port: process.env.MAIL_PORT ? parseInt(process.env.MAIL_PORT, 10) : 587,
+    host: process.env.MAIL_HOST,
+    user: process.env.MAIL_USER,
+    password: process.env.MAIL_PASSWORD,
+    defaultEmail: process.env.MAIL_DEFAULT_EMAIL,
+    defaultName: process.env.MAIL_DEFAULT_NAME,
+    ignoreTLS: process.env.MAIL_IGNORE_TLS === 'true',
+    secure: process.env.MAIL_SECURE === 'true',
+    requireTLS: process.env.MAIL_REQUIRE_TLS === 'true',
+  };
+});

package/src/lib/mailer/index.ts

@@ -0,0 +1,2 @@
+export * from './mailer.module';
+export * from './mailer.service';

package/src/lib/mailer/mailer.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { MailerService } from './mailer.service';
+
+@Module({
+  providers: [MailerService],
+  exports: [MailerService],
+})
+export class MailerModule {}

package/src/lib/mailer/mailer.service.ts

@@ -0,0 +1,53 @@
+import fs from 'node:fs/promises';
+import Handlebars from 'handlebars';
+import nodemailer from 'nodemailer';
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { AllConfigType } from '../../config';
+
+@Injectable()
+export class MailerService {
+  private readonly transporter: nodemailer.Transporter;
+  constructor(private readonly configService: ConfigService<AllConfigType>) {
+    this.transporter = nodemailer.createTransport({
+      host: configService.get('mail.host', { infer: true }),
+      port: configService.get('mail.port', { infer: true }),
+      ignoreTLS: configService.get('mail.ignoreTLS', { infer: true }),
+      secure: configService.get('mail.secure', { infer: true }),
+      requireTLS: configService.get('mail.requireTLS', { infer: true }),
+      auth: {
+        user: configService.get('mail.user', { infer: true }),
+        pass: configService.get('mail.password', { infer: true }),
+      },
+    });
+  }
+
+  async sendMail({
+    templatePath,
+    context,
+    ...mailOptions
+  }: nodemailer.SendMailOptions & {
+    templatePath: string;
+    context: Record<string, unknown>;
+  }): Promise<void> {
+    let html: string | undefined;
+    if (templatePath) {
+      const template = await fs.readFile(templatePath, 'utf-8');
+      html = Handlebars.compile(template, {
+        strict: true,
+      })(context);
+    }
+
+    await this.transporter.sendMail({
+      ...mailOptions,
+      from: mailOptions.from
+        ? mailOptions.from
+        : `"${this.configService.get('mail.defaultName', {
+            infer: true,
+          })}" <${this.configService.get('mail.defaultEmail', {
+            infer: true,
+          })}>`,
+      html: mailOptions.html ? mailOptions.html : html,
+    });
+  }
+}

package/src/lib/search-engine/document/base.document.ts

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

package/src/lib/search-engine/interface/search-document.interface.ts

@@ -1,5 +1,13 @@
-import { SearchOptions, SearchParams, SearchResponse, DocumentSchema } from 'typesense/lib/Typesense/Documents';
+import {
+  SearchOptions,
+  SearchParams,
+  SearchResponse,
+  DocumentSchema,
+} from 'typesense/lib/Typesense/Documents';
 
 export interface SearchDocumentService<Document extends DocumentSchema> {
-    searchDocument(searchParameters: SearchParams, options: SearchOptions): Promise<SearchResponse<any>>;
+  searchDocument(
+    searchParameters: SearchParams,
+    options: SearchOptions,
+  ): Promise<SearchResponse<Document>>;
 }

package/src/lib/search-engine/schema/generic.schema.ts

@@ -1 +1 @@
-export class GenericSchema {}
+export class GenericSchema {}

package/src/lib/search-engine/schema/index.ts

@@ -1 +1 @@
-export * from './generic.schema';
+export * from './generic.schema';

package/src/lib/search-engine/typesense/collection/index.ts

@@ -0,0 +1 @@
+export * from 'typesense/lib/Typesense/Collections';

package/src/lib/search-engine/typesense/document/index.ts

@@ -0,0 +1 @@
+export * from 'typesense/lib/Typesense/Documents';

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

@@ -1,3 +1,4 @@
 export * from './typesense.module';
 export * from './metadata';
 export * from './service';
+export * from './document';

package/src/lib/search-engine/typesense/service/client.service.ts

@@ -1,14 +1,14 @@
 import { Client } from 'typesense';
 import { Logger, Type } from '@nestjs/common';
 import { plainToClass } from 'class-transformer';
-import { CollectionCreateSchema } from 'typesense/lib/Typesense/Collections';
+import { CollectionCreateSchema } from '../collection';
 import {
   SearchParams,
   SearchOptions,
   SearchResponse,
   DeleteResponse,
   ImportResponse,
-} from 'typesense/lib/Typesense/Documents';
+} from '../document';
 import { BaseDocument } from '../../document';
 import { SearchDocumentService } from '../../interface';
 import { EntityGeneric } from '../../../../generic';
@@ -19,6 +19,7 @@ export abstract class ClientService<
   Entity extends EntityGeneric,
 > implements SearchDocumentService<Document>
 {
+  private readonly logger = new Logger(ClientService.name);
   protected readonly entity: Type<Entity>;
   protected abstract cache_s: number;
   protected readonly skipCheckSchema: boolean = false;
@@ -81,6 +82,7 @@ export abstract class ClientService<
       }
       return documents;
     } catch (error) {
+      this.logger.error(error);
       return null;
     }
   }
@@ -110,7 +112,7 @@ export abstract class ClientService<
           .documents()
           .import(data, { action: 'upsert' });
       } catch (error) {
-        console.log(error);
+        this.logger.error(error);
       }
     }
   }

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

@@ -0,0 +1 @@
+export { Client } from 'typesense';

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

@@ -0,0 +1 @@
+// export { CollectionSchema } from 'typesense/src/Typesense/Collection';

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

@@ -0,0 +1,89 @@
+/* eslint-disable max-classes-per-file */
+
+import { Field } from './field.decorator';
+import { FIELD_METADATA } from './field.decorator';
+import { Schema } from './schema.decorator';
+
+describe('typesense', () => {
+  describe('decorators', () => {
+    describe('field', () => {
+      it('should enhance field with metadata', () => {
+        @Schema()
+        class Test {
+          @Field('string')
+          field!: string;
+        }
+
+        expect(Reflect.getMetadata(FIELD_METADATA, Test)).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({
+              name: 'field',
+              type: 'string',
+            }),
+          ]),
+        );
+      });
+
+      it('should enhance field with custom name metadata', () => {
+        @Schema()
+        class Test {
+          @Field('string', { name: 'custom' })
+          field!: string;
+        }
+
+        expect(Reflect.getMetadata(FIELD_METADATA, Test)).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({
+              name: 'custom',
+              type: 'string',
+            }),
+          ]),
+        );
+      });
+    });
+
+    it('should enhance field with options metadata', () => {
+      @Schema()
+      class Test {
+        @Field('string', { facet: true, index: true, optional: true })
+        field!: string;
+      }
+
+      expect(Reflect.getMetadata(FIELD_METADATA, Test)).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            name: 'field',
+            type: 'string',
+            facet: true,
+            index: true,
+            optional: true,
+          }),
+        ]),
+      );
+    });
+
+    it('should enhance field with multiple fields metadata', () => {
+      @Schema()
+      class Test {
+        @Field('string')
+        field!: string;
+
+        @Field('string')
+        field2!: string;
+      }
+
+      expect(Reflect.getMetadata(FIELD_METADATA, Test)).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            name: 'field',
+            type: 'string',
+          }),
+          expect.objectContaining({
+            name: 'field2',
+            type: 'string',
+          }),
+        ]),
+      );
+    });
+  });
+});