mm-share-lib 0.0.5 → 0.0.6

package/src/generic/service/service.generic.ts

@@ -1,112 +1,112 @@
-import {
-  Repository,
-  Connection,
-  EntityManager,
-  SelectQueryBuilder,
-} from 'typeorm';
-import { EntityGeneric } from '../entity';
-import { PaginationDto, BaseFilterDto } from '../../dto';
-import { EntityStateConstant } from '../../constant';
-import { PaginationResponse } from '../../response';
-
-export abstract class ServiceGeneric<
-  Entity extends EntityGeneric,
-  CustomRepository extends Repository<Entity>,
-> {
-  protected readonly entityName: string;
-  protected readonly loggable: boolean = false;
-  protected repository: CustomRepository;
-  protected connection: Connection;
-  constructor(
-    protected readonly connectionOrManager: Connection | EntityManager,
-    repositoryType: { new (connection: Connection): CustomRepository },
-  ) {
-    if (connectionOrManager instanceof EntityManager) {
-      this.connection = connectionOrManager.connection;
-    } else {
-      this.connection = connectionOrManager;
-    }
-    this.repository = this.connection.getCustomRepository(repositoryType);
-  }
-
-  async create(entity: Entity): Promise<Entity> {
-    return this.repository.save(entity);
-  }
-
-  async update(entity: Entity): Promise<Entity> {
-    return this.repository.save(entity);
-  }
-
-  async getListWithPagination(
-    paginationDto: PaginationDto,
-    callback?: (query: SelectQueryBuilder<Entity>) => void,
-  ): Promise<PaginationResponse<Entity>> {
-    const { limit = 25, offset = 0 } = paginationDto;
-    const query = this.repository.createQueryBuilder(this.entityName);
-    query.limit(limit);
-    query.offset(offset);
-    query.where(`${this.entityName}.state != :state`, {
-      state: EntityStateConstant.Archived,
-    });
-    const defaultSelectable = ['createdAt', 'updatedAt'];
-    query.orderBy(`${this.entityName}.updatedAt`, 'DESC');
-    const selection = defaultSelectable.map(
-      (column: string) => `${this.entityName}.${column}`,
-    );
-    query.addSelect(selection);
-    if (callback != null) {
-      callback(query);
-    }
-    const entities = await query.getMany();
-    const total = await query.getCount();
-    const response = new PaginationResponse(entities, total, limit, offset);
-    return response;
-  }
-
-  async getAutocompleteWithPagination(
-    paginationDto: PaginationDto,
-    filter: BaseFilterDto,
-    callback?: (query: SelectQueryBuilder<Entity>) => void,
-  ): Promise<PaginationResponse<Entity>> {
-    const { limit = 25, offset = 0 } = paginationDto;
-    const query = this.repository.createQueryBuilder(this.entityName);
-    query.limit(limit);
-    query.offset(offset);
-    query.where(`${this.entityName}.state != :state`, {
-      state: EntityStateConstant.Archived,
-    });
-    const defaultSelectable = ['createdAt', 'updatedAt'];
-    query.orderBy(`${this.entityName}.updatedAt`, 'DESC');
-    const selection = defaultSelectable.map(
-      (column: string) => `${this.entityName}.${column}`,
-    );
-    query.addSelect(selection);
-    if (callback != null) {
-      callback(query);
-    }
-    const { excludeIds = [], includeIds = [] } = { ...filter };
-    // Exclude some ids from the list.
-    if (excludeIds?.length > 0) {
-      query.andWhere(`${this.entityName}.id NOT IN (:ids)`, {
-        ids: excludeIds,
-      });
-    }
-    let entities = await query.getMany();
-    const total = await query.getCount();
-    // Include some ids to the list.
-    const allIds: number[] = [];
-    for (const id of includeIds) {
-      const entity = entities.filter((entity: Entity) => entity.id === id);
-      if (entity.length == 0) {
-        allIds.push(id);
-      }
-    }
-    if (allIds.length > 0) {
-      query.where(`${this.entityName}.id IN (:ids)`, { ids: allIds });
-      const data = await query.getMany();
-      entities = data.concat(entities);
-    }
-    const response = new PaginationResponse(entities, total, limit, offset);
-    return response;
-  }
-}
+import {
+  Repository,
+  Connection,
+  EntityManager,
+  SelectQueryBuilder,
+} from 'typeorm';
+import { EntityGeneric } from '../entity';
+import { PaginationDto, BaseFilterDto } from '../../dto';
+import { EntityStateConstant } from '../../constant';
+import { PaginationResponse } from '../../response';
+
+export abstract class ServiceGeneric<
+  Entity extends EntityGeneric,
+  CustomRepository extends Repository<Entity>,
+> {
+  protected readonly entityName: string;
+  protected readonly loggable: boolean = false;
+  protected repository: CustomRepository;
+  protected connection: Connection;
+  constructor(
+    protected readonly connectionOrManager: Connection | EntityManager,
+    repositoryType: { new (connection: Connection): CustomRepository },
+  ) {
+    if (connectionOrManager instanceof EntityManager) {
+      this.connection = connectionOrManager.connection;
+    } else {
+      this.connection = connectionOrManager;
+    }
+    this.repository = this.connection.getCustomRepository(repositoryType);
+  }
+
+  async create(entity: Entity): Promise<Entity> {
+    return this.repository.save(entity);
+  }
+
+  async update(entity: Entity): Promise<Entity> {
+    return this.repository.save(entity);
+  }
+
+  async getListWithPagination(
+    paginationDto: PaginationDto,
+    callback?: (query: SelectQueryBuilder<Entity>) => void,
+  ): Promise<PaginationResponse<Entity>> {
+    const { limit = 25, offset = 0 } = paginationDto;
+    const query = this.repository.createQueryBuilder(this.entityName);
+    query.limit(limit);
+    query.offset(offset);
+    query.where(`${this.entityName}.state != :state`, {
+      state: EntityStateConstant.Archived,
+    });
+    const defaultSelectable = ['createdAt', 'updatedAt'];
+    query.orderBy(`${this.entityName}.updatedAt`, 'DESC');
+    const selection = defaultSelectable.map(
+      (column: string) => `${this.entityName}.${column}`,
+    );
+    query.addSelect(selection);
+    if (callback != null) {
+      callback(query);
+    }
+    const entities = await query.getMany();
+    const total = await query.getCount();
+    const response = new PaginationResponse(entities, total, limit, offset);
+    return response;
+  }
+
+  async getAutocompleteWithPagination(
+    paginationDto: PaginationDto,
+    filter: BaseFilterDto,
+    callback?: (query: SelectQueryBuilder<Entity>) => void,
+  ): Promise<PaginationResponse<Entity>> {
+    const { limit = 25, offset = 0 } = paginationDto;
+    const query = this.repository.createQueryBuilder(this.entityName);
+    query.limit(limit);
+    query.offset(offset);
+    query.where(`${this.entityName}.state != :state`, {
+      state: EntityStateConstant.Archived,
+    });
+    const defaultSelectable = ['createdAt', 'updatedAt'];
+    query.orderBy(`${this.entityName}.updatedAt`, 'DESC');
+    const selection = defaultSelectable.map(
+      (column: string) => `${this.entityName}.${column}`,
+    );
+    query.addSelect(selection);
+    if (callback != null) {
+      callback(query);
+    }
+    const { excludeIds = [], includeIds = [] } = { ...filter };
+    // Exclude some ids from the list.
+    if (excludeIds?.length > 0) {
+      query.andWhere(`${this.entityName}.id NOT IN (:ids)`, {
+        ids: excludeIds,
+      });
+    }
+    let entities = await query.getMany();
+    const total = await query.getCount();
+    // Include some ids to the list.
+    const allIds: number[] = [];
+    for (const id of includeIds) {
+      const entity = entities.filter((entity: Entity) => entity.id === id);
+      if (entity.length == 0) {
+        allIds.push(id);
+      }
+    }
+    if (allIds.length > 0) {
+      query.where(`${this.entityName}.id IN (:ids)`, { ids: allIds });
+      const data = await query.getMany();
+      entities = data.concat(entities);
+    }
+    const response = new PaginationResponse(entities, total, limit, offset);
+    return response;
+  }
+}

