mm-share-lib 0.0.6 → 0.0.7

package/src/lib/typesense/decorator/field.decorator.spec.ts

@@ -1,89 +1,89 @@
-/* eslint-disable max-classes-per-file */
-
-import { Field } from './field.decorator';
-import { FIELD_METADATA } from './field.decorator';
-import { Schema } from './schema.decorator';
-
-describe('typesense', () => {
-  describe('decorators', () => {
-    describe('field', () => {
-      it('should enhance field with metadata', () => {
-        @Schema()
-        class Test {
-          @Field('string')
-          field!: string;
-        }
-
-        expect(Reflect.getMetadata(FIELD_METADATA, Test)).toEqual(
-          expect.arrayContaining([
-            expect.objectContaining({
-              name: 'field',
-              type: 'string',
-            }),
-          ]),
-        );
-      });
-
-      it('should enhance field with custom name metadata', () => {
-        @Schema()
-        class Test {
-          @Field('string', { name: 'custom' })
-          field!: string;
-        }
-
-        expect(Reflect.getMetadata(FIELD_METADATA, Test)).toEqual(
-          expect.arrayContaining([
-            expect.objectContaining({
-              name: 'custom',
-              type: 'string',
-            }),
-          ]),
-        );
-      });
-    });
-
-    it('should enhance field with options metadata', () => {
-      @Schema()
-      class Test {
-        @Field('string', { facet: true, index: true, optional: true })
-        field!: string;
-      }
-
-      expect(Reflect.getMetadata(FIELD_METADATA, Test)).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            name: 'field',
-            type: 'string',
-            facet: true,
-            index: true,
-            optional: true,
-          }),
-        ]),
-      );
-    });
-
-    it('should enhance field with multiple fields metadata', () => {
-      @Schema()
-      class Test {
-        @Field('string')
-        field!: string;
-
-        @Field('string')
-        field2!: string;
-      }
-
-      expect(Reflect.getMetadata(FIELD_METADATA, Test)).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            name: 'field',
-            type: 'string',
-          }),
-          expect.objectContaining({
-            name: 'field2',
-            type: 'string',
-          }),
-        ]),
-      );
-    });
-  });
-});
+/* eslint-disable max-classes-per-file */
+
+import { Field } from './field.decorator';
+import { FIELD_METADATA } from './field.decorator';
+import { Schema } from './schema.decorator';
+
+describe('typesense', () => {
+  describe('decorators', () => {
+    describe('field', () => {
+      it('should enhance field with metadata', () => {
+        @Schema()
+        class Test {
+          @Field('string')
+          field!: string;
+        }
+
+        expect(Reflect.getMetadata(FIELD_METADATA, Test)).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({
+              name: 'field',
+              type: 'string',
+            }),
+          ]),
+        );
+      });
+
+      it('should enhance field with custom name metadata', () => {
+        @Schema()
+        class Test {
+          @Field('string', { name: 'custom' })
+          field!: string;
+        }
+
+        expect(Reflect.getMetadata(FIELD_METADATA, Test)).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({
+              name: 'custom',
+              type: 'string',
+            }),
+          ]),
+        );
+      });
+    });
+
+    it('should enhance field with options metadata', () => {
+      @Schema()
+      class Test {
+        @Field('string', { facet: true, index: true, optional: true })
+        field!: string;
+      }
+
+      expect(Reflect.getMetadata(FIELD_METADATA, Test)).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            name: 'field',
+            type: 'string',
+            facet: true,
+            index: true,
+            optional: true,
+          }),
+        ]),
+      );
+    });
+
+    it('should enhance field with multiple fields metadata', () => {
+      @Schema()
+      class Test {
+        @Field('string')
+        field!: string;
+
+        @Field('string')
+        field2!: string;
+      }
+
+      expect(Reflect.getMetadata(FIELD_METADATA, Test)).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            name: 'field',
+            type: 'string',
+          }),
+          expect.objectContaining({
+            name: 'field2',
+            type: 'string',
+          }),
+        ]),
+      );
+    });
+  });
+});

package/src/lib/typesense/decorator/field.decorator.ts

