@lenne.tech/nest-server 8.0.2 → 8.3.0

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

@@ -2,6 +2,7 @@ import * as _ from 'lodash';
 
 /**
  * Helper class for models
+ * @deprecated use functions directly
  */
 export class ModelHelper {
   /**
@@ -19,31 +20,7 @@ export class ModelHelper {
       mapId?: boolean;
     } = {}
   ): Partial<T> | Record<string, any> {
-    // Set config
-    const config = {
-      cloneDeep: true,
-      funcAllowed: false,
-      mapId: false,
-      ...options,
-    };
-
-    // Initializations
-    const result = {};
-
-    // Update properties
-    for (const key of Object.keys(target)) {
-      if (
-        (!['id', '_id'].includes(key) || config.mapId) &&
-        source[key] !== undefined &&
-        (config.funcAllowed || typeof (source[key] !== 'function'))
-      ) {
-        result[key] = source[key] !== 'function' && config.cloneDeep ? _.cloneDeep(source[key]) : source[key];
-      } else if (key === 'id' && !config.mapId) {
-        result['id'] = source[key];
-      }
-    }
-
-    return result;
+    return prepareMap(source, target, options);
   }
 
   /**
@@ -58,27 +35,7 @@ export class ModelHelper {
       mapId?: boolean;
     } = {}
   ): T {
-    // Set config
-    const config = {
-      cloneDeep: true,
-      funcAllowed: false,
-      mapId: false,
-      ...options,
-    };
-
-    // Check source
-    if (!source || typeof source !== 'object' || Array.isArray(source)) {
-      return config.cloneDeep ? _.cloneDeep(target) : target;
-    }
-
-    // Prepare source
-    const preparedSource = ModelHelper.prepareMap(source, target, config);
-
-    // Merge target with prepared source
-    Object.assign(target, preparedSource);
-
-    // Return target
-    return target;
+    return map(source, target, options);
   }
 
   /**
@@ -89,19 +46,107 @@ export class ModelHelper {
     targetClass: new (...args: any[]) => T,
     cloneDeep = true
   ): T[] {
-    // Check data
-    if (!data || typeof data !== 'object') {
-      return undefined;
-    }
+    return maps(data, targetClass, cloneDeep);
+  }
+}
+
+/**
+ * Remove all properties from source which are not in target
+ * @param source
+ * @param target
+ * @param options
+ */
+export function prepareMap<T = Record<string, any>>(
+  source: Partial<T> | Record<string, any>,
+  target: T,
+  options: {
+    cloneDeep?: boolean;
+    funcAllowed?: boolean;
+    mapId?: boolean;
+  } = {}
+): Partial<T> | Record<string, any> {
+  // Set config
+  const config = {
+    cloneDeep: true,
+    funcAllowed: false,
+    mapId: false,
+    ...options,
+  };
 
-    // Check array
-    if (!Array.isArray(data)) {
-      data = [data];
+  // Initializations
+  const result = {};
+
+  // Update properties
+  for (const key of Object.keys(target)) {
+    if (
+      (!['id', '_id'].includes(key) || config.mapId) &&
+      source[key] !== undefined &&
+      (config.funcAllowed || typeof (source[key] !== 'function'))
+    ) {
+      result[key] = source[key] !== 'function' && config.cloneDeep ? _.cloneDeep(source[key]) : source[key];
+    } else if (key === 'id' && !config.mapId) {
+      result['id'] = source[key];
     }
+  }
 
-    // Map
-    return (data as any[]).map((item) => {
-      return (targetClass as any).map(item, { cloneDeep });
-    });
+  return result;
+}
+
+/**
+ * Simple map function
+ */
+export function map<T = Record<string, any>>(
+  source: Partial<T> | Record<string, any>,
+  target: T,
+  options: {
+    cloneDeep?: boolean;
+    funcAllowed?: boolean;
+    mapId?: boolean;
+  } = {}
+): T {
+  // Set config
+  const config = {
+    cloneDeep: true,
+    funcAllowed: false,
+    mapId: false,
+    ...options,
+  };
+
+  // Check source
+  if (!source || typeof source !== 'object' || Array.isArray(source)) {
+    return config.cloneDeep ? _.cloneDeep(target) : target;
+  }
+
+  // Prepare source
+  const preparedSource = prepareMap(source, target, config);
+
+  // Merge target with prepared source
+  Object.assign(target, preparedSource);
+
+  // Return target
+  return target;
+}
+
+/**
+ * Create Object or Objects of specified type with specified data
+ */
+export function maps<T = Record<string, any>>(
+  data: Partial<T> | Partial<T>[] | Record<string, any> | Record<string, any>[],
+  targetClass: new (...args: any[]) => T,
+  cloneDeep = true
+): T[] {
+  // Check data
+  if (!data || typeof data !== 'object') {
+    return undefined;
+  }
+
+  // Check array
+  if (!Array.isArray(data)) {
+    data = [data];
   }
+
+  // Map
+  return (data as any[]).map((item) => {
+    return (targetClass as any).map(item, { cloneDeep });
+  });
 }

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

@@ -5,8 +5,9 @@ import { RoleEnum } from '../enums/role.enum';
 
 /**
  * Helper class for services
+ * @deprecated use functions directly
  */
-export class ServiceHelper {
+export default class ServiceHelper {
   /**
    * Prepare input before save
    */
@@ -21,78 +22,7 @@ export class ServiceHelper {
       removeUndefined?: boolean;
     } = {}
   ): Promise<T> {
-    // Configuration
-    const config = {
-      checkRoles: false,
-      clone: false,
-      create: false,
-      getNewArray: false,
-      removeUndefined: false,
-      ...options,
-    };
-
-    // 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) {
-      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 (
-      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 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 as Record<string, any>).roles = allowedRoles;
-      }
-    }
-
-    // Hash password
-    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 as Record<string, any>).createdBy = currentUser.id;
-    }
-
-    // Set updater
-    if (currentUser) {
-      (input as Record<string, any>).updatedBy = currentUser.id;
-    }
-
-    // Return prepared input
-    return input;
+    return prepareInput(input, currentUser, options);
   }
 
   /**
@@ -108,61 +38,163 @@ export class ServiceHelper {
       targetModel?: new (...args: any[]) => T;
     } = {}
   ): Promise<T | T[] | any> {
-    // Configuration
-    const config = {
-      clone: false,
-      getNewArray: false,
-      removeUndefined: false,
-      targetModel: undefined,
-      ...options,
-    };
-
-    // Check output
-    if (typeof output !== 'object') {
-      return output;
-    }
+    return prepareOutput(output, options);
+  }
+}
 
-    // Process array
-    if (Array.isArray(output)) {
-      const processedArray = output.map(async (item) => await ServiceHelper.prepareOutput(item, options)) as any;
-      return config.getNewArray ? processedArray : output;
+/**
+ * Prepare input before save
+ */
+export async function prepareInput<T = any>(
+  input: T,
+  currentUser: { [key: string]: any; id: string },
+  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,
+  };
+
+  // Check input
+  if (typeof input !== 'object') {
+    return input;
+  }
+
+  // Process array
+  if (Array.isArray(input)) {
+    const processedArray = input.map(async (item) => await prepareInput(item, currentUser, options)) as any;
+    return config.getNewArray ? processedArray : input;
+  }
+
+  // Clone input
+  if (config.clone) {
+    if ((input as Record<string, any>).mapDeep && typeof (input as any).mapDeep === 'function') {
+      input = await Object.getPrototypeOf(input).mapDeep(input);
+    } else {
+      input = _.cloneDeep(input);
     }
+  }
 