package/src/index.ts

@@ -1,3 +1,4 @@
+export * from './auth';
 export * from './generic';
 export * from './constant';
 export * from './dto';

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 './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;
-}
+export class BaseDocument {
+  id?: string;
+}

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

@@ -1 +1 @@
-export * from 'typesense';
+export * from 'typesense';

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

@@ -1,2 +1,2 @@
-export * from './search-document.interface';
+export * from './search-document.interface';
 export * from './transform-service.interface';

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

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

package/src/lib/search-engine/interface/transform-service.interface.ts

@@ -1,10 +1,10 @@
-import { EntityGeneric } from '../../../generic';
-import { BaseDocument } from '../document';
-
-export interface TransformerService<
-  T extends EntityGeneric,
-  Document extends BaseDocument,
-> {
-  transform(data: T): Document;
-  transforms(datas: T[]): Document[];
-}
+import { EntityGeneric } from '../../../generic';
+import { BaseDocument } from '../document';
+
+export interface TransformerService<
+  T extends EntityGeneric,
+  Document extends BaseDocument,
+> {
+  transform(data: T): Document;
+  transforms(datas: T[]): 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 './typesense.module';
+export * from './metadata';
+export * from './service';
+export * from './document';

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

@@ -1,2 +1,2 @@
-export * from './schema.metadata';
+export * from './schema.metadata';
 export * from './typesense.metadata-registry';

package/src/lib/search-engine/typesense/metadata/schema.metadata.ts

@@ -1,13 +1,13 @@
-export interface SchemaField {
-  name: string;
-  type: string;
-  facet?: boolean;
-  index?: boolean;
-  optional?: boolean;
-}
-
-export interface Schema {
-  name: string;
-  defaultSortingField: string;
-  fields: Array<SchemaField>;
-}
+export interface SchemaField {
+  name: string;
+  type: string;
+  facet?: boolean;
+  index?: boolean;
+  optional?: boolean;
+}
+
+export interface Schema {
+  name: string;
+  defaultSortingField: string;
+  fields: Array<SchemaField>;
+}

package/src/lib/search-engine/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[]) => Record<string, 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[]) => Record<string, 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()
+  }
+}