@@ -1,44 +1,44 @@
-import { SetMetadata } from '@nestjs/common';
-import { applyDecorators } from '@nestjs/common';
-
-export interface FieldMetadata {
-  name?: string;
-  facet?: boolean;
-  index?: boolean;
-  optional?: boolean;
-}
-
-export type FieldType =
-  | 'string'
-  | 'int32'
-  | 'int64'
-  | 'float'
-  | 'bool'
-  | 'geopoint'
-  | 'geopoint[]'
-  | 'string[]'
-  | 'int32[]'
-  | 'int64[]'
-  | 'float[]'
-  | 'bool[]'
-  | 'object'
-  | 'object[]'
-  | 'auto'
-  | 'string*';
-
-export const FIELD_METADATA = '__fieldMetadata__';
-
-export const Field = (type: FieldType, options: FieldMetadata = {}) =>
-  applyDecorators((target: object, key?: any, descriptor?: any) => {
-    const exists =
-      Reflect.getMetadata(FIELD_METADATA, target.constructor) || [];
-
-    return SetMetadata(FIELD_METADATA, [
-      ...exists,
-      {
-        ...options,
-        type,
-        name: options.name || key,
-      },
-    ])(target.constructor, key, descriptor);
-  });
+import { SetMetadata } from '@nestjs/common';
+import { applyDecorators } from '@nestjs/common';
+
+export interface FieldMetadata {
+  name?: string;
+  facet?: boolean;
+  index?: boolean;
+  optional?: boolean;
+}
+
+export type FieldType =
+  | 'string'
+  | 'int32'
+  | 'int64'
+  | 'float'
+  | 'bool'
+  | 'geopoint'
+  | 'geopoint[]'
+  | 'string[]'
+  | 'int32[]'
+  | 'int64[]'
+  | 'float[]'
+  | 'bool[]'
+  | 'object'
+  | 'object[]'
+  | 'auto'
+  | 'string*';
+
+export const FIELD_METADATA = '__fieldMetadata__';
+
+export const Field = (type: FieldType, options: FieldMetadata = {}) =>
+  applyDecorators((target: object, key?: any, descriptor?: any) => {
+    const exists =
+      Reflect.getMetadata(FIELD_METADATA, target.constructor) || [];
+
+    return SetMetadata(FIELD_METADATA, [
+      ...exists,
+      {
+        ...options,
+        type,
+        name: options.name || key,
+      },
+    ])(target.constructor, key, descriptor);
+  });

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

@@ -1,2 +1,2 @@
-export * from './field.decorator';
-export * from './schema.decorator';
+export * from './field.decorator';
+export * from './schema.decorator';

package/src/lib/typesense/decorator/schema.decorator.ts

@@ -1,23 +1,23 @@
-import decamelize from 'decamelize';
-import { SetMetadata, applyDecorators } from '@nestjs/common';
-
-export interface Schema {
-  name?: string;
-  defaultSortingField?: string;
-  auto?: boolean;
-}
-
-export const SCHEMA_METADATA = '__schemaMetadata__';
-
-export const Schema = (options: Schema = {}): ClassDecorator =>
-  applyDecorators((target: object, key?: any, descriptor?: any) =>
-    SetMetadata(SCHEMA_METADATA, {
-      name:
-        options.name ||
-        decamelize((target as any).name, {
-          separator: '-',
-          preserveConsecutiveUppercase: false,
-        }),
-      defaultSortingField: options.defaultSortingField,
-    })(target, key, descriptor),
-  );
+import decamelize from 'decamelize';
+import { SetMetadata, applyDecorators } from '@nestjs/common';
+
+export interface Schema {
+  name?: string;
+  defaultSortingField?: string;
+  auto?: boolean;
+}
+
+export const SCHEMA_METADATA = '__schemaMetadata__';
+
+export const Schema = (options: Schema = {}): ClassDecorator =>
+  applyDecorators((target: object, key?: any, descriptor?: any) =>
+    SetMetadata(SCHEMA_METADATA, {
+      name:
+        options.name ||
+        decamelize((target as any).name, {
+          separator: '-',
+          preserveConsecutiveUppercase: false,
+        }),
+      defaultSortingField: options.defaultSortingField,
+    })(target, key, descriptor),
+  );

package/src/lib/typesense/document/base.document.ts

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

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

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

package/src/lib/typesense/index.ts

@@ -1,6 +1,6 @@
-export * from './client';
-// export * from './collection';
-// export * from './decorator';
-export * from './document';
-export * from './metadata';
-export * from './module';
+export * from './client';
+// export * from './collection';
+// export * from './decorator';
+export * from './document';
+export * from './metadata';
+export * from './module';

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

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

package/src/lib/typesense/metadata/schema.metadata.ts

