@lenne.tech/nest-server 3.2.0 → 3.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "3.2.0",
+  "version": "3.3.2",
   "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",
@@ -52,11 +52,11 @@
     "node": ">= 16.13.0"
   },
   "dependencies": {
-    "@apollo/federation": "0.33.9",
-    "@apollo/gateway": "0.42.3",
+    "@apollo/gateway": "0.48.1",
+    "@nestjs/apollo": "10.0.2",
     "@nestjs/common": "8.2.6",
     "@nestjs/core": "8.2.6",
-    "@nestjs/graphql": "9.1.2",
+    "@nestjs/graphql": "10.0.2",
     "@nestjs/jwt": "8.0.0",
     "@nestjs/mongoose": "9.0.2",
     "@nestjs/passport": "8.1.0",
@@ -67,22 +67,24 @@
     "@types/jest": "27.4.0",
     "@types/lodash": "4.14.178",
     "@types/multer": "1.4.7",
-    "@types/node": "16.11.21",
+    "@types/node": "17.0.17",
     "@types/node-mailjet": "3.3.8",
     "@types/nodemailer": "6.4.4",
     "@types/passport": "1.0.7",
     "@types/supertest": "2.0.11",
-    "@typescript-eslint/eslint-plugin": "5.10.0",
-    "@typescript-eslint/parser": "5.10.0",
-    "apollo-server-core": "3.6.2",
-    "apollo-server-express": "3.6.2",
+    "@typescript-eslint/eslint-plugin": "5.11.0",
+    "@typescript-eslint/parser": "5.11.0",
+    "apollo-server-core": "3.6.3",
+    "apollo-server-express": "3.6.3",
     "bcrypt": "5.0.1",
     "class-transformer": "0.5.1",
     "class-validator": "0.13.2",
     "coffeescript": "2.6.1",
     "ejs": "3.1.6",
-    "fastify": "3.27.0",
-    "graphql": "15.8.0",
+    "eslint": "8.9.0",
+    "eslint-config-prettier": "8.3.0",
+    "fastify": "3.27.1",
+    "graphql": "16.3.0",
     "graphql-subscriptions": "2.0.0",
     "grunt": "1.4.1",
     "grunt-bg-shell": "2.3.3",
@@ -90,35 +92,33 @@
     "grunt-contrib-watch": "1.1.0",
     "grunt-sync": "0.8.2",
     "husky": "7.0.4",
-    "jest": "27.4.7",
-    "json-to-graphql-query": "2.2.0",
-    "light-my-request": "4.7.0",
+    "jest": "27.5.1",
+    "json-to-graphql-query": "2.2.2",
+    "light-my-request": "4.7.1",
     "lodash": "4.17.21",
-    "mongodb": "4.3.0",
-    "mongoose": "6.1.7",
+    "mongodb": "4.3.1",
+    "mongoose": "6.2.1",
     "multer": "1.4.4",
     "node-mailjet": "3.3.5",
     "nodemailer": "6.7.2",
     "nodemon": "2.0.15",
     "passport": "0.5.2",
     "passport-jwt": "4.0.0",
+    "prettier": "2.5.1",
+    "pretty-quick": "3.1.3",
     "reflect-metadata": "0.1.13",
     "rimraf": "3.0.2",
-    "rxjs": "7.5.2",
+    "rxjs": "7.5.4",
     "supertest": "6.2.2",
+    "ts-jest": "27.1.3",
     "ts-morph": "13.0.3",
-    "ts-node": "10.4.0",
-    "tsconfig-paths": "3.12.0"
+    "ts-node": "10.5.0",
+    "tsconfig-paths": "3.12.0",
+    "typescript": "4.5.5"
   },
   "devDependencies": {
-    "eslint": "8.7.0",
-    "eslint-config-prettier": "8.3.0",
     "find-file-up": "2.0.1",
-    "pm2": "5.1.2",
-    "prettier": "2.5.1",
-    "pretty-quick": "3.1.3",
-    "ts-jest": "27.1.3",
-    "typescript": "4.5.5"
+    "pm2": "5.1.2"
   },
   "jest": {
     "collectCoverage": true,

package/src/core/common/args/filter.args.ts

@@ -13,5 +13,26 @@ export class FilterArgs extends PaginationArgs {
     nullable: true,
   })
   @IsOptional()
