@lenne.tech/nest-server 8.6.8 → 8.6.9

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

@@ -1,56 +1,80 @@
-import { Args, Mutation, Resolver } from '@nestjs/graphql';
+import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
 import { createWriteStream } from 'fs';
 import * as GraphQLUpload from 'graphql-upload/GraphQLUpload.js';
-import type { FileUpload } from 'graphql-upload/processRequest.js';
+import { Roles } from '../../../core/common/decorators/roles.decorator';
+import { RoleEnum } from '../../../core/common/enums/role.enum';
+import { FileInfo } from '../../../core/modules/file/file-info.output';
+import { FileUpload } from '../../../core/modules/file/interfaces/file-upload.interface';
+import { FileService } from './file.service';
 
 /**
  * File resolver
  */
 @Resolver()
 export class FileResolver {
+  /**
+   * Integrate services
+   */
+  constructor(protected readonly fileService: FileService) {}
+
+  // ===========================================================================
+  // Queries
+  // ===========================================================================
+
+  /**
+   * Get file info
+   */
+  @Roles(RoleEnum.ADMIN)
+  @Query(() => FileInfo, { nullable: true })
+  async getFileInfo(@Args({ name: 'filename', type: () => String }) filename: string) {
+    return await this.fileService.getFileInfoByName(filename);
+  }
+
+  // ===========================================================================
+  // Mutations
+  // ===========================================================================
+
+  /**
+   * Delete file
+   */
+  @Roles(RoleEnum.ADMIN)
+  @Mutation(() => FileInfo)
+  async deleteFile(@Args({ name: 'filename', type: () => String }) filename: string) {
+    return await this.fileService.deleteFileByName(filename);
+  }
+
   /**
    * Upload file
    */
-  @Mutation(() => Boolean)
-  async uploadFile(
-    @Args({ name: 'file', type: () => GraphQLUpload })
-    file: FileUpload
-  ) {
-    console.log(JSON.stringify(file, null, 2));
-    /*
-    const {filename, mimetype, encoding, createReadStream} = file;
-    await new Promise((resolve, reject) =>
-      createReadStream()
-        .pipe(createWriteStream(`./uploads/${filename}`))
-        .on('finish', () => resolve(true))
-        .on('error', (error) => reject(error))
-    );
-    */
-    return true;
+  @Roles(RoleEnum.ADMIN)
+  @Mutation(() => FileInfo)
+  async uploadFile(@Args({ name: 'file', type: () => GraphQLUpload }) file: FileUpload) {
+    const { filename, mimetype, encoding, createReadStream } = file;
+
+    // Save file in DB
+    return await this.fileService.createFile(file);
   }
 
   /**
    * Upload files
    */
+  @Roles(RoleEnum.ADMIN)
   @Mutation(() => Boolean)
-  async uploadFiles(
-    @Args({ name: 'files', type: () => [GraphQLUpload] })
-    files: FileUpload[]
-  ) {
+  async uploadFiles(@Args({ name: 'files', type: () => [GraphQLUpload] }) files: FileUpload[]) {
+    // Save files in filesystem
     const promises: Promise<any>[] = [];
     for (const file of files) {
-      console.log(JSON.stringify(await file, null, 2));
-      /*
-      const {filename, mimetype, encoding, createReadStream} = await file
-      promises.push(new Promise((resolve, reject) =>
-        createReadStream()
-          .pipe(createWriteStream(`./uploads/${filename}`))
-          .on('finish', () => resolve(true))
-          .on('error', (error) => reject(error))
-      ));
-      */
+      const { filename, mimetype, encoding, createReadStream } = await file;
+      promises.push(
+        new Promise((resolve, reject) =>
+          createReadStream()
+            .pipe(createWriteStream(`./uploads/${filename}`))
+            .on('finish', () => resolve(true))
+            .on('error', (error) => reject(error))
+        )
+      );
     }
-    await Promise.all(promises);
+    await Promise.allSettled(promises);
     return true;
   }
 }

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

@@ -0,0 +1,11 @@
+import { Injectable } from '@nestjs/common';
+import { InjectConnection } from '@nestjs/mongoose';
+import { Connection } from 'mongoose';
+import { CoreFileService } from '../../../core/modules/file/core-file.service';
+
+@Injectable()
+export class FileService extends CoreFileService {
+  constructor(@InjectConnection() protected readonly connection: Connection) {
+    super(connection, 'File');
+  }
+}

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

@@ -1,6 +1,7 @@
 import { Field, ObjectType } from '@nestjs/graphql';
 import { Prop, Schema as MongooseSchema, SchemaFactory } from '@nestjs/mongoose';
 import { Document, Schema } from 'mongoose';
+import { mapClasses } from '../../../core/common/helpers/model.helper';
 import { CoreUserModel } from '../../../core/modules/user/core-user.model';
 import { PersistenceModel } from '../../common/models/persistence.model';
 
@@ -59,6 +60,14 @@ export class User extends CoreUserModel implements PersistenceModel {
     // Nothing more to initialize yet
     return this;
   }
+
+  /**
+   * Map input
+   */
+  map(input) {
+    super.map(input);
+    return mapClasses(input, { createdBy: User, updatedBy: User }, this);
+  }
 }
 
 export const UserSchema = SchemaFactory.createForClass(User);

package/src/server/server.module.ts

@@ -5,6 +5,7 @@ import { CoreAuthService } from '../core/modules/auth/services/core-auth.service
 import { AuthModule } from './modules/auth/auth.module';
 import { FileController } from './modules/file/file.controller';
 import { FileResolver } from './modules/file/file.resolver';
+import { FileService } from './modules/file/file.service';
 import { ServerController } from './server.controller';
 
 /**
@@ -28,7 +29,7 @@ import { ServerController } from './server.controller';
   controllers: [FileController, ServerController],
 
   // Include resolvers, services and other providers
-  providers: [FileResolver],
+  providers: [FileService, FileResolver],
 
   // Export modules for reuse in other modules
   exports: [CoreModule, AuthModule],

package/src/test/test.helper.ts

@@ -1,4 +1,6 @@
 import { INestApplication } from '@nestjs/common';
+import { Blob } from 'buffer';
+import * as fs from 'fs';
 import { createClient } from 'graphql-ws';
 import { jsonToGraphQLQuery } from 'json-to-graphql-query';
 import * as LightMyRequest from 'light-my-request';
@@ -53,6 +55,21 @@ export interface TestGraphQLConfig {
    * https://graphql.org/learn/queries
    */
   type?: TestGraphQLType;
+
+  /**
+   * GraphQL variables with variable name as key and Type as value
+   */
+  variables?: Record<string, string>;
+}
+
+export interface TestGraphQLAttachment {
+  file: Blob | Buffer | fs.ReadStream | string | boolean | number;
+  options?: string | { filename?: string | undefined; contentType?: string | undefined };
+}
+
+export interface TestGraphQLVariable {
+  value: string | string[] | TestGraphQLAttachment | TestGraphQLAttachment[] | any;
+  type: 'field' | 'attachment';
 }
 
 /**
@@ -89,6 +106,11 @@ export interface TestGraphQLOptions {
    * Token of user who is logged in
    */
   token?: string;
