@lenne.tech/nest-server 10.2.7 → 10.2.9

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

@@ -1,5 +1,6 @@
 import { NotFoundException } from '@nestjs/common';
-import { AggregateOptions, Document, FilterQuery, PipelineStage, Query, QueryOptions } from 'mongoose';
+import { AggregateOptions, Document, FilterQuery, Model as MongooseModel, PipelineStage, Query, QueryOptions } from 'mongoose';
+
 import { FilterArgs } from '../args/filter.args';
 import { getStringIds } from '../helpers/db.helper';
 import { convertFilterArgsToQuery } from '../helpers/filter.helper';
@@ -55,8 +56,7 @@ export abstract class CrudService<
    */
   async aggregateRaw<T = any>(pipeline: PipelineStage[], serviceOptions: ServiceOptions = {}): Promise<T> {
     serviceOptions = serviceOptions || {};
-    serviceOptions.prepareInput = null;
-    serviceOptions.prepareOutput = null;
+    serviceOptions.raw = true;
     return this.aggregateForce(pipeline, serviceOptions);
   }
 
@@ -90,16 +90,26 @@ export abstract class CrudService<
    */
   async createRaw(input: PlainObject<CreateInput>, serviceOptions: ServiceOptions = {}): Promise<Model> {
     serviceOptions = serviceOptions || {};
-    serviceOptions.prepareInput = null;
-    serviceOptions.prepareOutput = null;
+    serviceOptions.raw = true;
     return this.createForce(input, serviceOptions);
   }
 
+  /**
+   * Get distinct values of a property
+   */
+  distinct(property: string): Promise<string[]> {
+    return this.mainDbModel.distinct(property);
+  }
+
   /**
    * Get item by ID
    */
   async get(id: string, serviceOptions?: ServiceOptions): Promise<Model> {
-    const dbObject = await this.mainDbModel.findById(id).exec();
+    const query = this.mainDbModel.findById(id);
+    if (serviceOptions?.select) {
+      query.select(serviceOptions.select);
+    }
+    const dbObject = await query.exec();
     if (!dbObject) {
       throw new NotFoundException(`No ${this.mainModelConstructor.name} found with ID: ${id}`);
     }
@@ -122,8 +132,7 @@ export abstract class CrudService<
    */
   async getRaw(id: string, serviceOptions: ServiceOptions = {}): Promise<Model> {
     serviceOptions = serviceOptions || {};
-    serviceOptions.prepareInput = null;
-    serviceOptions.prepareOutput = null;
+    serviceOptions.raw = true;
     return this.getForce(id, serviceOptions);
   }
 
@@ -131,7 +140,7 @@ export abstract class CrudService<
    * Get items via filter
    */
   async find(
-    filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    filter?: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number } | FilterArgs,
     serviceOptions?: ServiceOptions,
   ): Promise<Model[]> {
     // If filter is not instance of FilterArgs a simple form with filterQuery and queryOptions is set
@@ -161,6 +170,9 @@ export abstract class CrudService<
         if (collation) {
           find = find.collation(collation);
         }
+        if (serviceOptions?.select) {
+          find = find.select(serviceOptions.select);
+        }
         return find.exec();
       },
       { input: filter, serviceOptions },
@@ -172,7 +184,7 @@ export abstract class CrudService<
    * Warning: Disables the handling of rights and restrictions!
    */
   async findForce(
-    filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    filter?: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number } | FilterArgs,
     serviceOptions: ServiceOptions = {},
   ): Promise<Model[]> {
     serviceOptions = serviceOptions || {};
@@ -185,12 +197,11 @@ export abstract class CrudService<
    * Warning: Disables the handling of rights and restrictions! The raw data may contain secrets (such as passwords).
    */
   async findRaw(
-    filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    filter?: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number } | FilterArgs,
     serviceOptions: ServiceOptions = {},
   ): Promise<Model[]> {
     serviceOptions = serviceOptions || {};
-    serviceOptions.prepareInput = null;
-    serviceOptions.prepareOutput = null;
+    serviceOptions.raw = true;
     return this.findForce(filter, serviceOptions);
   }
 
