@lenne.tech/nest-server 8.6.8 → 8.6.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "8.6.8",
+  "version": "8.6.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",
@@ -79,7 +79,8 @@
     "light-my-request": "5.0.0",
     "lodash": "4.17.21",
     "mongodb": "4.7.0",
-    "mongoose": "6.3.8",
+    "mongoose": "6.3.9",
+    "mongoose-gridfs": "1.3.0",
     "multer": "1.4.4",
     "node-mailjet": "3.4.1",
     "nodemailer": "6.7.5",
@@ -93,7 +94,7 @@
   "devDependencies": {
     "@nestjs/testing": "8.4.7",
     "@types/ejs": "3.1.1",
-    "@types/jest": "28.1.1",
+    "@types/jest": "28.1.3",
     "@types/lodash": "4.14.182",
     "@types/multer": "1.4.7",
     "@types/node": "18.0.0",
@@ -101,10 +102,10 @@
     "@types/nodemailer": "6.4.4",
     "@types/passport": "1.0.9",
     "@types/supertest": "2.0.12",
-    "@typescript-eslint/eslint-plugin": "5.28.0",
-    "@typescript-eslint/parser": "5.28.0",
+    "@typescript-eslint/eslint-plugin": "5.29.0",
+    "@typescript-eslint/parser": "5.29.0",
     "coffeescript": "2.7.0",
-    "eslint": "8.17.0",
+    "eslint": "8.18.0",
     "eslint-config-prettier": "8.5.0",
     "find-file-up": "2.0.1",
     "grunt": "1.5.3",
@@ -122,7 +123,7 @@
     "ts-morph": "15.1.0",
     "ts-node": "10.8.1",
     "tsconfig-paths": "4.0.0",
-    "typescript": "4.7.3"
+    "typescript": "4.7.4"
   },
   "jest": {
     "collectCoverage": true,

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

@@ -473,6 +473,8 @@ export async function popAndMap<T extends CoreModel>(
       populateOptions = getPopulatOptionsFromSelections(populate as SelectionNode[]);
     } else if ((populate as ResolveSelector).info) {
       populateOptions = getPopulateOptions((populate as ResolveSelector).info, (populate as ResolveSelector).select);
+    } else if (typeof populate === 'string' || (populate as PopulateOptions).path) {
+      populateOptions = [populate as PopulateOptions];
     }
   }
   if (queryOrDocument instanceof Query) {

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

@@ -139,7 +139,13 @@ export function generateFilterQuery<T = any>(filter?: Partial<FilterInput>): Fil
   // Process single filter
   if (filter.singleFilter) {
     // Init variables
-    const { not, options, field, value } = filter.singleFilter;
+    const { not, options, field, convertToObjectId } = filter.singleFilter;
+    let value = filter.singleFilter.value;
+
+    // Convert value to object ID(s)
+    if (convertToObjectId) {
+      value = getObjectIds(value);
+    }
 
     // Convert filter
     switch (filter.singleFilter.operator) {

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

@@ -1,4 +1,6 @@
+import { plainToInstance } from 'class-transformer';
 import * as _ from 'lodash';
+import { Types } from 'mongoose';
 
 /**
  * Helper class for models
@@ -150,3 +152,153 @@ export function maps<T = Record<string, any>>(
     return (targetClass as any).map(item, { cloneDeep });
   });
 }
+
+/**
+ * It takes an object, a mapping of properties to classes, and returns a new object with the properties mapped to instances
+ * of the classes
+ * @param input - The input object to map
+ * @param mapping - A mapping of property names to classes
+ * @param [target] - The object to map the input to. If not provided, a new object will be created
+ * @returns Record with mapped objects
+ */
+export function mapClasses<T = Record<string, any>>(
+  input: Record<string, any>,
+  mapping: Record<string, new (...args: any[]) => any>,
+  target?: T
+): T {
+  // Check params
+  if (!target) {
+    target = {} as T;
+  }
+  if (!input || !mapping) {
+    return target;
+  }
+
+  // Process input
+  for (const [prop, value] of Object.entries(input)) {
+    if (prop in mapping) {
+      const targetClass = mapping[prop] as any;
+
+      // Process array
+      if (Array.isArray(value)) {
+        const arr = [];
+        for (const item of value) {
+          if (value instanceof targetClass) {
+            arr.push(value);
+          }
+          if (value instanceof Types.ObjectId) {
+            arr.push(value);
+          } else if (typeof value === 'object') {
+            if (targetClass.map) {
+              arr.push(targetClass.map(item));
+            } else if (typeof value === 'object') {
+              arr.push(plainToInstance(targetClass, item));
+            }
+          } else {
+            arr.push(value);
+          }
+        }
+        target[prop] = arr as any;
+      }
+
+      // Process ObjectId
+      else if (value instanceof Types.ObjectId) {
+        target[prop] = value as any;
+      }
+
+      // Process object
+      else if (typeof value === 'object') {
+        if (value instanceof targetClass) {
+          target[prop] = value as any;
+        }
+        if (targetClass.map) {
+          target[prop] = targetClass.map(value);
+        } else {
+          target[prop] = plainToInstance(targetClass, value) as any;
+        }
+      }
+
+      // Others
+      else {
+        target[prop] = value;
+      }
+    }
+  }
+
+  return target;
+}
+
+/**
+ * It takes an object, a mapping of properties to classes, and returns a new object with the properties mapped to instances
+ * of the classes async
+ * @param input - The input object to map
+ * @param mapping - A mapping of property names to classes
+ * @param [target] - The object to map the input to. If not provided, a new object will be created
+ * @returns Record with mapped objects
+ */
+export async function mapClassesAsync<T = Record<string, any>>(
+  input: Record<string, any>,
+  mapping: Record<string, new (...args: any[]) => any>,
+  target?: T
+): Promise<T> {
+  // Check params
+  if (!target) {
+    target = {} as T;
+  }
+  if (!input || !mapping) {
+    return target;
+  }
+
+  // Process input
+  for (const [prop, value] of Object.entries(input)) {
+    if (prop in mapping) {
+      const targetClass = mapping[prop] as any;
+
+      // Process array
+      if (Array.isArray(value)) {
+        const arr = [];
+        for (const item of value) {
+          if (value instanceof targetClass) {
+            arr.push(value);
+          }
+          if (value instanceof Types.ObjectId) {
+            arr.push(value);
+          } else if (typeof value === 'object') {
+            if (targetClass.map) {
+              arr.push(await targetClass.map(item));
+            } else if (typeof value === 'object') {
+              arr.push(plainToInstance(targetClass, item));
+            }
+          } else {
+            arr.push(value);
+          }
+        }
+        target[prop] = arr as any;
+      }
+
+      // Process ObjectId
+      else if (value instanceof Types.ObjectId) {
+        target[prop] = value as any;
+      }
+
+      // Process object
+      else if (typeof value === 'object') {
+        if (value instanceof targetClass) {
+          target[prop] = value as any;
+        }
+        if (targetClass.map) {
+          target[prop] = await targetClass.map(value);
+        } else {
+          target[prop] = plainToInstance(targetClass, value) as any;
+        }
+      }
+
+      // Others
+      else {
+        target[prop] = value;
+      }
+    }
+  }
+
+  return target;
+}

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

@@ -9,7 +9,16 @@ import { CoreInput } from './core-input.input';
 @InputType({ description: 'Input for a configuration of a filter' })
 export class SingleFilterInput extends CoreInput {
   /**
-   * Name of the property to be used for the filter'
+   * Convert value to ObjectId
+   */
+  @Field({
+    description: 'Convert value to ObjectId',
+    nullable: true,
+  })
+  convertToObjectId?: boolean = undefined;
+
+  /**
+   * Name of the property to be used for the filter
    */
   @Field({ description: 'Name of the property to be used for the filter' })
   field: string = undefined;

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

@@ -71,7 +71,7 @@ export abstract class ModuleService<T extends CoreModel = any> {
     }
   ) {
     // Configuration with default values
-    const config = {
+    const config: { dbObject: string | Types.ObjectId | any; input: any } & ServiceOptions = {
       checkRights: true,
       dbObject: options?.dbObject,
       force: false,

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

@@ -17,7 +17,7 @@ export class CoreAuthModel extends CoreModel {
   token: string = undefined;
 
   // ===================================================================================================================
-  // Properties
+  // Methods
   // ===================================================================================================================
 
   /**
@@ -28,4 +28,13 @@ export class CoreAuthModel extends CoreModel {
     // Nothing more to initialize yet
     return this;
   }
+
+  /**
+   * Map input
+   */
+  map(input) {
+    super.map(input);
+    // There is nothing to map yet, if something comes up you can use `mapClass` / `mapClassAsync` from ModelHelper
+    return this;
+  }
 }

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

@@ -0,0 +1,179 @@
+import { NotFoundException } from '@nestjs/common';
+import { GridFSBucket, GridFSBucketReadStreamOptions } from 'mongodb';
+import { Connection, Types } from 'mongoose';
+import { createBucket, MongoGridFSOptions, MongooseGridFS } from 'mongoose-gridfs';
+import { FilterArgs } from '../../common/args/filter.args';
+import { getObjectIds, getStringIds } from '../../common/helpers/db.helper';
+import { convertFilterArgsToQuery } from '../../common/helpers/filter.helper';
+import { check } from '../../common/helpers/input.helper';
+import { prepareOutput } from '../../common/helpers/service.helper';
+import { FileInfo } from './file-info.output';
+import { FileServiceOptions } from './interfaces/file-service-options.interface';
+import { FileUpload } from './interfaces/file-upload.interface';
+
+/**
+ * Abstract core file service
+ */
+export abstract class CoreFileService {
+  files: GridFSBucket & MongooseGridFS;
+
+  /**
+   * Include MongoDB connection and create File bucket
+   */
+  protected constructor(protected readonly connection: Connection, modelName = 'File') {
+    this.files = createBucket({ modelName, connection });
+  }
+
+  /**
+   * Save file in DB
+   */
+  createFile(file: FileUpload, serviceOptions?: FileServiceOptions): Promise<FileInfo> {
+    return new Promise(async (resolve, reject) => {
+      const { filename, mimetype, encoding, createReadStream } = file;
+      const readStream = createReadStream();
+      const options: MongoGridFSOptions = { filename, contentType: mimetype };
+      this.files.writeFile(options, readStream, (error, fileInfo) => {
+        error ? reject(error) : resolve(this.prepareOutput(fileInfo, serviceOptions));
+      });
+    });
+  }
+
+  /**
+   * Save files in DB
+   */
+  async createFiles(files: FileUpload[], serviceOptions?: FileServiceOptions): Promise<FileInfo[]> {
+    const promises: Promise<FileInfo>[] = [];
+    for (const file of files) {
+      promises.push(this.createFile(file, serviceOptions));
+    }
+    return await Promise.all(promises);
+  }
+
+  /**
+   * Get file infos via filter
+   */
+  findFileInfo(filterArgs?: FilterArgs, serviceOptions?: FileServiceOptions): Promise<FileInfo[]> {
+    return new Promise((resolve, reject) => {
+      const filterQuery = convertFilterArgsToQuery(filterArgs);
+      const cursor = this.files.find(filterQuery[0], filterQuery[1]);
+      if (!cursor) {
+        throw new Error('File collection not found');
+      }
+      cursor.toArray((error, docs) => {
+        error ? reject(error) : resolve(this.prepareOutput(docs, serviceOptions));
+      });
+    });
+  }
+
+  /**
+   * Get info about file via file ID
+   */
+  getFileInfo(id: string | Types.ObjectId, serviceOptions?: FileServiceOptions): Promise<FileInfo> {
+    return new Promise((resolve, reject) => {
+      this.files.findById(getObjectIds(id), (error, fileInfo) => {
+        error ? reject(error) : resolve(this.prepareOutput(fileInfo, serviceOptions));
+      });
+    });
+  }
+
+  /**
+   * Get info about file via filename
+   */
+  getFileInfoByName(filename: string, serviceOptions?: FileServiceOptions): Promise<FileInfo> {
+    return new Promise((resolve, reject) => {
+      this.files.findOne({ filename }, (error, fileInfo) => {
+        error ? reject(error) : resolve(this.prepareOutput(fileInfo, serviceOptions));
+      });
+    });
+  }
+
+  /**
+   * Get file stream (for big files) via file ID
+   */
+  getFileStream(id: string | Types.ObjectId, options?: GridFSBucketReadStreamOptions) {
+    return this.files.openDownloadStream(getObjectIds(id), options);
+  }
+
+  /**
+   * Get file stream (for big files) via filename
+   */
+  getFileStreamByName(filename: string): GridFSBucketReadStreamOptions {
+    return this.files.readFile({ filename });
+  }
+
+  /**
+   * Get file buffer (for small files) via file ID
+   */
+  getBuffer(id: string | Types.ObjectId): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+      this.files.readFile({ _id: getObjectIds(id) }, (error, buffer) => {
+        error ? reject(error) : resolve(buffer);
+      });
+    });
+  }
+
+  /**
+   * Get file buffer (for small files) via file ID
+   */
+  getBufferByName(filename: string): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+      this.files.readFile({ filename }, (error, buffer) => {
+        error ? reject(error) : resolve(buffer);
+      });
+    });
+  }
+
+  /**
+   * Delete file reference of avatar
+   */
+  deleteFile(id: string | Types.ObjectId, serviceOptions?: FileServiceOptions): Promise<FileInfo> {
+    return new Promise((resolve, reject) => {
+      return this.files.unlink(getObjectIds(id), (error, fileInfo) => {
+        error ? reject(error) : resolve(this.prepareOutput(fileInfo, serviceOptions));
+      });
+    });
+  }
+
+  /**
+   * Delete file reference of avatar
+   */
+  async deleteFileByName(filename: string, serviceOptions?: FileServiceOptions): Promise<FileInfo> {
+    const fileInfo = await this.getFileInfoByName(filename);
+    if (!fileInfo) {
+      throw new NotFoundException('File not found with filename ' + filename);
+    }
+    return await this.deleteFile(fileInfo.id, serviceOptions);
+  }
+
+  // ===================================================================================================================
+  //  Helper methods
+  // ===================================================================================================================
+
+  /**
+   * Prepare output before return
+   */
+  protected async prepareOutput(fileInfo: FileInfo | FileInfo[], options?: FileServiceOptions) {
+    if (!fileInfo) {
+      return fileInfo;
+    }
+    this.setId(fileInfo);
+    fileInfo = await prepareOutput(fileInfo, { targetModel: FileInfo });
+    return check(fileInfo, options?.currentUser, { roles: options?.roles });
+  }
+
+  /**
+   * Set file info ID via _id
+   */
+  protected setId(fileInfo: FileInfo | FileInfo[]) {
+    if (Array.isArray(fileInfo)) {
+      fileInfo.forEach((item) => {
+        if (typeof item === 'object') {
+          item.id = getStringIds(item._id);
+        }
+      });
+    } else if (typeof fileInfo === 'object') {
+      fileInfo.id = getStringIds(fileInfo._id);
+    }
+    return fileInfo;
+  }
+}

