@lenne.tech/nest-server 3.2.0 → 3.3.2

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 });
       })
     );
   }

package/src/core/common/interfaces/core-persistence-model.interface.ts

@@ -12,5 +12,6 @@ export interface ICorePersistenceModel<T extends CorePersistenceModel = any> {
       merge?: boolean;
     }
   ): any;
+  init(this: new (...args: any[]) => T, ...args: any[]): any;
   [key: string]: any;
 }

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

@@ -1,8 +1,8 @@
-import { GqlModuleOptions } from '@nestjs/graphql';
+import { ApolloDriverConfig } from '@nestjs/apollo';
 import { JwtModuleOptions } from '@nestjs/jwt';
+import { MongooseModuleOptions } from '@nestjs/mongoose/dist/interfaces/mongoose-options.interface';
 import { ServeStaticOptions } from '@nestjs/platform-express/interfaces/serve-static-options.interface';
 import * as SMTPTransport from 'nodemailer/lib/smtp-transport';
-import { MongooseModuleOptions } from '@nestjs/mongoose/dist/interfaces/mongoose-options.interface';
 import { MailjetOptions } from './mailjet-options.interface';
 
 /**
@@ -20,37 +20,7 @@ export interface IServerOptions {
    * see https://docs.nestjs.com/graphql/quick-start
    * and https://www.apollographql.com/docs/apollo-server/api/apollo-server/
    */
