코딩 컨벤션에 맞게 코드 리포매팅

Author: BlizzardBlue

package-scripts.js

@@ -5,8 +5,8 @@ import { ExpressMiddlewareInterface, Middleware } from 'routing-controllers';
 @Middleware({ type: 'before' })
 export class CompressionMiddleware implements ExpressMiddlewareInterface {
 
-    public use(req: express.Request, res: express.Response, next: express.NextFunction): any {
-        return compression()(req, res, next);
-    }
+  public use(req: express.Request, res: express.Response, next: express.NextFunction): any {
+    return compression()(req, res, next);
+  }
 
 }

src/api/middlewares/CompressionMiddleware.ts

@@ -7,26 +7,27 @@ import { env } from '../../env';
 @Middleware({ type: 'after' })
 export class ErrorHandlerMiddleware implements ExpressErrorMiddlewareInterface {
 
-    public isProduction = env.isProduction;
-
-    constructor(
-        @Logger(__filename) private log: LoggerInterface
-    ) { }
-
-    public error(error: HttpError, req: express.Request, res: express.Response, next: express.NextFunction): void {
-        res.status(error.httpCode || 500);
-        res.json({
-            name: error.name,
-            message: error.message,
-            errors: error[`errors`] || [],
-        });
-
-        if (this.isProduction) {
-            this.log.error(error.name, error.message);
-        } else {
-            this.log.error(error.name, error.stack);
-        }
-
+  public isProduction = env.isProduction;
+
+  constructor(
+    @Logger(__filename) private log: LoggerInterface,
+  ) {
+  }
+
+  public error(error: HttpError, req: express.Request, res: express.Response, next: express.NextFunction): void {
+    res.status(error.httpCode || 500);
+    res.json({
+      name: error.name,
+      message: error.message,
+      errors: error[`errors`] || [],
+    });
+
+    if (this.isProduction) {
+      this.log.error(error.name, error.message);
+    } else {
+      this.log.error(error.name, error.stack);
     }
 
+  }
+
 }

src/api/middlewares/ErrorHandlerMiddleware.ts

@@ -8,14 +8,14 @@ import { Logger } from '../../lib/logger';
 @Middleware({ type: 'before' })
 export class LogMiddleware implements ExpressMiddlewareInterface {
 
-    private log = new Logger(__dirname);
+  private log = new Logger(__dirname);
 
-    public use(req: express.Request, res: express.Response, next: express.NextFunction): any {
-        return morgan(env.log.output, {
-            stream: {
-                write: this.log.info.bind(this.log),
-            },
-        })(req, res, next);
-    }
+  public use(req: express.Request, res: express.Response, next: express.NextFunction): any {
+    return morgan(env.log.output, {
+      stream: {
+        write: this.log.info.bind(this.log),
+      },
+    })(req, res, next);
+  }
 
 }

src/api/middlewares/LogMiddleware.ts

@@ -5,11 +5,11 @@ import { ExpressMiddlewareInterface, Middleware } from 'routing-controllers';
 @Middleware({ type: 'before' })
 export class SecurityHstsMiddleware implements ExpressMiddlewareInterface {
 
-    public use(req: express.Request, res: express.Response, next: express.NextFunction): any {
-        return helmet.hsts({
-            maxAge: 31536000,
-            includeSubdomains: true,
-        })(req, res, next);
-    }
+  public use(req: express.Request, res: express.Response, next: express.NextFunction): any {
+    return helmet.hsts({
+      maxAge: 31536000,
+      includeSubdomains: true,
+    })(req, res, next);
+  }
 
 }

src/api/middlewares/SecurityHstsMiddleware.ts

@@ -5,8 +5,8 @@ import { ExpressMiddlewareInterface, Middleware } from 'routing-controllers';
 @Middleware({ type: 'before' })
 export class SecurityMiddleware implements ExpressMiddlewareInterface {
 
-    public use(req: express.Request, res: express.Response, next: express.NextFunction): any {
-        return helmet()(req, res, next);
-    }
+  public use(req: express.Request, res: express.Response, next: express.NextFunction): any {
+    return helmet()(req, res, next);
+  }
 
 }

src/api/middlewares/SecurityMiddleware.ts

@@ -5,8 +5,8 @@ import { ExpressMiddlewareInterface, Middleware } from 'routing-controllers';
 @Middleware({ type: 'before' })
 export class SecurityNoCacheMiddleware implements ExpressMiddlewareInterface {
 
-    public use(req: express.Request, res: express.Response, next: express.NextFunction): any {
-        return helmet.noCache()(req, res, next);
-    }
+  public use(req: express.Request, res: express.Response, next: express.NextFunction): any {
+    return helmet.noCache()(req, res, next);
+  }
 
 }

src/api/middlewares/SecurityNoCacheMiddleware.ts

@@ -26,22 +26,22 @@ import { winstonLoader } from './loaders/winstonLoader';
 const log = new Logger(__filename);
 
 bootstrapMicroframework({
-    /**
-     * Loader is a place where you can configure all your modules during microframework
-     * bootstrap process. All loaders are executed one by one in a sequential order.
-     */
-    loaders: [
-        winstonLoader,
-        iocLoader,
-        eventDispatchLoader,
-        typeormLoader,
-        expressLoader,
-        swaggerLoader,
-        monitorLoader,
-        homeLoader,
-        publicLoader,
-        graphqlLoader,
-    ],
+  /**
+   * Loader is a place where you can configure all your modules during microframework
+   * bootstrap process. All loaders are executed one by one in a sequential order.
+   */
+  loaders: [
+    winstonLoader,
+    iocLoader,
+    eventDispatchLoader,
+    typeormLoader,
+    expressLoader,
+    swaggerLoader,
+    monitorLoader,
+    homeLoader,
+    publicLoader,
+    graphqlLoader,
+  ],
 })
-    .then(() => banner(log))
-    .catch(error => log.error('Application is crashed: ' + error));
+  .then(() => banner(log))
+  .catch(error => log.error('Application is crashed: ' + error));

src/app.ts

@@ -9,40 +9,41 @@ import { Logger, LoggerInterface } from '../decorators/Logger';
 @Service()
 export class AuthService {
 
-    constructor(
-        @Logger(__filename) private log: LoggerInterface,
-        @OrmRepository() private userRepository: UserRepository
-    ) { }
-
-    public parseBasicAuthFromRequest(req: express.Request): { username: string, password: string } {
-        const authorization = req.header('authorization');
-
-        if (authorization && authorization.split(' ')[0] === 'Basic') {
-            this.log.info('Credentials provided by the client');
-            const decodedBase64 = Buffer.from(authorization.split(' ')[1], 'base64').toString('ascii');
-            const username = decodedBase64.split(':')[0];
-            const password = decodedBase64.split(':')[1];
-            if (username && password) {
-                return { username, password };
-            }
-        }
-
-        this.log.info('No credentials provided by the client');
-        return undefined;
+  constructor(
+    @Logger(__filename) private log: LoggerInterface,
+    @OrmRepository() private userRepository: UserRepository,
+  ) {
+  }
+
+  public parseBasicAuthFromRequest(req: express.Request): { username: string, password: string } {
+    const authorization = req.header('authorization');
+
+    if (authorization && authorization.split(' ')[0] === 'Basic') {
+      this.log.info('Credentials provided by the client');
+      const decodedBase64 = Buffer.from(authorization.split(' ')[1], 'base64').toString('ascii');
+      const username = decodedBase64.split(':')[0];
+      const password = decodedBase64.split(':')[1];
+      if (username && password) {
+        return { username, password };
+      }
     }
 
-    public async validateUser(username: string, password: string): Promise<User> {
-        const user = await this.userRepository.findOne({
-            where: {
-                username,
-            },
-        });
+    this.log.info('No credentials provided by the client');
+    return undefined;
+  }
 
-        if (await User.comparePassword(user, password)) {
-            return user;
-        }
+  public async validateUser(username: string, password: string): Promise<User> {
+    const user = await this.userRepository.findOne({
+      where: {
+        username,
+      },
+    });
 
-        return undefined;
+    if (await User.comparePassword(user, password)) {
+      return user;
     }
 
+    return undefined;
+  }
+
 }

src/auth/AuthService.ts

@@ -6,29 +6,29 @@ import { Logger } from '../lib/logger';
 import { AuthService } from './AuthService';
 
 export function authorizationChecker(connection: Connection): (action: Action, roles: any[]) => Promise<boolean> | boolean {
-    const log = new Logger(__filename);
-    const authService = Container.get<AuthService>(AuthService);
+  const log = new Logger(__filename);
+  const authService = Container.get<AuthService>(AuthService);
 
-    return async function innerAuthorizationChecker(action: Action, roles: string[]): Promise<boolean> {
-        // here you can use request/response objects from action
-        // also if decorator defines roles it needs to access the action
-        // you can use them to provide granular access check
-        // checker must return either boolean (true or false)
-        // either promise that resolves a boolean value
-        const credentials = authService.parseBasicAuthFromRequest(action.request);
+  return async function innerAuthorizationChecker(action: Action, roles: string[]): Promise<boolean> {
+    // here you can use request/response objects from action
+    // also if decorator defines roles it needs to access the action
+    // you can use them to provide granular access check
+    // checker must return either boolean (true or false)
+    // either promise that resolves a boolean value
+    const credentials = authService.parseBasicAuthFromRequest(action.request);
 
-        if (credentials === undefined) {
-            log.warn('No credentials given');
-            return false;
-        }
+    if (credentials === undefined) {
+      log.warn('No credentials given');
+      return false;
+    }
 
-        action.request.user = await authService.validateUser(credentials.username, credentials.password);
-        if (action.request.user === undefined) {
-            log.warn('Invalid credentials given');
-            return false;
-        }
+    action.request.user = await authService.validateUser(credentials.username, credentials.password);
+    if (action.request.user === undefined) {
+      log.warn('Invalid credentials given');
+      return false;
+    }
 
-        log.info('Successfully checked credentials');
-        return true;
-    };
+    log.info('Successfully checked credentials');
+    return true;
+  };
 }

src/auth/authorizationChecker.ts

@@ -4,7 +4,7 @@ import { Connection } from 'typeorm';
 import { User } from '../api/models/User';
 
 export function currentUserChecker(connection: Connection): (action: Action) => Promise<User | undefined> {
-    return async function innerCurrentUserChecker(action: Action): Promise<User | undefined> {
-        return action.request.user;
-    };
+  return async function innerCurrentUserChecker(action: Action): Promise<User | undefined> {
+    return action.request.user;
+  };
 }

src/auth/currentUserChecker.ts

@@ -3,11 +3,11 @@ import { Container, ObjectType } from 'typedi';
 import { createDataLoader, CreateDataLoaderOptions } from '../lib/graphql';
 
 export function DLoader<T>(obj: ObjectType<T>, options: CreateDataLoaderOptions = {}): ParameterDecorator {
-    return (object, propertyKey, index) => {
-        const dataLoader = createDataLoader(obj, options);
-        const propertyName = propertyKey ? propertyKey.toString() : '';
-        Container.registerHandler({ object, propertyName, index, value: () => dataLoader });
-    };
+  return (object, propertyKey, index) => {
+    const dataLoader = createDataLoader(obj, options);
+    const propertyName = propertyKey ? propertyKey.toString() : '';
+    Container.registerHandler({ object, propertyName, index, value: () => dataLoader });
+  };
 }
 
 export * from '../lib/graphql';

src/decorators/DLoader.ts

@@ -2,10 +2,10 @@ import { EventDispatcher as EventDispatcherClass } from 'event-dispatch';
 import { Container } from 'typedi';
 
 export function EventDispatcher(): any {
-    return (object: any, propertyName: string, index?: number): any => {
-        const eventDispatcher = new EventDispatcherClass();
-        Container.registerHandler({ object, propertyName, index, value: () => eventDispatcher });
-    };
+  return (object: any, propertyName: string, index?: number): any => {
+    const eventDispatcher = new EventDispatcherClass();
+    Container.registerHandler({ object, propertyName, index, value: () => eventDispatcher });
+  };
 }
 
 export { EventDispatcher as EventDispatcherInterface } from 'event-dispatch';

src/decorators/EventDispatcher.ts

@@ -3,11 +3,11 @@ import { Container } from 'typedi';
 import { Logger as WinstonLogger } from '../lib/logger';
 
 export function Logger(scope: string): ParameterDecorator {
-    return (object, propertyKey, index): any => {
-        const logger = new WinstonLogger(scope);
-        const propertyName = propertyKey ? propertyKey.toString() : '';
-        Container.registerHandler({ object, propertyName, index, value: () => logger });
-    };
+  return (object, propertyKey, index): any => {
+    const logger = new WinstonLogger(scope);
+    const propertyName = propertyKey ? propertyKey.toString() : '';
+    Container.registerHandler({ object, propertyName, index, value: () => logger });
+  };
 }
 
 export { LoggerInterface } from '../lib/logger';