@lenne.tech/nest-server 10.8.9 → 10.8.11

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

@@ -50,52 +50,6 @@ export class ModelHelper {
   }
 }
 
-/**
- * Remove all properties from source which are not in target
- */
-export function prepareMap<T = Record<string, any>>(
-  source: Partial<T> | Record<string, any>,
-  target: T,
-  options: {
-    circles?: boolean;
-    cloneDeep?: boolean;
-    funcAllowed?: boolean;
-    mapId?: boolean;
-    proto?: boolean;
-  } = {},
-): Partial<T> | Record<string, any> {
-  // Set config
-  const config = {
-    circles: true,
-    cloneDeep: true,
-    funcAllowed: false,
-    mapId: false,
-    proto: 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
-          ? clone(source[key], { circles: config.circles, proto: config.proto })
-          : source[key];
-    } else if (key === 'id' && !config.mapId) {
-      result['id'] = source[key];
-    }
-  }
-
-  return result;
-}
-
 /**
  * Simple map function
  */
@@ -135,30 +89,6 @@ export function map<T = Record<string, any>>(
   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 });
-  });
-}
-
 /**
  * It takes an object, a mapping of properties to classes, and returns a new object with the properties mapped to instances
  * of the classes
@@ -366,3 +296,73 @@ export function mapInputClassesAsync<T = Record<string, any>>(
   };
   return mapClassesAsync(input, mapping, target, config);
 }
+
+/**
+ * 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 });
+  });
+}
+
+/**
+ * Remove all properties from source which are not in target
+ */
+export function prepareMap<T = Record<string, any>>(
+  source: Partial<T> | Record<string, any>,
+  target: T,
+  options: {
+    circles?: boolean;
+    cloneDeep?: boolean;
+    funcAllowed?: boolean;
+    mapId?: boolean;
+    proto?: boolean;
+  } = {},
+): Partial<T> | Record<string, any> {
+  // Set config
+  const config = {
+    circles: true,
+    cloneDeep: true,
+    funcAllowed: false,
+    mapId: false,
+    proto: 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
+          ? clone(source[key], { circles: config.circles, proto: config.proto })
+          : source[key];
+    } else if (key === 'id' && !config.mapId) {
+      result['id'] = source[key];
+    }
+  }
+
+  return result;
+}

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

@@ -54,7 +54,7 @@ export default class ServiceHelper {
       removeUndefined?: boolean;
       targetModel?: new (...args: any[]) => T;
     } = {},
-  ): Promise<T | T[] | any> {
+  ): Promise<any | T | T[]> {
     return prepareOutput(output, options);
   }
 }
