refactor: format code with prettier

Author: NoNameProvided

sample/sample1-simple-usage/app.ts

@@ -1,41 +1,37 @@
-import "reflect-metadata";
-import {createConnection, useContainer} from "typeorm";
-import {Container} from "typedi";
-import {PostRepository} from "./repository/PostRepository";
-import {Post} from "./entity/Post";
+import 'reflect-metadata';
+import { createConnection, useContainer } from 'typeorm';
+import { Container } from 'typedi';
+import { PostRepository } from './repository/PostRepository';
+import { Post } from './entity/Post';
 
 useContainer(Container);
 createConnection({
-    type: "mysql",
-    host: "localhost",
-    port: 3306,
-    username: "test",
-    password: "test",
-    database: "test",
-    entities: [
-        Post
-    ],
-    synchronize: true
-}).then(async connection => {
-    console.log("connected");
+  type: 'mysql',
+  host: 'localhost',
+  port: 3306,
+  username: 'test',
+  password: 'test',
+  database: 'test',
+  entities: [Post],
+  synchronize: true,
+})
+  .then(async connection => {
+    console.log('connected');
 
     const post1 = new Post();
-    post1.title = "TypeScript 2.0";
+    post1.title = 'TypeScript 2.0';
     post1.text = `New TypeScript version adds control flow based type analysis features.`;
 
     const post2 = new Post();
-    post2.title = "Control flow based type analysis";
+    post2.title = 'Control flow based type analysis';
     post2.text = `TypeScript 2.0 implements a control flow-based type analysis for local variables and parameters.`;
 
     const repository = Container.get(PostRepository);
-    await Promise.all([
-        repository.saveUsingRepository(post1),
-        repository.saveUsingManager(post2)
-    ]);
+    await Promise.all([repository.saveUsingRepository(post1), repository.saveUsingManager(post2)]);
 
-    console.log("Saved successfully.");
+    console.log('Saved successfully.');
 
     const loadedPosts = await repository.findAll();
-    console.log("All loaded posts: ", loadedPosts);
-
-}).catch(error => console.log("Error: ", error));
+    console.log('All loaded posts: ', loadedPosts);
+  })
+  .catch(error => console.log('Error: ', error));

sample/sample1-simple-usage/entity/Post.ts

@@ -1,15 +1,13 @@
-import {Entity, PrimaryGeneratedColumn, Column} from "typeorm";
+import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
 
 @Entity()
 export class Post {
+  @PrimaryGeneratedColumn()
+  id: number;
 
-    @PrimaryGeneratedColumn()
-    id: number;
+  @Column()
+  title: string;
 
-    @Column()
-    title: string;
-
-    @Column()
-    text: string;
-
-}
+  @Column()
+  text: string;
+}

sample/sample1-simple-usage/repository/PostRepository.ts

@@ -1,29 +1,26 @@
-import {EntityManager, Repository} from "typeorm";
-import {Service} from "typedi";
+import { EntityManager, Repository } from 'typeorm';
+import { Service } from 'typedi';
 
-import {Post} from "../entity/Post";
-import {InjectRepository} from "../../../src/decorators/InjectRepository";
-import {InjectManager} from "../../../src/decorators/InjectManager";
+import { Post } from '../entity/Post';
+import { InjectRepository } from '../../../src/decorators/InjectRepository';
+import { InjectManager } from '../../../src/decorators/InjectManager';
 
 @Service()
 export class PostRepository {
+  @InjectManager()
+  private entityManager: EntityManager;
 
-    @InjectManager()
-    private entityManager: EntityManager;
+  constructor(@InjectRepository(Post) private InjectRepository: Repository<Post>) {}
 
-    constructor(@InjectRepository(Post) private InjectRepository: Repository<Post>) {
-    }
+  saveUsingRepository(post: Post) {
+    return this.InjectRepository.save(post);
+  }
 
-    saveUsingRepository(post: Post) {
-        return this.InjectRepository.save(post);
-    }
+  saveUsingManager(post: Post) {
+    return this.entityManager.save(post);
+  }
 
-    saveUsingManager(post: Post) {
-        return this.entityManager.save(post);
-    }
-
-    findAll() {
-        return this.InjectRepository.find();
-    }
-
-}
+  findAll() {
+    return this.InjectRepository.find();
+  }
+}

