@lenne.tech/nest-server 3.3.1 → 3.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "3.3.1",
+  "version": "3.4.0",
   "description": "Modern, fast, powerful Node.js web framework in TypeScript based on Nest with a GraphQL API and a connection to MongoDB (or other databases).",
   "keywords": [
     "node",

package/src/config.env.ts

@@ -32,8 +32,10 @@ const config: { [env: string]: IServerOptions } = {
     },
     env: 'development',
     graphQl: {
-      debug: true,
-      introspection: true,
+      driver: {
+        debug: true,
+        introspection: true,
+      },
     },
     jwt: {
       secret: 'SECRET_OR_PRIVATE_KEY_DEV',
@@ -79,8 +81,10 @@ const config: { [env: string]: IServerOptions } = {
     },
     env: 'productive',
     graphQl: {
-      debug: false,
-      introspection: true,
+      driver: {
+        debug: false,
+        introspection: true,
+      },
     },
     jwt: {
       secret: 'SECRET_OR_PRIVATE_KEY_PROD',

package/src/core/common/interfaces/server-options.interface.ts

@@ -20,7 +20,10 @@ export interface IServerOptions {
    * see https://docs.nestjs.com/graphql/quick-start
    * and https://www.apollographql.com/docs/apollo-server/api/apollo-server/
    */
-  graphQl?: ApolloDriverConfig;
+  graphQl?: {
+    driver?: ApolloDriverConfig;
+    enableSubscriptionAuth?: boolean;
+  };
 
   /**
    * Configuration of JavaScript Web Token (JWT) module

package/src/core/modules/auth/core-auth.module.ts

@@ -1,4 +1,4 @@
-import { DynamicModule, Module, Type } from '@nestjs/common';
+import { DynamicModule, ForwardReference, Module, Provider, Type } from '@nestjs/common';
 import { APP_GUARD } from '@nestjs/core';
 import { JwtModule, JwtModuleOptions } from '@nestjs/jwt';
 import { PassportModule } from '@nestjs/passport';
@@ -20,30 +20,46 @@ export class CoreAuthModule {
   static forRoot(
     UserModule: Type<any>,
     UserService: Type<CoreAuthUserService>,
-    options: JwtModuleOptions
+    options: JwtModuleOptions & {
+      imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+      providers?: Provider[];
+    }
   ): DynamicModule {
+    // Porcess imports
+    let imports: any[] = [UserModule, PassportModule.register({ defaultStrategy: 'jwt' }), JwtModule.register(options)];
+    if (Array.isArray(options?.imports)) {
+      imports = imports.concat(options.imports);
+    }
+
+    // Process providers
+    let providers = [
+      // [Global] The GraphQLAuthGard integrates the user into context
+      {
+        provide: APP_GUARD,
+        useClass: RolesGuard,
+      },
+      {
+        provide: CoreAuthUserService,
+        useClass: UserService,
+      },
+      {
+        provide: 'PUB_SUB',
+        useValue: new PubSub(),
+      },
+
+      // Standard services
+      CoreAuthService,
+      JwtStrategy,
+    ];
+    if (Array.isArray(options?.providers)) {
+      providers = imports.concat(options.providers);
+    }
+
+    // Return CoreAuthModule
     return {
       module: CoreAuthModule,
-      imports: [UserModule, PassportModule.register({ defaultStrategy: 'jwt' }), JwtModule.register(options)],
-      providers: [
-        // [Global] The GraphQLAuthGard integrates the user into context
-        {
-          provide: APP_GUARD,
-          useClass: RolesGuard,
-        },
-        {
-          provide: CoreAuthUserService,
-          useClass: UserService,
-        },
-        {
-          provide: 'PUB_SUB',
-          useValue: new PubSub(),
-        },
-
-        // Standard services
-        CoreAuthService,
-        JwtStrategy,
-      ],
+      imports: imports,
+      providers: providers,
       exports: [CoreAuthService, JwtModule, JwtStrategy, PassportModule, UserModule],
     };
   }

package/src/core/modules/auth/services/core-auth.service.ts

@@ -33,4 +33,8 @@ export class CoreAuthService {
   async validateUser(payload: JwtPayload): Promise<any> {
     return await this.userService.getViaEmail(payload.email);
   }
+
+  decodeJwt(token: string): JwtPayload {
+    return this.jwtService.decode(token) as JwtPayload;
+  }
 }

package/src/core.module.ts

@@ -1,4 +1,4 @@
-import { DynamicModule, Global, Module } from '@nestjs/common';
+import { DynamicModule, Global, Module, UnauthorizedException } from '@nestjs/common';
 import { APP_INTERCEPTOR, APP_PIPE } from '@nestjs/core';
 import { GraphQLModule } from '@nestjs/graphql';
 import { Config } from './core/common/helpers/config.helper';
@@ -34,23 +34,43 @@ export class CoreModule {
    * Dynamic module
    * see https://docs.nestjs.com/modules#dynamic-modules
    */
-  static forRoot(options: Partial<IServerOptions>): DynamicModule {
+  static forRoot(AuthService: any, AuthModule: any, options: Partial<IServerOptions>): DynamicModule {
     // Process config
     const config: IServerOptions = Config.merge(
       {
         env: 'develop',
         graphQl: {
-          autoSchemaFile: 'schema.gql',
-          context: ({ req }) => ({ req }),
-          installSubscriptionHandlers: true,
-          subscriptions: {
-            'subscriptions-transport-ws': {
-              onConnect: (connectionParams) => {
-                // TODO: Handle Authorization
-                const authToken = connectionParams.Authorization;
+          driver: {
+            imports: [AuthModule],
+            inject: [AuthService],
+            useFactory: async (authService: any) => ({
+              autoSchemaFile: 'schema.gql',
+              context: ({ req }) => ({ req }),
+              installSubscriptionHandlers: true,
+              subscriptions: {
+                'subscriptions-transport-ws': {
+                  onConnect: async (connectionParams) => {
+                    if (config.graphQl.enableSubscriptionAuth) {
+                      // get authToken from authorization header
+                      const authToken: string =
+                        'Authorization' in connectionParams && connectionParams?.Authorization?.split(' ')[1];
+
+                      if (authToken) {
+                        // verify authToken/getJwtPayLoad
+                        const payload = authService.decodeJwt(authToken);
+                        const user = await authService.validateUser(payload);
+                        // the user/jwtPayload object found will be available as context.currentUser/jwtPayload in your GraphQL resolvers
+                        return { user: user, headers: connectionParams };
+                      }
+
+                      throw new UnauthorizedException();
+                    }
+                  },
+                },
               },
-            },
+            }),
           },
+          enableSubscriptionAuth: true,
         },
         port: 3000,
         mongoose: {
@@ -107,7 +127,7 @@ export class CoreModule {
       module: CoreModule,
       imports: [
         MongooseModule.forRoot(config.mongoose.uri, config.mongoose.options),
-        GraphQLModule.forRoot<ApolloDriverConfig>(Object.assign({ driver: ApolloDriver }, config.graphQl)),
+        GraphQLModule.forRootAsync<ApolloDriverConfig>(Object.assign({ driver: ApolloDriver }, config.graphQl.driver)),
       ],
       providers,
       exports: [ConfigService, EmailService, TemplateService, MailjetService],

package/src/server/server.module.ts

@@ -4,6 +4,7 @@ import { CoreModule } from '../core.module';
 import { AuthModule } from './modules/auth/auth.module';
 import { FileController } from './modules/file/file.controller';
 import { ServerController } from './server.controller';
+import { CoreAuthService } from '../core/modules/auth/services/core-auth.service';
 
 /**
  * Server module (dynamic)
@@ -15,7 +16,7 @@ import { ServerController } from './server.controller';
   // Include modules
   imports: [
     // Include CoreModule for standard processes
-    CoreModule.forRoot(envConfig),
+    CoreModule.forRoot(CoreAuthService, AuthModule.forRoot(envConfig.jwt), envConfig),
 
     // Include AuthModule for authorization handling,
     // which will also include UserModule

package/src/test/test.helper.ts

@@ -18,7 +18,7 @@ export enum TestGraphQLType {
  * GraphQL fields
  */
 export interface TestFieldObject {
-  [key: string]: boolean | string[] | TestFieldObject;
+  [key: string]: boolean | (string | TestFieldObject)[] | TestFieldObject;
 }
 
 /**