-    // Clone output
-    if (config.clone) {
-      if (output.mapDeep && typeof output.mapDeep === 'function') {
-        output = await Object.getPrototypeOf(output).mapDeep(output);
-      } else {
-        output = _.cloneDeep(output);
+  // Remove undefined properties to avoid unwanted overwrites
+  if (config.removeUndefined) {
+    Object.keys(input).forEach((key) => input[key] === undefined && delete input[key]);
+  }
+
+  // Process roles
+  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 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 as Record<string, any>).roles = allowedRoles;
     }
+  }
 
-    // Map output if target model exist
-    if (config.targetModel) {
-      output = await (config.targetModel as any).map(output);
-    }
+  // Hash password
+  if ((input as Record<string, any>).password) {
+    (input as Record<string, any>).password = await bcrypt.hash((input as any).password, 10);
+  }
 
-    // Remove password if exists
-    if (output.password) {
-      output.password = undefined;
-    }
+  // Set creator
+  if (config.create && currentUser) {
+    (input as Record<string, any>).createdBy = currentUser.id;
+  }
 
-    // Remove verification token if exists
-    if (output.verificationToken) {
-      output.verificationToken = undefined;
-    }
+  // Set updater
+  if (currentUser) {
+    (input as Record<string, any>).updatedBy = currentUser.id;
+  }
 
