style: format all

Author: marian2js

.dockerignore

@@ -0,0 +1,2 @@
+dist
+node_modules

apps/api/Dockerfile

@@ -1,11 +1,11 @@
 FROM node:14
 
 # context path: ./backend
-COPY . /app/chainjet/backend
+COPY ../.. /app/chainjet/backend
 WORKDIR /app/chainjet/backend
 
 RUN yarn
-RUN yarn build
+RUN yarn build api
 
 CMD [ "yarn", "start:prod:api" ]
 

apps/api/src/account-credentials/account-credentials.module.ts

@@ -15,14 +15,14 @@ import { AccountCredentialService } from './services/account-credentials.service
     ConfigModule.forRoot(),
     NestjsQueryGraphQLModule.forFeature({
       imports: [NestjsQueryTypegooseModule.forFeature([AccountCredential])],
-      resolvers: []
+      resolvers: [],
     }),
     UsersModule, // required for GraphqlGuard
     IntegrationsModule,
     IntegrationAccountsModule,
-    forwardRef(() => RunnerModule)
+    forwardRef(() => RunnerModule),
   ],
   providers: [AccountCredentialResolver, AccountCredentialService, AccountCredentialAuthorizer],
-  exports: [AccountCredentialService]
+  exports: [AccountCredentialService],
 })
 export class AccountCredentialsModule {}

apps/api/src/account-credentials/resolvers/account-credentials.resolver.spec.ts

@@ -13,11 +13,8 @@ describe('AccountCredentialResolver', () => {
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      imports: [
-        TypegooseModule.forFeature([AccountCredential]),
-        MockModule
-      ],
-      providers: [AccountCredentialResolver, AccountCredentialService, AccountCredentialAuthorizer]
+      imports: [TypegooseModule.forFeature([AccountCredential]), MockModule],
+      providers: [AccountCredentialResolver, AccountCredentialService, AccountCredentialAuthorizer],
     }).compile()
 
     resolver = module.get<AccountCredentialResolver>(AccountCredentialResolver)

apps/api/src/account-credentials/resolvers/account-credentials.resolver.ts

@@ -7,7 +7,7 @@ import { GraphqlGuard } from '../../auth/guards/graphql.guard'
 import {
   AccountCredential,
   CreateAccountCredentialInput,
-  UpdateAccountCredentialInput
+  UpdateAccountCredentialInput,
 } from '../entities/account-credential'
 import { AccountCredentialService } from '../services/account-credentials.service'
 