-  filter?: FilterInput;
+  filter?: FilterInput = undefined;
+
+  // ===================================================================================================================
+  // Methods
+  // ===================================================================================================================
+
+  /**
+   * Mapping for Subtypes
+   */
+  map(
+    data: Partial<this> | Record<string, any>,
+    options: {
+      cloneDeep?: boolean;
+      funcAllowed?: boolean;
+      mapId?: boolean;
+    } = {}
+  ): this {
+    super.map(data, options);
+    this.filter = data.filter ? FilterInput.map(data.filter, options) : undefined;
+    Object.keys(this).forEach((key) => this[key] === undefined && delete this[key]);
+    return this;
+  }
 }

package/src/core/common/args/pagination.args.ts

@@ -1,9 +1,11 @@
 import { IsOptional, Max } from 'class-validator';
 import { ArgsType, Field, Int } from '@nestjs/graphql';
+import { ModelHelper } from '../helpers/model.helper';
+import { CoreInput } from '../inputs/core-input.input';
 import { SortInput } from '../inputs/sort.input';
 
 @ArgsType()
-export class PaginationArgs {
+export class PaginationArgs extends CoreInput {
   /**
    * Limit for pagination
    */
@@ -14,7 +16,7 @@ export class PaginationArgs {
   })
   @IsOptional()
   @Max(100)
-  limit?: number = 25;
+  limit?: number = undefined;
 
   /**
    * Offset for pagination
@@ -25,7 +27,7 @@ export class PaginationArgs {
     defaultValue: 0,
   })
   @IsOptional()
-  offset?: number = 0;
+  offset?: number = undefined;
 
   /**
    * Alias for offset
@@ -33,10 +35,10 @@ export class PaginationArgs {
   @Field((type) => Int, {
     description: 'Alias for offset',
     nullable: true,
-    defaultValue: 0,
+    defaultValue: undefined,
   })
   @IsOptional()
-  skip?: number = 0;
+  skip?: number = undefined;
 
   /**
    * Sorting for pagination
@@ -46,7 +48,7 @@ export class PaginationArgs {
     nullable: true,
   })
   @IsOptional()
-  sort?: SortInput[];
+  sort?: SortInput[] = undefined;
 
   /**
    * Alias for limit
@@ -58,5 +60,38 @@ export class PaginationArgs {
   })
   @IsOptional()
   @Max(100)
-  take?: number = 25;
+  take?: number = undefined;
+
+  // ===================================================================================================================
+  // Methods
+  // ===================================================================================================================
+
+  /**
+   * Initialize instance with default values instead of undefined
+   */
+  init(): this {
+    super.init();
+    this.limit = this.limit === undefined ? 25 : this.limit;
+    this.offset = this.offset === undefined ? 0 : this.offset;
+    this.skip = this.skip === undefined ? 0 : this.skip;
+    this.take = this.take === undefined ? 0 : this.take;
+    return this;
+  }
+
+  /**
+   * Mapping for Subtypes
+   */
+  map(
+    data: Partial<this> | Record<string, any>,
+    options: {
+      cloneDeep?: boolean;
+      funcAllowed?: boolean;
+      mapId?: boolean;
+    } = {}
+  ): this {
+    super.map(data, options);
+    this.sort = ModelHelper.maps(data.sort, SortInput, options.cloneDeep);
+    Object.keys(this).forEach((key) => this[key] === undefined && delete this[key]);
+    return this;
+  }
 }

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

@@ -1,4 +1,5 @@
 import 'reflect-metadata';