package/src/core/modules/file/file-info.output.ts

@@ -0,0 +1,26 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+import { Types } from 'mongoose';
+import { CoreModel } from '../../common/models/core-model.model';
+
+/**
+ * File info (output)
+ */
+@ObjectType({ description: 'Information about attachment file' })
+export class FileInfo extends CoreModel {
+  _id: Types.ObjectId;
+
+  @Field(() => String, { description: 'ID of the file in bytes' })
+  id: string = undefined;
+
+  @Field(() => Number, { description: 'Length of the file in bytes', nullable: true })
+  length: number = undefined;
+
+  @Field(() => Number, { description: 'Size of the chunk', nullable: true })
+  chunkSize: number = undefined;
+
+  @Field(() => String, { description: 'Name of the file', nullable: true })
+  filename?: string = undefined;
+
+  @Field(() => String, { description: 'Content type', nullable: true })
+  contentType?: string = undefined;
+}

package/src/core/modules/file/interfaces/file-service-options.interface.ts

@@ -0,0 +1,7 @@
+/**
+ * Interface for service options in file services
+ */
+export interface FileServiceOptions {
+  currentUser?: { id: any; hasRole: (roles: string[]) => boolean };
+  roles?: string | string[];
+}

package/src/core/modules/file/interfaces/file-upload.interface.ts

