mm-share-lib 0.0.1

package/.eslintrc.js

@@ -0,0 +1,25 @@
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: 'tsconfig.json',
+    tsconfigRootDir: __dirname,
+    sourceType: 'module',
+  },
+  plugins: ['@typescript-eslint/eslint-plugin'],
+  extends: [
+    'plugin:@typescript-eslint/recommended',
+    'plugin:prettier/recommended',
+  ],
+  root: true,
+  env: {
+    node: true,
+    jest: true,
+  },
+  ignorePatterns: ['.eslintrc.js'],
+  rules: {
+    '@typescript-eslint/interface-name-prefix': 'off',
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+  },
+};

package/.nvmrc

@@ -0,0 +1 @@
+18.16.0

package/.prettierrc

@@ -0,0 +1,4 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all"
+}

package/README.md

@@ -0,0 +1,73 @@
+<p align="center">
+  <a href="http://nestjs.com/" target="blank"><img src="https://nestjs.com/img/logo-small.svg" width="200" alt="Nest Logo" /></a>
+</p>
+
+[circleci-image]: https://img.shields.io/circleci/build/github/nestjs/nest/master?token=abc123def456
+[circleci-url]: https://circleci.com/gh/nestjs/nest
+
+  <p align="center">A progressive <a href="http://nodejs.org" target="_blank">Node.js</a> framework for building efficient and scalable server-side applications.</p>
+    <p align="center">
+<a href="https://www.npmjs.com/~nestjscore" target="_blank"><img src="https://img.shields.io/npm/v/@nestjs/core.svg" alt="NPM Version" /></a>
+<a href="https://www.npmjs.com/~nestjscore" target="_blank"><img src="https://img.shields.io/npm/l/@nestjs/core.svg" alt="Package License" /></a>
+<a href="https://www.npmjs.com/~nestjscore" target="_blank"><img src="https://img.shields.io/npm/dm/@nestjs/common.svg" alt="NPM Downloads" /></a>
+<a href="https://circleci.com/gh/nestjs/nest" target="_blank"><img src="https://img.shields.io/circleci/build/github/nestjs/nest/master" alt="CircleCI" /></a>
+<a href="https://coveralls.io/github/nestjs/nest?branch=master" target="_blank"><img src="https://coveralls.io/repos/github/nestjs/nest/badge.svg?branch=master#9" alt="Coverage" /></a>
+<a href="https://discord.gg/G7Qnnhy" target="_blank"><img src="https://img.shields.io/badge/discord-online-brightgreen.svg" alt="Discord"/></a>
+<a href="https://opencollective.com/nest#backer" target="_blank"><img src="https://opencollective.com/nest/backers/badge.svg" alt="Backers on Open Collective" /></a>
+<a href="https://opencollective.com/nest#sponsor" target="_blank"><img src="https://opencollective.com/nest/sponsors/badge.svg" alt="Sponsors on Open Collective" /></a>
+  <a href="https://paypal.me/kamilmysliwiec" target="_blank"><img src="https://img.shields.io/badge/Donate-PayPal-ff3f59.svg"/></a>
+    <a href="https://opencollective.com/nest#sponsor"  target="_blank"><img src="https://img.shields.io/badge/Support%20us-Open%20Collective-41B883.svg" alt="Support us"></a>
+  <a href="https://twitter.com/nestframework" target="_blank"><img src="https://img.shields.io/twitter/follow/nestframework.svg?style=social&label=Follow"></a>
+</p>
+  <!--[![Backers on Open Collective](https://opencollective.com/nest/backers/badge.svg)](https://opencollective.com/nest#backer)
+  [![Sponsors on Open Collective](https://opencollective.com/nest/sponsors/badge.svg)](https://opencollective.com/nest#sponsor)-->
+
+## Description
+
+[Nest](https://github.com/nestjs/nest) framework TypeScript starter repository.
+
+## Installation
+
+```bash
+$ npm install
+```
+
+## Running the app
+
+```bash
+# development
+$ npm run start
+
+# watch mode
+$ npm run start:dev
+
+# production mode
+$ npm run start:prod
+```
+
+## Test
+
+```bash
+# unit tests
+$ npm run test
+
+# e2e tests
+$ npm run test:e2e
+
+# test coverage
+$ npm run test:cov
+```
+
+## Support
+
+Nest is an MIT-licensed open source project. It can grow thanks to the sponsors and support by the amazing backers. If you'd like to join them, please [read more here](https://docs.nestjs.com/support).
+
+## Stay in touch
+
+- Author - [Kamil Myśliwiec](https://kamilmysliwiec.com)
+- Website - [https://nestjs.com](https://nestjs.com/)
+- Twitter - [@nestframework](https://twitter.com/nestframework)
+
+## License
+
+Nest is [MIT licensed](LICENSE).

package/index.ts

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

package/nest-cli.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true
+  }
+}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "mm-share-lib",
+  "version": "0.0.1",
+  "description": "Share the generic service, entity, dto.",
+  "author": "Mesa SOT",
+  "license": "MIT",
+  "homepage": "https://github.com/memotechs/share-lib",
+  "scripts": {
+    "build": "nest build",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "node dist/main",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
+    "test:e2e": "jest --config ./test/jest-e2e.json",
+    "prepare": "husky install"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.22.5",
+    "@nestjs/common": "^9.4.2",
+    "@nestjs/core": "^9.4.2",
+    "@nestjs/platform-express": "^9.4.2",
+    "@nestjs/typeorm": "^9.0.1",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.0",
+    "reflect-metadata": "^0.1.13",
+    "rxjs": "^7.8.1",
+    "typeorm": "^0.3.16",
+    "typesense": "^1.5.4"
+  },
+  "devDependencies": {
+    "@nestjs/cli": "^9.5.0",
+    "@nestjs/schematics": "^9.2.0",
+    "@nestjs/testing": "^9.4.2",
+    "@types/express": "^4.17.17",
+    "@types/jest": "29.5.2",
+    "@types/node": "20.2.5",
+    "@types/supertest": "^2.0.12",
+    "@typescript-eslint/eslint-plugin": "^5.59.9",
+    "@typescript-eslint/parser": "^5.59.9",
+    "eslint": "^8.42.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "husky": "^8.0.3",
+    "jest": "29.5.0",
+    "prettier": "^2.8.8",
+    "source-map-support": "^0.5.21",
+    "supertest": "^6.3.3",
+    "ts-jest": "29.1.0",
+    "ts-loader": "^9.4.3",
+    "ts-node": "^10.9.1",
+    "tsconfig-paths": "4.2.0",
+    "typescript": "^5.1.3"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".*\\.spec\\.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "collectCoverageFrom": [
+      "**/*.(t|j)s"
+    ],
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  }
+}

package/src/common/constant/entity-state.constant.ts

@@ -0,0 +1,4 @@
+export enum EntityStateConstant {
+  Active = 1,
+  Archived = 0,
+}

package/src/common/constant/index.ts

@@ -0,0 +1 @@
+export * from './entity-state.constant';

package/src/common/generic/entity/entity.generic.ts

@@ -0,0 +1,34 @@
+import {
+  Column,
+  VersionColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  PrimaryGeneratedColumn,
+} from 'typeorm';
+
+export class EntityGeneric {
+  constructor(id?: number) {
+    this.id = id;
+  }
+
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+
+  @Column()
+  createdBy: number;
+
+  @Column({ select: false })
+  updatedBy: number;
+
+  @Column()
+  state: number;
+
+  @VersionColumn({ select: false })
+  version: number;
+}

package/src/common/generic/entity/index.ts

@@ -0,0 +1 @@
+export * from './entity.generic';

package/src/common/generic/index.ts

@@ -0,0 +1,2 @@
+export * from './entity/entity.generic';
+export * from './service/service.generic';

package/src/common/generic/service/index.ts

@@ -0,0 +1 @@
+export * from './service.generic';

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

@@ -0,0 +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);
+  }
+
+  create = async (entity: Entity): Promise<Entity> => {
+    return this.repository.save(entity);
+  };
+
+  update = async (entity: Entity): Promise<Entity> => {
+    return this.repository.save(entity);
+  };
+
+  getListWithPagination = async (
+    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;
+  };
+
+  getAutocompleteWithPagination = async (
+    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/common/index.ts

@@ -0,0 +1,2 @@
+export * from './generic';
+export * from './constant';

package/src/dto/base-filter.dto.ts

@@ -0,0 +1,4 @@
+export abstract class BaseFilterDto {
+  excludeIds: number[] = undefined;
+  includeIds: number[] = undefined;
+}

package/src/dto/index.ts

@@ -0,0 +1,2 @@
+export * from './pagination.dto';
+export * from './base-filter.dto';

package/src/dto/pagination.dto.ts

@@ -0,0 +1,4 @@
+export class PaginationDto {
+  limit = 25;
+  offset = 0;
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './common';
+export * from './dto';
+export * from './lib';
+export * from './response';
+export * from './util';

package/src/lib/index.ts

@@ -0,0 +1 @@
+export * from './search-engine';

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

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

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

@@ -0,0 +1 @@
+export * from './base.document';

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { EntityGeneric } from '../../../common';
+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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,258 @@
+import { Client } from 'typesense';
+import { Logger, Type } from '@nestjs/common';
+import { plainToClass } from 'class-transformer';
+import { CollectionCreateSchema } from 'typesense/lib/Typesense/Collections';
+import {
+  SearchParams,
+  SearchOptions,
+  SearchResponse,
+  DeleteResponse,
+  ImportResponse,
+} from 'typesense/lib/Typesense/Documents';
+import { BaseDocument } from '../../document';
+import { SearchDocumentService } from '../../interface';
+import { EntityGeneric } from '../../../../common';
+import { PaginationResponse } from '../../../../response';
+
+export abstract class ClientService<
+  Document extends BaseDocument,
+  Entity extends EntityGeneric,
+> implements SearchDocumentService<Document>
+{
+  protected readonly entity: Type<Entity>;
+  protected abstract cache_s: number;
+  protected readonly skipCheckSchema: boolean = false;
+  constructor(
+    protected readonly client: Client,
+    protected readonly schema: CollectionCreateSchema,
+    protected readonly prefix: string,
+  ) {
+    if (!this.skipCheckSchema && schema != null) {
+      this.ensureCollection();
+    }
+  }
+
+  // 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);
+  // }
+
+  async searchDocument(
+    searchParameters: SearchParams,
+    options: SearchOptions,
+  ): Promise<SearchResponse<any>> {
+    try {
+      const { includeIds = [], per_page = 25 } = { ...searchParameters };
+      // TODO: should be support with include/exclude ids.
+      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)
+          .documents()
+          .search(includeOpts, options);
+        if (includeDocs?.hits?.length > 0) {
+          const names = includeDocs.hits.map(
+            (data: Record<string, any>) => data.document.name,
+          );
+          searchParameters.filter_by =
+            searchParameters.filter_by == null
+              ? `name:!=[${names.join(', ')}]`
+              : `${searchParameters.filter_by} && name:!=[${names.join(', ')}]`;
+          searchParameters.per_page = per_page - names.length;
+        }
+        includeDocuments.push(...includeDocs?.hits);
+      }
+      const documents = await this.client
+        .collections(this?.schema?.name || this.prefix)
+        .documents()
+        .search(searchParameters, options);
+      if (includeDocuments.length > 0) {
+        documents.hits.push(...includeDocuments);
+        documents.request_params.per_page = per_page;
+      }
+      return documents;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  getAllRawDocs = async (
+    searchParameters: SearchParams,
+    options: SearchOptions,
+  ) => {
+    searchParameters.per_page = searchParameters.per_page ?? 250;
+    options.cacheSearchResultsForSeconds = 1;
+    const response = await this.searchDocument(searchParameters, options);
+    const { hits = [], found = 0, page = 1 } = response;
+    let documents = hits;
+    const hasNext = hits.length * page < found;
+    if (hasNext) {
+      searchParameters.page = page + 1;
+      documents = await this.getAllRawDocs(searchParameters, options);
+    }
+    return documents;
+  };
+
+  async importIndex(data: Document[]): Promise<ImportResponse[]> {
+    if (data.length > 0) {
+      try {
+        return this.client
+          .collections(this?.schema?.name || this.prefix)
+          .documents()
+          .import(data, { action: 'upsert' });
+      } catch (error) {
+        console.log(error);
+      }
+    }
+  }
+
+  async deleteOutOfDate(data: string[] | number[], key: string): Promise<any> {
+    if (data?.length > 0) {
+      const deleteParameters = {
+        filter_by: `${key}:!=[${data.join(', ')}]`,
+      };
+      return await this.client
+        .collections(this?.schema?.name || this.prefix)
+        .documents()
+        .delete(deleteParameters);
+    }
+  }
+
+  async insertIndex(data: Document): Promise<any> {
+    return this.client
+      .collections(this?.schema?.name || this.prefix)
+      .documents()
+      .create(data, { action: 'upsert' });
+  }
+
+  async updateIndex(data: Document): Promise<any> {
+    return this.client
+      .collections(this?.schema?.name || this.prefix)
+      .documents()
+      .upsert(data, { action: 'upsert' });
+  }
+
+  updateDocumentById = async (data: Document) => {
+    if (data?.id) {
+      const exist = await this.client
+        .collections(this?.schema?.name || this.prefix)
+        .documents(data.id)
+        .retrieve();
+      if (exist) {
+        return this.client
+          .collections(this?.schema?.name || this.prefix)
+          .documents(data.id)
+          .update(data);
+      }
+    }
+  };
+
+  async upsertOrDeleteIndex(datas: Document) {
+    throw new Error('Method is not implement.');
+  }
+
+  async deleteIndex(data: Document): Promise<DeleteResponse> {
+    return this.client
+      .collections(this?.schema?.name || this.prefix)
+      .documents()
+      .delete({ filter_by: `id: ${data.id}` });
+  }
+
+  async deleteBatchIndex(ids: string[]): Promise<DeleteResponse> {
+    return this.client
+      .collections(this?.schema?.name || this.prefix)
+      .documents()
+      .delete({ filter_by: `id: [${ids.join(',')}]` });
+  }
+
+  async deleteIndexByKeyValue(
+    key = 'id',
+    value: number,
+  ): Promise<DeleteResponse> {
+    return this.client
+      .collections(this?.schema?.name || this.prefix)
+      .documents()
+      .delete({ filter_by: `${key}:=${value}` });
+  }
+
+  transforms = (
+    searchResponse: SearchResponse<Record<string, unknown>>,
+  ): Entity[] => {
+    const entities: Entity[] = [];
+    const { hits = [] } = { ...searchResponse };
+    for (const hit of hits) {
+      const document = hit?.document;
+      if (document) {
+        const entity = plainToClass(this.entity, document);
+        entity.id = Number(document.id);
+        entities.push(entity);
+      }
+    }
+    return entities;
+  };
+
+  transform = (
+    searchResponse: SearchResponse<Record<string, unknown>>,
+  ): Entity => {
+    let entity: Entity = null;
+    const { hits = [] } = { ...searchResponse };
+    for (const hit of hits) {
+      const document = hit?.document;
+      if (document) {
+        entity = plainToClass(this.entity, document);
+        entity.id = Number(document.id);
+      }
+      break;
+    }
+    return entity;
+  };
+
+  responseList = (
+    searchResponse: SearchResponse<Record<string, unknown>>,
+    offset = 0,
+  ): PaginationResponse<Entity> => {
+    const entities: Entity[] = [];
+    const {
+      hits = [],
+      found = 0,
+      page = 1,
+      request_params,
+    } = { ...searchResponse };
+    for (const hit of hits) {
+      const document = hit?.document;
+      if (document) {
+        const entity = plainToClass(this.entity, document);
+        entity.id = Number(document.id);
+        entities.push(entity);
+      }
+    }
+
+    const limit = request_params?.per_page;
+
+    // offset = offset ?? (page - 1) * limit;
+
+    return new PaginationResponse(entities, found, limit, offset);
+  };
+
+  private ensureCollection = async (): Promise<void> => {
+    this.checkSchemaName();
+    const exists = await this.client.collections(this.schema.name).exists();
+    if (!exists) {
+      await this.client.collections().create(this.schema);
+    }
+  };
+
+  private checkSchemaName = (): void => {
+    const schemaName = this.schema.name.replace(/.*?\_/gi, '');
+    this.schema.name = `${this.prefix}_${schemaName}`;
+  };
+}

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

@@ -0,0 +1 @@
+export * from './client.service';

package/src/lib/search-engine/typesense/typesense-module.interface.ts

@@ -0,0 +1,36 @@
+import { ModuleMetadata, Type } from '@nestjs/common/interfaces';
+import { LogLevelDesc } from 'loglevel';
+
+export interface TypesenseNodeOptions {
+  host: string;
+  port: number;
+  protocol: string;
+  path?: string;
+  url?: string;
+}
+
+export interface TypesenseModuleOptions {
+  nodes?: Array<TypesenseNodeOptions>;
+  numRetries?: number;
+  apiKey?: string;
+  connectionTimeoutSeconds?: number;
+  retryIntervalSeconds?: number;
+  healthcheckIntervalSeconds?: number;
+  logLevel?: LogLevelDesc;
+}
+
+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/search-engine/typesense/typesense.constants.ts

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

package/src/lib/search-engine/typesense/typesense.module.test.ts

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

@@ -0,0 +1,76 @@
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+import { DiscoveryModule } from '@nestjs/core';
+import {
+  TypesenseModuleAsyncOptions,
+  TypesenseOptionsFactory,
+  TypesenseModuleOptions,
+} from './typesense-module.interface';
+import { TYPESENSE_MODULE_OPTIONS } from './typesense.constants';
+import {
+  createTypesenseExportsProvider,
+  createTypesenseOptionsProvider,
+} from './typesense.providers';
+
+@Module({
+  imports: [DiscoveryModule],
+})
+export class TypesenseModule {
+  static register(options: TypesenseModuleOptions = {}): DynamicModule {
+    const optionsProviders = createTypesenseOptionsProvider(options);
+    const exportsProviders = createTypesenseExportsProvider();
+
+    return {
+      global: true,
+      module: TypesenseModule,
+      providers: [...optionsProviders, ...exportsProviders],
+      exports: exportsProviders,
+    };
+  }
+
+  static registerAsync(options: TypesenseModuleAsyncOptions): DynamicModule {
+    const exportsProviders = createTypesenseExportsProvider();
+
+    return {
+      global: true,
+      module: TypesenseModule,
+      imports: options.imports || [],
+      providers: [...this.createAsyncProviders(options), ...exportsProviders],
+      exports: exportsProviders,
+    };
+  }
+
+  private static createAsyncProviders(
+    options: TypesenseModuleAsyncOptions,
+  ): Provider[] {
+    if (options.useExisting || options.useFactory) {
+      return [this.createAsyncOptionsProvider(options)];
+    }
+
+    return [
+      this.createAsyncOptionsProvider(options),
+      {
+        provide: options?.useClass,
+        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(),
+      inject: [options?.useExisting || options?.useClass],
+    };
+  }
+}

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

@@ -0,0 +1,42 @@
+import { Provider } from '@nestjs/common';
+import { Client } from 'typesense';
+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 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/index.ts

@@ -0,0 +1 @@
+export * from './pagination.response';

package/src/response/pagination.response.ts

@@ -0,0 +1,37 @@
+export class PaginationResponse<T> {
+  data: T[];
+  total?: number;
+  offset?: number;
+  limit?: number;
+  hasNext?: boolean;
+
+  constructor(
+    data: T[],
+    total: number = data?.length || 0,
+    limit?: number,
+    offset?: number,
+  ) {
+    this.data = data;
+    this.total = total;
+    this.offset = offset;
+    this.limit = limit;
+    this.hasNext = this.offset + this.limit < this.total;
+  }
+
+  toJSON() {
+    return {
+      data: this.data,
+      total: this.total,
+      count: this.data.length,
+      offset: this.offset,
+      limit: this.limit,
+      hasNext: this.hasNext,
+    };
+  }
+
+  promise(): Promise<PaginationResponse<T>> {
+    return new Promise((resolve, reject) => {
+      resolve(this);
+    });
+  }
+}

package/src/util/date.util.ts

@@ -0,0 +1 @@
+export class Test {}

package/src/util/generator.util.spec.ts

@@ -0,0 +1,35 @@
+import { generateKey, generateDigitCode } from './generator.util';
+
+describe('Utils', () => {
+  describe('generateKey', () => {
+    it('should generate a key of the specified length', () => {
+      const keyLength = 10;
+      const key = generateKey(keyLength);
+      expect(key).toHaveLength(keyLength);
+    });
+
+    it('should generate a key with default length if not specified', () => {
+      const defaultKeyLength = 36;
+      const key = generateKey();
+      expect(key).toHaveLength(defaultKeyLength);
+    });
+  });
+
+  describe('generateDigitCode', () => {
+    it('should generate a digit code of the specified length', () => {
+      const codeLength = 6;
+      const code = generateDigitCode(codeLength);
+      expect(code).toHaveLength(codeLength);
+      expect(Number(code)).toBeGreaterThanOrEqual(100000);
+      expect(Number(code)).toBeLessThanOrEqual(999999);
+    });
+
+    it('should generate a digit code with default length if not specified', () => {
+      const defaultCodeLength = 4;
+      const code = generateDigitCode();
+      expect(code).toHaveLength(defaultCodeLength);
+      expect(Number(code)).toBeGreaterThanOrEqual(1000);
+      expect(Number(code)).toBeLessThanOrEqual(9999);
+    });
+  });
+});

package/src/util/generator.util.ts

@@ -0,0 +1,18 @@
+export const generateKey = (length = 36) => {
+  const chars =
+    'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+  let result = '';
+  for (let i = length; i > 0; i--) {
+    result += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return result;
+};
+
+export const generateDigitCode = (length = 4): string => {
+  const startAt = 1 + '0'.repeat(length - 1);
+  const endAt = 9 + '0'.repeat(length - 1);
+  const generateCode = `${Math.floor(
+    Number(startAt) + Math.random() * Number(endAt),
+  )}`;
+  return generateCode;
+};

package/src/util/index.ts

@@ -0,0 +1,2 @@
+export * from './date.util';
+export * from './generator.util';

package/test/app.e2e-spec.ts

@@ -0,0 +1,24 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import * as request from 'supertest';
+import { AppModule } from './../src/app.module';
+
+describe('AppController (e2e)', () => {
+  let app: INestApplication;
+
+  beforeEach(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = moduleFixture.createNestApplication();
+    await app.init();
+  });
+
+  it('/ (GET)', () => {
+    return request(app.getHttpServer())
+      .get('/')
+      .expect(200)
+      .expect('Hello World!');
+  });
+});

package/test/jest-e2e.json

@@ -0,0 +1,9 @@
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "rootDir": ".",
+  "testEnvironment": "node",
+  "testRegex": ".e2e-spec.ts$",
+  "transform": {
+    "^.+\\.(t|j)s$": "ts-jest"
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "es2017",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false
+  }
+}