+import { UnauthorizedException } from '@nestjs/common';
 import { RoleEnum } from '../enums/role.enum';
 
 /**
@@ -31,8 +32,15 @@ export const getRestricted = (object: unknown, propertyKey: string) => {
 export const checkRestricted = (
   data: any,
   user: { id: any; hasRole: (roles: string[]) => boolean },
+  options: { ignoreUndefined?: boolean; throwError?: boolean } = {},
   processedObjects: any[] = []
 ) => {
+  const config = {
+    ignoreUndefined: true,
+    throwError: true,
+    ...options,
+  };
+
   // Primitives
   if (!data || typeof data !== 'object') {
     return data;
@@ -47,11 +55,16 @@ export const checkRestricted = (
   // Array
   if (Array.isArray(data)) {
     // Check array items
-    return data.map((item) => checkRestricted(item, user, processedObjects));
+    return data.map((item) => checkRestricted(item, user, options, processedObjects));
   }
 
   // Object
   for (const propertyKey of Object.keys(data)) {
+    // Check undefined
+    if (data[propertyKey] === undefined && config.ignoreUndefined) {
+      continue;
+    }
+
     // Get roles
     const roles = getRestricted(data, propertyKey);
 
@@ -71,20 +84,24 @@ export const checkRestricted = (
                 data.ownerIds.some((item) => (item.id ? item.id.toString() === userId : item.toString() === userId)))
             )
           ) {
-            // User is not the owner
-            delete data[propertyKey];
+            // The user does not have the required rights and is not the owner
+            if (config.throwError) {
+              throw new UnauthorizedException('Current user is not allowed to set ' + propertyKey);
+            }
             continue;
           }
         } else {
           // The user does not have the required rights
-          delete data[propertyKey];
+          if (config.throwError) {
+            throw new UnauthorizedException('Current user is not allowed to set ' + propertyKey);
+          }
           continue;
         }
       }
     }
 
     // Check property data
-    data[propertyKey] = checkRestricted(data[propertyKey], user, processedObjects);
+    data[propertyKey] = checkRestricted(data[propertyKey], user, options, processedObjects);
   }
 
   // Return processed data

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

@@ -16,15 +16,26 @@ export class Context {
 
     // Init data
     let user: { [key: string]: any };
-    const ctx: any = GqlExecutionContext.create(context).getContext();
-    let args: any = GqlExecutionContext.create(context).getArgs();
+    let ctx: any = null;
+    try {
+      ctx = GqlExecutionContext.create(context)?.getContext();
+    } catch (e) {
+      // console.log(e);
+    }
+
+    let args: any;
+    try {
+      args = GqlExecutionContext.create(context)?.getArgs();
+    } catch (e) {
+      // console.log(e);
+    }
 
     // Get data
     if (ctx) {
       // User from GraphQL context
       user = ctx?.user || ctx?.req?.user;
     } else {
-      const request = context.switchToHttp().getRequest();
+      const request = context?.switchToHttp ? context.switchToHttp()?.getRequest() : null;
       if (request) {
         args = request.body;
 

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

@@ -13,14 +13,14 @@ export class Filter {
    * Convert filter arguments to a query array
    * @param filterArgs
    */