@@ -198,7 +209,7 @@ export abstract class CrudService<
    * Get items and total count via filter
    */
   async findAndCount(
-    filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    filter?: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number } | FilterArgs,
     serviceOptions?: ServiceOptions,
   ): Promise<{ items: Model[]; totalCount: number }> {
     // If filter is not instance of FilterArgs a simple form with filterQuery and queryOptions is set
@@ -277,11 +288,10 @@ export abstract class CrudService<
    * Warning: Disables the handling of rights and restrictions!
    */
   async findAndCountForce(
-    filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    filter?: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number } | FilterArgs,
     serviceOptions: ServiceOptions = {},
   ): Promise<{ items: Model[]; totalCount: number }> {
-    serviceOptions = serviceOptions || {};
-    serviceOptions.force = true;
+    serviceOptions.raw = true;
     return this.findAndCount(filter, serviceOptions);
   }
 
@@ -290,12 +300,11 @@ export abstract class CrudService<
    * Warning: Disables the handling of rights and restrictions! The raw data may contain secrets (such as passwords).
    */
   async findAndCountRaw(
-    filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    filter?: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number } | FilterArgs,
     serviceOptions: ServiceOptions = {},
   ): Promise<{ items: Model[]; totalCount: number }> {
     serviceOptions = serviceOptions || {};
-    serviceOptions.prepareInput = null;
-    serviceOptions.prepareOutput = null;
+    serviceOptions.raw = true;
     return this.findAndCountForce(filter, serviceOptions);
   }
 
@@ -303,7 +312,7 @@ export abstract class CrudService<
    * Find and update
    */
   async findAndUpdate(
-    filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    filter: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number } | FilterArgs,
     update: PlainObject<UpdateInput>,
     serviceOptions?: ServiceOptions,
   ): Promise<Model[]> {
@@ -332,7 +341,7 @@ export abstract class CrudService<
    * Warning: Disables the handling of rights and restrictions!
    */
   async findAndUpdateForce(
-    filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    filter: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number } | FilterArgs,
     update: PlainObject<UpdateInput>,
     serviceOptions: ServiceOptions = {},
   ): Promise<Model[]> {
@@ -346,13 +355,12 @@ export abstract class CrudService<
    * Warning: Disables the handling of rights and restrictions! The raw data may contain secrets (such as passwords).
    */
   async findAndUpdateRaw(
-    filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    filter: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number } | FilterArgs,
     update: PlainObject<UpdateInput>,
     serviceOptions: ServiceOptions = {},
   ): Promise<Model[]> {
     serviceOptions = serviceOptions || {};
-    serviceOptions.prepareInput = null;
-    serviceOptions.prepareOutput = null;
+    serviceOptions.raw = true;
     return this.findAndUpdateForce(filter, update, serviceOptions);
   }
 
@@ -360,7 +368,7 @@ export abstract class CrudService<
    * Find one item via filter
    */
   async findOne(
-    filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
+    filter?: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions } | FilterArgs,
     serviceOptions?: ServiceOptions,
   ): Promise<Model> {
     // If filter is not instance of FilterArgs a simple form with filterQuery and queryOptions is set
@@ -386,6 +394,9 @@ export abstract class CrudService<
         if (collation) {
           find = find.collation(collation);
         }
+        if (serviceOptions?.select) {
+          find = find.select(serviceOptions.select);
+        }
         return find.exec();
       },
       { input: filter, serviceOptions },
@@ -397,7 +408,7 @@ export abstract class CrudService<
    * Warning: Disables the handling of rights and restrictions!
    */
   async findOneForce(
-    filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    filter?: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number } | FilterArgs,
     serviceOptions: ServiceOptions = {},
   ): Promise<Model> {
     serviceOptions = serviceOptions || {};
@@ -410,15 +421,22 @@ export abstract class CrudService<
    * Warning: Disables the handling of rights and restrictions! The raw data may contain secrets (such as passwords).
    */
   async findOneRaw(
-    filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    filter?: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number } | FilterArgs,
     serviceOptions: ServiceOptions = {},
   ): Promise<Model> {
     serviceOptions = serviceOptions || {};
-    serviceOptions.prepareInput = null;
-    serviceOptions.prepareOutput = null;
+    serviceOptions.raw = true;
     return this.findOneForce(filter, serviceOptions);
   }
 