-  graphQl?: {
-    /**
-     * Autogenerated schema file
-     * e.g. 'schema.gql'
-     */
-    autoSchemaFile?: string;
-
-    /**
-     * Function for context manipulation
-     * e.g. ({ req }) => ({ req })
-     */
-    context?: (context: { [key: string]: any; req: any }) => { [key: string]: any; req: any };
-
-    /**
-     * Enables and disables development mode helpers of apollo
-     * e.g. true
-     */
-    debug?: boolean;
-
-    /**
-     * Determines whether or not to install subscription handlers
-     * e.g. true
-     */
-    installSubscriptionHandlers?: boolean;
-
-    /**
-     * Enables and disables schema introspection
-     * e.g. true
-     */
-    introspection?: boolean;
-  } & GqlModuleOptions;
+  graphQl?: ApolloDriverConfig;
 
   /**
    * Configuration of JavaScript Web Token (JWT) module

package/src/core/common/models/core-model.model.ts

@@ -2,8 +2,23 @@ import { ModelHelper } from '../helpers/model.helper';
 
 /**
  * Core Model
+ *
+ * HINT: All properties (in this class and all classes that extend this class) must be initialized with a default
+ * value or undefined otherwise the property will not be recognized via Object.keys (this is necessary for mapping).
+ * If the property is initialized with a default value (e.g. an empty array or boolean), there is a risk that the
+ * current value will be overwritten during mapping without this being intentional, so all values should be initialized
+ * with undefined if possible. If necessary and useful, the init method can then be used deliberately:
+ * const coreModel = item ? CoreModel.map(item).init() : CoreModel.init();
  */
 export abstract class CoreModel {
+  /**
+   * Static init method
+   */
+  public static init<T extends CoreModel>(this: new (...args: any[]) => T, ...args: any[]): T {
+    const item = new this();
+    return item.init(args);
+  }
+
   /**
    * Static map method
    */
@@ -13,13 +28,19 @@ export abstract class CoreModel {
     options: {
       cloneDeep?: boolean;
       funcAllowed?: boolean;
+      init?: any;
       item?: T;
       mapId?: boolean;
     } = {}
   ): T {
+    const config = {
+      init: true,
+      ...options,
+    };
+
     const item = options.item || new this();
     delete options.item;
-    return item.map(data, options);
+    return item.map(data, config);
   }
 
   /**
@@ -36,13 +57,27 @@ export abstract class CoreModel {
     options: {
       cloneDeep?: boolean;
       funcAllowed?: boolean;
+      init?: any;
       item?: T;
       mapId?: boolean;
     } = {}
   ): T {
+    const config = {
+      init: true,
+      ...options,
+    };
+
     const item = options.item || new this();
     delete options.item;
-    return item.mapDeep(data, options);
+    return item.mapDeep(data, config);
+  }
+
+  /**
+   * Initialize instance with default values instead of undefined
+   * Should be overwritten in child class to organize the defaults
+   */
+  public init<T extends CoreModel>(...args: any[]): this {
+    return this;
   }
 
   /**
@@ -53,16 +88,18 @@ export abstract class CoreModel {
     options: {
       cloneDeep?: boolean;
       funcAllowed?: boolean;
+      init?: any;
       mapId?: boolean;
     } = {}
   ): this {
     const config = {
       cloneDeep: false,
       funcAllowed: false,
+      init: undefined,
       mapId: false,
       ...options,
     };
-    return ModelHelper.map(data, this, config);
+    return config.init ? ModelHelper.map(data, this, config).init(config.init) : ModelHelper.map(data, this, config);
   }
 
   /**
@@ -78,12 +115,14 @@ export abstract class CoreModel {
     options: {
       cloneDeep?: boolean;
       funcAllowed?: boolean;
+      init?: any;
       mapId?: boolean;
     } = {}
   ): this {
     const config = {
       cloneDeep: true,
       funcAllowed: false,
+      init: undefined,
       mapId: false,
       ...options,
     };

package/src/core/common/models/core-persistence.model.ts

@@ -1,32 +1,38 @@
 import { Field, ID, ObjectType } from '@nestjs/graphql';
-import * as _ from 'lodash';
-import { ModelHelper } from '../helpers/model.helper';
 import { Prop, Schema } from '@nestjs/mongoose';
-import * as mongoose from 'mongoose';
+import { Types } from 'mongoose';
+import { CoreModel } from './core-model.model';
 
 /**
  * Metadata for persistent objects
  *
  * The models are a combination of Mongoose Entities and TypeGraphQL Types
+ *
+ * HINT: All properties (in this class and all classes that extend this class) must be initialized with a default
+ * value or undefined otherwise the property will not be recognized via Object.keys (this is necessary for mapping).
+ * If the property is initialized with a default value (e.g. an empty array or boolean), there is a risk that the
+ * current value will be overwritten during mapping without this being intentional, so all values should be initialized
+ * with undefined if possible. If necessary and useful, the init method can then be used deliberately:
+ * const corePersistenceModel = item ? CorePersistenceModel.map(item).init() : CorePersistenceModel.init();
  */
 @ObjectType({
   description: 'Persistence model which will be saved in DB',
   isAbstract: true,
 })
-@Schema()
-export abstract class CorePersistenceModel {
+@Schema({ timestamps: true })
+export abstract class CorePersistenceModel extends CoreModel {
   // ===========================================================================
   // Getter
   // ===========================================================================
+
   get _id() {
-    return new mongoose.Types.ObjectId(this.id);
+    return new Types.ObjectId(this.id);
   }
 
   // ===========================================================================
   // Properties
-  //
-  // TestFields: https://typegraphql.ml/docs/types-and-fields.html
   // ===========================================================================
+
   /**
    * ID of the persistence object as string
    */
@@ -37,11 +43,11 @@ export abstract class CorePersistenceModel {
   id: string = undefined;
 
   /**
-   * Created date
+   * Created date, is set automatically by mongoose
    */
   @Field({ description: 'Created date', nullable: true })
-  @Prop()
-  createdAt: Date = new Date();
+  @Prop({ onCreate: () => new Date() })
+  createdAt: Date = undefined;
 
   /**
    * Labels of the object
@@ -51,7 +57,7 @@ export abstract class CorePersistenceModel {
     nullable: true,
   })
   @Prop([String])
-  labels: string[] = [];
+  labels: string[] = undefined;
 
   /**
    * IDs of the Owners
@@ -61,7 +67,7 @@ export abstract class CorePersistenceModel {
     nullable: true,
   })
   @Prop([String])
-  ownerIds: string[] = [];
+  ownerIds: string[] = undefined;
 
   /**
    * Tags for the object
@@ -71,122 +77,29 @@ export abstract class CorePersistenceModel {
     nullable: true,
   })
   @Prop([String])
-  tags: string[] = [];
+  tags: string[] = undefined;
 
   /**
-   * Updated date
+   * Updated date is set automatically by mongoose
    */
   @Field({ description: 'Updated date', nullable: true })
   @Prop({ onUpdate: () => new Date() })
-  updatedAt: Date = new Date();
-
-  /**
-   * Static map method
-   */
-  public static map<T extends CorePersistenceModel>(
-    this: new (...args: any[]) => T,
-    data: Partial<T> | Record<string, any>,
-    options: {
-      cloneDeep?: boolean;
-      funcAllowed?: boolean;
-      item?: T;
-      mapId?: boolean;
-      merge?: boolean;
-    } = {}
-  ): T {
-    const item = options.item || new this();
-    delete options.item;
-    return item.map(data, options);
-  }
+  updatedAt: Date = undefined;
 
-  /**
-   * Static map deep method
-   *
-   * Alias for map with cloneDeep = true
-   *
-   * MapDeep prevents side effects, because objects will be cloned
-   * (cloneDeep = true), but it will be slower than a simple map
-   */
-  public static mapDeep<T extends CorePersistenceModel>(
-    this: new (...args: any[]) => T,
-    data: Partial<T> | Record<string, any>,
-    options: {
-      cloneDeep?: boolean;
-      funcAllowed?: boolean;
-      item?: T;
-      mapId?: boolean;
-      merge?: boolean;
-    } = {}
-  ): T {
-    const item = options.item || new this();
-    delete options.item;
-    return item.mapDeep(data, options);
-  }
+  // ===========================================================================
+  // Methods
+  // ===========================================================================
 
   /**
-   * Map method
+   * Initialize instance with default values instead of undefined
    */
-  public map(
-    data: Partial<this> | Record<string, any>,
-    options: {
-      cloneDeep?: boolean;
-      funcAllowed?: boolean;
-      mapId?: boolean;
-      merge?: boolean;
-    } = {}
-  ): this {
-    const config = {
-      cloneDeep: false,
-      funcAllowed: false,
-      mapId: false,
-      merge: false,
-      ...options,
-    };
-
-    // Prepare data
-    let preparedData = data;
-    preparedData = ModelHelper.prepareMap(preparedData, this, config);
-    if (config.cloneDeep) {
-      preparedData = _.cloneDeep(preparedData);
-    }
-
-    // Assign
-    if (this['assign'] !== 'function') {
-      if (!config.merge) {
-        Object.assign(this, preparedData);
-      }
-    } else {
-      this['assign'](preparedData, { mergeObjects: config.merge });
-    }
-
-    // Return
+  init() {
+    super.init();
+    this.createdAt = this.createdAt === undefined ? new Date() : this.createdAt;
+    this.labels = this.labels === undefined ? [] : this.labels;
+    this.ownerIds = this.ownerIds === undefined ? [] : this.ownerIds;
+    this.tags = this.tags === undefined ? [] : this.tags;
+    this.updatedAt = this.tags === undefined ? this.createdAt : this.updatedAt;
     return this;
   }
-
-  /**
-   * Map deep method
-   *
-   * Alias for map with cloneDeep = true
-   *
-   * MapDeep prevents side effects, because objects will be cloned
-   * (cloneDeep = true), but it will be slower than a simple map
-   */
-  public mapDeep(
-    data: Partial<this> | Record<string, any>,
-    options: {
-      cloneDeep?: boolean;
-      funcAllowed?: boolean;
-      mapId?: boolean;
-      merge?: boolean;
-    } = {}
-  ): this {
-    const config = {
-      cloneDeep: true,
-      funcAllowed: false,
-      mapId: false,
-      merge: false,
-      ...options,
-    };
-    return this.map(data, config);
-  }
 }

package/src/core/common/pipes/check-input.pipe.ts

@@ -1,16 +1,17 @@
-import { ArgumentMetadata, BadRequestException, Inject, Injectable, PipeTransform, Scope } from '@nestjs/common';
+import { ArgumentMetadata, Inject, Injectable, PipeTransform } from '@nestjs/common';
 import { CONTEXT } from '@nestjs/graphql';
-import { plainToClass } from 'class-transformer';
-import { validate, ValidationError } from 'class-validator';
-import { checkRestricted } from '../decorators/restricted.decorator';
 import { Context } from '../helpers/context.helper';
+import { InputHelper } from '../helpers/input.helper';
 
 /**
  * The CheckInputPipe checks the permissibility of individual properties of inputs for the resolvers
  * in relation to the current user
+ *
+ * ATTENTION: Pipe does not work yet, because context is missing: https://github.com/nestjs/graphql/issues/325
+ * Once this works MapAndValidate can be replaced in the CoreModule with this pipe.
  */
-@Injectable({ scope: Scope.REQUEST })
-export class CheckInputPipe implements PipeTransform<any> {
+@Injectable()
+export class CheckInputPipe implements PipeTransform {
   /**
    * Constructor to inject context
    */
@@ -19,35 +20,14 @@ export class CheckInputPipe implements PipeTransform<any> {
   /**
    * Check input
    */
-  async transform(value: any, { metatype }: ArgumentMetadata) {
-    // Return value if it is only a basic type
-    if (!metatype || this.isBasicType(metatype)) {
-      return value;
-    }
+  async transform(value: any, metadata: ArgumentMetadata) {
+    // Get meta type
+    const metatype = metadata?.metatype;
 
-    // Remove restricted values if roles are missing
+    // Get user
     const { user }: any = Context.getData(this.context);
-    value = checkRestricted(value, user);
 
-    // Validate value
-    const plainValue = JSON.parse(JSON.stringify(value));
-    const object = plainToClass(metatype, plainValue);
-    const errors: ValidationError[] = await validate(object);
-
-    // Check errors
-    if (errors.length > 0) {
-      throw new BadRequestException('Validation failed');
-    }
-
-    // Everything is ok
-    return value;
-  }
-
-  /**
-   * Checks if it is a basic type
-   */
-  protected isBasicType(metatype: any): boolean {
-    const types = [String, Boolean, Number, Array, Object, Buffer, ArrayBuffer];
-    return types.includes(metatype);
+    // Check and return
+    return InputHelper.check(value, user, metatype);
   }
 }

package/src/core/common/pipes/map-and-validate.pipe.ts

@@ -0,0 +1,32 @@
+import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from '@nestjs/common';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { InputHelper } from '../helpers/input.helper';
+
+@Injectable()
+export class MapAndValidatePipe implements PipeTransform {
+  async transform(value: any, metadata: ArgumentMetadata) {
+    const { metatype } = metadata;
+
+    if (typeof value !== 'object' || !metatype || InputHelper.isBasicType(metatype)) {
+      return value;
+    }
+
+    // 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('Input validation failed');
+    }
+
+    return value;
+  }
+}

package/src/core/common/types/plain-input.type.ts

@@ -0,0 +1,6 @@
+/**
+ * Type for plain Inputs
+ */
+export type PlainInput<T> = {
+  [P in keyof T]?: Partial<T[P]> | Partial<PlainInput<T[P]>>;
+};