mm-share-lib 0.0.14 → 0.0.16

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/lib/datasource-mapper/datasource-mapper.ts

@@ -0,0 +1,39 @@
+import { DataSource } from 'typeorm';
+import { ConfigService } from '@nestjs/config';
+import { DatabaseConfig } from '../../config';
+
+export class DataSourceManager {
+  private static instance: DataSourceManager;
+
+  private dataSources: { [key: string]: DataSource };
+
+  private constructor(private configService: ConfigService<DatabaseConfig>) {
+    this.dataSources = {};
+  }
+
+  public static getInstance(): DataSourceManager {
+    if (!DataSourceManager.instance) {
+      // TODO: Fix DataSourceManager object instantiation
+      // DataSourceManager.instance = new DataSourceManager();
+    }
+
+    return DataSourceManager.instance;
+  }
+
+  async getDBDataSource(dataSourceName: string): Promise<DataSource> {
+    if (this.dataSources[dataSourceName]) {
+      const dataSource = this.dataSources[dataSourceName];
+      return dataSource.isInitialized
+        ? dataSource
+        : await dataSource.initialize();
+    }
+
+    const newDataSource = new DataSource({
+      /** connection info */
+    } as any);
+
+    this.dataSources[dataSourceName] = newDataSource;
+
+    return await newDataSource.initialize();
+  }
+}

package/src/lib/datasource-mapper/index.ts

@@ -0,0 +1 @@
+export * from './datasource-mapper';

package/src/lib/index.ts

@@ -2,3 +2,4 @@ export * from './search-engine';
 export * from './mailer';
 export * from './redis';
 export * from './storage';
+export * from './datasource-mapper';

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,13 +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<Document>>;
-}
+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/typesense/service/client.service.ts

@@ -3,16 +3,17 @@ import { Logger, Type } from '@nestjs/common';
 import { plainToClass } from 'class-transformer';
 import { CollectionCreateSchema } from '../collection';
 import {
-  SearchParams,
-  SearchOptions,
-  SearchResponse,
   DeleteResponse,
   ImportResponse,
+  SearchOptions,
+  SearchParams,
+  SearchResponse,
 } from '../document';
 import { BaseDocument } from '../../document';
 import { SearchDocumentService } from '../../interface';
 import { EntityGeneric } from '../../../../generic';
 import { PaginationResponse } from '../../../../response';
+import { BaseFilterDto } from '../../../../dto';
 
 export abstract class ClientService<
   Document extends BaseDocument,
@@ -23,6 +24,7 @@ export abstract class ClientService<
   protected readonly entity: Type<Entity>;
   protected abstract cache_s: number;
   protected readonly skipCheckSchema: boolean = false;
+
   constructor(
     protected readonly client: Client,
     protected readonly schema: CollectionCreateSchema,
@@ -33,31 +35,42 @@ export abstract class ClientService<
     }
   }
 