+  /**
+   * Get service model to process queries directly
+   * See https://mongoosejs.com/docs/api/model.html
+   */
+  getModel(): MongooseModel<Model & Document> {
+    return this.mainDbModel;
+  }
+
   /**
    * CRUD alias for get
    */
@@ -428,7 +446,7 @@ export abstract class CrudService<
    * CRUD alias for find
    */
   async read(
-    filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
+    filter: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions } | FilterArgs,
     serviceOptions?: ServiceOptions
   ): Promise<Model[]>;
 
@@ -436,7 +454,7 @@ export abstract class CrudService<
    * CRUD alias for get or find
    */
   async read(
-    input: string | FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
+    input: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions } | FilterArgs | string,
     serviceOptions?: ServiceOptions,
   ): Promise<Model | Model[]> {
     if (typeof input === 'string') {
@@ -457,7 +475,7 @@ export abstract class CrudService<
    * Warning: Disables the handling of rights and restrictions!
    */
   async readForce(
-    filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
+    filter: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions } | FilterArgs,
     serviceOptions?: ServiceOptions
   ): Promise<Model[]>;
 
@@ -466,7 +484,7 @@ export abstract class CrudService<
    * Warning: Disables the handling of rights and restrictions!
    */
   async readForce(
-    input: string | FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
+    input: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions } | FilterArgs | string,
     serviceOptions?: ServiceOptions,
   ): Promise<Model | Model[]> {
     if (typeof input === 'string') {
@@ -487,7 +505,7 @@ export abstract class CrudService<
    * Warning: Disables the handling of rights and restrictions! The raw data may contain secrets (such as passwords).
    */
   async readRaw(
-    filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
+    filter: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions } | FilterArgs,
     serviceOptions?: ServiceOptions
   ): Promise<Model[]>;
 
@@ -496,7 +514,7 @@ export abstract class CrudService<
    * Warning: Disables the handling of rights and restrictions! The raw data may contain secrets (such as passwords).
    */
   async readRaw(
-    input: string | FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
+    input: { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions } | FilterArgs | string,
     serviceOptions?: ServiceOptions,
   ): Promise<Model | Model[]> {
     if (typeof input === 'string') {
@@ -518,7 +536,11 @@ export abstract class CrudService<
       async (data) => {
         const currentUserId = serviceOptions?.currentUser?.id;
         const merged = mergePlain(dbObject, data.input, { updatedBy: currentUserId });
-        return await this.mainDbModel.findByIdAndUpdate(id, merged, { returnDocument: 'after' }).exec();
+        const query = this.mainDbModel.findByIdAndUpdate(id, merged, { returnDocument: 'after' });
+        if (serviceOptions?.select) {
+          query.select(serviceOptions.select);
+        }
+        return await query.exec();
       },
       { dbObject, input, serviceOptions },
     );
@@ -540,8 +562,7 @@ export abstract class CrudService<
    */
   async updateRaw(id: string, input: PlainObject<UpdateInput>, serviceOptions?: ServiceOptions): Promise<Model> {
     serviceOptions = serviceOptions || {};
-    serviceOptions.prepareInput = null;
-    serviceOptions.prepareOutput = null;
+    serviceOptions.raw = true;
     return this.updateForce(id, input, serviceOptions);
   }
 
@@ -549,7 +570,11 @@ export abstract class CrudService<
    * Delete item via ID
    */
   async delete(id: string, serviceOptions?: ServiceOptions): Promise<Model> {
-    const dbObject = await this.mainDbModel.findById(id).exec();
+    const query = this.mainDbModel.findById(id);
+    if (serviceOptions?.select) {
+      query.select(serviceOptions.select);
+    }
+    const dbObject = await query.exec();
     if (!dbObject) {
       throw new NotFoundException(`No ${this.mainModelConstructor.name} found with ID: ${id}`);
     }
@@ -578,8 +603,7 @@ export abstract class CrudService<
    */
   async deleteRaw(id: string, serviceOptions?: ServiceOptions): Promise<Model> {
     serviceOptions = serviceOptions || {};
-    serviceOptions.prepareInput = null;
-    serviceOptions.prepareOutput = null;
+    serviceOptions.raw = true;
     return this.deleteForce(id, serviceOptions);
   }
 
@@ -591,11 +615,14 @@ export abstract class CrudService<
    * @example const users = await this.populateAndProcessQuery<User[]>(User.find({name: {'$regex': 'ma'}}), {...serviceOptions, populate:['contacts'], force: true});
    */
   async processQueryOrDocument<T extends CoreModel | CoreModel[] = CoreModel>(
-    queryOrDocument: Query<unknown, unknown> | Document | Document[],
+    queryOrDocument: Document | Document[] | Query<unknown, unknown>,
     serviceOptions?: ServiceOptions,
   ): Promise<T> {
     return this.process(() => {
       if (queryOrDocument instanceof Query) {
+        if (serviceOptions?.select && queryOrDocument.select && typeof queryOrDocument.select === 'function') {
+          queryOrDocument.select(serviceOptions.select);
+        }
         return queryOrDocument.exec();
       }
       return queryOrDocument;

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

@@ -1,10 +1,12 @@
 import { Injectable } from '@nestjs/common';
-import nodemailer = require('nodemailer');
 import { Attachment } from 'nodemailer/lib/mailer';
+
 import { isNonEmptyString, isTrue, returnFalse } from '../helpers/input.helper';
 import { ConfigService } from './config.service';
 import { TemplateService } from './template.service';
 
+import nodemailer = require('nodemailer');
+
 /**
  * Email service
  */
@@ -33,7 +35,7 @@ export class EmailService {
     },
   ): Promise<any> {
     // Process config
-    const { attachments, htmlTemplate, senderName, senderEmail, templateData, textTemplate } = {
+    const { attachments, htmlTemplate, senderEmail, senderName, templateData, textTemplate } = {
       senderEmail: this.configService.getFastButReadOnly('email.defaultSender.email'),
       senderName: this.configService.getFastButReadOnly('email.defaultSender.name'),
       ...config,
@@ -71,12 +73,12 @@ export class EmailService {
 
     // Send mail
     return transporter.sendMail({
+      attachments,
       from: `"${senderName}" <${senderEmail}>`,
-      to: recipients,
+      html,
       subject,
       text,
-      html,
-      attachments,
+      to: recipients,
     });
   }
 }

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

@@ -1,5 +1,6 @@
 import { HttpException, Injectable } from '@nestjs/common';
 import Mailjet from 'node-mailjet';
+
 import { ConfigService } from './config.service';
 
 /**
@@ -20,24 +21,24 @@ export class MailjetService {
     subject: string,
     templateId: number,
     config: {
-      senderEmail?: string;
-      senderName?: string;
       attachments?: {
+        Base64Content: string;
         ContentID?: string;
         ContentType: string;
         Filename: string;
-        Base64Content: string;
       }[];
-      templateData?: { [key: string]: any };
       sandbox?: boolean;
+      senderEmail?: string;
+      senderName?: string;
+      templateData?: { [key: string]: any };
     },
   ) {
     // Process config
-    const { senderName, senderEmail, templateData, attachments, sandbox } = {
+    const { attachments, sandbox, senderEmail, senderName, templateData } = {
+      attachments: null,
+      sandbox: false,
       senderEmail: this.configService.getFastButReadOnly('email.defaultSender.email'),
       senderName: this.configService.getFastButReadOnly('email.defaultSender.name'),
-      sandbox: false,
-      attachments: null,
       templateData: null,
       ...config,
     };
@@ -57,16 +58,16 @@ export class MailjetService {
     const body = {
       Messages: [
         {
+          Attachments: attachments,
           From: {
             Email: senderEmail,
             Name: senderName,
           },
-          To: to,
+          Subject: subject,
           TemplateID: templateId,
           TemplateLanguage: true,
+          To: to,
           Variables: templateData,
-          Subject: subject,
-          Attachments: attachments,
         },
       ],
       SandboxMode: sandbox,
@@ -89,11 +90,11 @@ export class MailjetService {
       console.debug(
         JSON.stringify(
           {
-            'info': 'Mailjet credentials are missing',
-            'email.mailjet.api_key_public':
-              this.configService.getFastButReadOnly('email.mailjet.api_key_public') || 'missing',
             'email.mailjet.api_key_private':
               this.configService.getFastButReadOnly('email.mailjet.api_key_private') || 'missing',
+            'email.mailjet.api_key_public':
+              this.configService.getFastButReadOnly('email.mailjet.api_key_public') || 'missing',
+            'info': 'Mailjet credentials are missing',
             'templateData': templateData,
           },
           null,

package/src/core/common/services/model-doc.service.ts

@@ -1,7 +1,8 @@
-import fs = require('fs');
 import { Injectable, OnApplicationBootstrap } from '@nestjs/common';
 import { InjectConnection } from '@nestjs/mongoose';
 import { Connection } from 'mongoose';
+
+import fs = require('fs');
 import YumlDiagram = require('yuml-diagram');
 
 /**

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

@@ -1,5 +1,5 @@
-import _ = require('lodash');
 import { Document, Model, Types } from 'mongoose';
+
 import { ProcessType } from '../enums/process-type.enum';
 import { getStringIds, popAndMap } from '../helpers/db.helper';
 import { check } from '../helpers/input.helper';
@@ -9,6 +9,8 @@ import { CoreModel } from '../models/core-model.model';
 import { FieldSelection } from '../types/field-selection.type';
 import { ConfigService } from './config.service';
 
+import _ = require('lodash');
+
 /**
  * Module service class to be extended by concrete module services
  */
@@ -46,7 +48,7 @@ export abstract class ModuleService<T extends CoreModel = any> {
    */
   checkRights(
     input: any,
-    currentUser: { id: any; hasRole: (roles: string[]) => boolean },
+    currentUser: { hasRole: (roles: string[]) => boolean; id: any },
     options?: {
       dbObject?: any;
       metatype?: any;
@@ -73,31 +75,37 @@ export abstract class ModuleService<T extends CoreModel = any> {
     serviceFunc: (options?: { [key: string]: any; input?: any; serviceOptions?: ServiceOptions }) => any,
     options?: {
       [key: string]: any;
-      dbObject?: string | Types.ObjectId | any;
-      outputPath?: string | string[];
+      dbObject?: Types.ObjectId | any | string;
       input?: any;
+      outputPath?: string | string[];
       serviceOptions?: ServiceOptions;
     },
   ) {
     // Configuration with default values
     const config: {
-      dbObject: string | Types.ObjectId | any;
-      outputPath: string | string[];
+      dbObject: Types.ObjectId | any | string;
       input: any;
+      outputPath: string | string[];
     } & ServiceOptions = {
       checkRights: true,
       dbObject: options?.dbObject,
-      outputPath: options?.outputPath,
       force: false,
       input: options?.input,
-      processFieldSelection: {},
+      outputPath: options?.outputPath,
       prepareInput: {},
       prepareOutput: {},
+      processFieldSelection: {},
       pubSub: true,
       setCreateOrUpdateUserId: true,
       ...options?.serviceOptions,
     };
 
+    // Note raw configuration
+    if (config.raw) {
+      config.prepareInput = null;
+      config.prepareOutput = null;
+    }
+
     // Set default for ignoreSelections if not set
     const ignoreSelections = this.configService?.getFastButReadOnly('ignoreSelectionsForPopulate', true);
     if (ignoreSelections) {
@@ -256,14 +264,14 @@ export abstract class ModuleService<T extends CoreModel = any> {
     data: any,
     fieldsSelection: FieldSelection,
     options: {
-      model?: new (...args: any[]) => T;
       dbModel?: Model<T & Document>;
       ignoreSelections?: boolean;
+      model?: new (...args: any[]) => T;
     } = {},
   ) {
     const config = {
-      model: this.mainModelConstructor,
       dbModel: this.mainDbModel,
+      model: this.mainModelConstructor,
       ...options,
     };
     return popAndMap(data, fieldsSelection, config.model, config.dbModel, {

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

@@ -1,10 +1,12 @@
-import fs = require('fs');
-import { join } from 'path';
 import { Injectable } from '@nestjs/common';
-import ejs = require('ejs');
 import { TemplateFunction } from 'ejs';
+import { join } from 'path';
+
 import { ConfigService } from './config.service';
 
+import ejs = require('ejs');
+import fs = require('fs');
+
 /**
  * Template service
  */

package/src/core/common/types/core-model-constructor.type.ts

@@ -1,7 +1,6 @@
 import { CoreModel } from '../models/core-model.model';
 
 export interface CoreModelConstructor<T extends CoreModel> {
-  new (): T;
   init(this: new (...args: any[]) => T, ...args: any[]): T;
   map(
     this: new (...args: any[]) => T,
@@ -27,4 +26,5 @@ export interface CoreModelConstructor<T extends CoreModel> {
       mapId?: boolean;
     }
   ): T;
+  new (): T;
 }

package/src/core/common/types/falsy.type.ts

@@ -1,4 +1,4 @@
 /**
  * Falsy type for anything that is considered false if it occurs in a Boolean context
  */
-export type Falsy = false | 0 | '' | null | undefined;
+export type Falsy = '' | 0 | false | null | undefined;

package/src/core/common/types/field-selection.type.ts

@@ -1,13 +1,14 @@
 import { SelectionNode } from 'graphql';
 import { PopulateOptions } from 'mongoose';
+
 import { ResolveSelector } from '../interfaces/resolve-selector.interface';
 
 /**
  * Field selection to set fields of (populated) result
  */
 export type FieldSelection =
-  | string
-  | PopulateOptions
   | (PopulateOptions | string)[]
+  | PopulateOptions
+  | ResolveSelector
   | SelectionNode[]
-  | ResolveSelector;
+  | string;

package/src/core/common/types/ids.type.ts

@@ -1,7 +1,7 @@
 import { Types } from 'mongoose';
 
 export type IdsType =
-  | string
+  | ({ _id?: Types.ObjectId | string; id?: Types.ObjectId | string } | Types.ObjectId | string)[]
+  | { _id?: Types.ObjectId | string; id?: Types.ObjectId | string }
   | Types.ObjectId
-  | { id?: string | Types.ObjectId; _id?: string | Types.ObjectId }
-  | (string | Types.ObjectId | { id?: string | Types.ObjectId; _id?: string | Types.ObjectId })[];
+  | string;

package/src/core/common/types/maybe-promise.type.ts

@@ -1,4 +1,4 @@
 /**
  * Promise or direct value
  */
-export type MaybePromise<T = any> = T | Promise<T>;
+export type MaybePromise<T = any> = Promise<T> | T;

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

@@ -2,5 +2,5 @@
  * Type for plain inputs with only optional properties
  */
 export type PlainInput<T> = {
-  [P in keyof T]?: Partial<T[P]> | Partial<PlainInput<T[P]>>;
+  [P in keyof T]?: Partial<PlainInput<T[P]>> | Partial<T[P]>;
 };

package/src/core/common/types/populate-config.type.ts

@@ -3,4 +3,4 @@ import { PopulateOptions } from 'mongoose';
 /**
  * Configuration (path or options) for Mongoose populate methode
  */
-export type PopulateConfig = string | string[] | PopulateOptions | (PopulateOptions | string)[];
+export type PopulateConfig = (PopulateOptions | string)[] | PopulateOptions | string | string[];

package/src/core/common/types/string-or-object-id.type.ts

@@ -3,4 +3,4 @@ import { Types } from 'mongoose';
 /**
  * Everything which will be used by getStringIds or getObjectIds (see helpers/db.helper.ts)
  */
-export type StringOrObjectId<T = any> = string | Types.ObjectId | T;
+export type StringOrObjectId<T = any> = T | Types.ObjectId | string;

package/src/core/modules/auth/core-auth.controller.ts

@@ -1,6 +1,7 @@
 import { Body, Controller, Get, Param, ParseBoolPipe, Post, Res, UseGuards } from '@nestjs/common';
 import { Args } from '@nestjs/graphql';
 import { Response as ResponseType } from 'express';
+
 import { CurrentUser } from '../../common/decorators/current-user.decorator';
 import { ConfigService } from '../../common/services/config.service';
 import { AuthGuardStrategy } from './auth-guard-strategy.enum';
@@ -30,7 +31,7 @@ export class CoreAuthController {
     @Res() res: ResponseType,
     @Param('allDevices', ParseBoolPipe) allDevices?: boolean,
   ): Promise<boolean> {
-    const result = await this.authService.logout(token, { currentUser, allDevices });
+    const result = await this.authService.logout(token, { allDevices, currentUser });
     return this.processCookies(res, result);
   }
 

package/src/core/modules/auth/core-auth.model.ts

@@ -1,4 +1,5 @@
 import { Field, ObjectType } from '@nestjs/graphql';
+
 import { CoreModel } from '../../common/models/core-model.model';
 import { CoreUserModel } from '../user/core-user.model';