@@ -1,21 +1,21 @@
-import type { FieldType } from '../decorator/field.decorator';
-
-export interface SchemaField {
-  name: string;
-  type: FieldType;
-  optional?: boolean;
-  facet?: boolean;
-  index?: boolean;
-  sort?: boolean;
-  locale?: string;
-  infix?: boolean;
-  num_dim?: number;
-  [t: string]: unknown;
-}
-
-export interface Schema {
-  name: string;
-  fields: Array<SchemaField>;
-  enable_nested_fields?: boolean;
-  defaultSortingField?: string;
-}
+import type { FieldType } from '../decorator/field.decorator';
+
+export interface SchemaField {
+  name: string;
+  type: FieldType;
+  optional?: boolean;
+  facet?: boolean;
+  index?: boolean;
+  sort?: boolean;
+  locale?: string;
+  infix?: boolean;
+  num_dim?: number;
+  [t: string]: unknown;
+}
+
+export interface Schema {
+  name: string;
+  fields: Array<SchemaField>;
+  enable_nested_fields?: boolean;
+  defaultSortingField?: string;
+}

package/src/lib/typesense/metadata/typesense.metadata-accessor.ts

@@ -1,37 +1,37 @@
-import { Injectable } from '@nestjs/common';
-import { Reflector } from '@nestjs/core';
-
-import { SCHEMA_METADATA } from '../decorator';
-import { FIELD_METADATA } from '../decorator';
-import { Schema } from './schema.metadata';
-
-@Injectable()
-export class TypesenseMetadataAccessor {
-  constructor(private readonly reflector: Reflector) {}
-
-  getTypesenseMetadata(target): Schema | undefined {
-    if (target.constructor) {
-      const schema = this.reflector.get(SCHEMA_METADATA, target.constructor);
-      const fields = this.reflector.get(FIELD_METADATA, target.constructor);
-
-      if (!schema) {
-        return undefined;
-      }
-
-      if (!(fields || schema.auto)) {
-        return undefined;
-      }
-
-      return {
-        name: schema.name,
-        defaultSortingField: schema.defaultSortingField,
-        fields: [
-          ...(schema.auto ? [{ name: '.*', type: 'auto' }] : []),
-          ...(fields || []),
-        ],
-      };
-    }
-
-    return undefined;
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+
+import { SCHEMA_METADATA } from '../decorator';
+import { FIELD_METADATA } from '../decorator';
+import { Schema } from './schema.metadata';
+
+@Injectable()
+export class TypesenseMetadataAccessor {
+  constructor(private readonly reflector: Reflector) {}
+
+  getTypesenseMetadata(target): Schema | undefined {
+    if (target.constructor) {
+      const schema = this.reflector.get(SCHEMA_METADATA, target.constructor);
+      const fields = this.reflector.get(FIELD_METADATA, target.constructor);
+
+      if (!schema) {
+        return undefined;
+      }
+
+      if (!(fields || schema.auto)) {
+        return undefined;
+      }
+
+      return {
+        name: schema.name,
+        defaultSortingField: schema.defaultSortingField,
+        fields: [
+          ...(schema.auto ? [{ name: '.*', type: 'auto' }] : []),
+          ...(fields || []),
+        ],
+      };
+    }
+
+    return undefined;
+  }
+}

package/src/lib/typesense/metadata/typesense.metadata-explorer.spec.ts

@@ -1,56 +1,56 @@
-/* eslint-disable max-classes-per-file */
-
-import 'reflect-metadata';
-
-import { Module } from '@nestjs/common';
-import { DiscoveryModule } from '@nestjs/core';
-import { Test } from '@nestjs/testing';
-
-import { Schema } from '../decorators';
-import { Field } from '../decorators';
-import { TypesenseMetadataAccessor } from './typesense.metadata-accessor';
-import { TypesenseMetadataExplorer } from './typesense.metadata-explorer';
-import { TypesenseMetadataRegistry } from './typesense.metadata-registry';
-
-describe('typesense', () => {
-  describe('metadata', () => {
-    describe('explorer', () => {
-      let module;
-
-      @Module({
-        imports: [DiscoveryModule],
-        providers: [
-          TypesenseMetadataAccessor,
-          TypesenseMetadataExplorer,
-          TypesenseMetadataRegistry,
-        ],
-      })
-      class TestMetadataModule {}
-
-      @Schema()
-      class TestSchema {
-        @Field('string')
-        field!: string;
-      }
-
-      beforeEach(async () => {
-        module = await Test.createTestingModule({
-          imports: [TestMetadataModule],
-          providers: [TestSchema],
-        }).compile();
-
-        await module.init();
-      });
-
-      afterEach(async () => {
-        await module.close();
-      });
-
-      it('should store schema metadata', () => {
-        expect(
-          module.get(TypesenseMetadataRegistry).getSchemaByTarget(TestSchema),
-        ).toBeDefined();
-      });
-    });
-  });
-});
+/* eslint-disable max-classes-per-file */
+
+import 'reflect-metadata';
+
+import { Module } from '@nestjs/common';
+import { DiscoveryModule } from '@nestjs/core';
+import { Test } from '@nestjs/testing';
+
+import { Schema } from '../decorators';
+import { Field } from '../decorators';
+import { TypesenseMetadataAccessor } from './typesense.metadata-accessor';
+import { TypesenseMetadataExplorer } from './typesense.metadata-explorer';
+import { TypesenseMetadataRegistry } from './typesense.metadata-registry';
+
+describe('typesense', () => {
+  describe('metadata', () => {
+    describe('explorer', () => {
+      let module;
+
+      @Module({
+        imports: [DiscoveryModule],
+        providers: [
+          TypesenseMetadataAccessor,
+          TypesenseMetadataExplorer,
+          TypesenseMetadataRegistry,
+        ],
+      })
+      class TestMetadataModule {}
+
+      @Schema()
+      class TestSchema {
+        @Field('string')
+        field!: string;
+      }
+
+      beforeEach(async () => {
+        module = await Test.createTestingModule({
+          imports: [TestMetadataModule],
+          providers: [TestSchema],
+        }).compile();
+
+        await module.init();
+      });
+
+      afterEach(async () => {
+        await module.close();
+      });
+
+      it('should store schema metadata', () => {
+        expect(
+          module.get(TypesenseMetadataRegistry).getSchemaByTarget(TestSchema),
+        ).toBeDefined();
+      });
+    });
+  });
+});

package/src/lib/typesense/metadata/typesense.metadata-explorer.ts

@@ -1,41 +1,41 @@
-import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
-import { DiscoveryService } from '@nestjs/core';
-import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
-
-import { TypesenseMetadataAccessor } from './typesense.metadata-accessor';
-import { TypesenseMetadataRegistry } from './typesense.metadata-registry';
-
-@Injectable()
-export class TypesenseMetadataExplorer implements OnModuleInit {
-  private readonly logger = new Logger(TypesenseMetadataExplorer.name);
-
-  constructor(
-    private readonly discoveryService: DiscoveryService,
-    private readonly metadataAccessor: TypesenseMetadataAccessor,
-    private readonly metadataRegistry: TypesenseMetadataRegistry,
-  ) {}
-
-  onModuleInit() {
-    this.explore();
-  }
-
-  explore() {
-    this.discoveryService.getProviders().forEach((wrapper: InstanceWrapper) => {
-      const { instance } = wrapper;
-
-      if (!instance || !Object.getPrototypeOf(instance)) {
-        return;
-      }
-
-      this.lookupSchema(instance);
-    });
-  }
-
-  lookupSchema(instance) {
-    const metadata = this.metadataAccessor.getTypesenseMetadata(instance);
-
-    if (metadata) {
-      this.metadataRegistry.addSchema(instance.constructor, metadata);
-    }
-  }
-}
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
+import { DiscoveryService } from '@nestjs/core';
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+
+import { TypesenseMetadataAccessor } from './typesense.metadata-accessor';
+import { TypesenseMetadataRegistry } from './typesense.metadata-registry';
+
+@Injectable()
+export class TypesenseMetadataExplorer implements OnModuleInit {
+  private readonly logger = new Logger(TypesenseMetadataExplorer.name);
+
+  constructor(
+    private readonly discoveryService: DiscoveryService,
+    private readonly metadataAccessor: TypesenseMetadataAccessor,
+    private readonly metadataRegistry: TypesenseMetadataRegistry,
+  ) {}
+
+  onModuleInit() {
+    this.explore();
+  }
+
+  explore() {
+    this.discoveryService.getProviders().forEach((wrapper: InstanceWrapper) => {
+      const { instance } = wrapper;
+
+      if (!instance || !Object.getPrototypeOf(instance)) {
+        return;
+      }
+
+      this.lookupSchema(instance);
+    });
+  }
+
+  lookupSchema(instance) {
+    const metadata = this.metadataAccessor.getTypesenseMetadata(instance);
+
+    if (metadata) {
+      this.metadataRegistry.addSchema(instance.constructor, metadata);
+    }
+  }
+}