@lenne.tech/nest-server 10.2.6 → 10.2.8

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

@@ -1,5 +1,6 @@
 import { NotFoundException } from '@nestjs/common';
-import { 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';
@@ -15,6 +16,50 @@ export abstract class CrudService<
   CreateInput = any,
   UpdateInput = any,
 > extends ModuleService<Model> {
+
+  /**
+   * Aggregate
+   * @param serviceOptions.aggregateOptions Aggregate options, see https://www.mongodb.com/docs/manual/core/aggregation-pipeline/
+   * @param serviceOptions.collation Collation, see https://www.mongodb.com/docs/manual/reference/collation/
+   * @param serviceOptions.outputPath Output path of items which should be prepared, e.g. 'items'
+   */
+  async aggregate<T = any>(
+    pipeline: PipelineStage[],
+    serviceOptions?: ServiceOptions & { aggregateOptions?: AggregateOptions },
+  ): Promise<T> {
+    return this.process(
+      async () => {
+        const aggregateOptions = serviceOptions?.aggregateOptions || {};
+        const collation = serviceOptions?.collation || ConfigService.get('mongoose.collation');
+        if (collation && !aggregateOptions.collation) {
+          aggregateOptions.collation = collation;
+        }
+        return this.mainDbModel.aggregate(pipeline, aggregateOptions).exec();
+      },
+      { serviceOptions },
+    );
+  }
+
+  /**
+   * Aggregate without checks or restrictions
+   * Warning: Disables the handling of rights and restrictions!
+   */
+  async aggregateForce<T = any>(pipeline: PipelineStage[], serviceOptions: ServiceOptions = {}): Promise<T> {
+    serviceOptions = serviceOptions || {};
+    serviceOptions.force = true;
+    return this.aggregate(pipeline, serviceOptions);
+  }
+
+  /**
+   * Aggregate without checks, restrictions or preparations
+   * Warning: Disables the handling of rights and restrictions! The raw data may contain secrets (such as passwords).
+   */
+  async aggregateRaw<T = any>(pipeline: PipelineStage[], serviceOptions: ServiceOptions = {}): Promise<T> {
+    serviceOptions = serviceOptions || {};
+    serviceOptions.raw = true;
+    return this.aggregateForce(pipeline, serviceOptions);
+  }
+
   /**
    * Create item
    */
@@ -45,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}`);
     }
@@ -77,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);
   }
 
@@ -86,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
@@ -116,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 },
@@ -127,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 || {};
@@ -140,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);
   }
 
@@ -153,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
@@ -232,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);
   }
 
@@ -245,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);
   }
 
@@ -258,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[]> {
@@ -287,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[]> {
@@ -301,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);
   }
 
@@ -315,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
@@ -341,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 },
@@ -352,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 || {};
@@ -365,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
    */
@@ -383,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[]>;
 
@@ -391,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') {
@@ -412,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[]>;
 
@@ -421,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') {
@@ -442,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[]>;
 
@@ -451,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') {
@@ -473,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 },
     );
@@ -495,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);
   }
 
@@ -504,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}`);
     }
@@ -533,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);
   }
 
@@ -546,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) {
@@ -180,8 +188,14 @@ export abstract class ModuleService<T extends CoreModel = any> {
 
     // Pop and map main model
     if (config.processFieldSelection && config.fieldSelection && this.processFieldSelection) {
-      const field = config.outputPath ? _.get(result, config.outputPath) : result;
-      await this.processFieldSelection(field, config.fieldSelection, config.processFieldSelection);
+      let temps = result;
+      if (!Array.isArray(result)) {
+        temps = [result];
+      }
+      for (const temp of temps) {
+        const field = config.outputPath ? _.get(temp, config.outputPath) : temp;
+        await this.processFieldSelection(field, config.fieldSelection, config.processFieldSelection);
+      }
     }
 
     // Prepare output
@@ -191,7 +205,13 @@ export abstract class ModuleService<T extends CoreModel = any> {
         opts.targetModel = config.outputType;
       }
       if (config.outputPath) {
-        _.set(result, config.outputPath, await this.prepareOutput(_.get(result, config.outputPath), opts));
+        let temps = result;
+        if (!Array.isArray(result)) {
+          temps = [result];
+        }
+        for (const temp of temps) {
+          _.set(temp, config.outputPath, await this.prepareOutput(_.get(temp, config.outputPath), opts));
+        }
       } else {
         result = await this.prepareOutput(result, config);
       }
@@ -244,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;