+
+  /**
+   * GraphQL variables
+   */
+  variables?: Record<string, TestGraphQLVariable>;
 }
 
 /**
@@ -122,6 +144,35 @@ export class TestHelper {
     this.subscriptionUrl = subscriptionUrl;
   }
 
+  /**
+   * Download file from URL
+   */
+  download(url: string, token?: string) {
+    return new Promise((resolve, reject) => {
+      const request = supertest((this.app as INestApplication).getHttpServer()).get(url);
+      if (token) {
+        request.set('Authorization', 'bearer ' + token);
+      }
+      let data = '';
+      request
+        .buffer()
+        .parse((res: any, callback) => {
+          res.setEncoding('binary');
+          res.on('data', (chunk) => {
+            data += chunk;
+          });
+          res.on('error', reject);
+          res.on('end', (err) => {
+            err ? reject(err) : callback(null, null);
+          });
+        })
+        .end((err, res: unknown) => {
+          (res as Response & { data: string }).data = new Buffer(data, 'binary').toString();
+          err ? reject(err) : resolve(res);
+        });
+    });
+  }
+
   /**
    * GraphQL request
    */
@@ -138,7 +189,7 @@ export class TestHelper {
     };
 
     // Init vars
-    const { token, statusCode, log, logError } = config;
+    const { token, statusCode, log, logError, variables } = config;
 
     // Init
     let query = '';