-    // Remove password reset token if exists
-    if (output.passwordResetToken) {
-      output.passwordResetToken = undefined;
-    }
+  // Return prepared input
+  return input;
+}
 
-    // Remove undefined properties to avoid unwanted overwrites
-    if (config.removeUndefined) {
-      Object.keys(output).forEach((key) => output[key] === undefined && delete output[key]);
+/**
+ * Prepare output before return
+ */
+export async function prepareOutput<T = { [key: string]: any; map: (...args: any[]) => any }>(
+  output: any,
+  options: {
+    [key: string]: any;
+    clone?: boolean;
+    getNewArray?: boolean;
+    removeUndefined?: boolean;
+    targetModel?: new (...args: any[]) => T;
+  } = {}
+): Promise<T | T[] | any> {
+  // Configuration
+  const config = {
+    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 prepareOutput(item, options)) as any;
+    return config.getNewArray ? processedArray : output;
+  }
+
+  // Clone output
+  if (config.clone) {
+    if (output.mapDeep && typeof output.mapDeep === 'function') {
+      output = await Object.getPrototypeOf(output).mapDeep(output);
+    } else {
+      output = _.cloneDeep(output);
     }
+  }
 
-    // Return prepared output
-    return output;
+  // Map output if target model exist
+  if (config.targetModel) {
+    output = await (config.targetModel as any).map(output);
+  }
+
+  // Remove password if exists
+  if (output.password) {
+    output.password = undefined;
   }
+
+  // Remove verification token if exists
+  if (output.verificationToken) {
+    output.verificationToken = undefined;
+  }
+
+  // Remove password reset token if exists
+  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 output
+  return output;
 }

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

@@ -1,6 +1,6 @@
 import { Field, InputType } from '@nestjs/graphql';
 import { LogicalOperatorEnum } from '../enums/logical-operator.enum';
-import { ModelHelper } from '../helpers/model.helper';
+import { maps } from '../helpers/model.helper';
 import { CoreInput } from './core-input.input';
 import { FilterInput } from './filter.input';
 