@@ -0,0 +1,38 @@
+import { WriteStream } from 'fs-capacitor';
+import { Readable } from 'stream';
+
+/**
+ * Interface for file uploads
+ */
+export interface FileUpload {
+  /**
+   * A private implementation detail that shouldn’t be used outside
+   */
+  capacitor: WriteStream;
+
+  /**
+   * A function that returns a FileUploadCreateReadStream.
+   */
+  createReadStream: (options?: {
+    /** Specify an encoding for the chunks, default: utf8 */
+    encoding?: 'utf8' | 'utf8' | 'ucs2' | 'utf16le' | 'latin1' | 'ascii' | 'base64' | 'base64url' | 'hex';
+
+    /**  Maximum number of bytes to store in the internal buffer before ceasing to read from the underlying resource, default: 16384 */
+    highWaterMark?: number;
+  }) => Readable;
+
+  /**
+   * Stream transfer encoding of the file
+   */
+  encoding: string;
+
+  /**
+   * Name of the file
+   */
+  filename: string;
+
+  /**
+   * Mimetype of the file
+   */
+  mimetype: string;
+}

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

@@ -122,4 +122,13 @@ export abstract class CoreUserModel extends CorePersistenceModel {
     this.roles = this.roles === undefined ? [] : this.roles;
     return this;
   }
