@lenne.tech/nest-server 9.0.1 → 9.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "9.0.1",
+  "version": "9.0.2",
   "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",
@@ -59,17 +59,17 @@
   },
   "dependencies": {
     "@apollo/gateway": "2.0.5",
-    "@nestjs/apollo": "10.0.17",
-    "@nestjs/common": "9.0.3",
-    "@nestjs/core": "9.0.3",
-    "@nestjs/graphql": "10.0.18",
+    "@nestjs/apollo": "10.0.19",
+    "@nestjs/common": "9.0.9",
+    "@nestjs/core": "9.0.9",
+    "@nestjs/graphql": "10.0.21",
     "@nestjs/jwt": "9.0.0",
     "@nestjs/mongoose": "9.2.0",
     "@nestjs/passport": "9.0.0",
-    "@nestjs/platform-express": "9.0.3",
+    "@nestjs/platform-express": "9.0.9",
     "@nestjs/schedule": "2.1.0",
-    "apollo-server-core": "3.10.0",
-    "apollo-server-express": "3.10.0",
+    "apollo-server-core": "3.10.1",
+    "apollo-server-express": "3.10.1",
     "bcrypt": "5.0.1",
     "class-transformer": "0.5.1",
     "class-validator": "0.13.2",
@@ -79,14 +79,14 @@
     "graphql-upload": "15.0.2",
     "js-sha256": "0.9.0",
     "json-to-graphql-query": "2.2.4",
-    "light-my-request": "5.1.0",
+    "light-my-request": "5.4.0",
     "lodash": "4.17.21",
-    "mongodb": "4.8.0",
-    "mongoose": "6.4.4",
+    "mongodb": "4.8.1",
+    "mongoose": "6.5.2",
     "mongoose-gridfs": "1.3.0",
     "multer": "1.4.5-lts.1",
-    "node-mailjet": "5.0.1",
-    "nodemailer": "6.7.7",
+    "node-mailjet": "5.1.1",
+    "nodemailer": "6.7.8",
     "nodemon": "2.0.19",
     "passport": "0.6.0",
     "passport-jwt": "4.0.0",
@@ -96,20 +96,20 @@
     "rxjs": "7.5.6"
   },
   "devDependencies": {
-    "@nestjs/testing": "9.0.3",
+    "@nestjs/testing": "9.0.9",
     "@types/cron": "2.0.0",
     "@types/ejs": "3.1.1",
     "@types/jest": "28.1.6",
     "@types/lodash": "4.14.182",
     "@types/multer": "1.4.7",
-    "@types/node": "18.0.5",
-    "@types/nodemailer": "6.4.4",
-    "@types/passport": "1.0.9",
+    "@types/node": "18.7.3",
+    "@types/nodemailer": "6.4.5",
+    "@types/passport": "1.0.10",
     "@types/supertest": "2.0.12",
-    "@typescript-eslint/eslint-plugin": "5.30.6",
-    "@typescript-eslint/parser": "5.30.6",
+    "@typescript-eslint/eslint-plugin": "5.33.0",
+    "@typescript-eslint/parser": "5.33.0",
     "coffeescript": "2.7.0",
-    "eslint": "8.20.0",
+    "eslint": "8.22.0",
     "eslint-config-prettier": "8.5.0",
     "find-file-up": "2.0.1",
     "grunt": "1.5.3",
@@ -126,7 +126,7 @@
     "ts-jest": "28.0.7",
     "ts-morph": "15.1.0",
     "ts-node": "10.9.1",
-    "tsconfig-paths": "4.0.0",
+    "tsconfig-paths": "4.1.0",
     "typescript": "4.7.4"
   },
   "jest": {

package/src/core/common/args/pagination.args.ts

@@ -19,10 +19,10 @@ export class PaginationArgs extends CoreInput {
   limit?: number = undefined;
 
   /**
-   * Offset for pagination
+   * Alias for skip
    */
   @Field((type) => Int, {
-    description: 'Offset specifies how many found elements should be skipped on return',
+    description: 'Alias for skip',
     nullable: true,
     defaultValue: 0,
   })
@@ -30,10 +30,10 @@ export class PaginationArgs extends CoreInput {
   offset?: number = undefined;
 
   /**
-   * Alias for offset
+   * Skip for pagination
    */
   @Field((type) => Int, {
-    description: 'Alias for offset',
+    description: 'Skip specifies how many found elements should be skipped on return',
     nullable: true,
     defaultValue: undefined,
   })

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

@@ -479,7 +479,7 @@ export async function popAndMap<T extends CoreModel>(
   }
   if (queryOrDocument instanceof Query) {
     // Get result
-    result = await setPopulates(queryOrDocument, populateOptions, mongooseModel?.schema?.paths);
+    result = await setPopulates(queryOrDocument, populateOptions, mongooseModel);
     if (result instanceof Query) {
       result = await result.exec();
     }
@@ -493,13 +493,13 @@ export async function popAndMap<T extends CoreModel>(
   } else {
     // Process documents
     if (Array.isArray(queryOrDocument)) {
-      await setPopulates(queryOrDocument, populateOptions, mongooseModel?.schema?.paths);
+      await setPopulates(queryOrDocument, populateOptions, mongooseModel);
       result = queryOrDocument.map((item) => (modelClass as any).map(item));
     }
 
     // Process document
     else {
-      await setPopulates(queryOrDocument, populateOptions, mongooseModel?.schema?.paths);
+      await setPopulates(queryOrDocument, populateOptions, mongooseModel);
       result = (modelClass as any).map(queryOrDocument);
     }
   }
@@ -544,7 +544,7 @@ export function removeIds(source: any[], ids: StringOrObjectId | StringOrObjectI
 export async function setPopulates<T = Query<any, any> | Document>(
   queryOrDocument: T,
   populateOptions: string[] | PopulateOptions[] | (string | PopulateOptions)[],
-  modelSchemaPaths?: { [key: string]: SchemaType }
+  mongooseModel: Model<any>
 ): Promise<T> {
   // Check parameters
   if (!populateOptions?.length || !queryOrDocument) {
@@ -552,13 +552,13 @@ export async function setPopulates<T = Query<any, any> | Document>(
   }
 
   // Filter populate options via model schema paths
-  if (modelSchemaPaths) {
+  if (mongooseModel?.schema?.paths) {
     populateOptions = populateOptions.filter((option: string | PopulateOptions) => {
       let key: string = option as string;
       if ((option as PopulateOptions)?.path) {
         key = (option as PopulateOptions)?.path;
       }
-      return Object.keys(modelSchemaPaths).includes(key);
+      return Object.keys(mongooseModel.schema.paths).includes(key);
     });
   }
 
@@ -573,12 +573,20 @@ export async function setPopulates<T = Query<any, any> | Document>(
   // Array with documents
   else if (Array.isArray(queryOrDocument)) {
     const promises = [];
-    queryOrDocument.forEach((item) => promises.push(item.populate(populateOptions)));
+    queryOrDocument.forEach((item) => {
+      if (item.populate) {
+        promises.push(item.populate(populateOptions));
+      } else if (mongooseModel) {
+        promises.push(mongooseModel.populate(item, populateOptions as any));
+      }
+    });
     await Promise.all(promises);
   }
   // Single document
-  else {
+  else if ((queryOrDocument as any).populate) {
     await (queryOrDocument as any).populate(populateOptions);
+  } else {
+    return (await mongooseModel.populate(queryOrDocument as any, populateOptions as any)) as any;
   }
 
   // Return populated

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

@@ -2,6 +2,7 @@ import { FilterQuery, QueryOptions } from 'mongoose';
 import { FilterArgs } from '../args/filter.args';
 import { ComparisonOperatorEnum } from '../enums/comparison-operator.enum';
 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';
@@ -193,36 +194,45 @@ export function generateFilterQuery<T = any>(filter?: Partial<FilterInput>): Fil
 /**
  * Generate find options
  */
-export function generateFindOptions<T = any>(filterArgs: Partial<FilterArgs>): QueryOptions {
+export function generateFindOptions<T = any>(
+  filterArgs: Partial<FilterArgs>,
+  options?: { maxLimit?: number }
+): QueryOptions {
   // Check filterArgs
   if (!filterArgs) {
     return {};
   }
 
+  // Config
+  const config = {
+    maxLimit: 100,
+    ...options,
+  };
+
   // Get values
   const { limit, offset, skip, sort, take } = filterArgs;
 
   // Init options
-  const options: QueryOptions = {
-    limit: limit ? limit : take,
+  const queryOptions: QueryOptions = {
+    limit: limit || take,
   };
 
   if (skip > 0 || offset > 0) {
-    options.skip = offset ? offset : skip;
+    queryOptions.skip = skip || offset;
   }
 
-  // Check take
-  if (!options.limit || options.limit > 100) {
-    options.limit = 25;
+  // Check limit
+  if (!queryOptions.limit || queryOptions.limit > config.maxLimit) {
+    queryOptions.limit = 25;
   }
 
   // Prepare order
   if (sort) {
-    options.sort = {};
+    queryOptions.sort = {};
     sort.forEach((item: SortInput) => {
-      options.sort[item.field] = item.order;
+      queryOptions.sort[item.field] = item.order === SortOrderEnum.DESC ? -1 : 1;
     });
   }
 
-  return options;
+  return queryOptions;
 }

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

@@ -1,5 +1,5 @@
 import { NotFoundException } from '@nestjs/common';
-import { FilterQuery, QueryOptions } from 'mongoose';
+import { FilterQuery, PipelineStage, QueryOptions } from 'mongoose';
 import { FilterArgs } from '../args/filter.args';
 import { merge } from '../helpers/config.helper';
 import { getStringIds } from '../helpers/db.helper';
@@ -59,6 +59,69 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
     );
   }
 
+  /**
+   * Get items and total count via filter
+   */
+  async findAndCount(
+    filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
+    serviceOptions?: ServiceOptions
+  ): Promise<{ items: T[]; totalCount: number }> {
+    return this.process(
+      async (data) => {
+        // Prepare filter query
+        const filterQuery = { filterQuery: data?.input?.filterQuery, queryOptions: data?.input?.queryOptions };
+        if (data?.input instanceof FilterArgs) {
+          const converted = convertFilterArgsToQuery(data.input);
+          filterQuery.filterQuery = converted[0];
+          filterQuery.queryOptions = converted[1];
+        }
+
+        // Prepare aggregation (with fixed defined sequence)
+        const aggregation: PipelineStage[] = [
+          {
+            // Add pipeline stage 1: match
+            $match: filterQuery.filterQuery,
+          },
+        ];
+
+        // Prepare $facet
+        const facet = {
+          items: [],
+          totalCount: [{ $count: 'total' }],
+        };
+
+        // Prepare query options
+        if (filterQuery.queryOptions) {
+          // Add pipeline stage 2: sort (optional)
+          const options = filterQuery.queryOptions;
+          if (options.sort) {
+            aggregation.push({ $sort: options.sort });
+          }
+
+          // Prepare skip / offset in facet
+          if (options.skip || options.offset) {
+            facet.items.push({ $skip: options.skip || options.offset });
+          }
+
+          // Prepare limit / take in facet
+          if (options.limit || options.take) {
+            facet.items.push({ $limit: options.limit || options.take });
+          }
+        }
+
+        // Set pipeline stage 3: facet => items (with skip & limit) and totalCount
+        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));
+        return dbResult;
+      },
+      { input: filter, outputPath: 'items', serviceOptions }
+    );
+  }
+
   /**
    * Find and update
    */

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

@@ -1,3 +1,4 @@
+import * as _ from 'lodash';
 import { Document, Model, Types } from 'mongoose';
 import { ProcessType } from '../enums/process-type.enum';
 import { getStringIds, popAndMap } from '../helpers/db.helper';
@@ -65,14 +66,20 @@ export abstract class ModuleService<T extends CoreModel = any> {
     options?: {
       [key: string]: any;
       dbObject?: string | Types.ObjectId | any;
+      outputPath?: string | string[];
       input?: any;
       serviceOptions?: ServiceOptions;
     }
   ) {
     // Configuration with default values
-    const config: { dbObject: string | Types.ObjectId | any; input: any } & ServiceOptions = {
+    const config: {
+      dbObject: string | Types.ObjectId | any;
+      outputPath: string | string[];
+      input: any;
+    } & ServiceOptions = {
       checkRights: true,
       dbObject: options?.dbObject,
+      outputPath: options?.outputPath,
       force: false,
       input: options?.input,
       processFieldSelection: {},
@@ -136,7 +143,8 @@ export abstract class ModuleService<T extends CoreModel = any> {
 
     // Pop and map main model
     if (config.processFieldSelection && config.fieldSelection && this.processFieldSelection) {
-      await this.processFieldSelection(result, config.fieldSelection, config.processFieldSelection);
+      const field = config.outputPath ? _.get(result, config.outputPath) : result;
+      await this.processFieldSelection(field, config.fieldSelection, config.processFieldSelection);
     }
 
     // Prepare output
@@ -145,7 +153,11 @@ export abstract class ModuleService<T extends CoreModel = any> {
       if (!opts.targetModel && config.outputType) {
         opts.targetModel = config.outputType;
       }
-      result = await this.prepareOutput(result, opts);
+      if (config.outputPath) {
+        _.set(result, config.outputPath, await this.prepareOutput(_.get(result, config.outputPath), opts));
+      } else {
+        result = await this.prepareOutput(result, opts);
+      }
     }
 
     // Check output rights

package/src/server/modules/user/outputs/find-and-count-user-result.output.ts

@@ -0,0 +1,11 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+import { User } from '../user.model';
+
+@ObjectType({ description: 'Result of find and count' })
+export class FindAndCountUserResult {
+  @Field(() => [User], { description: 'Found users' })
+  items: User[];
+
+  @Field({ description: 'Total count (skip/offset and limit/take are ignored in the count)' })
+  totalCount: number;
+}

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

@@ -8,6 +8,7 @@ import { Roles } from '../../../core/common/decorators/roles.decorator';
 import { RoleEnum } from '../../../core/common/enums/role.enum';
 import { UserCreateInput } from './inputs/user-create.input';
 import { UserInput } from './inputs/user.input';
+import { FindAndCountUserResult } from './outputs/find-and-count-user-result.output';
 import { User } from './user.model';
 import { UserService } from './user.service';
 
@@ -38,6 +39,18 @@ export class UserResolver {
     });
   }
 
+  /**
+   * Get users and total count (via filter)
+   */
+  @Roles(RoleEnum.ADMIN)
+  @Query(() => FindAndCountUserResult, { description: 'Find users (via filter)' })
+  async findAndCountUsers(@Info() info: GraphQLResolveInfo, @Args() args?: FilterArgs) {
+    return await this.userService.findAndCount(args, {
+      fieldSelection: { info, select: 'findAndCountUsers' },
+      inputType: FilterArgs,
+    });
+  }
+
   /**
    * Get user via ID
    */