-  // searchDocument(searchParameters: SearchParams, options: SearchOptions) {
-  //     const {
-  //         per_page = 25,
-  //         filter_by,
-  //         archived = false,
-  //     } = { ...searchParameters };
-  //     searchParameters.per_page = per_page;
-  //     return this.client.collections(this?.schema?.name || this.prefix).documents().search(searchParameters, options);
-  // }
+  getCollectionName(): string {
+    return this?.schema?.name || this.prefix;
+  }
 
   async searchDocument(
     searchParameters: SearchParams,
     options: SearchOptions,
+    filter?: BaseFilterDto,
+  ): Promise<SearchResponse<any>> {
+    return this.searchDocumentByCollection(
+      this.getCollectionName(),
+      searchParameters,
+      options,
+      filter,
+    );
+  }
+
+  async searchDocumentByCollection(
+    collection: string,
+    searchParameters: SearchParams,
+    options: SearchOptions,
+    filter?: BaseFilterDto,
   ): Promise<SearchResponse<any>> {
     try {
-      const { includeIds = [], per_page = 25 } = { ...searchParameters };
+      const { per_page = 25 } = searchParameters;
       // TODO: should be support with include/exclude ids.
+      const { includeIds = [] } = filter;
       const includeDocuments = [];
+
       if (includeIds.length > 0) {
         const includeOpts = {
           ...searchParameters,
           filter_by: `id:=[${includeIds.join(', ')}]`,
         };
         const includeDocs = await this.client
-          .collections(this?.schema?.name || this.prefix)
+          .collections(collection)
           .documents()
           .search(includeOpts, options);
         if (includeDocs?.hits?.length > 0) {
@@ -73,7 +86,7 @@ export abstract class ClientService<
         includeDocuments.push(...includeDocs?.hits);
       }
       const documents = await this.client
-        .collections(this?.schema?.name || this.prefix)
+        .collections(collection)
         .documents()
         .search(searchParameters, options);
       if (includeDocuments.length > 0) {
@@ -108,7 +121,7 @@ export abstract class ClientService<
     if (data.length > 0) {
       try {
         return this.client
-          .collections(this?.schema?.name || this.prefix)
+          .collections(this.getCollectionName())
           .documents()
           .import(data, { action: 'upsert' });
       } catch (error) {
@@ -123,7 +136,7 @@ export abstract class ClientService<
         filter_by: `${key}:!=[${data.join(', ')}]`,
       };
       return await this.client
-        .collections(this?.schema?.name || this.prefix)
+        .collections(this.getCollectionName())
         .documents()
         .delete(deleteParameters);
     }
@@ -131,14 +144,14 @@ export abstract class ClientService<
 
   async insertIndex(data: Document): Promise<any> {
     return this.client
-      .collections(this?.schema?.name || this.prefix)
+      .collections(this.getCollectionName())
       .documents()
       .create(data, { action: 'upsert' });
   }
 
   async updateIndex(data: Document): Promise<any> {
     return this.client
-      .collections(this?.schema?.name || this.prefix)
+      .collections(this.getCollectionName())
       .documents()
       .upsert(data, { action: 'upsert' });
   }
@@ -146,12 +159,12 @@ export abstract class ClientService<
   updateDocumentById = async (data: Document) => {
     if (data?.id) {
       const exist = await this.client
-        .collections(this?.schema?.name || this.prefix)
+        .collections(this.getCollectionName())
         .documents(data.id)
         .retrieve();
       if (exist) {
         return this.client
-          .collections(this?.schema?.name || this.prefix)
+          .collections(this.getCollectionName())
           .documents(data.id)
           .update(data);
       }
@@ -164,14 +177,14 @@ export abstract class ClientService<
 
   async deleteIndex(data: Document): Promise<DeleteResponse> {
     return this.client
-      .collections(this?.schema?.name || this.prefix)
+      .collections(this.getCollectionName())
       .documents()
       .delete({ filter_by: `id: ${data.id}` });
   }
 
   async deleteBatchIndex(ids: string[]): Promise<DeleteResponse> {
     return this.client
-      .collections(this?.schema?.name || this.prefix)
+      .collections(this.getCollectionName())
       .documents()
       .delete({ filter_by: `id: [${ids.join(',')}]` });
   }
@@ -181,7 +194,7 @@ export abstract class ClientService<
     value: number,
   ): Promise<DeleteResponse> {
     return this.client
-      .collections(this?.schema?.name || this.prefix)
+      .collections(this.getCollectionName())
       .documents()
       .delete({ filter_by: `${key}:=${value}` });
   }

package/src/setup/index.ts

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

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);
+    });
+  };
+}

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);
+  });
+});

package/src/util/date.util.ts

@@ -1,10 +1,10 @@
-import dayjs from 'dayjs';
-
-export const addSecond = (duration: number): Date => {
-  return dayjs().add(duration, 'seconds').toDate();
-};
-
-export const isExpired = (date: Date): boolean => {
-  const currentDate = dayjs();
-  return dayjs(date).isBefore(currentDate);
-};
+import dayjs from 'dayjs';
+
+export const addSecond = (duration: number): Date => {
+  return dayjs().add(duration, 'seconds').toDate();
+};
+
+export const isExpired = (date: Date): boolean => {
+  const currentDate = dayjs();
+  return dayjs(date).isBefore(currentDate);
+};