-  public static convertFilterArgsToQuery<T = any>(filterArgs: FilterArgs): [FilterQuery<T>, QueryOptions] {
+  public static convertFilterArgsToQuery<T = any>(filterArgs: Partial<FilterArgs>): [FilterQuery<T>, QueryOptions] {
     return [Filter.generateFilterQuery(filterArgs.filter), Filter.generateFindOptions(filterArgs)];
   }
 
   /**
    * Generate filter query
    */
-  public static generateFilterQuery<T = any>(filter?: FilterInput): FilterQuery<T> | any {
+  public static generateFilterQuery<T = any>(filter?: Partial<FilterInput>): FilterQuery<T> | any {
     // Check filter
     if (!filter) {
       return undefined;
@@ -98,7 +98,7 @@ export class Filter {
   /**
    * Generate find options
    */
-  public static generateFindOptions<T = any>(filterArgs: FilterArgs): QueryOptions {
+  public static generateFindOptions<T = any>(filterArgs: Partial<FilterArgs>): QueryOptions {
     // Check filterArgs
     if (!filterArgs) {
       return {};

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

@@ -1,5 +1,5 @@
 import { BadRequestException } from '@nestjs/common';
-import { plainToClass } from 'class-transformer';
+import { plainToInstance } from 'class-transformer';
 import { validate } from 'class-validator';
 import * as _ from 'lodash';
 import { checkRestricted } from '../decorators/restricted.decorator';
@@ -17,21 +17,27 @@ export class InputHelper {
     metatype?
   ): Promise<any> {
     // Return value if it is only a basic type
-    if (!metatype || this.isBasicType(metatype)) {
+    if (typeof value !== 'object' || !metatype || this.isBasicType(metatype)) {
       return value;
     }
 
-    // Remove restricted values if roles are missing
-    value = checkRestricted(value, user);
-
-    // Check values
-    if (metatype) {
-      const object = plainToClass(metatype, value);
-      const errors = await validate(object);
-      if (errors.length > 0) {
-        throw new BadRequestException('Validation failed');
+    // Convert to metatype
+    if (!(value instanceof metatype)) {
+      if ((metatype as any)?.map) {
+        value = (metatype as any)?.map(value);
+      } else {
+        value = plainToInstance(metatype, value);
       }
     }
+
+    // Validate
+    const errors = await validate(value);
+    if (errors.length > 0) {
+      throw new BadRequestException('Validation failed');
+    }
+
+    // Remove restricted values if roles are missing
+    value = checkRestricted(value, user);
     return value;
   }
 

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

@@ -77,9 +77,6 @@ export class ModelHelper {
     // Merge target with prepared source
     Object.assign(target, preparedSource);
 
-    // Remove all props with undefined
-    Object.keys(target).forEach((key) => target[key] === undefined && delete target[key]);
-
     // Return target
     return target;
   }

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

@@ -10,52 +10,85 @@ export class ServiceHelper {
   /**
    * Prepare input before save
    */
-  static async prepareInput(
-    input: { [key: string]: any },
+  static async prepareInput<T = any>(
+    input: T,
     currentUser: { [key: string]: any; id: string },
-    options: { [key: string]: any; create?: boolean; clone?: boolean } = {},
-    ...args: any[]
-  ) {
+    options: {
+      [key: string]: any;
+      create?: boolean;
+      clone?: boolean;
+      getNewArray?: boolean;
+      removeUndefined?: boolean;
+    } = {}
+  ): Promise<T> {
     // Configuration
     const config = {
       checkRoles: false,
       clone: false,
       create: false,
+      getNewArray: false,
+      removeUndefined: false,
       ...options,
     };
 
-    // Clone output
+    // Check input
+    if (typeof input !== 'object') {
+      return input;
+    }
+
+    // Process array
+    if (Array.isArray(input)) {
+      const processedArray = input.map(
+        async (item) => await ServiceHelper.prepareInput(item, currentUser, options)
+      ) as any;
+      return config.getNewArray ? processedArray : input;
+    }
+
+    // Clone input
     if (config.clone) {
-      input = JSON.parse(JSON.stringify(input));
+      if ((input as Record<string, any>).mapDeep && typeof (input as any).mapDeep === 'function') {
+        input = await Object.getPrototypeOf(input).mapDeep(input);
+      } else {
+        input = _.cloneDeep(input);
+      }
+    }
+
+    // Remove undefined properties to avoid unwanted overwrites
+    if (config.removeUndefined) {
+      Object.keys(input).forEach((key) => input[key] === undefined && delete input[key]);
     }
 
     // Process roles
-    if (input.roles && config.checkRoles && (!currentUser?.hasRole || !currentUser.hasRole(RoleEnum.ADMIN))) {
+    if (
+      config.checkRoles &&
+      (input as Record<string, any>).roles &&
+      (!currentUser?.hasRole || !currentUser.hasRole(RoleEnum.ADMIN))
+    ) {
       if (!(currentUser as any)?.roles) {
         throw new UnauthorizedException('Missing roles of current user');
       } else {
-        const allowedRoles = _.intersection(input.roles, (currentUser as any).roles);
-        if (allowedRoles.length !== input.roles.length) {
-          const missingRoles = _.difference(input.roles, (currentUser as any).roles);
+        const allowedRoles = _.intersection((input as Record<string, any>).roles, (currentUser as any).roles);
+        if (allowedRoles.length !== (input as Record<string, any>).roles.length) {
+          const missingRoles = _.difference((input as Record<string, any>).roles, (currentUser as any).roles);
           throw new UnauthorizedException('Current user not allowed setting roles: ' + missingRoles);
         }
-        input.roles = allowedRoles;
+        (input as Record<string, any>).roles = allowedRoles;
       }
     }
 
     // Hash password
-    if (input.password) {
-      input.password = await bcrypt.hash((input as any).password, 10);
+    if ((input as Record<string, any>).password) {
+      (input as Record<string, any>).password = await bcrypt.hash((input as any).password, 10);
     }
 
     // Set creator
     if (config.create && currentUser) {
-      input.createdBy = currentUser.id;
+      (input as Record<string, any>).createdBy = currentUser.id;
     }
 
     // Set updater
     if (currentUser) {
-      input.updatedBy = currentUser.id;
+      (input as Record<string, any>).updatedBy = currentUser.id;
     }
 
     // Return prepared input
@@ -65,39 +98,71 @@ export class ServiceHelper {
   /**
    * Prepare output before return
    */
-  static async prepareOutput<T = Record<string, any>>(
+  static async prepareOutput<T = { [key: string]: any; map: (...args: any[]) => any }>(
     output: any,
-    userModel: new () => any,
-    userService: any,
-    options: { [key: string]: any; clone?: boolean; targetModel?: Partial<T> } = {},
-    ...args: any[]
-  ) {
+    options: {
+      [key: string]: any;
+      clone?: boolean;
+      getNewArray?: boolean;
+      removeUndefined?: boolean;
+      targetModel?: new (...args: any[]) => T;
+    } = {}
+  ): Promise<T | T[] | any> {
     // Configuration
     const config = {
-      clone: true,
+      clone: false,
+      getNewArray: false,
+      removeUndefined: false,
+      targetModel: undefined,
       ...options,
     };
 
+    // Check output
+    if (typeof output !== 'object') {
+      return output;
+    }
+
+    // Process array
+    if (Array.isArray(output)) {
+      const processedArray = output.map(async (item) => await ServiceHelper.prepareOutput(item, options)) as any;
+      return config.getNewArray ? processedArray : output;
+    }
+
     // Clone output
     if (config.clone) {
-      output = JSON.parse(JSON.stringify(output));
+      if (output.mapDeep && typeof output.mapDeep === 'function') {
+        output = await Object.getPrototypeOf(output).mapDeep(output);
+      } else {
+        output = _.cloneDeep(output);
+      }
     }
 
     // Map output if target model exist
-    if (options.targetModel) {
-      (options.targetModel as any).map(output);
+    if (config.targetModel) {
+      output = await (config.targetModel as any).map(output);
     }
 
     // Remove password if exists
-    delete output.password;
+    if (output.password) {
+      output.password = undefined;
+    }
 
     // Remove verification token if exists
-    delete output.verificationToken;
+    if (output.verificationToken) {
+      output.verificationToken = undefined;
+    }
 
     // Remove password reset token if exists
-    delete output.passwordResetToken;
+    if (output.passwordResetToken) {
+      output.passwordResetToken = undefined;
+    }
+
+    // Remove undefined properties to avoid unwanted overwrites
+    if (config.removeUndefined) {
+      Object.keys(output).forEach((key) => output[key] === undefined && delete output[key]);
+    }
 
-    // Return prepared user
+    // Return prepared output
     return output;
   }
 }

package/src/core/common/inputs/combined-filter.input.ts

@@ -1,26 +1,47 @@
 import { Field, InputType } from '@nestjs/graphql';
 import { LogicalOperatorEnum } from '../enums/logical-operator.enum';
+import { ModelHelper } from '../helpers/model.helper';
+import { CoreInput } from './core-input.input';
 import { FilterInput } from './filter.input';
 
 @InputType({
   description: 'Combination of multiple filters via logical operator',
 })
-export class CombinedFilterInput {
+export class CombinedFilterInput extends CoreInput {
   /**
-   * Logical Operator to combine filters. If set the `filters` must be also set.
+   * Logical Operator to combine filters
    */
   @Field((type) => LogicalOperatorEnum, {
-    description: 'Logical Operator to combine filters. If set the `filters` must be also set.',
-    nullable: true,
+    description: 'Logical Operator to combine filters',
   })
-  logicalOperator?: LogicalOperatorEnum;
+  logicalOperator: LogicalOperatorEnum = undefined;
 
   /**
-   * Filters to combine via logical operator. If set `logicalOperator` must be also set.
+   * Filters to combine via logical operator
    */
   @Field((type) => [FilterInput], {
-    description: 'Filters to combine via logical operator. If set `logicalOperator` must be also set.',
-    nullable: true,
+    description: 'Filters to combine via logical operator',
   })
-  filters: FilterInput[];
+  filters: FilterInput[] = undefined;
+
+  // ===================================================================================================================
+  // Methods
+  // ===================================================================================================================
+
+  /**
+   * Mapping for Subtypes
+   */
+  map(
+    data: Partial<this> | Record<string, any>,
+    options: {
+      cloneDeep?: boolean;
+      funcAllowed?: boolean;
+      mapId?: boolean;
+    } = {}
+  ): this {
+    super.map(data, options);
+    this.filters = ModelHelper.maps(data.filters, FilterInput, options.cloneDeep);
+    Object.keys(this).forEach((key) => this[key] === undefined && delete this[key]);
+    return this;
+  }
 }