mm-share-lib 0.0.6 → 0.0.7

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/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()
+  }
+}

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,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()
-    })
-  })
-})
+/* 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

@@ -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/src/lib/typesense/client/index.ts

@@ -1 +1 @@
-export { Client } from 'typesense';
+export { Client } from 'typesense';

package/src/lib/typesense/collection/index.ts

@@ -1 +1 @@
-// export { CollectionSchema } from 'typesense/src/Typesense/Collection';
+export * from './typesense-colletctions.creator';

package/src/lib/typesense/collection/typesense-colletctions.creator.ts

@@ -0,0 +1,29 @@
+import { Client } from 'typesense';
+import { OnModuleInit, Logger, Injectable } from '@nestjs/common';
+import { TypesenseMetadataRegistry } from '../metadata';
+
+@Injectable()
+export class TypesenseCollectionsCreator implements OnModuleInit {
+  private readonly logger = new Logger(TypesenseCollectionsCreator.name);
+
+  constructor(
+    private readonly registry: TypesenseMetadataRegistry,
+    private readonly typesense: Client,
+  ) {}
+
+  async onModuleInit() {
+    for (const target of this.registry.getTargets()) {
+      const schema = this.registry.getSchemaByTarget(target);
+
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        await this.typesense.collections(schema!.name).retrieve();
+      } catch (error) {
+        if ((error as any).httpStatus === 404) {
+          // eslint-disable-next-line no-await-in-loop
+          await this.typesense.collections().create(schema);
+        }
+      }
+    }
+  }
+}