add eslint and prettier

ChenNima · ChenNima · commit bd554cf31f31 · 2023-02-26T13:51:40.000+08:00
diff --git a/.eslintignore b/.eslintignore
@@ -0,0 +1 @@
+jest.config.js
diff --git a/.eslintrc.js b/.eslintrc.js
@@ -0,0 +1,26 @@
+module.exports = {
+    parser: '@typescript-eslint/parser',
+    parserOptions: {
+      project: 'tsconfig.json',
+      sourceType: 'module',
+    },
+    plugins: ['@typescript-eslint/eslint-plugin'],
+    extends: [
+      'plugin:@typescript-eslint/recommended',
+      'plugin:prettier/recommended',
+    ],
+    root: true,
+    env: {
+      node: true,
+      jest: true,
+    },
+    ignorePatterns: ['.eslintrc.js'],
+    rules: {
+      '@typescript-eslint/interface-name-prefix': 'off',
+      '@typescript-eslint/explicit-function-return-type': 'off',
+      '@typescript-eslint/explicit-module-boundary-types': 'off',
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-empty-interface': 'off',
+      '@typescript-eslint/no-non-null-assertion': 'off',
+    },
+  };
diff --git a/.prettierrc b/.prettierrc
@@ -0,0 +1,4 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all"
+}
diff --git a/lib/index.ts b/lib/index.ts
@@ -2,4 +2,4 @@ export * from './type-dorm.module';
 export * from './type-dorm.decorator';
 export * from './type-dorm.interface';
 export * from './type-dorm.util';
-export * from './type-dorm.service';
+export * from './type-dorm.service';
diff --git a/lib/type-dorm.const.ts b/lib/type-dorm.const.ts
@@ -1,3 +1,3 @@
 export const TYPE_DORM_MODULE_NAME = 'default';
 export const TYPE_DORM_MODULE_TOKEN = 'TypeDormModuleToken';
-export const TYPE_DORM_MODULE_OPTION_TOKEN = 'TypeDormModuleOptionToken';
+export const TYPE_DORM_MODULE_OPTION_TOKEN = 'TypeDormModuleOptionToken';
diff --git a/lib/type-dorm.decorator.ts b/lib/type-dorm.decorator.ts
@@ -3,4 +3,4 @@ import { getTypeDormConnectionToken } from './type-dorm.util';
 
 export const InjectTypeDorm = (name?: string) => {
   return Inject(getTypeDormConnectionToken(name));
-};
+};
diff --git a/lib/type-dorm.interface.ts b/lib/type-dorm.interface.ts
@@ -1,16 +1,21 @@
-import { ModuleMetadata, Type } from "@nestjs/common";
-import { ConnectionOptions } from "@typedorm/core";
+import { ModuleMetadata, Type } from '@nestjs/common';
+import { ConnectionOptions } from '@typedorm/core';
 
 export interface TypeDormModuleOption extends ConnectionOptions {}
 
 export interface TypeDormModuleOptionFactory {
-  createTypeDormConnectionOptions(): Promise<ConnectionOptions> | ConnectionOptions;
+  createTypeDormConnectionOptions():
+    | Promise<ConnectionOptions>
+    | ConnectionOptions;
 }
 
-export interface TypeDormModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+export interface TypeDormModuleAsyncOptions
+  extends Pick<ModuleMetadata, 'imports'> {
   name?: string;
   inject?: any[];
   useClass?: Type<TypeDormModuleOptionFactory>;
   useExisting?: Type<TypeDormModuleOptionFactory>;
-  useFactory?: (...args: any[]) => Promise<ConnectionOptions> | ConnectionOptions;
-}
+  useFactory?: (
+    ...args: any[]
+  ) => Promise<ConnectionOptions> | ConnectionOptions;
+}
diff --git a/lib/type-dorm.module.spec.ts b/lib/type-dorm.module.spec.ts
@@ -1,7 +1,7 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { Table } from '@typedorm/common';
-import {DocumentClientV3} from '@typedorm/document-client';
-import {DynamoDBClient} from '@aws-sdk/client-dynamodb';
+import { DocumentClientV3 } from '@typedorm/document-client';
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
 import { TypeDormModule } from './type-dorm.module';
 import { getTypeDormConnectionToken } from './type-dorm.util';
 import { Connection, getEntityManager } from '@typedorm/core';
