@lenne.tech/nest-server 8.6.27 → 8.6.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "8.6.27",
+  "version": "8.6.28",
   "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",
@@ -91,6 +91,7 @@
     "passport": "0.6.0",
     "passport-jwt": "4.0.0",
     "reflect-metadata": "0.1.13",
+    "rfdc": "1.3.0",
     "rimraf": "3.0.2",
     "rxjs": "7.5.5"
   },
@@ -105,8 +106,8 @@
     "@types/nodemailer": "6.4.4",
     "@types/passport": "1.0.9",
     "@types/supertest": "2.0.12",
-    "@typescript-eslint/eslint-plugin": "5.30.4",
-    "@typescript-eslint/parser": "5.30.4",
+    "@typescript-eslint/eslint-plugin": "5.30.5",
+    "@typescript-eslint/parser": "5.30.5",
     "coffeescript": "2.7.0",
     "eslint": "8.19.0",
     "eslint-config-prettier": "8.5.0",

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

@@ -3,6 +3,7 @@ import { plainToInstance } from 'class-transformer';
 import { validate } from 'class-validator';
 import { ValidatorOptions } from 'class-validator/types/validation/ValidatorOptions';
 import * as _ from 'lodash';
+import * as rfdc from 'rfdc';
 import { checkRestricted } from '../decorators/restricted.decorator';
 import { ProcessType } from '../enums/process-type.enum';
 import { RoleEnum } from '../enums/role.enum';
@@ -196,7 +197,7 @@ export function assignPlain(target: Record<any, any>, ...args: Record<any, any>[
           ? // Return item if not an object
             item
           : // Return cloned record with undefined properties removed
-            filterProperties(JSON.parse(JSON.stringify(item)), (prop) => prop !== undefined)
+            filterProperties(clone(item, { circles: false }), (prop) => prop !== undefined)
     )
   );
 }
@@ -297,6 +298,44 @@ export async function check(
   return value;
 }
 
+/**
+ * Clone object
+ * @param object Any object
+ * @param options Finetuning of rfdc cloning
+ * @param options.proto Copy prototype properties as well as own properties into the new object.
+ *                      It's marginally faster to allow enumerable properties on the prototype to be copied into the
+ *                      cloned object (not onto it's prototype, directly onto the object).
+ * @param options.circles Keeping track of circular references will slow down performance with an additional 25% overhead.
+ *                        Even if an object doesn't have any circular references, the tracking overhead is the cost.
+ *                        By default if an object with a circular reference is passed to rfdc, it will throw
+ *                        (similar to how JSON.stringify would throw). Use the circles option to detect and preserve
+ *                        circular references in the object. If performance is important, try removing the circular
+ *                        reference from the object (set to undefined) and then add it back manually after cloning
+ *                        instead of using this option.
+ */
+export function clone(object: any, options?: { proto?: boolean; circles?: boolean }) {
+  const config = {
+    proto: false,
+    circles: true,
+    ...options,
+  };
+  try {
+    return rfdc(config)(object);
+  } catch (e) {
+    console.info(e);
+    if (object.circle) {
+      try {
+        return rfdc({ ...config, ...{ circles: true } })(object);
+      } catch (e) {
+        console.info(e);
+        return _.clone(object);
+      }
+    } else {
+      return _.clone(object);
+    }
+  }
+}
+
 /**
  * Combines objects to a new single plain object and ignores undefined
  */
@@ -304,6 +343,19 @@ export function combinePlain(...args: Record<any, any>[]): any {
   return assignPlain({}, ...args);
 }
 
+/**
+ * Get deep frozen object
+ */
+export function deepFreeze(object: any) {
+  if (typeof object !== 'object') {
+    return object;
+  }
+  for (const [key, value] of Object.entries(object)) {
+    object[key] = deepFreeze(value);
+  }
+  return Object.freeze(object);
+}
+
 /**
  * Standard error function
  */
