mm-share-lib 0.0.6 → 0.0.8

package/src/util/app.utils.ts

@@ -1,18 +1,18 @@
-import type { INestApplication } from '@nestjs/common';
-
-export class AppUtils {
-  public static killAppWithGrace = (app: INestApplication) => {
-    process.on('SIGINT', async () => {
-      setTimeout(() => process.exit(1), 5000);
-      await app.close();
-      process.exit(0);
-    });
-
-    // kill -15
-    process.on('SIGTERM', async () => {
-      setTimeout(() => process.exit(1), 5000);
-      await app.close();
-      process.exit(0);
-    });
-  };
-}
+import type { INestApplication } from '@nestjs/common';
+
+export class AppUtils {
+  public static killAppWithGrace = (app: INestApplication) => {
+    process.on('SIGINT', async () => {
+      setTimeout(() => process.exit(1), 5000);
+      await app.close();
+      process.exit(0);
+    });
+
+    // kill -15
+    process.on('SIGTERM', async () => {
+      setTimeout(() => process.exit(1), 5000);
+      await app.close();
+      process.exit(0);
+    });
+  };
+}

package/src/util/date.util.spec.ts

@@ -1,49 +1,49 @@
-import dayjs from 'dayjs';
-import { addSecond, isExpired } from './date.util';
-
-describe('Utility Functions', () => {
-  test('addSecond should return a Date object with the specified duration added', () => {
-    // Arrange
-    const duration = 10;
-
-    // Act
-    const result = addSecond(duration);
-
-    // Assert
-    const expectedDate = dayjs().add(duration, 'seconds').toDate();
-    expect(result).toEqual(expectedDate);
-  });
-
-  test('isExpired should return true for a past date', () => {
-    // Arrange
-    const pastDate = dayjs().subtract(1, 'day').toDate();
-
-    // Act
-    const result = isExpired(pastDate);
-
-    // Assert
-    expect(result).toBe(true);
-  });
-
-  test('isExpired should return false for a future date', () => {
-    // Arrange
-    const futureDate = dayjs().add(1, 'day').toDate();
-
-    // Act
-    const result = isExpired(futureDate);
-
-    // Assert
-    expect(result).toBe(false);
-  });
-
-  test('isExpired should return false for the current date', () => {
-    // Arrange
-    const currentDate = dayjs().toDate();
-
-    // Act
-    const result = isExpired(currentDate);
-
-    // Assert
-    expect(result).toBe(false);
-  });
-});
+import dayjs from 'dayjs';
+import { addSecond, isExpired } from './date.util';
+
+describe('Utility Functions', () => {
+  test('addSecond should return a Date object with the specified duration added', () => {
+    // Arrange
+    const duration = 10;
+
+    // Act
+    const result = addSecond(duration);
+
+    // Assert
+    const expectedDate = dayjs().add(duration, 'seconds').toDate();
+    expect(result).toEqual(expectedDate);
+  });
+
+  test('isExpired should return true for a past date', () => {
+    // Arrange
+    const pastDate = dayjs().subtract(1, 'day').toDate();
+
+    // Act
+    const result = isExpired(pastDate);
+
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  test('isExpired should return false for a future date', () => {
+    // Arrange
+    const futureDate = dayjs().add(1, 'day').toDate();
+
+    // Act
+    const result = isExpired(futureDate);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test('isExpired should return false for the current date', () => {
+    // Arrange
+    const currentDate = dayjs().toDate();
+
+    // Act
+    const result = isExpired(currentDate);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+});

package/src/util/date.util.ts

@@ -1,10 +1,10 @@
-import dayjs from 'dayjs';
-
-export const addSecond = (duration: number): Date => {
-  return dayjs().add(duration, 'seconds').toDate();
-};
-
-export const isExpired = (date: Date): boolean => {
-  const currentDate = dayjs();
-  return dayjs(date).isBefore(currentDate);
-};
+import dayjs from 'dayjs';
+
+export const addSecond = (duration: number): Date => {
+  return dayjs().add(duration, 'seconds').toDate();
+};
+
+export const isExpired = (date: Date): boolean => {
+  const currentDate = dayjs();
+  return dayjs(date).isBefore(currentDate);
+};

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

@@ -1,79 +1,79 @@
-import * as bcrypt from 'bcrypt';
-import {
-  generateKey,
-  generateDigitCode,
-  generatePassword,
-} 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);
-    });
-  });
-
-  describe('Utility Functions', () => {
-    test('generatePassword should return a hashed password with the specified salt rounds', async () => {
-      // Arrange
-      const password = 'password123';
-      const saltRounds = 12;
-
-      // Act
-      const hashedPassword = await generatePassword(password, saltRounds);
-
-      // Assert
-      expect(typeof hashedPassword).toBe('string');
-      expect(hashedPassword).not.toBe(password);
-      expect(await bcrypt.compare(password, hashedPassword)).toBeTruthy();
-    });
-
-    test('generatePassword should use the default salt rounds when no value is provided', async () => {
-      // Arrange
-      const password = 'password123';
-      const defaultSaltRounds = 10;
-
-      // Act
-      const hashedPassword = await generatePassword(password);
-
-      // Assert
-      expect(typeof hashedPassword).toBe('string');
-      expect(hashedPassword).not.toBe(password);
-      expect(await bcrypt.compare(password, hashedPassword)).toBeTruthy();
-      expect(bcrypt.getRounds(hashedPassword)).toBe(defaultSaltRounds);
-    });
-
-    test('generatePassword should throw an error when an invalid password is provided', async () => {
-      // Arrange
-      const invalidPassword = '';
-
-      // Act and Assert
-      await expect(generatePassword(invalidPassword)).rejects.toThrow();
-    });
-  });
-});
+import * as bcrypt from 'bcrypt';
+import {
+  generateKey,
+  generateDigitCode,
+  generatePassword,
+} 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);
+    });
+  });
+
+  describe('Utility Functions', () => {
+    test('generatePassword should return a hashed password with the specified salt rounds', async () => {
+      // Arrange
+      const password = 'password123';
+      const saltRounds = 12;
+
+      // Act
+      const hashedPassword = await generatePassword(password, saltRounds);
+
+      // Assert
+      expect(typeof hashedPassword).toBe('string');
+      expect(hashedPassword).not.toBe(password);
+      expect(await bcrypt.compare(password, hashedPassword)).toBeTruthy();
+    });
+
+    test('generatePassword should use the default salt rounds when no value is provided', async () => {
+      // Arrange
+      const password = 'password123';
+      const defaultSaltRounds = 10;
+
+      // Act
+      const hashedPassword = await generatePassword(password);
+
+      // Assert
+      expect(typeof hashedPassword).toBe('string');
+      expect(hashedPassword).not.toBe(password);
+      expect(await bcrypt.compare(password, hashedPassword)).toBeTruthy();
+      expect(bcrypt.getRounds(hashedPassword)).toBe(defaultSaltRounds);
+    });
+
+    test('generatePassword should throw an error when an invalid password is provided', async () => {
+      // Arrange
+      const invalidPassword = '';
+
+      // Act and Assert
+      await expect(generatePassword(invalidPassword)).rejects.toThrow();
+    });
+  });
+});