@@ -40,7 +40,7 @@ export class CombinedFilterInput extends CoreInput {
     } = {}
   ): this {
     super.map(data, options);
-    this.filters = ModelHelper.maps(data.filters, FilterInput, options.cloneDeep);
+    this.filters = 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

@@ -1,4 +1,4 @@
-import { ModelHelper } from '../helpers/model.helper';
+import { map } from '../helpers/model.helper';
 import { CoreModel } from '../models/core-model.model';
 
 /**
@@ -29,7 +29,7 @@ export abstract class CoreInput extends CoreModel {
       mapId: false,
       ...options,
     };
-    const coreInput = ModelHelper.map(data, this, config);
+    const coreInput = map(data, this, config);
     Object.keys(coreInput).forEach((key) => coreInput[key] === undefined && delete coreInput[key]);
     return coreInput;
   }

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

@@ -2,7 +2,7 @@ import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nes
 import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { checkRestricted } from '../decorators/restricted.decorator';
-import { Context } from '../helpers/context.helper';
+import { getContextData } from '../helpers/context.helper';
 
 /**
  * Interceptor to check the response data for current user
@@ -14,7 +14,7 @@ export class CheckResponseInterceptor implements NestInterceptor {
    */
   intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
     // Get current user
-    const { currentUser }: any = Context.getData(context);
+    const { currentUser }: any = getContextData(context);
 
     // Response interception
     return next.handle().pipe(

package/src/core/common/interfaces/resolve-selector.interface.ts

@@ -0,0 +1,9 @@
+import { GraphQLResolveInfo } from 'graphql';
+
+/**
+ * Resolve selector to get requested fields from GraphQL resolve info
+ */
+export interface ResolveSelector {
+  info: GraphQLResolveInfo;
+  select?: string;
+}

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

@@ -0,0 +1,71 @@
+import { Model, Types } from 'mongoose';
+import { FieldSelection } from '../types/field-selection.type';
+import { IdsType } from '../types/ids.type';
+
+/**
+ * General service options
+ */
+export interface ServiceOptions {
+  // All fields are allowed to be compatible as far as possible
+  [key: string]: any;
+
+  // Check rights for input data (see check function in InputHelper)
+  // If falsy: input data will not be checked
+  // If truly (default): input data will be checked
+  checkRights?: boolean;
+
+  // Current user to set ownership, check roles and other things
+  currentUser?: {
+    [key: string]: any;
+    id: string;
+    roles?: string[];
+  };
+
+  // Field selection for results
+  fieldSelection?: FieldSelection;
+
+  // Overwrites type of input (array items)
+  inputType?: new (...params: any[]) => any;
+
+  // Owner IDs
+  ownerIds?: IdsType;
+
+  // 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
+  processFieldSelection?: {
+    model?: new (...args: any[]) => any;
+    dbModel?: Model<any>;
+  };
+
+  // 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;
+  };
+
+  // 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;
+  };
+
+  // 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/models/core-model.model.ts

@@ -1,4 +1,4 @@
-import { ModelHelper } from '../helpers/model.helper';
+import { map } from '../helpers/model.helper';
 
 /**
  * Core Model
@@ -26,6 +26,7 @@ export abstract class CoreModel {
     this: new (...args: any[]) => T,
     data: Partial<T> | Record<string, any>,
     options: {
+      [key: string]: any;
       cloneDeep?: boolean;
       funcAllowed?: boolean;
       init?: any;
@@ -55,6 +56,7 @@ export abstract class CoreModel {
     this: new (...args: any[]) => T,
     data: Partial<T> | Record<string, any>,
     options: {
+      [key: string]: any;
       cloneDeep?: boolean;
       funcAllowed?: boolean;
       init?: any;
@@ -76,7 +78,7 @@ export abstract class CoreModel {
    * 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 {
+  public init(...args: any[]): this {
     return this;
   }
 
@@ -86,6 +88,7 @@ export abstract class CoreModel {
   public map(
     data: Partial<this> | Record<string, any>,
     options: {
+      [key: string]: any;
       cloneDeep?: boolean;
       funcAllowed?: boolean;
       init?: any;
@@ -99,7 +102,7 @@ export abstract class CoreModel {
       mapId: false,
       ...options,
     };
-    return config.init ? ModelHelper.map(data, this, config).init(config.init) : ModelHelper.map(data, this, config);
+    return config.init ? map(data, this, config).init(config.init) : map(data, this, config);
   }
 
   /**
@@ -113,6 +116,7 @@ export abstract class CoreModel {
   public mapDeep(
     data: Partial<this> | Record<string, any>,
     options: {
+      [key: string]: any;
       cloneDeep?: boolean;
       funcAllowed?: boolean;
       init?: any;

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

@@ -1,7 +1,7 @@
 import { ArgumentMetadata, Inject, Injectable, PipeTransform } from '@nestjs/common';
 import { CONTEXT } from '@nestjs/graphql';
-import { Context } from '../helpers/context.helper';
-import { InputHelper } from '../helpers/input.helper';
+import { getContextData } from '../helpers/context.helper';
+import { check } from '../helpers/input.helper';
 
 /**
  * The CheckInputPipe checks the permissibility of individual properties of inputs for the resolvers
@@ -25,9 +25,9 @@ export class CheckInputPipe implements PipeTransform {
     const metatype = metadata?.metatype;
 
     // Get user
-    const { user }: any = Context.getData(this.context);
+    const { user }: any = getContextData(this.context);
 
     // Check and return
-    return InputHelper.check(value, user, metatype);
+    return check(value, user, { metatype });
   }
 }