@@ -19,11 +19,11 @@ export class AccountCredentialAuthorizer extends OwnedAuthorizer<AccountCredenti
 export class AccountCredentialResolver extends BaseResolver(AccountCredential, {
   CreateDTOClass: CreateAccountCredentialInput,
   UpdateDTOClass: UpdateAccountCredentialInput,
-  guards: [GraphqlGuard]
+  guards: [GraphqlGuard],
 }) {
-  constructor (
+  constructor(
     protected accountCredentialService: AccountCredentialService,
-    @InjectAuthorizer(AccountCredential) readonly authorizer: Authorizer<AccountCredential>
+    @InjectAuthorizer(AccountCredential) readonly authorizer: Authorizer<AccountCredential>,
   ) {
     super(accountCredentialService)
   }

apps/api/src/account-credentials/services/account-credentials.service.spec.ts

@@ -12,11 +12,8 @@ describe('AccountCredentialService', () => {
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      imports: [
-        TypegooseModule.forFeature([AccountCredential]),
-        MockModule
-      ],
-      providers: [AccountCredentialService]
+      imports: [TypegooseModule.forFeature([AccountCredential]), MockModule],
+      providers: [AccountCredentialService],
     }).compile()
 
     service = module.get<AccountCredentialService>(AccountCredentialService)

apps/api/src/app.controller.spec.ts

@@ -8,7 +8,7 @@ describe('AppController', () => {
   beforeEach(async () => {
     const app: TestingModule = await Test.createTestingModule({
       controllers: [AppController],
-      providers: [AppService]
+      providers: [AppService],
     }).compile()
 
     appController = app.get<AppController>(AppController)

apps/api/src/app.controller.ts

@@ -3,10 +3,10 @@ import { AppService } from './app.service'
 
 @Controller()
 export class AppController {
-  constructor (private readonly appService: AppService) {}
+  constructor(private readonly appService: AppService) {}
 
   @Get()
-  getHello (): string {
+  getHello(): string {
     return this.appService.getHello()
   }
 }

apps/api/src/app.service.ts

@@ -2,7 +2,7 @@ import { Injectable } from '@nestjs/common'
 
 @Injectable()
 export class AppService {
-  getHello (): string {
+  getHello(): string {
     return 'Hello World!'
   }
 }

apps/api/src/auth/auth.module.ts

@@ -23,31 +23,29 @@ import { OwnershipService } from './services/ownership.service'
       inject: [ConfigService],
       useFactory: (configService: ConfigService) => {
         return {
-          secret: configService.get('JWT_SECRET')
+          secret: configService.get('JWT_SECRET'),
         }
-      }
+      },
     }),
 
     // Sessions are required for passport-oauth1
     SessionModule.forRoot({
       // An empty string will make the sesion fail if for some reason a secret is not defined
-      session: { secret: process.env.SESSION_SECRET ?? '' }
+      session: { secret: process.env.SESSION_SECRET ?? '' },
     }),
 
     UsersModule,
     forwardRef(() => AccountCredentialsModule),
     ProjectsModule,
     IntegrationAccountsModule,
-    EmailsModule
+    EmailsModule,
   ],
   providers: [AuthService, AuthResolver, JwtStrategy, OwnershipService, OAuthStrategyFactory],
   controllers: [ExternalOAuthController],
-  exports: [AuthService, OAuthStrategyFactory]
+  exports: [AuthService, OAuthStrategyFactory],
 })
 export class AuthModule {
-  configure (consumer: MiddlewareConsumer): void {
-    consumer
-      .apply(OAuthStrategyFactory.initializePassport())
-      .forRoutes(ExternalOAuthController)
+  configure(consumer: MiddlewareConsumer): void {
+    consumer.apply(OAuthStrategyFactory.initializePassport()).forRoutes(ExternalOAuthController)
   }
 }

apps/api/src/auth/config/admins.ts

@@ -1,3 +1 @@
-export const ADMIN_USERS = [
-  'mariano.pardo'
-]
+export const ADMIN_USERS = ['mariano.pardo']

apps/api/src/auth/decorators/user-id.decorator.ts

@@ -2,9 +2,7 @@ import { createParamDecorator, ExecutionContext } from '@nestjs/common'
 import { GqlExecutionContext } from '@nestjs/graphql'
 
 // TODO see createGqlParamDecorator
-export const UserId = createParamDecorator(
-  (data: unknown, context: ExecutionContext) => {
-    const ctx = GqlExecutionContext.create(context)
-    return ctx.getContext().req.user?.id
-  }
-)
+export const UserId = createParamDecorator((data: unknown, context: ExecutionContext) => {
+  const ctx = GqlExecutionContext.create(context)
+  return ctx.getContext().req.user?.id
+})

apps/api/src/auth/external-oauth/controllers/external-oauth.controller.spec.ts

@@ -11,7 +11,7 @@ describe('ExternalOAuth Controller', () => {
     const module: TestingModule = await Test.createTestingModule({
       imports: [MockModule],
       controllers: [ExternalOAuthController],
-      providers: [OAuthStrategyFactory]
+      providers: [OAuthStrategyFactory],
     }).compile()
 
     controller = module.get<ExternalOAuthController>(ExternalOAuthController)

apps/api/src/auth/external-oauth/guards/cookie.guard.ts

@@ -5,15 +5,15 @@ import { GqlUserContext } from '../../typings/gql-context'
 
 @Injectable()
 export class CookieGuard implements CanActivate {
-  constructor (private readonly authService: AuthService) {}
+  constructor(private readonly authService: AuthService) {}
 
-  canActivate (context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean> {
+  canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean> {
     const user = this.getUserFromContext(context)
     context.switchToHttp().getRequest().user = user
     return !!user?.id
   }
 
-  getAccessTokenContext (context: ExecutionContext): string | null {
+  getAccessTokenContext(context: ExecutionContext): string | null {
     try {
       const cookie = context.switchToHttp().getRequest()?.headers?.cookie
       const tokenStr = decodeURIComponent(cookie.split('fw-token=')?.[1]?.split(';')?.[0])
@@ -24,7 +24,7 @@ export class CookieGuard implements CanActivate {
     }
   }
 
-  getUserFromContext (context: ExecutionContext): GqlUserContext | null {
+  getUserFromContext(context: ExecutionContext): GqlUserContext | null {
     try {
       const accessToken = this.getAccessTokenContext(context)
       if (!accessToken) {
@@ -42,7 +42,7 @@ export class CookieGuard implements CanActivate {
  * Loads the user from cookies into the request, but allows the request to continue
  */
 export class NotAuthRequiredCookieGuard extends CookieGuard {
-  async canActivate (context: ExecutionContext): Promise<true> {
+  async canActivate(context: ExecutionContext): Promise<true> {
     await super.canActivate(context)
     return true
   }

apps/api/src/auth/external-oauth/login-strategies/FacebookLoginStrategy.ts

@@ -4,19 +4,25 @@ import { LoginProviderStrategy, LoginStrategyCallback } from './LoginProviderStr
 
 export class FacebookLoginStrategy extends LoginProviderStrategy {
   strategyOptions = {
-    scope: ['email']
+    scope: ['email'],
   }
 
-  constructor (readonly strategyName: string, readonly callbackURL: string) {
+  constructor(readonly strategyName: string, readonly callbackURL: string) {
     super(strategyName, callbackURL)
   }
 
-  registerStrategy (callback: LoginStrategyCallback): void {
-    passport.use(this.strategyName, new Strategy({
-      clientID: process.env.FACEBOOK_CLIENT_ID ?? '',
-      clientSecret: process.env.FACEBOOK_CLIENT_SECRET ?? '',
-      callbackURL: this.callbackURL,
-      profileFields: ['id', 'emails', 'displayName']
-    }, callback))
+  registerStrategy(callback: LoginStrategyCallback): void {
+    passport.use(
+      this.strategyName,
+      new Strategy(
+        {
+          clientID: process.env.FACEBOOK_CLIENT_ID ?? '',
+          clientSecret: process.env.FACEBOOK_CLIENT_SECRET ?? '',
+          callbackURL: this.callbackURL,
+          profileFields: ['id', 'emails', 'displayName'],
+        },
+        callback,
+      ),
+    )
   }
 }

apps/api/src/auth/external-oauth/login-strategies/GithubLoginStrategy.ts

@@ -4,19 +4,25 @@ import { LoginProviderStrategy, LoginStrategyCallback } from './LoginProviderStr
 
 export class GithubLoginStrategy extends LoginProviderStrategy {
   strategyOptions = {
-    scope: ['user:email']
+    scope: ['user:email'],
   }
 
-  constructor (readonly strategyName: string, readonly callbackURL: string) {
+  constructor(readonly strategyName: string, readonly callbackURL: string) {
     super(strategyName, callbackURL)
   }
 
-  registerStrategy (callback: LoginStrategyCallback): void {
-    passport.use(this.strategyName, new Strategy({
-      clientID: process.env.GITHUB_CLIENT_ID ?? '',
-      clientSecret: process.env.GITHUB_CLIENT_SECRET ?? '',
-      callbackURL: this.callbackURL,
-      scope: ['user:email']
-    }, callback))
+  registerStrategy(callback: LoginStrategyCallback): void {
+    passport.use(
+      this.strategyName,
+      new Strategy(
+        {
+          clientID: process.env.GITHUB_CLIENT_ID ?? '',
+          clientSecret: process.env.GITHUB_CLIENT_SECRET ?? '',
+          callbackURL: this.callbackURL,
+          scope: ['user:email'],
+        },
+        callback,
+      ),
+    )
   }
 }

apps/api/src/auth/external-oauth/login-strategies/GoogleLoginStrategy.ts

@@ -4,18 +4,24 @@ import { LoginProviderStrategy, LoginStrategyCallback } from './LoginProviderStr
 
 export class GoogleLoginStrategy extends LoginProviderStrategy {
   strategyOptions = {
-    scope: ['profile', 'email']
+    scope: ['profile', 'email'],
   }
 
-  constructor (readonly strategyName: string, readonly callbackURL: string) {
+  constructor(readonly strategyName: string, readonly callbackURL: string) {
     super(strategyName, callbackURL)
   }
 
-  registerStrategy (callback: LoginStrategyCallback): void {
-    passport.use(this.strategyName, new Strategy({
-      clientID: process.env.GOOGLE_CLIENT_ID ?? '',
-      clientSecret: process.env.GOOGLE_CLIENT_SECRET ?? '',
-      callbackURL: this.callbackURL
-    }, callback))
+  registerStrategy(callback: LoginStrategyCallback): void {
+    passport.use(
+      this.strategyName,
+      new Strategy(
+        {
+          clientID: process.env.GOOGLE_CLIENT_ID ?? '',
+          clientSecret: process.env.GOOGLE_CLIENT_SECRET ?? '',
+          callbackURL: this.callbackURL,
+        },
+        callback,
+      ),
+    )
   }
 }

apps/api/src/auth/external-oauth/login-strategies/LoginProviderStrategy.ts

@@ -2,22 +2,19 @@ import passport, { Profile } from 'passport'
 
 export type ProviderCallback = (err?: any, user?: any, info?: any) => void
 
-export type LoginProvider =
-  'google' |
-  'facebook' |
-  'github'
+export type LoginProvider = 'google' | 'facebook' | 'github'
 
 export type LoginStrategyCallback = (
   accessToken: string,
   refreshToken: string,
   profile: Profile,
-  done: ProviderCallback
+  done: ProviderCallback,
 ) => any
 
 export abstract class LoginProviderStrategy {
-  constructor (readonly strategyName: string, readonly callbackURL: string) {}
+  constructor(readonly strategyName: string, readonly callbackURL: string) {}
 
   abstract strategyOptions: passport.AuthenticateOptions
 
-  abstract registerStrategy (callback: LoginStrategyCallback): void
+  abstract registerStrategy(callback: LoginStrategyCallback): void
 }

apps/api/src/auth/guards/graphql.guard.spec.ts

@@ -7,10 +7,8 @@ describe('GraphqlGuard', () => {
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      imports: [
-        MockModule
-      ],
-      providers: []
+      imports: [MockModule],
+      providers: [],
     }).compile()
 
     guard = module.get<GraphqlGuard>(GraphqlGuard)

apps/api/src/auth/guards/graphql.guard.ts

@@ -7,11 +7,11 @@ import { GqlContext } from '../typings/gql-context'
 
 @Injectable()
 export class GraphqlGuard extends AuthGuard('jwt') implements CanActivate {
-  constructor (private readonly userService: UserService) {
+  constructor(private readonly userService: UserService) {
     super()
   }
 
-  async canActivate (context: ExecutionContext): Promise<boolean> {
+  async canActivate(context: ExecutionContext): Promise<boolean> {
     const ctx = GqlExecutionContext.create(context)
     const req = ctx.getContext().req
 
@@ -21,8 +21,8 @@ export class GraphqlGuard extends AuthGuard('jwt') implements CanActivate {
       const [username, apiKey] = token.split(':')
       const user = await this.userService.findOne({ username })
       if (user && apiKey && (user.apiKey === apiKey || user.apiKey === `${username}:${apiKey}`)) {
-        (req.user as AuthPayload) = {
-          id: user.id
+        ;(req.user as AuthPayload) = {
+          id: user.id,
         }
         return true
       }
@@ -36,7 +36,7 @@ export class GraphqlGuard extends AuthGuard('jwt') implements CanActivate {
     return await canActivate.toPromise()
   }
 
-  getRequest (context: ExecutionContext): GqlContext['req'] {
+  getRequest(context: ExecutionContext): GqlContext['req'] {
     const ctx = GqlExecutionContext.create(context)
     return ctx.getContext().req
   }