package/src/util/generator.util.ts

@@ -1,34 +1,34 @@
-import * as bcrypt from 'bcrypt';
-
-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;
-};
-
-export const generatePassword = async (
-  password: string,
-  saltOrRounds = 10,
-): Promise<string> => {
-  return await bcrypt.hash(password, saltOrRounds);
-};
-
-export const comparePassword = (
-  password: string,
-  hashPassword: string,
-): Promise<boolean> => {
-  return bcrypt.compare(password, hashPassword);
-};
+import * as bcrypt from 'bcrypt';
+
+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;
+};
+
+export const generatePassword = async (
+  password: string,
+  saltOrRounds = 10,
+): Promise<string> => {
+  return await bcrypt.hash(password, saltOrRounds);
+};
+
+export const comparePassword = (
+  password: string,
+  hashPassword: string,
+): Promise<boolean> => {
+  return bcrypt.compare(password, hashPassword);
+};

package/src/util/index.ts

@@ -1,4 +1,4 @@
-export * from './date.util';
-export * from './generator.util';
-export * from './app.utils';
-export * from './validate-config';
+export * from './date.util';
+export * from './generator.util';
+export * from './app.utils';
+export * from './validate-config';

package/test/app.e2e-spec.ts

@@ -1,24 +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!');
-  });
-});
+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

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

package/tsconfig.build.json

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

package/tsconfig.json

@@ -1,21 +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
-  }
-}
+{
+  "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
+  }
+}

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

@@ -1 +0,0 @@
-// export { CollectionSchema } from 'typesense/src/Typesense/Collection';

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

@@ -1,89 +0,0 @@
-/* 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 +0,0 @@
-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);
-  });