mm-share-lib 0.0.7 → 0.0.9

package/src/lib/typesense/module/typesense.module.spec.ts

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

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

package/src/lib/typesense/module/typesense.provider.ts

@@ -1,54 +0,0 @@
-import { Client } from 'typesense';
-import { Provider } from '@nestjs/common';
-import { TypesenseCollectionsCreator } from '../collection';
-import {
-  TypesenseMetadataAccessor,
-  TypesenseMetadataRegistry,
-  TypesenseMetadataExplorer,
-} from '../metadata';
-import { TypesenseModuleOptions } from './interface.module';
-import { TYPESENSE_MODULE_OPTIONS } from './typesense.constant';
-
-export const createTypesenseOptionsProvider = (
-  options: TypesenseModuleOptions = {},
-): Provider[] => [
-  {
-    provide: TYPESENSE_MODULE_OPTIONS,
-    useValue: options,
-  },
-];
-
-export const createTypesenseProvider = (): Provider[] => [
-  TypesenseMetadataAccessor,
-  TypesenseMetadataExplorer,
-  TypesenseMetadataRegistry,
-  TypesenseCollectionsCreator,
-];
-
-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],
-  },
-];