feat(common): extend streamable-file header support

Provide option to specify additional headers when using StreamableFile.
No need to access the native response option.

BREAKING CHANGE: not specifying content-disposition header and
StreamableFile option disposition would send header value 'null'
instead of not sending the header at all.
This changes to not sending the header if no value is specified.
This commit closes issue nestjs#9229.

Author: davidschuette

integration/send-files/e2e/express.spec.ts

@@ -9,7 +9,8 @@ import { join } from 'path';
 import * as request from 'supertest';
 import { AppModule } from '../src/app.module';
 
-const readmeString = readFileSync(join(process.cwd(), 'Readme.md')).toString();
+const readme = readFileSync(join(process.cwd(), 'Readme.md'));
+const readmeString = readme.toString();
 
 describe('Express FileSend', () => {
   let app: NestExpressApplication;
@@ -53,12 +54,18 @@ describe('Express FileSend', () => {
         expect(res.body.toString()).to.be.eq(readmeString);
       });
   });
-  it('should return a file with correct content type and disposition', async () => {
+  it('should return a file with correct headers', async () => {
     return request(app.getHttpServer())
       .get('/file/with/headers')
       .expect(200)
       .expect('Content-Type', 'text/markdown')
       .expect('Content-Disposition', 'attachment; filename="Readme.md"')
+      .expect('Content-Length', readme.byteLength.toString())
+      .expect('Accept-Ranges', 'bytes')
+      .expect(
+        'Content-Range',
+        `bytes 0-${readme.byteLength - 1}/${readme.byteLength}`,
+      )
       .expect(res => {
         expect(res.text).to.be.eq(readmeString);
       });

integration/send-files/e2e/fastify.spec.ts

@@ -4,11 +4,12 @@ import {
 } from '@nestjs/platform-fastify';
 import { Test } from '@nestjs/testing';
 import { expect } from 'chai';
-import { readFileSync } from 'fs';
+import { read, readFileSync } from 'fs';
 import { join } from 'path';
 import { AppModule } from '../src/app.module';
 
-const readmeString = readFileSync(join(process.cwd(), 'Readme.md')).toString();
+const readme = readFileSync(join(process.cwd(), 'Readme.md'));
+const readmeString = readme.toString();
 
 describe('Fastify FileSend', () => {
   let app: NestFastifyApplication;
@@ -67,4 +68,21 @@ describe('Fastify FileSend', () => {
         expect(payload.toString()).to.be.eq(readmeString);
       });
   });
+  it('should return a file with correct headers', async () => {
+    return app
+      .inject({ url: '/file/with/headers', method: 'get' })
+      .then(({ statusCode, headers, payload }) => {
+        expect(statusCode).to.equal(200);
+        expect(headers['content-type']).to.equal('text/markdown');
+        expect(headers['content-disposition']).to.equal(
+          'attachment; filename="Readme.md"',
+        );
+        expect(headers['content-length']).to.equal(readme.byteLength);
+        expect(headers['accept-ranges']).to.equal('bytes');
+        expect(headers['content-range']).to.equal(
+          `bytes 0-${readme.byteLength - 1}/${readme.byteLength}`,
+        );
+        expect(payload).to.equal(readmeString);
+      });
+  });
 });

integration/send-files/src/app.service.ts

@@ -25,11 +25,15 @@ export class AppService {
   }
 
   getFileWithHeaders(): StreamableFile {
+    const file = readFileSync(join(process.cwd(), 'Readme.md'));
     return new StreamableFile(
       createReadStream(join(process.cwd(), 'Readme.md')),
       {
         type: 'text/markdown',
         disposition: 'attachment; filename="Readme.md"',
+        length: file.byteLength,
+        acceptRanges: 'bytes',
+        range: `bytes 0-${file.byteLength - 1}/${file.byteLength}`,
       },
     );
   }

packages/common/file-stream/streamable-file.ts

@@ -26,8 +26,19 @@ export class StreamableFile {
   }
 
   getHeaders() {
-    const { type = 'application/octet-stream', disposition = null } =
-      this.options;
-    return { type, disposition };
+    const {
+      type = 'application/octet-stream',
+      disposition = undefined,
+      acceptRanges = undefined,
+      length = undefined,
+      range = undefined,
+    } = this.options;
+    return {
+      type,
+      disposition,
+      acceptRanges,
+      length,
+      range,
+    };
   }
 }

packages/common/file-stream/streamable-options.interface.ts

@@ -1,4 +1,7 @@
 export interface StreamableFileOptions {
   type?: string;
   disposition?: string;
+  length?: number;
+  range?: string;
+  acceptRanges?: string;
 }

packages/common/test/file-stream/streamable-file.spec.ts

@@ -17,6 +17,38 @@ describe('StreamableFile', () => {
       expect(streamableFile.getStream()).to.equal(stream);
     });
   });