src/decorators/InjectConnection.ts

@@ -1,19 +1,26 @@
-import {ConnectionManager} from "typeorm";
-import {Container} from "typedi";
+import { ConnectionManager } from 'typeorm';
+import { Container, Constructable } from 'typedi';
 
 /**
  * Allows to inject an Connection using typedi's Container.
  */
-export function InjectConnection(connectionName: string = "default"): Function {
-    return function(object: Object|Function, propertyName: string, index?: number) {
-        Container.registerHandler({ object, index, propertyName, value: () => {
-            const connectionManager = Container.get(ConnectionManager);
-            if (!connectionManager.has(connectionName))
-                throw new Error(`Cannot get connection "${connectionName}" from the connection manager. ` +
-                  `Make sure you have created such connection. Also make sure you have called useContainer(Container) ` +
-                  `in your application before you established a connection and importing any entity.`);
+export function InjectConnection(connectionName: string = 'default'): Function {
+  return function (object: Object | Function, propertyName: string, index?: number) {
+    Container.registerHandler({
+      object: object as Constructable<unknown>,
+      index,
+      propertyName,
+      value: () => {
+        const connectionManager = Container.get(ConnectionManager);
+        if (!connectionManager.has(connectionName))
+          throw new Error(
+            `Cannot get connection "${connectionName}" from the connection manager. ` +
+              `Make sure you have created such connection. Also make sure you have called useContainer(Container) ` +
+              `in your application before you established a connection and importing any entity.`
+          );
 
-            return connectionManager.get(connectionName);
-        }});
-    };
+        return connectionManager.get(connectionName);
+      },
+    });
+  };
 }

src/decorators/InjectManager.ts

@@ -1,25 +1,34 @@
-import {ConnectionManager} from "typeorm";
-import {Container} from "typedi";
+import { ConnectionManager } from 'typeorm';
+import { Constructable, Container } from 'typedi';
 
 /**
  * Allows to inject an EntityManager using typedi's Container.
  */
-export function InjectManager(connectionName: string = "default"): Function {
-    return function(object: Object|Function, propertyName: string, index?: number) {
-        Container.registerHandler({ object, index, propertyName, value: () => {
-            const connectionManager = Container.get(ConnectionManager);
-            if (!connectionManager.has(connectionName))
-                throw new Error(`Cannot get connection "${connectionName}" from the connection manager. ` +
-                  `Make sure you have created such connection. Also make sure you have called useContainer(Container) ` +
-                  `in your application before you established a connection and importing any entity.`);
+export function InjectManager(connectionName: string = 'default'): Function {
+  return function (object: Object | Function, propertyName: string, index?: number) {
+    Container.registerHandler({
+      object: object as Constructable<unknown>,
+      index,
+      propertyName,
+      value: () => {
+        const connectionManager = Container.get(ConnectionManager);
+        if (!connectionManager.has(connectionName))
+          throw new Error(
+            `Cannot get connection "${connectionName}" from the connection manager. ` +
+              `Make sure you have created such connection. Also make sure you have called useContainer(Container) ` +
+              `in your application before you established a connection and importing any entity.`
+          );
 
-            const connection = connectionManager.get(connectionName);
-            const entityManager = connection.manager;
-            if (!entityManager)
-                throw new Error(`Entity manager was not found on "${connectionName}" connection. ` +
-                  `Make sure you correctly setup connection and container usage.`);
+        const connection = connectionManager.get(connectionName);
+        const entityManager = connection.manager;
+        if (!entityManager)
+          throw new Error(
+            `Entity manager was not found on "${connectionName}" connection. ` +
+              `Make sure you correctly setup connection and container usage.`
+          );
 
-            return entityManager;
-        }});
-    };
+        return entityManager;
+      },
+    });
+  };
 }