@lenne.tech/nest-server 8.4.0 → 8.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "8.4.0",
+  "version": "8.6.1",
   "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",
@@ -112,7 +112,7 @@
     "prettier": "2.6.2",
     "pretty-quick": "3.1.3",
     "supertest": "6.2.3",
-    "ts-jest": "28.0.1",
+    "ts-jest": "28.0.2",
     "ts-morph": "14.0.0",
     "ts-node": "10.7.0",
     "tsconfig-paths": "4.0.0",

package/src/core/common/decorators/restricted.decorator.ts

@@ -9,6 +9,10 @@ import { RequireAtLeastOne } from '../types/required-at-least-one.type';
  * Restricted meta key
  */
 const restrictedMetaKey = Symbol('restricted');
+
+/**
+ * Restricted type
+ */
 export type RestrictedType = (
   | string
   | RequireAtLeastOne<
@@ -31,14 +35,17 @@ export type RestrictedType = (
  *    properties of the processed item, which is specified by the value of `memberOf`
  *    Via processType the restriction can be set for input or output only
  */
-export const Restricted = (...rolesOrMember: RestrictedType): PropertyDecorator => {
+export const Restricted = (...rolesOrMember: RestrictedType): ClassDecorator & PropertyDecorator => {
   return Reflect.metadata(restrictedMetaKey, rolesOrMember);
 };
 
 /**
- * Get restricted
+ * Get restricted data for (property of) object
  */
-export const getRestricted = (object: unknown, propertyKey: string): RestrictedType => {
+export const getRestricted = (object: unknown, propertyKey?: string): RestrictedType => {
+  if (!propertyKey) {
+    return Reflect.getMetadata(restrictedMetaKey, object);
+  }
   return Reflect.getMetadata(restrictedMetaKey, object, propertyKey);
 };
 
@@ -49,11 +56,18 @@ export const getRestricted = (object: unknown, propertyKey: string): RestrictedT
 export const checkRestricted = (
   data: any,
   user: { id: any; hasRole: (roles: string[]) => boolean },
-  options: { dbObject?: any; ignoreUndefined?: boolean; processType?: ProcessType; throwError?: boolean } = {},
+  options: {
+    dbObject?: any;
+    ignoreUndefined?: boolean;
+    processType?: ProcessType;
+    removeUndefinedFromResultArray?: boolean;
+    throwError?: boolean;
+  } = {},
   processedObjects: any[] = []
 ) => {
   const config = {
     ignoreUndefined: true,
+    removeUndefinedFromResultArray: true,
     throwError: true,
     ...options,
   };
@@ -72,18 +86,15 @@ export const checkRestricted = (
   // Array
   if (Array.isArray(data)) {
     // Check array items
-    return data.map((item) => checkRestricted(item, user, config, processedObjects));
-  }
-
-  // Object
-  for (const propertyKey of Object.keys(data)) {
-    // Check undefined
-    if (data[propertyKey] === undefined && config.ignoreUndefined) {
-      continue;
+    let result = data.map((item) => checkRestricted(item, user, config, processedObjects));
+    if (!config.throwError && config.removeUndefinedFromResultArray) {
+      result = result.filter((item) => item !== undefined);
     }
+    return result;
+  }
 
-    // Check restricted
-    const restricted = getRestricted(data, propertyKey);
+  // Check function
+  const validateRestricted = (restricted) => {
     let valid = true;
     if (restricted?.length) {
       valid = false;
@@ -110,6 +121,7 @@ export const checkRestricted = (
         // Check roles
         if (
           user?.hasRole(roles) ||
+          (user?.id && roles.includes(RoleEnum.S_USER)) ||
           (roles.includes(RoleEnum.S_CREATOR) && getIncludedIds(config.dbObject?.createdBy, user))
         ) {
           valid = true;
@@ -161,6 +173,30 @@ export const checkRestricted = (
         }
       }
     }
+    return valid;
+  };
+
+  // Check object
+  const objectRestrictions = getRestricted(data.constructor);
+  const objectIsValid = validateRestricted(objectRestrictions);
+  if (!objectIsValid) {
+    // Throw error
+    if (config.throwError) {
+      throw new UnauthorizedException('The current user has no access rights for ' + data.constructor?.name);
+    }
+    return null;
+  }
+
+  // Check properties of object
+  for (const propertyKey of Object.keys(data)) {
+    // Check undefined
+    if (data[propertyKey] === undefined && config.ignoreUndefined) {
+      continue;
+    }
+
+    // Check restricted
+    const restricted = getRestricted(data, propertyKey);
+    const valid = validateRestricted(restricted);
 
     // Check rights
     if (valid) {

package/src/core/common/helpers/db.helper.ts

@@ -275,19 +275,41 @@ export function getElementsViaIds<T = any>(
 /**
  * Get populate options from GraphQL resolve info
  */
-export function getPopulateOptions(info: GraphQLResolveInfo, select?: string): PopulateOptions[] {
+export function getPopulateOptions(info: GraphQLResolveInfo, dotSeparatedSelect?: string): PopulateOptions[] {
   const result = [];
 
   if (!info?.fieldNodes?.length) {
     return result;
   }
 
-  for (const fieldNode of info.fieldNodes) {
-    if ((select || fieldNode?.name?.value === select) && fieldNode?.selectionSet?.selections?.length) {
-      return getPopulatOptionsFromSelections(fieldNode.selectionSet.selections);
+  if (dotSeparatedSelect?.length) {
+    for (const fieldNode of info.fieldNodes) {
+      const selects = dotSeparatedSelect.split('.');
+      const fieldNodeName = selects.shift();
+      if (fieldNode?.name?.value === fieldNodeName && fieldNode?.selectionSet?.selections?.length) {
+        if (!selects.length) {
+          return getPopulatOptionsFromSelections(fieldNode.selectionSet.selections);
+        } else {
+          let selections = fieldNode.selectionSet.selections;
+          do {
+            if (!selections?.length) {
+              break;
+            }
+            const select = selects.shift();
+            for (const selection of selections) {
+              if ((selection as FieldNode)?.name?.value === select) {
+                selections = (selection as FieldNode)?.selectionSet?.selections;
+                if (!selects.length) {
+                  return getPopulatOptionsFromSelections(selections);
+                }
+                break;
+              }
+            }
+          } while (selects.length);
+        }
+      }
     }
   }
-
   return result;
 }
 

package/src/core/common/helpers/service.helper.ts

@@ -1,7 +1,12 @@
 import { UnauthorizedException } from '@nestjs/common';
 import * as bcrypt from 'bcrypt';
+import { plainToInstance } from 'class-transformer';
 import * as _ from 'lodash';
 import { RoleEnum } from '../enums/role.enum';
+import { PrepareInputOptions } from '../interfaces/prepare-input-options.interface';
+import { PrepareOutputOptions } from '../interfaces/prepare-output-options.interface';
+import { ResolveSelector } from '../interfaces/resolve-selector.interface';
+import { ServiceOptions } from '../interfaces/service-options.interface';
 
 /**
  * Helper class for services
@@ -54,6 +59,7 @@ export async function prepareInput<T = any>(
     clone?: boolean;
     getNewArray?: boolean;
     removeUndefined?: boolean;
+    targetModel?: new (...args: any[]) => T;
   } = {}
 ): Promise<T> {
   // Configuration
@@ -86,6 +92,15 @@ export async function prepareInput<T = any>(
     }
   }
 
+  // Map input if target model exist
+  if (config.targetModel && !(input instanceof config.targetModel)) {
+    if ((config.targetModel as any)?.map) {
+      input = await (config.targetModel as any).map(input);
+    } else {
+      input = plainToInstance(config.targetModel, input);
+    }
+  }
+
   // Remove undefined properties to avoid unwanted overwrites
   if (config.removeUndefined) {
     Object.keys(input).forEach((key) => input[key] === undefined && delete input[key]);
@@ -171,8 +186,12 @@ export async function prepareOutput<T = { [key: string]: any; map: (...args: any
   }
 
   // Map output if target model exist
-  if (config.targetModel) {
-    output = await (config.targetModel as any).map(output);
+  if (config.targetModel && !(output instanceof config.targetModel)) {
+    if ((config.targetModel as any)?.map) {
+      output = await (config.targetModel as any).map(output);
+    } else {
+      output = plainToInstance(config.targetModel, output);
+    }
   }
 
   // Remove password if exists
@@ -198,3 +217,54 @@ export async function prepareOutput<T = { [key: string]: any; map: (...args: any
   // Return prepared output
   return output;
 }
+
+/**
+ * Prepare service options
+ */
+export function prepareServiceOptions(
+  serviceOptions: ServiceOptions,
+  options?: {
+    clone?: boolean;
+    inputType?: any;
+    outputType?: any;
+    subFieldSelection?: string;
+    prepareInput?: PrepareInputOptions;
+    prepareOutput?: PrepareOutputOptions;
+  }
+): ServiceOptions {
+  // Set default values
+  const config = {
+    clone: true,
+    ...options,
+  };
+
+  // Clone
+  if (serviceOptions && config.clone) {
+    serviceOptions = _.cloneDeep(serviceOptions);
+  }
+
+  // Init if not exists
+  serviceOptions = serviceOptions || {};
+
+  // Set properties
+  serviceOptions.inputType = serviceOptions.inputType || options?.inputType;
+  serviceOptions.outputType = serviceOptions.outputType || options?.outputType;
+
+  // Set properties which can deactivate handling when falsy
+  if (!serviceOptions.prepareInput && 'prepareInput' in config) {
+    serviceOptions.prepareInput = config.prepareInput;
+  }
+  if (!serviceOptions.prepareOutput && 'prepareOutput' in config) {
+    serviceOptions.prepareOutput = config.prepareOutput;
+  }
+
+  // Set subfield selection
+  if (config.subFieldSelection) {
+    if ((serviceOptions.fieldSelection as ResolveSelector)?.select) {
+      (serviceOptions.fieldSelection as ResolveSelector).select += '.' + config.subFieldSelection;
+    }
+  }
+
+  // Return (cloned and) prepared service options
+  return serviceOptions;
+}

package/src/core/common/interfaces/prepare-input-options.interface.ts

@@ -0,0 +1,11 @@
+/**
+ * Interface for prepare input options
+ */
+export interface PrepareInputOptions {
+  [key: string]: any;
+  create?: boolean;
+  clone?: boolean;
+  getNewArray?: boolean;
+  removeUndefined?: boolean;
+  targetModel?: new (...args: any[]) => any;
+}

package/src/core/common/interfaces/prepare-output-options.interface.ts

@@ -0,0 +1,10 @@
+/**
+ * Interface for prepare output options
+ */
+export interface PrepareOutputOptions {
+  [key: string]: any;
+  clone?: boolean;
+  getNewArray?: boolean;
+  removeUndefined?: boolean;
+  targetModel?: new (...args: any[]) => any;
+}

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

@@ -1,5 +1,7 @@
 import { Model } from 'mongoose';
 import { FieldSelection } from '../types/field-selection.type';
+import { PrepareInputOptions } from './prepare-input-options.interface';
+import { PrepareOutputOptions } from './prepare-output-options.interface';
 
 /**
  * General service options
@@ -26,6 +28,9 @@ export interface ServiceOptions {
   // Overwrites type of input (array items)
   inputType?: new (...params: any[]) => any;
 
+  // Overwrites type of output (array items)
+  outputType?: new (...params: any[]) => any;
+
   // Process field selection
   // If {} or not set, then the field selection runs with defaults
   // If falsy, then the field selection will not be automatically executed
@@ -37,31 +42,16 @@ export interface ServiceOptions {
   // Prepare input configuration:
   // If {} or not set, then the prepareInput function will run with defaults
   // If falsy, then the prepareInput function is not executed
-  prepareInput?: {
-    [key: string]: any;
-    create?: boolean;
-    clone?: boolean;
-    getNewArray?: boolean;
-    removeUndefined?: boolean;
-  };
+  prepareInput?: PrepareInputOptions;
 
   // Prepare output configuration:
   // If {} or not set, then the prepareInput function will run with defaults
   // If falsy, then the prepareInput function is not executed
-  prepareOutput?: {
-    [key: string]: any;
-    clone?: boolean;
-    getNewArray?: boolean;
-    removeUndefined?: boolean;
-    targetModel?: new (...args: any[]) => any;
-  };
+  prepareOutput?: PrepareOutputOptions;
 
   // Whether to publish action via GraphQL subscription
   pubSub?: boolean;
 
-  // Overwrites type of result (array items)
-  resultType?: new (...params: any[]) => any;
-
   // Roles (as string) to check
   roles?: string | string[];
 }

package/src/core/common/services/module.service.ts

@@ -84,7 +84,11 @@ export abstract class ModuleService<T extends CoreModel = any> {
 
     // Prepare input
     if (config.prepareInput && this.prepareInput) {
-      await this.prepareInput(config.input, config.prepareInput);
+      const opts = config.prepareInput;
+      if (!opts.targetModel && config.inputType) {
+        opts.targetModel = config.inputType;
+      }
+      await this.prepareInput(config.input, opts);
     }
 
     // Get DB object
@@ -101,7 +105,7 @@ export abstract class ModuleService<T extends CoreModel = any> {
     if (config.input && config.checkRights && this.checkRights) {
       const opts: any = { dbObject: config.dbObject, processType: ProcessType.INPUT, roles: config.roles };
       if (config.inputType) {
-        opts.metatype = config.resultType;
+        opts.metatype = config.inputType;
       }
       config.input = await this.checkRights(config.input, config.currentUser as any, opts);
     }
@@ -116,11 +120,11 @@ export abstract class ModuleService<T extends CoreModel = any> {
 
     // Prepare output
     if (config.prepareOutput && this.prepareOutput) {
-      // Check if mapping is already done by processFieldSelection
-      if (config.processFieldSelection && config.fieldSelection && this.processFieldSelection) {
-        config.prepareOutput.targetModel = null;
+      const opts = config.prepareOutput;
+      if (!opts.targetModel && config.outputType) {
+        opts.targetModel = config.outputType;
       }
-      result = await this.prepareOutput(result, config.prepareOutput);
+      result = await this.prepareOutput(result, opts);
     }
 
     // Check output rights
@@ -131,8 +135,8 @@ export abstract class ModuleService<T extends CoreModel = any> {
         roles: config.roles,
         throwError: false,
       };
-      if (config.resultType) {
-        opts.metatype = config.resultType;
+      if (config.outputType) {
+        opts.metatype = config.outputType;
       }
       result = await this.checkRights(result, config.currentUser as any, opts);
     }
@@ -145,7 +149,11 @@ export abstract class ModuleService<T extends CoreModel = any> {
    * Prepare input before save
    */
   async prepareInput(input: Record<string, any>, options: ServiceOptions = {}) {
-    return prepareInput(input, options.currentUser, options.prepareInput);
+    const config = {
+      targetModel: this.mainModelConstructor,
+      ...options?.prepareInput,
+    };
+    return prepareInput(input, options.currentUser, config);
   }
 
   /**

package/src/core/modules/auth/inputs/core-auth-sign-in.input.ts

@@ -0,0 +1,18 @@
+import { Field, InputType } from '@nestjs/graphql';
+import { CoreInput } from '../../../common/inputs/core-input.input';
+
+/**
+ * SignIn input
+ */
+@InputType({ description: 'Sign-in input' })
+export class CoreAuthSignInInput extends CoreInput {
+  // ===================================================================================================================
+  // Properties
+  // ===================================================================================================================
+
+  @Field({ description: 'Email', nullable: false })
+  email: string = undefined;
+
+  @Field({ description: 'Password', nullable: false })
+  password: string = undefined;
+}

package/src/core/modules/auth/inputs/core-auth-sign-up.input.ts

@@ -0,0 +1,18 @@
+import { Field, InputType } from '@nestjs/graphql';
+import { CoreInput } from '../../../common/inputs/core-input.input';
+
+/**
+ * SignUp input
+ */
+@InputType({ description: 'Sign-up input' })
+export class CoreAuthSignUpInput extends CoreInput {
+  // ===================================================================================================================
+  // Properties
+  // ===================================================================================================================
+
+  @Field({ description: 'Email', nullable: false })
+  email: string = undefined;
+
+  @Field({ description: 'Password', nullable: false })
+  password: string = undefined;
+}

package/src/index.ts

@@ -35,6 +35,8 @@ export * from './core/common/inputs/sort.input';
 export * from './core/common/interceptors/check-response.interceptor';
 export * from './core/common/interfaces/core-persistence-model.interface';
 export * from './core/common/interfaces/mailjet-options.interface';
+export * from './core/common/interfaces/prepare-input-options.interface';
+export * from './core/common/interfaces/prepare-output-options.interface';
 export * from './core/common/interfaces/resolve-selector.interface';
 export * from './core/common/interfaces/server-options.interface';
 export * from './core/common/interfaces/service-options.interface';
@@ -65,6 +67,8 @@ export * from './core/common/types/string-or-object-id.type';
 
 export * from './core/modules/auth/guards/auth.guard';
 export * from './core/modules/auth/guards/roles.guard';
+export * from './core/modules/auth/inputs/core-auth-sign-in.input';
+export * from './core/modules/auth/inputs/core-auth-sign-up.input';
 export * from './core/modules/auth/interfaces/core-auth-user.interface';
 export * from './core/modules/auth/interfaces/jwt-payload.interface';
 export * from './core/modules/auth/services/core-auth.service';

package/src/server/modules/auth/auth.model.ts

@@ -3,22 +3,22 @@ import { CoreAuthModel } from '../../../core/modules/auth/core-auth.model';
 import { User } from '../user/user.model';
 
 /**
- * CoreAuthModel model for the response after the sign in
+ * Authentication data
  */
-@ObjectType({ description: 'Auth' })
+@ObjectType({ description: 'Authentication data' })
 export class Auth extends CoreAuthModel {
   // ===================================================================================================================
   // Properties
   // ===================================================================================================================
 
   /**
-   * Signed in user
+   * Signed-in user
    */
-  @Field((type) => User, { description: 'User who signed in' })
+  @Field(() => User, { description: 'User who signed in' })
   user: User = undefined;
 
   // ===================================================================================================================
-  // Properties
+  // Methods
   // ===================================================================================================================
 
   /**

package/src/server/modules/auth/auth.module.ts

@@ -1,9 +1,11 @@
 import { DynamicModule, Module } from '@nestjs/common';
 import { JwtModuleOptions } from '@nestjs/jwt';
+import { EmailService } from '../../../core/common/services/email.service';
 import { CoreAuthModule } from '../../../core/modules/auth/core-auth.module';
 import { UserModule } from '../user/user.module';
 import { UserService } from '../user/user.service';
 import { AuthResolver } from './auth.resolver';
+import { AuthService } from './auth.service';
 
 /**
  * CoreAuthModule to handle user authentication
@@ -17,8 +19,17 @@ export class AuthModule {
   static forRoot(options: JwtModuleOptions): DynamicModule {
     return {
       module: AuthModule,
-      imports: [CoreAuthModule.forRoot(UserModule, UserService, options)],
-      providers: [AuthResolver],
+      imports: [
+        CoreAuthModule.forRoot(UserModule, UserService, {
+          ...options,
+          ...{
+            // imports: [], // Integrate additional Services here to resolve dependencies
+            // providers: [] // Integrate additional Providers here to resolve dependencies
+          },
+        }),
+        EmailService,
+      ],
+      providers: [AuthResolver, AuthService],
       exports: [AuthResolver, CoreAuthModule],
     };
   }

package/src/server/modules/auth/auth.resolver.ts

@@ -1,22 +1,40 @@
-import { Args, Info, Query, Resolver } from '@nestjs/graphql';
+import { Args, Info, Mutation, Query, Resolver } from '@nestjs/graphql';
 import { GraphQLResolveInfo } from 'graphql';
-import { CoreAuthResolver } from '../../../core/modules/auth/core-auth.resolver';
 import { Auth } from './auth.model';
+import { AuthService } from './auth.service';
+import { AuthSignInInput } from './inputs/auth-sign-in.input';
+import { AuthSignUpInput } from './inputs/auth-sign-up.input';
 
 /**
  * Authentication resolver for the sign in
  */
-@Resolver((of) => Auth)
-export class AuthResolver extends CoreAuthResolver {
+@Resolver(() => Auth)
+export class AuthResolver {
   /**
-   * Get user via ID
+   * Integrate services
    */
-  @Query((returns) => Auth, { description: 'Get JWT token' })
-  async signIn(
-    @Args('email') email: string,
-    @Args('password') password: string,
-    @Info() info: GraphQLResolveInfo
-  ): Promise<Auth> {
-    return (await this.authService.signIn(email, password, { fieldSelection: { info, select: 'signIn' } })) as Auth;
+  constructor(private readonly authService: AuthService) {}
+
+  /**
+   * SignIn for User
+   */
+  @Query(() => Auth, { description: 'Sign in and get JWT token' })
+  async signIn(@Info() info: GraphQLResolveInfo, @Args('input') input: AuthSignInInput): Promise<Auth> {
+    return this.authService.signIn(input, {
+      fieldSelection: { info, select: 'signIn' },
+      inputType: AuthSignInInput,
+    });
+  }
+
+  /**
+   * Sign up for user
+   */
+  @Mutation(() => Auth, {
+    description: 'Sign up user and get JWT token',
+  })
+  async signUp(@Info() info: GraphQLResolveInfo, @Args('input') input: AuthSignUpInput): Promise<Auth> {
+    return this.authService.signUp(input, {
+      fieldSelection: { info, select: 'signUp' },
+    });
   }
 }