@@ -20,74 +20,83 @@ describe('TypeDormModule', () => {
   it('Instance typeDorm', async () => {
     const instanceName = 'dummy';
     const module: TestingModule = await Test.createTestingModule({
-      imports: [TypeDormModule.forRoot({
-        table,
-        entities: [],
-        documentClient: new DocumentClientV3(new DynamoDBClient({})),
-        name: instanceName
-      })],
+      imports: [
+        TypeDormModule.forRoot({
+          table,
+          entities: [],
+          documentClient: new DocumentClientV3(new DynamoDBClient({})),
+          name: instanceName,
+        }),
+      ],
     }).compile();
 
     const typeDormModule = module.get(TypeDormModule);
     expect(typeDormModule).toBeInstanceOf(TypeDormModule);
 
-    const typeDormConnection: Connection = module.get(getTypeDormConnectionToken(instanceName));
+    const typeDormConnection: Connection = module.get(
+      getTypeDormConnectionToken(instanceName),
+    );
     expect(typeDormConnection).toBeInstanceOf(Connection);
 
-    const entityManager = getEntityManager(instanceName)
-    expect(entityManager).toStrictEqual(typeDormConnection.entityManager)
+    const entityManager = getEntityManager(instanceName);
+    expect(entityManager).toStrictEqual(typeDormConnection.entityManager);
   });
 
   it('inject redis connection', async () => {
-
     @Injectable()
     class TestProvider {
-      constructor(@InjectTypeDorm() private readonly connection: TypeDormConnection) {}
+      constructor(
+        @InjectTypeDorm() private readonly connection: TypeDormConnection,
+      ) {}
 
       getConnection() {
         return this.connection;
       }
     }
 
     const module: TestingModule = await Test.createTestingModule({
-      imports: [TypeDormModule.forRoot({
-        table,
-        entities: [],
-        documentClient: new DocumentClientV3(new DynamoDBClient({})),
-      })],
+      imports: [
+        TypeDormModule.forRoot({
+          table,
+          entities: [],
+          documentClient: new DocumentClientV3(new DynamoDBClient({})),
+        }),
+      ],
       providers: [TestProvider],
     }).compile();
 
-
     const provider = module.get(TestProvider);
     expect(provider.getConnection()).toBeInstanceOf(Connection);
-
   });
 
   it('Instance async typeDorm', async () => {
     const instanceName = 'dummy2';
     const module: TestingModule = await Test.createTestingModule({
-      imports: [TypeDormModule.forRootAsync({
-        name: instanceName,
-        useFactory: async () => {
-          return {
-            table,
-            entities: [],
-            documentClient: new DocumentClientV3(new DynamoDBClient({})),
-            name: instanceName
-          }
-        },
-      })],
+      imports: [
+        TypeDormModule.forRootAsync({
+          name: instanceName,
+          useFactory: async () => {
+            return {
+              table,
+              entities: [],
+              documentClient: new DocumentClientV3(new DynamoDBClient({})),
+              name: instanceName,
+            };
+          },
+        }),
+      ],
     }).compile();
 
     const typeDormModule = module.get(TypeDormModule);
     expect(typeDormModule).toBeInstanceOf(TypeDormModule);
 
-    const typeDormConnection: Connection = module.get(getTypeDormConnectionToken(instanceName));
+    const typeDormConnection: Connection = module.get(
+      getTypeDormConnectionToken(instanceName),
+    );
     expect(typeDormConnection).toBeInstanceOf(Connection);
 
-    const entityManager = getEntityManager(instanceName)
-    expect(entityManager).toStrictEqual(typeDormConnection.entityManager)
+    const entityManager = getEntityManager(instanceName);
+    expect(entityManager).toStrictEqual(typeDormConnection.entityManager);
   });
 
   it('Instance async typeDorm use class', async () => {
@@ -97,38 +106,44 @@ describe('TypeDormModule', () => {
           table,
           entities: [],
           documentClient: new DocumentClientV3(new DynamoDBClient({})),
-          name: instanceName
-        }
+          name: instanceName,
+        };
       }
     }
 
     const instanceName = 'dummy3';
     const module: TestingModule = await Test.createTestingModule({
-      imports: [TypeDormModule.forRootAsync({
-        name: instanceName,
-        useClass: Factory,
-      })],
+      imports: [
+        TypeDormModule.forRootAsync({
+          name: instanceName,
+          useClass: Factory,
+        }),
+      ],
     }).compile();
 
     const typeDormModule = module.get(TypeDormModule);
     expect(typeDormModule).toBeInstanceOf(TypeDormModule);
 
-    const typeDormConnection: Connection = module.get(getTypeDormConnectionToken(instanceName));
+    const typeDormConnection: Connection = module.get(
+      getTypeDormConnectionToken(instanceName),
+    );
     expect(typeDormConnection).toBeInstanceOf(Connection);
 
-    const entityManager = getEntityManager(instanceName)
-    expect(entityManager).toStrictEqual(typeDormConnection.entityManager)
+    const entityManager = getEntityManager(instanceName);
+    expect(entityManager).toStrictEqual(typeDormConnection.entityManager);
   });
 
   it('Instance typeDorm without injection', async () => {
     const instanceName = 'dummy5';
     const module: TestingModule = await Test.createTestingModule({
-      imports: [TypeDormModule.forRootNonInjection({
-        table,
-        entities: [],
-        documentClient: new DocumentClientV3(new DynamoDBClient({})),
-        name: instanceName
-      })],
+      imports: [
+        TypeDormModule.forRootNonInjection({
+          table,
+          entities: [],
+          documentClient: new DocumentClientV3(new DynamoDBClient({})),
+          name: instanceName,
+        }),
+      ],
     }).compile();
 
     const typeDormModule = module.get(TypeDormModule);
@@ -137,16 +152,22 @@ describe('TypeDormModule', () => {
     const typeDormConnection = module.get(TypeDormConnection);
     expect(typeDormConnection).toBeInstanceOf(Connection);
 
-    const entityManager = getEntityManager(instanceName)
-    expect(entityManager).toStrictEqual(typeDormConnection.entityManager)
+    const entityManager = getEntityManager(instanceName);
+    expect(entityManager).toStrictEqual(typeDormConnection.entityManager);
   });
 
   it('Throw error if pass invalid configuration', async () => {
     const instanceName = 'dummy6';
-    expect(() => Test.createTestingModule({
-      imports: [TypeDormModule.forRootAsync({
-        name: instanceName,
-      })],
-    }).compile()).toThrow('Invalid configuration. Must provide useFactory, useClass or useExisting');
+    expect(() =>
+      Test.createTestingModule({
+        imports: [
+          TypeDormModule.forRootAsync({
+            name: instanceName,
+          }),
+        ],
+      }).compile(),
+    ).toThrow(
+      'Invalid configuration. Must provide useFactory, useClass or useExisting',
+    );
   });
-});
+});
diff --git a/lib/type-dorm.module.ts b/lib/type-dorm.module.ts
diff --git a/lib/type-dorm.util.ts b/lib/type-dorm.util.ts
diff --git a/package.json b/package.json
diff --git a/yarn.lock b/yarn.lock

-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
 +{
 +  "singleQuote": true,
 +  "trailingComma": "all"
 +}