@lenne.tech/nest-server 3.1.2 → 3.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "3.1.2",
+  "version": "3.3.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/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,18 +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/service.helper.ts

@@ -11,26 +11,35 @@ export class ServiceHelper {
    * Prepare input before save
    */
   static async prepareInput(
-    input: { [key: string]: any },
+    input: Record<string, any>,
     currentUser: { [key: string]: any; id: string },
-    options: { [key: string]: any; create?: boolean; clone?: boolean } = {},
-    ...args: any[]
+    options: { [key: string]: any; create?: boolean; clone?: boolean; removeUndefined?: boolean } = {}
   ) {
     // Configuration
     const config = {
-      checkRoles: true,
+      checkRoles: false,
       clone: false,
       create: false,
+      removeUndefined: false,
       ...options,
     };
 
-    // Clone output
+    // Clone input
     if (config.clone) {
-      input = JSON.parse(JSON.stringify(input));
+      if (input.mapDeep && typeof input.mapDeep === 'function') {
+        input = 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.roles && (!currentUser?.hasRole || !currentUser.hasRole(RoleEnum.ADMIN))) {
       if (!(currentUser as any)?.roles) {
         throw new UnauthorizedException('Missing roles of current user');
       } else {
@@ -67,37 +76,51 @@ export class ServiceHelper {
    */
   static async prepareOutput<T = Record<string, 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; removeUndefined?: boolean; targetModel?: Partial<T> } = {}
   ) {
     // Configuration
     const config = {
-      clone: true,
+      clone: false,
+      removeUndefined: false,
+      targetModel: undefined,
       ...options,
     };
 
     // Clone output
     if (config.clone) {
-      output = JSON.parse(JSON.stringify(output));
+      if (output.cloneDeep && typeof output.cloneDeep === 'function') {
+        output = Object.getPrototypeOf(output).cloneDeep(output);
+      } else {
+        output = _.cloneDeep(output);
+      }
     }
 
     // Map output if target model exist
-    if (options.targetModel) {
-      (options.targetModel as any).map(output);
+    if (config.targetModel) {
+      output = (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;
+  }
 }

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

@@ -0,0 +1,36 @@
+import { ModelHelper } from '../helpers/model.helper';
+import { CoreModel } from '../models/core-model.model';
+
+/**
+ * Core Input
+ *
+ * All properties (in this class and all classes that extend this class) must be initialized with undefined!
+ *
+ * In contrast to the core model, properties that are undefined are completely removed from the instance during mapping,
+ * so that no existing data is overwritten when a data set is updated, for example. However, re-mapping causes the
+ * removed properties to be ignored and no longer automatically integrated into the instance. They must then be
+ * reactivated by direct assignment `instance.property = ...`.
+ */
+export abstract class CoreInput extends CoreModel {
+  /**
+   * Map method
+   */
+  public map(
+    data: Partial<this> | Record<string, any>,
+    options: {
+      cloneDeep?: boolean;
+      funcAllowed?: boolean;
+      mapId?: boolean;
+    } = {}
+  ): this {
+    const config = {
+      cloneDeep: false,
+      funcAllowed: false,
+      mapId: false,
+      ...options,
+    };
+    const coreInput = ModelHelper.map(data, this, config);
+    Object.keys(coreInput).forEach((key) => coreInput[key] === undefined && delete coreInput[key]);
+    return coreInput;
+  }
+}

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

@@ -1,5 +1,7 @@
 import { Field, InputType } from '@nestjs/graphql';
+import { ModelHelper } from '../helpers/model.helper';
 import { CombinedFilterInput } from './combined-filter.input';
+import { CoreInput } from './core-input.input';
 import { SingleFilterInput } from './single-filter.input';
 
 /**
@@ -8,7 +10,7 @@ import { SingleFilterInput } from './single-filter.input';
 @InputType({
   description: 'Input for filtering. The `singleFilter` will be ignored if the `combinedFilter` is set.',
 })
-export class FilterInput {
+export class FilterInput extends CoreInput {
   /**
    * Combination of multiple filters via logical operator
    */
@@ -16,7 +18,7 @@ export class FilterInput {
     description: 'Combination of multiple filters via logical operator',
     nullable: true,
   })
-  combinedFilter?: CombinedFilterInput;
+  combinedFilter?: CombinedFilterInput = undefined;
 
   /**
    * Filter for a single property
@@ -25,5 +27,27 @@ export class FilterInput {
     description: 'Filter for a single property',
     nullable: true,
   })
-  singleFilter?: SingleFilterInput;
+  singleFilter?: SingleFilterInput = 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.combinedFilter = data.combinedFilter ? CombinedFilterInput.map(data.combinedFilter, options) : undefined;
+    this.singleFilter = data.singleFilter ? SingleFilterInput.map(data.singleFilter, options) : undefined;
+    Object.keys(this).forEach((key) => this[key] === undefined && delete this[key]);
+    return this;
+  }
 }

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

@@ -1,17 +1,18 @@
 import { Field, InputType } from '@nestjs/graphql';
 import { ComparisonOperatorEnum } from '../enums/comparison-operator.enum';
 import { JSON } from '../scalars/json.scalar';
+import { CoreInput } from './core-input.input';
 
 /**
  * Input for a configuration of a filter
  */
 @InputType({ description: 'Input for a configuration of a filter' })
-export class SingleFilterInput {
+export class SingleFilterInput extends CoreInput {
   /**
    * Name of the property to be used for the filter'
    */
   @Field({ description: 'Name of the property to be used for the filter' })
-  field: string;
+  field: string = undefined;
 
   /**
    * [Negate operator](https://docs.mongodb.com/manual/reference/operator/query/not/)
@@ -20,7 +21,7 @@ export class SingleFilterInput {
     description: '[Negate operator](https://docs.mongodb.com/manual/reference/operator/query/not/)',
     nullable: true,
   })
-  not?: boolean;
+  not?: boolean = undefined;
 
   /**
    * [Comparison operator](https://docs.mongodb.com/manual/reference/operator/query-comparison/)
@@ -28,7 +29,7 @@ export class SingleFilterInput {
   @Field((type) => ComparisonOperatorEnum, {
     description: '[Comparison operator](https://docs.mongodb.com/manual/reference/operator/query-comparison/)',
   })
-  operator: ComparisonOperatorEnum;
+  operator: ComparisonOperatorEnum = undefined;
 
   /**
    * [Options](https://docs.mongodb.com/manual/reference/operator/query/regex/#op._S_options) for
@@ -40,8 +41,8 @@ export class SingleFilterInput {
       '[REGEX](https://docs.mongodb.com/manual/reference/operator/query/regex/) operator',
     nullable: true,
   })
-  options?: string;
+  options?: string = undefined;
 
   @Field((type) => JSON, { description: 'Value of the property' })
-  value: any;
+  value: any = undefined;
 }

package/src/core/common/inputs/sort.input.ts

@@ -1,20 +1,21 @@
 import { Field, InputType } from '@nestjs/graphql';
 import { SortOrderEnum } from '../enums/sort-order.emum';
+import { CoreInput } from './core-input.input';
 
 /**
  * Sorting the returned elements
  */
 @InputType({ description: 'Sorting the returned elements' })
-export class SortInput {
+export class SortInput extends CoreInput {
   /**
    * Field that is to be used for sorting
    */
   @Field({ description: 'Field that is to be used for sorting' })
-  field: string;
+  field: string = undefined;
 
   /**
    * SortInput order of the field
    */
   @Field((type) => SortOrderEnum, { description: 'SortInput order of the field' })
-  order: SortOrderEnum;
+  order: SortOrderEnum = undefined;
 }

package/src/core/common/interceptors/check-response.interceptor.ts

@@ -19,8 +19,8 @@ export class CheckResponseInterceptor implements NestInterceptor {
     // Response interception
     return next.handle().pipe(
       map((data) => {
-        // Prepare data for current user
-        return checkRestricted(data, currentUser);
+        // Prepare response data for current user
+        return checkRestricted(data, currentUser, { throwError: false });
       })
     );
   }