mm-share-lib 0.0.8 → 0.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mm-share-lib",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "Share the generic service, entity, dto.",
   "author": "Mesa SOT",
   "license": "MIT",

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/document/index.ts

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

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

@@ -1 +1,2 @@
-export * from './typesense';
+export * from './typesense';
+export * from './document';

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

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

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

@@ -1,13 +1,18 @@
-export interface SchemaField {
-  name: string;
-  type: string;
-  facet?: boolean;
-  index?: boolean;
-  optional?: boolean;
-}
-
-export interface Schema {
-  name: string;
-  defaultSortingField: string;
-  fields: Array<SchemaField>;
-}
+import {
+  CollectionSchema,
+  CollectionFieldSchema,
+} from 'typesense/lib/Typesense/Collection';
+
+export interface SchemaField extends CollectionFieldSchema {
+  name: string;
+  facet?: boolean;
+  index?: boolean;
+  optional?: boolean;
+  sort?: boolean;
+}
+
+export interface Schema extends CollectionSchema {
+  name: string;
+  defaultSortingField: string;
+  fields: 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: unknown[]) => 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/index.ts

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

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

@@ -1,36 +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[];
-}
+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

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

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

@@ -1,94 +1,92 @@
-/* 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()
-    })
-  })
-})
+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

@@ -1,76 +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],
-    };
-  }
-}
+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

@@ -1,42 +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],
-  },
-];
+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/dist/src/lib/search-engine/schema/generic.schema.d.ts

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

package/dist/src/lib/search-engine/schema/generic.schema.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GenericSchema = void 0;
-class GenericSchema {
-}
-exports.GenericSchema = GenericSchema;
-//# sourceMappingURL=generic.schema.js.map

package/dist/src/lib/search-engine/schema/generic.schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generic.schema.js","sourceRoot":"","sources":["../../../../../src/lib/search-engine/schema/generic.schema.ts"],"names":[],"mappings":";;;AAAA,MAAa,aAAa;CAAG;AAA7B,sCAA6B"}

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

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