@@ -100,7 +100,7 @@ export async function prepareInput<T = any>(
 
   // Process array
   if (Array.isArray(input)) {
-    const processedArray = config.getNewArray ? ([] as T & any[]) : input;
+    const processedArray = config.getNewArray ? ([] as any[] & T) : input;
     for (let i = 0; i <= input.length - 1; i++) {
       processedArray[i] = await prepareInput(input[i], currentUser, options);
       if (processedArray[i] === undefined && config.removeUndefined) {
@@ -193,7 +193,7 @@ export async function prepareOutput<T = { [key: string]: any; map: (...args: any
     removeUndefined?: boolean;
     targetModel?: new (...args: any[]) => T;
   } = {},
-): Promise<T | T[] | any> {
+): Promise<any | T | T[]> {
   // Configuration
   const config = {
     circles: false,

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

@@ -5,8 +5,8 @@ export function htmlTable(
     tableStyle?: string;
     tbodyStyle?: string;
     tdStyle?: string;
-    thStyle?: string;
     theadStyle?: string;
+    thStyle?: string;
     trHeadStyle?: string;
     trStyle?: string;
   },

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

@@ -7,27 +7,27 @@ import { maps } from '../helpers/model.helper';
 import { CoreInput } from './core-input.input';
 import { FilterInput } from './filter.input';
 
-@Restricted(RoleEnum.S_EVERYONE)
 @InputType({
   description: 'Combination of multiple filters via logical operator',
 })
+@Restricted(RoleEnum.S_EVERYONE)
 export class CombinedFilterInput extends CoreInput {
   /**
    * Logical Operator to combine filters
    */
-  @Restricted(RoleEnum.S_EVERYONE)
-  @Field(type => LogicalOperatorEnum, {
+  @Field(() => LogicalOperatorEnum, {
     description: 'Logical Operator to combine filters',
   })
+  @Restricted(RoleEnum.S_EVERYONE)
   logicalOperator: LogicalOperatorEnum = undefined;
 
   /**
    * Filters to combine via logical operator
    */
-  @Restricted(RoleEnum.S_EVERYONE)
-  @Field(type => [FilterInput], {
+  @Field(() => [FilterInput], {
     description: 'Filters to combine via logical operator',
   })
+  @Restricted(RoleEnum.S_EVERYONE)
   filters: FilterInput[] = undefined;
 
   // ===================================================================================================================

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

@@ -9,29 +9,29 @@ import { SingleFilterInput } from './single-filter.input';
 /**
  * Input for filtering. The `singleFilter` will be ignored if the `combinedFilter` is set.
  */
-@Restricted(RoleEnum.S_EVERYONE)
 @InputType({
   description: 'Input for filtering. The `singleFilter` will be ignored if the `combinedFilter` is set.',
 })
+@Restricted(RoleEnum.S_EVERYONE)
 export class FilterInput extends CoreInput {
   /**
    * Combination of multiple filters via logical operator
    */
-  @Restricted(RoleEnum.S_EVERYONE)
-  @Field(type => CombinedFilterInput, {
+  @Field(() => CombinedFilterInput, {
     description: 'Combination of multiple filters via logical operator',
     nullable: true,
   })
+  @Restricted(RoleEnum.S_EVERYONE)
   combinedFilter?: CombinedFilterInput = undefined;
 
   /**
    * Filter for a single property
    */
-  @Restricted(RoleEnum.S_EVERYONE)
-  @Field(type => SingleFilterInput, {
+  @Field(() => SingleFilterInput, {
     description: 'Filter for a single property',
     nullable: true,
   })
+  @Restricted(RoleEnum.S_EVERYONE)
   singleFilter?: SingleFilterInput = undefined;
 
   // ===================================================================================================================

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

@@ -9,69 +9,69 @@ import { CoreInput } from './core-input.input';
 /**
  * Input for a configuration of a filter
  */
-@Restricted(RoleEnum.S_EVERYONE)
 @InputType({ description: 'Input for a configuration of a filter' })
+@Restricted(RoleEnum.S_EVERYONE)
 export class SingleFilterInput extends CoreInput {
   /**
    * Convert value to ObjectId
    */
-  @Restricted(RoleEnum.S_EVERYONE)
   @Field({
     description: 'Convert value to ObjectId',
     nullable: true,
   })
+  @Restricted(RoleEnum.S_EVERYONE)
   convertToObjectId?: boolean = undefined;
 
   /**
    * Name of the property to be used for the filter
    */
-  @Restricted(RoleEnum.S_EVERYONE)
   @Field({ description: 'Name of the property to be used for the filter' })
+  @Restricted(RoleEnum.S_EVERYONE)
   field: string = undefined;
 
   /**
    * Process value as reference
    */
-  @Restricted(RoleEnum.S_EVERYONE)
   @Field({
     description: 'Process value as reference',
     nullable: true,
   })
+  @Restricted(RoleEnum.S_EVERYONE)
   isReference?: boolean = undefined;
 
   /**
    * [Negate operator](https://docs.mongodb.com/manual/reference/operator/query/not/)
    */
-  @Restricted(RoleEnum.S_EVERYONE)
   @Field({
     description: '[Negate operator](https://docs.mongodb.com/manual/reference/operator/query/not/)',
     nullable: true,
   })
+  @Restricted(RoleEnum.S_EVERYONE)
   not?: boolean = undefined;
 
   /**
    * [Comparison operator](https://docs.mongodb.com/manual/reference/operator/query-comparison/)
    */
-  @Restricted(RoleEnum.S_EVERYONE)
-  @Field(type => ComparisonOperatorEnum, {
+  @Field(() => ComparisonOperatorEnum, {
     description: '[Comparison operator](https://docs.mongodb.com/manual/reference/operator/query-comparison/)',
   })
+  @Restricted(RoleEnum.S_EVERYONE)
   operator: ComparisonOperatorEnum = undefined;
 
   /**
    * [Options](https://docs.mongodb.com/manual/reference/operator/query/regex/#op._S_options) for
    * [REGEX](https://docs.mongodb.com/manual/reference/operator/query/regex/) operator
    */
-  @Restricted(RoleEnum.S_EVERYONE)
   @Field({
     description:
       '[Options](https://docs.mongodb.com/manual/reference/operator/query/regex/#op._S_options) for '
       + '[REGEX](https://docs.mongodb.com/manual/reference/operator/query/regex/) operator',
     nullable: true,
   })
+  @Restricted(RoleEnum.S_EVERYONE)
   options?: string = undefined;
 
+  @Field(() => JSON, { description: 'Value of the property' })
   @Restricted(RoleEnum.S_EVERYONE)
-  @Field(type => JSON, { description: 'Value of the property' })
   value: any = undefined;
 }

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

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

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

@@ -324,20 +324,21 @@ export interface IServerOptions {
    * Hint: The secrets of the different environments should be different, otherwise a JWT can be used in different
    * environments, which can lead to security vulnerabilities.
    */
-  jwt?: {
+  jwt?: IJwt & JwtModuleOptions &
+    {
     /**
      * Configuration for refresh Token (JWT)
      * Hint: The secret of the JWT and the Refresh Token should be different, otherwise a new RefreshToken can also be
      * requested with the JWT, which can lead to a security vulnerability.
      */
-    refresh?: {
+    refresh?: IJwt & {
       /**
        * Whether renewal of the refresh token is permitted
        * If falsy (default): during refresh only a new token, the refresh token retains its original term
        * If true: during refresh not only a new token but also a new refresh token is created
        */
       renewal?: boolean;
-    } & IJwt;
+    };
 
     /**
      * Time period in milliseconds
@@ -345,8 +346,7 @@ export interface IServerOptions {
      * default: 0 (every token includes a new token ID, all parallel token refresh requests must be prevented by the client or processed accordingly)
      */
     sameTokenIdPeriod?: number;
-  } & IJwt &
-    JwtModuleOptions;
+  };
 
   /**
    * Load local configuration
@@ -412,6 +412,7 @@ export interface IServerOptions {
      * See @lenne.tech/nest-server/src/core/common/interceptors/check-response.interceptor.ts
      */
     checkResponseInterceptor?:
+      | boolean
       | {
           /**
            * Check the object itself for restrictions
@@ -457,8 +458,7 @@ export interface IServerOptions {
            * default = false (for output objects)
            */
           throwError?: boolean;
-        }
-      | boolean;
+        };
 
     /**
      * Process securityCheck() methode of Object before response
@@ -466,6 +466,7 @@ export interface IServerOptions {
      * default = true
      */
     checkSecurityInterceptor?:
+      | boolean
       | {
           /**
            * Whether to log if a process is slow
@@ -479,8 +480,7 @@ export interface IServerOptions {
            * default = true
            */
           noteCheckedObjects?: boolean;
-        }
-      | boolean;
+        };
 
     /**
      * Map incoming plain objects to meta-type and validate

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

@@ -20,11 +20,11 @@ import { CoreModel } from './core-model.model';
  * 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();
  */
-@Restricted(RoleEnum.S_EVERYONE)
 @ObjectType({
   description: 'Persistence model which will be saved in DB',
   isAbstract: true,
 })
+@Restricted(RoleEnum.S_EVERYONE)
 @Schema({ timestamps: true })
 export abstract class CorePersistenceModel extends CoreModel {
   // ===========================================================================
@@ -43,30 +43,30 @@ export abstract class CorePersistenceModel extends CoreModel {
   /**
    * ID of the persistence object as string
    */
-  @Restricted(RoleEnum.S_EVERYONE)
-  @Field(type => ID, {
+  @ApiProperty({ type: String })
+  @Field(() => ID, {
     description: 'ID of the persistence object',
     nullable: true,
   })
-  @ApiProperty({ type: String })
+  @Restricted(RoleEnum.S_EVERYONE)
   id: string = undefined;
 
   /**
    * Created date, is set automatically by mongoose
    */
-  @Restricted(RoleEnum.S_EVERYONE)
+  @ApiProperty({ example: 1740037703939, format: 'int64', type: Date })
   @Field({ description: 'Created date', nullable: true })
   @Prop({ onCreate: () => new Date() })
-  @ApiProperty({ example: 1740037703939, format: 'int64', type: Date })
+  @Restricted(RoleEnum.S_EVERYONE)
   createdAt: Date = undefined;
 
   /**
    * Updated date is set automatically by mongoose
    */
-  @Restricted(RoleEnum.S_EVERYONE)
+  @ApiProperty({ example: 1740037703939, format: 'int64', type: String })
   @Field({ description: 'Updated date', nullable: true })
   @Prop({ onUpdate: () => new Date() })
-  @ApiProperty({ example: 1740037703939, format: 'int64', type: String })
+  @Restricted(RoleEnum.S_EVERYONE)
   updatedAt: Date = undefined;
 
   // ===========================================================================

package/src/core/common/plugins/mongoose-id.plugin.js

@@ -1,5 +1,5 @@
-export function mongooseIdPlugin(schema, options) {
-  schema.post(['find', 'findOne', 'save', 'deleteOne'], function (docs) {
+export function mongooseIdPlugin(schema) {
+  schema.post(['find', 'findOne', 'save', 'deleteOne'], (docs) => {
     if (!Array.isArray(docs)) {
       docs = [docs];
     }

package/src/core/common/scalars/any.scalar.ts

@@ -4,7 +4,7 @@ import { Kind, ValueNode } from 'graphql';
 /**
  * Any scalar (is equivalent to the JSON scalar)
  */
-@Scalar('Any', type => Any)
+@Scalar('Any', () => Any)
 export class Any implements CustomScalar<string, any> {
   /**
    * Description of the scalar
@@ -30,13 +30,17 @@ export class Any implements CustomScalar<string, any> {
    */
   parseLiteral(ast: ValueNode, variables?: Record<string, any>) {
     switch (ast.kind) {
-      case Kind.STRING:
-      case Kind.ENUM:
       case Kind.BOOLEAN:
+      case Kind.ENUM:
+      case Kind.STRING:
         return ast.value;
-      case Kind.INT:
       case Kind.FLOAT:
+      case Kind.INT:
         return parseFloat(ast.value);
+      case Kind.LIST:
+        return ast.values.map(n => this.parseLiteral(n, variables));
+      case Kind.NULL:
+        return null;
       case Kind.OBJECT: {
         const value = Object.create(null);
         ast.fields.forEach((field) => {
@@ -44,10 +48,6 @@ export class Any implements CustomScalar<string, any> {
         });
         return value;
       }
-      case Kind.LIST:
-        return ast.values.map(n => this.parseLiteral(n, variables));
-      case Kind.NULL:
-        return null;
       case Kind.VARIABLE: {
         const name = ast.name.value;
         return variables ? variables[name] : undefined;

package/src/core/common/scalars/date-timestamp.scalar.ts

@@ -5,7 +5,7 @@ import { checkAndGetDate, getDateFromGraphQL } from '../helpers/input.helper';
 /**
  * Date-Timestamp-Scalar to convert timestamp to date and vice versa
  */
-@Scalar('Date', type => Date)
+@Scalar('Date', () => Date)
 export class DateTimestampScalar implements CustomScalar<number, Date> {
   description = 'Date (by Timestamp) custom scalar type';
 

package/src/core/common/scalars/date.scalar.ts

@@ -5,7 +5,7 @@ import { checkAndGetDate, getDateFromGraphQL } from '../helpers/input.helper';
 /**
  * Date scalar to convert string into date
  */
-@Scalar('Date', type => Date)
+@Scalar('Date', () => Date)
 export class DateScalar implements CustomScalar<string, Date> {
   description = 'Date custom scalar type';
 

package/src/core/common/scalars/json.scalar.ts

@@ -4,7 +4,7 @@ import { Kind, ValueNode } from 'graphql';
 /**
  * JSON scalar (is equivalent to the Any scalar)
  */
-@Scalar('JSON', type => JSON)
+@Scalar('JSON', () => JSON)
 export class JSON implements CustomScalar<string, any> {
   /**
    * Description of the scalar
@@ -31,13 +31,17 @@ export class JSON implements CustomScalar<string, any> {
    */
   parseLiteral(ast: ValueNode, variables?: Record<string, any>) {
     switch (ast.kind) {
-      case Kind.STRING:
-      case Kind.ENUM:
       case Kind.BOOLEAN:
+      case Kind.ENUM:
+      case Kind.STRING:
         return ast.value;
-      case Kind.INT:
       case Kind.FLOAT:
+      case Kind.INT:
         return parseFloat(ast.value);
+      case Kind.LIST:
+        return ast.values.map(n => this.parseLiteral(n, variables));
+      case Kind.NULL:
+        return null;
       case Kind.OBJECT: {
         const value = Object.create(null);
         ast.fields.forEach((field) => {
@@ -45,10 +49,6 @@ export class JSON implements CustomScalar<string, any> {
         });
         return value;
       }
-      case Kind.LIST:
-        return ast.values.map(n => this.parseLiteral(n, variables));
-      case Kind.NULL:
-        return null;
       case Kind.VARIABLE: {
         const name = ast.name.value;
         return variables ? variables[name] : undefined;

package/src/core/common/services/config.service.ts

@@ -39,13 +39,13 @@ export class ConfigService {
   /**
    * BehaviorSubject for config
    */
-  protected static _configSubject$: BehaviorSubject<{ [key: string]: any } & Partial<IServerOptions>>
+  protected static _configSubject$: BehaviorSubject<Partial<IServerOptions> & { [key: string]: any }>
     = new BehaviorSubject(undefined);
 
   /**
    * BehaviorSubject for frozen config
    */
-  protected static _frozenConfigSubject$: BehaviorSubject<{ [key: string]: any } & Partial<IServerOptions>>
+  protected static _frozenConfigSubject$: BehaviorSubject<Partial<IServerOptions> & { [key: string]: any }>
     = new BehaviorSubject(undefined);
 
   /**
@@ -61,7 +61,7 @@ export class ConfigService {
    * Create config service or return singleton instance if exists
    */
   constructor(
-    configObject?: { [key: string]: any } & Partial<IServerOptions>,
+    configObject?: Partial<IServerOptions> & { [key: string]: any },
     options?: { reInit?: boolean; warn?: boolean },
   ) {
     const config = {
@@ -236,7 +236,7 @@ export class ConfigService {
   /**
    * Merge config and set in ConfigService
    */
-  mergeConfig(configData: { [key: string]: any } & Partial<IServerOptions>, options?: { warn?: boolean }) {
+  mergeConfig(configData: Partial<IServerOptions> & { [key: string]: any }, options?: { warn?: boolean }) {
     return ConfigService.mergeConfig(configData, options);
   }
 
@@ -244,7 +244,7 @@ export class ConfigService {
    * Merge config and set in ConfigService
    */
   static mergeConfig(
-    configData: { [key: string]: any } & Partial<IServerOptions>,
+    configData: Partial<IServerOptions> & { [key: string]: any },
     options?: { init?: boolean; warn?: boolean },
   ) {
     const config = {
@@ -318,7 +318,7 @@ export class ConfigService {
    * Set config in ConfigService
    */
   setConfig(
-    configData: { [key: string]: any } & Partial<IServerOptions>,
+    configData: Partial<IServerOptions> & { [key: string]: any },
     options?: { reInit?: boolean; warn?: boolean },
   ) {
     return ConfigService.setConfig(configData, options);
@@ -328,7 +328,7 @@ export class ConfigService {
    * Set config in ConfigService
    */
   static setConfig(
-    configObject: { [key: string]: any } & Partial<IServerOptions>,
+    configObject: Partial<IServerOptions> & { [key: string]: any },
     options?: { init?: boolean; reInit?: boolean; warn?: boolean },
   ) {
     const config = {