+
+  /**
+   * Map input
+   */
+  map(input) {
+    super.map(input);
+    // There is nothing to map yet, if something comes up you can use `mapClass` / `mapClassAsync` from ModelHelper
+    return this;
+  }
 }

package/src/core.module.ts

@@ -79,8 +79,7 @@ export class CoreModule implements NestModule {
                         const { connectionParams, extra } = context;
                         if (config.graphQl.enableSubscriptionAuth) {
                           // get authToken from authorization header
-                          const authToken: string =
-                            'Authorization' in connectionParams && connectionParams?.Authorization?.split(' ')[1];
+                          const authToken: string = connectionParams?.Authorization?.split(' ')[1];
                           if (authToken) {
                             // verify authToken/getJwtPayLoad
                             const payload = authService.decodeJwt(authToken);

package/src/index.ts

@@ -78,6 +78,15 @@ export * from './core/modules/auth/core-auth.module';
 export * from './core/modules/auth/core-auth.resolver';
 export * from './core/modules/auth/jwt.strategy';
 
+// =====================================================================================================================
+// Core - Modules - File
+// =====================================================================================================================
+
+export * from './core/modules/file/interfaces/file-service-options.interface';
+export * from './core/modules/file/interfaces/file-upload.interface';
+export * from './core/modules/file/core-file.service';
+export * from './core/modules/file/file-info.output';
+
 // =====================================================================================================================
 // Core - Modules - User
 // =====================================================================================================================

package/src/server/common/models/persistence.model.ts

@@ -15,33 +15,37 @@ import { User } from '../../modules/user/user.model';
   isAbstract: true,
 })
 export abstract class PersistenceModel extends CorePersistenceModel {
+  // ===================================================================================================================
+  // Properties
+  // ===================================================================================================================
+
   /**
-   * User who created the object
+   * ID of the user who created the object
    *
    * Not set when created by system
    */
-  @Field((type) => User, {
-    description: 'User who created the object',
+  @Field(() => User, {
+    description: 'ID of the user who created the object',
     nullable: true,
   })
   @Prop({ type: mongoose.Schema.Types.ObjectId, ref: 'User' })
-  createdBy?: Types.ObjectId | User = undefined;
+  createdBy?: Types.ObjectId | string = undefined;
 
   /**
-   * User who last updated the object
+   * ID of the user who updated the object
    *
    * Not set when updated by system
    */
-  @Field((type) => User, {
-    description: 'User who last updated the object',
+  @Field(() => User, {
+    description: 'ID of the user who updated the object',
     nullable: true,
   })
   @Prop({ type: mongoose.Schema.Types.ObjectId, ref: 'User' })
-  updatedBy?: Types.ObjectId | User = undefined;
+  updatedBy?: Types.ObjectId | string = undefined;
 
-  // ===========================================================================
-  // Properties
-  // ===========================================================================
+  // ===================================================================================================================
+  // Methods
+  // ===================================================================================================================
 
   /**
    * Initialize instance with default values instead of undefined
@@ -51,4 +55,13 @@ export abstract class PersistenceModel extends CorePersistenceModel {
     // Nothing more to initialize yet
     return this;
   }
+
+  /**
+   * Map input
+   */
+  map(input) {
+    super.map(input);
+    // There is nothing to map yet, if something comes up you can use `mapClass` / `mapClassAsync` from ModelHelper
+    return this;
+  }
 }

package/src/server/modules/auth/auth.model.ts

@@ -29,4 +29,13 @@ export class Auth extends CoreAuthModel {
     // Nothing more to initialize yet
     return this;
   }
+
+  /**
+   * Map input
+   */
+  map(input) {
+    super.map(input);
+    // There is nothing to map yet, if something comes up you can use `mapClass` / `mapClassAsync` from ModelHelper
+    return this;
+  }
 }