+  describe('when options is empty', () => {
+    it('should return application/octet-stream for type and undefined for others', () => {
+      const stream = new Readable();
+      const streamableFile = new StreamableFile(stream);
+      expect(streamableFile.getHeaders()).to.deep.equal({
+        type: 'application/octet-stream',
+        disposition: undefined,
+        acceptRanges: undefined,
+        length: undefined,
+        range: undefined,
+      });
+    });
+  });
+  describe('when options is defined', () => {
+    it('should pass provided headers', () => {
+      const stream = new Readable();
+      const streamableFile = new StreamableFile(stream, {
+        type: 'application/pdf',
+        acceptRanges: '123',
+        disposition: 'inline',
+        length: 100,
+        range: '456',
+      });
+      expect(streamableFile.getHeaders()).to.deep.equal({
+        type: 'application/pdf',
+        acceptRanges: '123',
+        disposition: 'inline',
+        length: 100,
+        range: '456',
+      });
+    });
+  });
   describe('otherwise', () => {
     describe('when input is a Buffer instance', () => {
       it('should create a readable stream and push the input buffer', () => {

packages/platform-express/adapters/express-adapter.ts

@@ -48,12 +48,36 @@ export class ExpressAdapter extends AbstractHttpAdapter {
     }
     if (body instanceof StreamableFile) {
       const streamHeaders = body.getHeaders();
-      if (response.getHeader('Content-Type') === undefined) {
+      if (
+        response.getHeader('Content-Type') === undefined &&
+        streamHeaders.type
+      ) {
         response.setHeader('Content-Type', streamHeaders.type);
       }
-      if (response.getHeader('Content-Disposition') === undefined) {
+      if (
+        response.getHeader('Content-Disposition') === undefined &&
+        streamHeaders.disposition
+      ) {
         response.setHeader('Content-Disposition', streamHeaders.disposition);
       }
+      if (
+        response.getHeader('Content-Length') === undefined &&
+        streamHeaders.length
+      ) {
+        response.setHeader('Content-Length', streamHeaders.length);
+      }
+      if (
+        response.getHeader('Content-Range') === undefined &&
+        streamHeaders.range
+      ) {
+        response.setHeader('Content-Range', streamHeaders.range);
+      }
+      if (
+        response.getHeader('Accept-Ranges') === undefined &&
+        streamHeaders.acceptRanges
+      ) {
+        response.setHeader('Accept-Ranges', streamHeaders.acceptRanges);
+      }
       return body.getStream().pipe(response);
     }
     return isObject(body) ? response.json(body) : response.send(String(body));

packages/platform-fastify/adapters/fastify-adapter.ts

@@ -282,12 +282,36 @@ export class FastifyAdapter<
     }
     if (body instanceof StreamableFile) {
       const streamHeaders = body.getHeaders();
-      if (fastifyReply.getHeader('Content-Type') === undefined) {
+      if (
+        fastifyReply.getHeader('Content-Type') === undefined &&
+        streamHeaders.type
+      ) {
         fastifyReply.header('Content-Type', streamHeaders.type);
       }
-      if (fastifyReply.getHeader('Content-Disposition') === undefined) {
+      if (
+        fastifyReply.getHeader('Content-Disposition') === undefined &&
+        streamHeaders.disposition
+      ) {
         fastifyReply.header('Content-Disposition', streamHeaders.disposition);
       }
+      if (
+        fastifyReply.getHeader('Content-Length') === undefined &&
+        streamHeaders.length
+      ) {
+        fastifyReply.header('Content-Length', streamHeaders.length);
+      }
+      if (
+        fastifyReply.getHeader('Content-Range') === undefined &&
+        streamHeaders.range
+      ) {
+        fastifyReply.header('Content-Range', streamHeaders.range);
+      }
+      if (
+        fastifyReply.getHeader('Accept-Ranges') === undefined &&
+        streamHeaders.acceptRanges
+      ) {
+        fastifyReply.header('Accept-Ranges', streamHeaders.acceptRanges);
+      }
       body = body.getStream();
     }
     return fastifyReply.send(body);