@lenne.tech/nest-server 9.0.31 → 9.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "9.0.31",
+  "version": "9.1.0",
   "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",

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

@@ -6,6 +6,7 @@ import { CoreModel } from '../models/core-model.model';
 import { FieldSelection } from '../types/field-selection.type';
 import { IdsType } from '../types/ids.type';
 import { StringOrObjectId } from '../types/string-or-object-id.type';
+import { removePropertiesDeep } from './input.helper';
 
 // =====================================================================================================================
 // Export functions
@@ -350,7 +351,7 @@ export function getPopulatOptionsFromSelections(selectionNodes: readonly Selecti
     // Check for subfields
     if (node.selectionSet?.selections?.length) {
       for (const innerNode of node.selectionSet.selections as FieldNode[]) {
-        // Subfiled is a primitive
+        // Subfield is a primitive
         if (!innerNode.selectionSet?.selections?.length) {
           option.select ? option.select.push(innerNode.name.value) : (option.select = [innerNode.name.value]);
         }
@@ -477,10 +478,14 @@ export async function popAndMap<T extends CoreModel>(
   queryOrDocument: Query<any, any> | Document | Document[],
   populate: FieldSelection,
   modelClass: new (...args: any[]) => T,
-  mongooseModel?: Model<any>
+  mongooseModel?: Model<any>,
+  options?: {
+    ignoreSelections?: boolean;
+  }
 ): Promise<T | T[]> {
   let result;
   let populateOptions: PopulateOptions[] = [];
+  const ignoreSelections = options?.ignoreSelections;
   if (populate) {
     if (
       Array.isArray(populate) &&
@@ -511,13 +516,13 @@ export async function popAndMap<T extends CoreModel>(
   } else {
     // Process documents
     if (Array.isArray(queryOrDocument)) {
-      await setPopulates(queryOrDocument, populateOptions, mongooseModel);
+      await setPopulates(queryOrDocument, populateOptions, mongooseModel, { ignoreSelections });
       result = queryOrDocument.map((item) => (modelClass as any).map(item));
     }
 
     // Process document
     else {
-      await setPopulates(queryOrDocument, populateOptions, mongooseModel);
+      await setPopulates(queryOrDocument, populateOptions, mongooseModel, { ignoreSelections });
       result = (modelClass as any).map(queryOrDocument);
     }
   }
@@ -562,7 +567,8 @@ export function removeIds(source: any[], ids: StringOrObjectId | StringOrObjectI
 export async function setPopulates<T = Query<any, any> | Document>(
   queryOrDocument: T,
   populateOptions: string[] | PopulateOptions[] | (string | PopulateOptions)[],
-  mongooseModel: Model<any>
+  mongooseModel: Model<any>,
+  options?: { ignoreSelections: boolean }
 ): Promise<T> {
   // Check parameters
   if (!populateOptions?.length || !queryOrDocument) {
@@ -580,6 +586,10 @@ export async function setPopulates<T = Query<any, any> | Document>(
     });
   }
 
+  if (options?.ignoreSelections) {
+    removePropertiesDeep(populateOptions, ['select']);
+  }
+
   // Query => Chaining
   if (queryOrDocument instanceof Query) {
     for (const options of populateOptions) {

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

@@ -718,3 +718,52 @@ export function prepareServiceOptionsForCreate(serviceOptions: any) {
   }
   return serviceOptions;
 }
+
+/**
+ * Remove properties deep
+ */
+export function removePropertiesDeep(
+  data: any,
+  properties: string[],
+  options?: {
+    processedObjects?: WeakMap<new () => any, boolean>;
+  }
+): any {
+  // Set options
+  const { processedObjects } = {
+    processedObjects: new WeakMap(),
+    ...options,
+  };
+
+  // Check for falsifiable values
+  if (!data) {
+    return data;
+  }
+
+  // Prevent circular processing
+  else if (typeof data === 'object') {
+    if (processedObjects.get(data)) {
+      return data;
+    }
+    processedObjects.set(data, true);
+  }
+
+  // Process array
+  if (Array.isArray(data)) {
+    return data.map((item) => removePropertiesDeep(item, properties, { processedObjects }));
+  }
+
+  // Process object
+  if (typeof data === 'object') {
+    for (const prop of properties) {
+      delete data[prop];
+    }
+    for (const [key, value] of Object.entries(data)) {
+      data[key] = removePropertiesDeep(value, properties, { processedObjects });
+    }
+    return data;
+  }
+
+  // Process others
+  return data;
+}

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

@@ -111,6 +111,14 @@ export interface IServerOptions {
     options?: GqlModuleAsyncOptions;
   };
 
+  /**
+   * Ignore selections in fieldSelection
+   * [ConfigService must be integrated in ModuleService]
+   * If falsy (default): select and populate information in fieldSelection will be respected
+   * If truly: select fields will be ignored and only populate fields in fieldSelection will be respected
+   */
+  ignoreSelectionsForPopulate?: boolean;
+
   /**
    * Configuration of JavaScript Web Token (JWT) module
    */

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

@@ -53,6 +53,10 @@ export interface ServiceOptions {
   processFieldSelection?: {
     model?: new (...args: any[]) => any;
     dbModel?: Model<any>;
+    // Ignore selections in fieldSelection and populate
+    // If falsy (default, if not set in env.config): select and populate information in fieldSelection and populate will be respected
+    // If truly: select fields will be ignored and only populate fields in fieldSelection and populate will be respected
+    ignoreSelections?: boolean;
   };
 
   // Prepare input configuration:

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

@@ -7,11 +7,17 @@ import { prepareInput, prepareOutput } from '../helpers/service.helper';
 import { ServiceOptions } from '../interfaces/service-options.interface';
 import { CoreModel } from '../models/core-model.model';
 import { FieldSelection } from '../types/field-selection.type';
+import { ConfigService } from './config.service';
 
 /**
  * Module service class to be extended by concrete module services
  */
 export abstract class ModuleService<T extends CoreModel = any> {
+  /**
+   * Config service, is used to determine certain behavior
+   */
+  protected configService: ConfigService;
+
   /**
    * Main model constructor of the service, will be used as default for populate and mapping
    */
@@ -26,9 +32,11 @@ export abstract class ModuleService<T extends CoreModel = any> {
    * Set main properties
    */
   protected constructor(options?: {
-    mainDbModel: Model<T & Document>;
+    configService?: ConfigService;
+    mainDbModel?: Model<T & Document>;
     mainModelConstructor?: new (...args: any[]) => T;
   }) {
+    this.configService = options?.configService;
     this.mainDbModel = options?.mainDbModel;
     this.mainModelConstructor = options?.mainModelConstructor;
   }
@@ -90,6 +98,14 @@ export abstract class ModuleService<T extends CoreModel = any> {
       ...options?.serviceOptions,
     };
 
+    // Set default for ignoreSelections if not set
+    const ignoreSelections = this.configService?.getFastButReadOnly('ignoreSelectionsForPopulate', false);
+    if (ignoreSelections) {
+      if (config.processFieldSelection.ignoreSelections === undefined) {
+        config.processFieldSelection.ignoreSelections = ignoreSelections;
+      }
+    }
+
     // Note force configuration
     if (config.force) {
       config.checkRights = false;
@@ -104,6 +120,9 @@ export abstract class ModuleService<T extends CoreModel = any> {
     // Note populate
     if (config.populate) {
       config.fieldSelection = config.populate;
+      if (config.processFieldSelection?.ignoreSelections) {
+        config.processFieldSelection.ignoreSelections = false;
+      }
     }
 
     // Prepare input
@@ -220,6 +239,7 @@ export abstract class ModuleService<T extends CoreModel = any> {
     options: {
       model?: new (...args: any[]) => T;
       dbModel?: Model<T & Document>;
+      ignoreSelections?: boolean;
     } = {}
   ) {
     const config = {
@@ -227,6 +247,8 @@ export abstract class ModuleService<T extends CoreModel = any> {
       dbModel: this.mainDbModel,
       ...options,
     };
-    return popAndMap(data, fieldsSelection, config.model, config.dbModel);
+    return popAndMap(data, fieldsSelection, config.model, config.dbModel, {
+      ignoreSelections: config.ignoreSelections,
+    });
   }
 }

package/src/core/modules/user/core-user.service.ts

@@ -22,10 +22,10 @@ export abstract class CoreUserService<
   TUserCreateInput extends CoreUserCreateInput
 > extends CrudService<TUser> {
   protected constructor(
+    protected override readonly configService: ConfigService,
     protected readonly emailService: EmailService,
     protected override readonly mainDbModel: Model<TUser & Document>,
-    protected override readonly mainModelConstructor: CoreModelConstructor<TUser>,
-    protected readonly configService?: ConfigService
+    protected override readonly mainModelConstructor: CoreModelConstructor<TUser>
   ) {
     super();
   }

package/src/server/modules/user/user.service.ts

@@ -31,7 +31,7 @@ export class UserService extends CoreUserService<User, UserInput, UserCreateInpu
     @InjectModel('User') protected override readonly mainDbModel: Model<UserDocument>,
     @Inject('PUB_SUB') protected readonly pubSub: PubSub
   ) {
-    super(emailService, mainDbModel, mainModelConstructor);
+    super(configService, emailService, mainDbModel, mainModelConstructor);
   }
 
   // ===================================================================================================================