@lenne.tech/nest-server 9.0.9 → 9.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "9.0.9",
+  "version": "9.0.11",
   "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",
@@ -102,12 +102,12 @@
     "@types/jest": "29.1.2",
     "@types/lodash": "4.14.186",
     "@types/multer": "1.4.7",
-    "@types/node": "18.8.3",
+    "@types/node": "18.8.4",
     "@types/nodemailer": "6.4.6",
     "@types/passport": "1.0.11",
     "@types/supertest": "2.0.12",
-    "@typescript-eslint/eslint-plugin": "5.39.0",
-    "@typescript-eslint/parser": "5.39.0",
+    "@typescript-eslint/eslint-plugin": "5.40.0",
+    "@typescript-eslint/parser": "5.40.0",
     "coffeescript": "2.7.0",
     "eslint": "8.25.0",
     "eslint-config-prettier": "8.5.0",

package/src/config.env.ts

@@ -11,6 +11,7 @@ const config: { [env: string]: IServerOptions } = {
   // Local environment
   // ===========================================================================
   local: {
+    automaticObjectIdFiltering: true,
     cronJobs: {
       sayHello: {
         cronTime: CronExpression.EVERY_10_SECONDS,
@@ -72,6 +73,7 @@ const config: { [env: string]: IServerOptions } = {
   // Development environment
   // ===========================================================================
   development: {
+    automaticObjectIdFiltering: true,
     email: {
       smtp: {
         auth: {
@@ -124,6 +126,7 @@ const config: { [env: string]: IServerOptions } = {
   // Production environment
   // ===========================================================================
   production: {
+    automaticObjectIdFiltering: true,
     email: {
       smtp: {
         auth: {

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

@@ -1,6 +1,6 @@
 import { FieldNode, GraphQLResolveInfo, SelectionNode } from 'graphql';
 import * as _ from 'lodash';
-import { Document, Model, PopulateOptions, Query, SchemaType, Types } from 'mongoose';
+import { Document, Model, PopulateOptions, Query, Types } from 'mongoose';
 import { ResolveSelector } from '../interfaces/resolve-selector.interface';
 import { CoreModel } from '../models/core-model.model';
 import { FieldSelection } from '../types/field-selection.type';
@@ -79,6 +79,24 @@ export function addIds(
   return result;
 }
 
+/**
+ * Checks if string is a valid ID or if the string array contains only valid IDs that can be used in mongodb ObjectId
+ */
+export function checkStringIds(ids: string | string[]): boolean {
+  if (!Array.isArray(ids)) {
+    ids = [ids];
+  }
+  try {
+    for (const id of ids) {
+      if (typeof id !== 'string' || id.length !== 24 || !Types.ObjectId.isValid(id)) {
+        return false;
+      }
+    }
+    return true;
+  } catch (e) {}
+  return false;
+}
+
 /**
  * Checks if all IDs are equal
  */

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

@@ -5,8 +5,9 @@ import { LogicalOperatorEnum } from '../enums/logical-operator.enum';
 import { SortOrderEnum } from '../enums/sort-order.emum';
 import { FilterInput } from '../inputs/filter.input';
 import { SortInput } from '../inputs/sort.input';
-import { getObjectIds } from './db.helper';
-import { assignPlain } from './input.helper';
+import { ConfigService } from '../services/config.service';
+import { checkStringIds, getObjectIds } from './db.helper';
+import { assignPlain, clone } from './input.helper';
 
 /**
  * Helper for filter handling
@@ -110,12 +111,21 @@ export function convertFilterArgsToQuery<T = any>(filterArgs: Partial<FilterArgs
 /**
  * Generate filter query
  */
-export function generateFilterQuery<T = any>(filter?: Partial<FilterInput>): FilterQuery<T> | any {
+export function generateFilterQuery<T = any>(
+  filter?: Partial<FilterInput>,
+  options?: { automaticObjectIdFiltering?: boolean }
+): FilterQuery<T> | any {
   // Check filter
   if (!filter) {
     return undefined;
   }
 
+  // Configuration
+  const config = {
+    automaticObjectIdFiltering: ConfigService.get('automaticObjectIdFiltering'),
+    ...options,
+  };
+
   // Init result
   const result: any = {};
 
@@ -124,15 +134,15 @@ export function generateFilterQuery<T = any>(filter?: Partial<FilterInput>): Fil
     switch (filter.combinedFilter.logicalOperator) {
       case LogicalOperatorEnum.AND:
         return {
-          $and: filter.combinedFilter.filters.map((item: FilterInput) => generateFilterQuery(item)),
+          $and: filter.combinedFilter.filters.map((item: FilterInput) => generateFilterQuery(item, options)),
         };
       case LogicalOperatorEnum.NOR:
         return {
-          $nor: filter.combinedFilter.filters.map((item: FilterInput) => generateFilterQuery(item)),
+          $nor: filter.combinedFilter.filters.map((item: FilterInput) => generateFilterQuery(item, options)),
         };
       case LogicalOperatorEnum.OR:
         return {
-          $or: filter.combinedFilter.filters.map((item: FilterInput) => generateFilterQuery(item)),
+          $or: filter.combinedFilter.filters.map((item: FilterInput) => generateFilterQuery(item, options)),
         };
     }
   }
@@ -140,14 +150,27 @@ export function generateFilterQuery<T = any>(filter?: Partial<FilterInput>): Fil
   // Process single filter
   if (filter.singleFilter) {
     // Init variables
-    const { not, options, field, convertToObjectId } = filter.singleFilter;
+    const { not, options, field, convertToObjectId, isReference } = filter.singleFilter;
     let value = filter.singleFilter.value;
 
     // Convert value to object ID(s)
-    if (convertToObjectId) {
+    if (convertToObjectId || isReference) {
       value = getObjectIds(value);
     }
 
+    // Check if value is a string ID and automatic ObjectID filtering is activated
+    else if (config.automaticObjectIdFiltering && checkStringIds(value)) {
+      // Set both the string filter and the ObjectID filtering in an OR construction
+      const alternativeQuery = clone(filter.singleFilter, { circles: false });
+      alternativeQuery.value = getObjectIds(value);
+      return {
+        $or: [
+          generateFilterQuery(filter.singleFilter, Object.assign({}, config, { automaticObjectIdFiltering: false })),
+          generateFilterQuery(alternativeQuery, Object.assign({}, config, { automaticObjectIdFiltering: false })),
+        ],
+      };
+    }
+
     // Convert filter
     switch (filter.singleFilter.operator) {
       case ComparisonOperatorEnum.EQ:

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

@@ -23,6 +23,15 @@ export class SingleFilterInput extends CoreInput {
   @Field({ description: 'Name of the property to be used for the filter' })
   field: string = undefined;
 
+  /**
+   * Process value as reference
+   */
+  @Field({
+    description: 'Process value as reference',
+    nullable: true,
+  })
+  isReference?: boolean = undefined;
+
   /**
    * [Negate operator](https://docs.mongodb.com/manual/reference/operator/query/not/)
    */

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

@@ -13,6 +13,13 @@ import { MailjetOptions } from './mailjet-options.interface';
  * Options for the server
  */
 export interface IServerOptions {
+  /**
+   * Automatically detect ObjectIds in string values in FilterQueries
+   * and expand them as OR query with string and ObjectId
+   * See generateFilterQuery in Filter helper (src/core/common/helpers/filter.helper.ts)
+   */
+  automaticObjectIdFiltering?: boolean;
+
   /**
    * Cron jobs configuration object with the name of the cron job function as key
    * and the cron expression or config as value

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

@@ -197,9 +197,9 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
         aggregation.push({ $facet: facet });
 
         // Find and process db items
-        const dbResult = (await this.mainDbModel.aggregate(aggregation).exec())[0];
-        dbResult.totalCount = dbResult.totalCount[0].total;
-        dbResult.items = dbResult.items.map((item) => this.mainDbModel.hydrate(item));
+        const dbResult = (await this.mainDbModel.aggregate(aggregation).exec())[0] || {};
+        dbResult.totalCount = dbResult.totalCount?.[0]?.total || 0;
+        dbResult.items = dbResult.items?.map((item) => this.mainDbModel.hydrate(item)) || [];
         return dbResult;
       },
       { input: filter, outputPath: 'items', serviceOptions }