@@ -170,6 +221,11 @@ export class TestHelper {
       // Set request type
       queryObj[graphql.type] = {};
 
+      // Set variables
+      if (graphql.variables) {
+        queryObj[graphql.type]['__variables'] = graphql.variables;
+      }
+
       // Set request name and fields
       queryObj[graphql.type][graphql.name] = this.prepareFields(graphql.fields) || {};
 
@@ -212,7 +268,7 @@ export class TestHelper {
     }
 
     // Get response
-    const response = await this.getResponse(token, requestConfig, statusCode, log, logError);
+    const response = await this.getResponse(token, requestConfig, statusCode, log, logError, variables);
 
     // Response of fastify
     // if ((this.app as FastifyInstance).inject) {
@@ -325,7 +381,8 @@ export class TestHelper {
     requestConfig: LightMyRequest.InjectOptions,
     statusCode: number,
     log: boolean,
-    logError: boolean
+    logError: boolean,
+    variables?: Record<string, TestGraphQLVariable>
   ): Promise<any> {
     // Token
     if (token) {
@@ -356,12 +413,71 @@ export class TestHelper {
     const method: string = requestConfig.method.toLowerCase();
     let request = supertest((this.app as INestApplication).getHttpServer())[method](requestConfig.url as string);
     if (token) {
-      request = request.set('Authorization', 'bearer ' + token);
+      request.set('Authorization', 'bearer ' + token);
+    }
+
+    // Process variables
+    if (variables) {
+      request = this.processVariables(request, variables, (requestConfig.payload as any)?.query);
     }
 
     // Response
-    const response = await request.send(requestConfig.payload);
+    const response = await (variables ? request : request.send(requestConfig.payload));
+    return this.processResponse(response, statusCode, log, logError);
+  }
+
+  /**
+   * Process GraphQL variables
+   */
+  processVariables(request: any, variables: Record<string, TestGraphQLVariable>, query: string | object) {
+    // Check and optimize parameters
+    if (!variables) {
+      return request;
+    }
+    if (typeof query === 'object') {
+      query = JSON.stringify(query).replace(/"/g, '');
+    }
+
+    // Create map
+    const mapArray: { key: string; type: 'attachment' | 'field'; value: any; index?: number }[] = [];
+    for (const [key, item] of Object.entries(variables)) {
+      if (item.type === 'attachment' && Array.isArray(item.value)) {
+        item.value.forEach((element, index) => {
+          mapArray.push({ key, type: 'attachment', value: element, index });
+        });
+      } else {
+        mapArray.push({ key, type: item.type, value: item.value });
+      }
+    }
+    const map = {};
+    mapArray.forEach((item, index) => {
+      map[index] = ['variables.' + item.key + ('index' in item ? '.' + item.index : '')];
+    });
 
+    // Add operations
+    request.field('operations', JSON.stringify({ query })).field('map', JSON.stringify(map));
+
+    // Add variables as attachment or field
+    mapArray.forEach((variable, i) => {
+      if (variable.type === 'attachment') {
+        if (typeof variable.value === 'object' && variable.value.file) {
+          request.attach(`${i}`, variable.value.file, variable.value.options);
+        } else {
+          request.attach(`${i}`, variable.value);
+        }
+      } else {
+        request.field(`${i}`, variable.value);
+      }
+    });
+
+    // Return processed request
+    return request;
+  }
+
+  /**
+   * Process GraphQL response
+   */
+  processResponse(response, statusCode, log, logError) {
     // Log response
     if (log) {
       console.log(JSON.stringify(response, null, 2));
@@ -372,7 +488,7 @@ export class TestHelper {
       if (response && response.error && response.error.text) {
         const errors = JSON.parse(response.error.text).errors;
         for (const error of errors) {
-          console.log(util.inspect(error, false, null, true));
+          console.error(util.inspect(error, false, null, true));
         }
       }
     }