@@ -327,7 +379,6 @@ export function filterProperties<T = Record<string, any>>(
 
 /**
  * Get plain copy of object
- * @param element
  */
 export function getPlain(object: any) {
   return JSON.parse(JSON.stringify(object));
@@ -512,11 +563,24 @@ export function match(expression: any, cases: Record<any, any>): any {
 /**
  * Map values into specific type
  */
-export function mapClass<T>(values: Partial<T>, ctor: new () => T, cloneDeep = true): T {
+export function mapClass<T>(
+  values: Partial<T>,
+  ctor: new () => T,
+  options?: {
+    cloneDeep?: boolean;
+    circle?: boolean;
+    proto?: boolean;
+  }
+): T {
+  const config = {
+    cloneDeep: true,
+    circles: false,
+    proto: false,
+  };
   const instance = new ctor();
 
   return Object.keys(instance).reduce((obj, key) => {
-    obj[key] = cloneDeep ? _.cloneDeep(values[key]) : values[key];
+    obj[key] = config.cloneDeep ? clone(values[key], { circles: config.circles, proto: config.proto }) : values[key];
     return obj;
   }, instance);
 }

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

@@ -1,6 +1,6 @@
 import { plainToInstance } from 'class-transformer';
-import * as _ from 'lodash';
 import { Types } from 'mongoose';
+import { clone } from './input.helper';
 
 /**
  * Helper class for models
@@ -63,15 +63,19 @@ export function prepareMap<T = Record<string, any>>(
   target: T,
   options: {
     cloneDeep?: boolean;
+    circles?: boolean;
     funcAllowed?: boolean;
     mapId?: boolean;
+    proto?: boolean;
   } = {}
 ): Partial<T> | Record<string, any> {
   // Set config
   const config = {
     cloneDeep: true,
+    circles: true,
     funcAllowed: false,
     mapId: false,
+    proto: false,
     ...options,
   };
 
@@ -85,7 +89,10 @@ export function prepareMap<T = Record<string, any>>(
       source[key] !== undefined &&
       (config.funcAllowed || typeof (source[key] !== 'function'))
     ) {
-      result[key] = source[key] !== 'function' && config.cloneDeep ? _.cloneDeep(source[key]) : source[key];
+      result[key] =
+        source[key] !== 'function' && config.cloneDeep
+          ? clone(source[key], { circles: config.circles, proto: config.proto })
+          : source[key];
     } else if (key === 'id' && !config.mapId) {
       result['id'] = source[key];
     }
@@ -102,21 +109,25 @@ export function map<T = Record<string, any>>(
   target: T,
   options: {
     cloneDeep?: boolean;
+    circles?: boolean;
     funcAllowed?: boolean;
     mapId?: boolean;
+    proto?: boolean;
   } = {}
 ): T {
   // Set config
   const config = {
     cloneDeep: true,
+    circles: false,
     funcAllowed: false,
     mapId: false,
+    proto: false,
     ...options,
   };
 
   // Check source
   if (!source || typeof source !== 'object' || Array.isArray(source)) {
-    return config.cloneDeep ? _.cloneDeep(target) : target;
+    return config.cloneDeep ? clone(target, { circles: config.circles, proto: config.proto }) : target;
   }
 
   // Prepare source

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

@@ -4,12 +4,13 @@ import { plainToInstance } from 'class-transformer';
 import { sha256 } from 'js-sha256';
 import * as _ from 'lodash';
 import { Types } from 'mongoose';
-import envConfig from '../../../config.env';
 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';
+import { ConfigService } from '../services/config.service';
+import { clone } from './input.helper';
 
 /**
  * Helper class for services
@@ -24,10 +25,13 @@ export default class ServiceHelper {
     currentUser: { [key: string]: any; id: string },
     options: {
       [key: string]: any;
+      checkRoles?: boolean;
       create?: boolean;
       clone?: boolean;
       getNewArray?: boolean;
       removeUndefined?: boolean;
+      sha256?: boolean;
+      targetModel?: new (...args: any[]) => T;
     } = {}
   ): Promise<T> {
     return prepareInput(input, currentUser, options);
@@ -42,6 +46,8 @@ export default class ServiceHelper {
       [key: string]: any;
       clone?: boolean;
       getNewArray?: boolean;
+      objectIdsToStrings?: boolean;
+      removeSecrets?: boolean;
       removeUndefined?: boolean;
       targetModel?: new (...args: any[]) => T;
     } = {}
@@ -59,10 +65,13 @@ export async function prepareInput<T = any>(
   options: {
     [key: string]: any;
     checkRoles?: boolean;
+    circles?: boolean;
     create?: boolean;
     clone?: boolean;
     getNewArray?: boolean;
+    proto?: boolean;
     removeUndefined?: boolean;
+    sha256?: boolean;
     targetModel?: new (...args: any[]) => T;
   } = {}
 ): Promise<T> {
@@ -70,9 +79,12 @@ export async function prepareInput<T = any>(
   const config = {
     checkRoles: false,
     clone: false,
+    circles: false,
     create: false,
     getNewArray: false,
+    proto: false,
     removeUndefined: true,
+    sha256: ConfigService.configFastButReadOnly.sha256,
     ...options,
   };
 
@@ -98,7 +110,7 @@ export async function prepareInput<T = any>(
     if ((input as Record<string, any>).mapDeep && typeof (input as any).mapDeep === 'function') {
       input = await Object.getPrototypeOf(input).mapDeep(input);
     } else {
-      input = _.cloneDeep(input);
+      input = clone(input, { circles: config.circles, proto: config.proto });
     }
   }
 
@@ -134,7 +146,7 @@ export async function prepareInput<T = any>(
   if ((input as any).password) {
     // Check if the password was transmitted encrypted
     // If not, the password is encrypted to enable future encrypted and unencrypted transmissions
-    if (envConfig.sha256 && !/^[a-f0-9]{64}$/i.test((input as any).password)) {
+    if (config.sha256 && !/^[a-f0-9]{64}$/i.test((input as any).password)) {
       (input as any).password = sha256((input as any).password);
     }
 
@@ -164,8 +176,10 @@ export async function prepareOutput<T = { [key: string]: any; map: (...args: any
   options: {
     [key: string]: any;
     clone?: boolean;
+    circles?: boolean;
     getNewArray?: boolean;
     objectIdsToStrings?: boolean;
+    proto?: boolean;
     removeSecrets?: boolean;
     removeUndefined?: boolean;
     targetModel?: new (...args: any[]) => T;
@@ -174,8 +188,10 @@ export async function prepareOutput<T = { [key: string]: any; map: (...args: any
   // Configuration
   const config = {
     clone: false,
+    circles: false,
     getNewArray: false,
     objectIdsToStrings: true,
+    proto: false,
     removeSecrets: true,
     removeUndefined: false,
     targetModel: undefined,
@@ -204,7 +220,7 @@ export async function prepareOutput<T = { [key: string]: any; map: (...args: any
     if (output.mapDeep && typeof output.mapDeep === 'function') {
       output = await Object.getPrototypeOf(output).mapDeep(output);
     } else {
-      output = _.cloneDeep(output);
+      output = clone(output, { circles: config.circles, proto: config.proto });
     }
   }
 
@@ -259,9 +275,11 @@ export function prepareServiceOptions(
   serviceOptions: ServiceOptions,
   options?: {
     clone?: boolean;
+    circles?: boolean;
     inputType?: any;
     outputType?: any;
     subFieldSelection?: string;
+    proto?: boolean;
     prepareInput?: PrepareInputOptions;
     prepareOutput?: PrepareOutputOptions;
   }
@@ -269,12 +287,14 @@ export function prepareServiceOptions(
   // Set default values
   const config = {
     clone: true,
+    circles: true,
+    proto: false,
     ...options,
   };
 
   // Clone
   if (serviceOptions && config.clone) {
-    serviceOptions = _.cloneDeep(serviceOptions);
+    serviceOptions = clone(serviceOptions, { circles: config.circles, proto: config.proto });
   }
 
   // Init if not exists