feat(core): option to customize error responses

examples/express-basic.ts

@@ -19,6 +19,6 @@ const uploads = uploadx({
   }
 });
 
-app.use('/uploads', uploads);
+app.use('/files', uploads);
 
 app.listen(PORT, () => console.log('listening on port:', PORT));

examples/express.ts

@@ -32,7 +32,15 @@ app.use(
     directory: 'upload',
     expiration: { maxAge: '1h', purgeInterval: '10min' },
     userIdentifier: (req: AuthRequest) => (req.user ? `${req.user.id}-${req.user.email}` : ''),
-    logger
+    logger,
+    onError: ({ statusCode, body }) => {
+      const errors = [{ status: statusCode, title: body?.code, detail: body?.message }];
+      return {
+        statusCode,
+        headers: { 'Content-Type': 'application/vnd.api+json' },
+        body: { errors }
+      };
+    }
   }),
   onComplete
 );

packages/core/src/handlers/base-handler.ts

@@ -17,6 +17,7 @@ import {
   fail,
   getBaseUrl,
   hash,
+  HttpErrorBody,
   IncomingMessageWithBody,
   isUploadxError,
   isValidationError,
@@ -207,7 +208,7 @@ export abstract class BaseHandler<TFile extends UploadxFile>
     let data: string;
     if (typeof body !== 'string') {
       data = JSON.stringify(body);
-      res.setHeader('Content-Type', 'application/json');
+      if (!headers['Content-Type']) res.setHeader('Content-Type', 'application/json');
     } else {
       data = body;
     }
@@ -221,21 +222,15 @@ export abstract class BaseHandler<TFile extends UploadxFile>
    * Send Error to client
    */
   sendError(res: http.ServerResponse, error: Error): void {
-    const response = isUploadxError(error)
+    const httpError = isUploadxError(error)
       ? this._errorResponses[error.uploadxErrorCode]
       : !isValidationError(error)
       ? this.storage.normalizeError(error)
       : error;
-    const { statusCode = 200, headers, ...rest } = response;
-    const body = response.body ? response.body : rest;
-    this.send(res, this.formatErrorResponse({ statusCode, body, headers }));
-  }
-
-  /**
-   * Adjusting the error response
-   */
-  formatErrorResponse({ statusCode, body, headers }: UploadxResponse): UploadxResponse {
-    return { statusCode, body: { error: body }, headers };
+    const { statusCode = 200, headers, ...rest } = httpError;
+    const body = httpError.body ? httpError.body : (rest as HttpErrorBody);
+    const response = { statusCode, body, headers };
+    this.send(res, this.storage.onError(response) || response);
   }
 
   /**

packages/core/src/storages/config.ts

@@ -1,14 +1,17 @@
-import { logger, Logger } from '../utils';
+import { HttpError, logger } from '../utils';
 import { File } from './file';
 import { BaseStorageOptions } from './storage';
 
-class ConfigHandler {
+export class ConfigHandler {
   static defaults = {
     allowMIME: ['*/*'],
     maxUploadSize: '5TB',
     filename: ({ id }: File): string => id,
     useRelativeLocation: false,
     onComplete: () => null,
+    onError: ({ statusCode, body, headers }: HttpError) => {
+      return { statusCode, body: { error: body }, headers };
+    },
     path: '/files',
     validation: {},
     maxMetadataSize: '4MB',
@@ -24,10 +27,4 @@ class ConfigHandler {
   get<T extends File>(): Required<BaseStorageOptions<T>> {
     return this._config as unknown as Required<BaseStorageOptions<T>>;
   }
-
-  getLogger(): Logger {
-    return this._config.logger;
-  }
 }
-
-export const configHandler = new ConfigHandler();

packages/core/src/storages/disk-storage.ts

@@ -61,7 +61,7 @@ export class DiskStorage extends BaseStorage<DiskFile> {
     if (config.metaStorage) {
       this.meta = config.metaStorage;
     } else {
-      const metaConfig = { ...config, ...(config.metaStorageConfig || {}) };
+      const metaConfig = { ...config, ...(config.metaStorageConfig || {}), logger: this.logger };
       this.meta = new LocalMetaStorage(metaConfig);
     }
     this.accessCheck().catch(err => {

packages/core/src/storages/meta-storage.ts

@@ -1,5 +1,5 @@
 import { FileName } from './file';
-import { configHandler } from './config';
+import { logger, Logger } from '../utils';
 
 /** @experimental */
 export interface UploadListEntry {
@@ -19,6 +19,7 @@ export interface UploadList {
 export interface MetaStorageOptions {
   prefix?: string;
   suffix?: string;
+  logger?: Logger;
 }
 
 /**
@@ -27,13 +28,14 @@ export interface MetaStorageOptions {
 export class MetaStorage<T> {
   prefix = '';
   suffix = '';
-  logger = configHandler.getLogger();
+  logger: Logger;
 
   constructor(config?: MetaStorageOptions) {
     this.prefix = config?.prefix || '';
     this.suffix = config?.suffix || METAFILE_EXTNAME;
     this.prefix && FileName.INVALID_PREFIXES.push(this.prefix);
     this.suffix && FileName.INVALID_SUFFIXES.push(this.suffix);
+    this.logger = config?.logger || logger;
   }
 
   /**

packages/core/src/storages/storage.ts

@@ -1,34 +1,37 @@
 import * as bytes from 'bytes';
 import * as http from 'http';
-
 import {
   Cache,
   ErrorMap,
   ErrorResponses,
   ERRORS,
   fail,
   HttpError,
+  HttpErrorBody,
   isEqual,
   Locker,
   Logger,
   LogLevel,
   toMilliseconds,
   typeis,
+  UploadxResponse,
   Validation,
   Validator,
   ValidatorConfig
 } from '../utils';
 import { File, FileInit, FileName, FilePart, FileQuery, isExpired, updateMetadata } from './file';
 import { MetaStorage, UploadList } from './meta-storage';
 import { setInterval } from 'timers';
-import { configHandler } from './config';
+import { ConfigHandler } from './config';
 
 export type UserIdentifier = (req: any, res: any) => string;
 
 export type OnComplete<TFile extends File, TResponseBody = any> = (
   file: TFile
 ) => Promise<TResponseBody> | TResponseBody;
 
+export type OnError<TResponseBody = HttpErrorBody> = (error: HttpError<TResponseBody>) => any;
+
 export type PurgeList = UploadList & { maxAgeMs: number };
 
 export interface ExpirationOptions {
@@ -59,6 +62,7 @@ export interface BaseStorageOptions<T extends File> {
   useRelativeLocation?: boolean;
   /** Completed callback */
   onComplete?: OnComplete<T>;
+  onError?: OnError;
   /** Node http base path */
   path?: string;
   /** Upload validation options */
@@ -97,6 +101,7 @@ export const locker = new Locker(1000, LOCK_TIMEOUT);
 
 export abstract class BaseStorage<TFile extends File> {
   onComplete: (file: TFile) => Promise<any> | any;
+  onError: (err: HttpError) => UploadxResponse;
   maxUploadSize: number;
   maxMetadataSize: number;
   path: string;
@@ -110,9 +115,11 @@ export abstract class BaseStorage<TFile extends File> {
   abstract meta: MetaStorage<TFile>;
 
   protected constructor(public config: BaseStorageOptions<TFile>) {
+    const configHandler = new ConfigHandler();
     const opts = configHandler.set(config);
     this.path = opts.path;
     this.onComplete = opts.onComplete;
+    this.onError = opts.onError;
     this.namingFunction = opts.filename;
     this.maxUploadSize = bytes.parse(opts.maxUploadSize);
     this.maxMetadataSize = bytes.parse(opts.maxMetadataSize);

packages/gcs/src/gcs-storage.ts

@@ -108,7 +108,7 @@ export class GCStorage extends BaseStorage<GCSFile> {
     if (config.metaStorage) {
       this.meta = config.metaStorage;
     } else {
-      const metaConfig = { ...config, ...(config.metaStorageConfig || {}) };
+      const metaConfig = { ...config, ...(config.metaStorageConfig || {}), logger: this.logger };
       this.meta =
         'directory' in metaConfig
           ? new LocalMetaStorage(metaConfig)

packages/s3/src/s3-storage.ts

@@ -106,7 +106,7 @@ export class S3Storage extends BaseStorage<S3File> {
     if (config.metaStorage) {
       this.meta = config.metaStorage;
     } else {
-      const metaConfig = { ...config, ...(config.metaStorageConfig || {}) };
+      const metaConfig = { ...config, ...(config.metaStorageConfig || {}), logger: this.logger };
       this.meta =
         'directory' in metaConfig
           ? new LocalMetaStorage(metaConfig)

test/shared/uploader.ts

@@ -1,6 +1,7 @@
 import {
   BaseHandler,
   BaseStorage,
+  BaseStorageOptions,
   File,
   FileInit,
   FilePart,
@@ -14,7 +15,7 @@ export class TestStorage extends BaseStorage<File> {
   path = '/files';
   isReady = true;
   meta = new MetaStorage<File>();
-  constructor(config = {}) {
+  constructor(config = {} as BaseStorageOptions<File>) {
     super(config);
   }
 

test/uploadx.spec.ts

@@ -11,14 +11,23 @@ jest.mock('fs');
 describe('::Uploadx', () => {
   const file1 = { ...metadata };
   const file2 = { ...metadata, name: 'testfile2.mp4' };
-  let uri1 = '';
-  let uri2 = '';
-  let start: number;
   const path1 = '/uploadx';
   const path2 = '/uploadx2';
   const directory = join(testRoot, 'uploadx');
   const opts = { ...storageOptions, directory, maxMetadataSize: 250 };
-  const uploadx2 = new Uploadx({ storage: new DiskStorage(opts) });
+  const uploadx2 = new Uploadx({
+    storage: new DiskStorage({
+      ...storageOptions,
+      onError: ({ statusCode, body }) => {
+        const errors = [{ status: statusCode, title: body?.code, detail: body?.message }];
+        return {
+          statusCode,
+          headers: { 'Content-Type': 'application/vnd.api+json' },
+          body: { errors }
+        };
+      }
+    })
+  });
   app.use(path1, uploadx(opts));
   app.use(path2, uploadx2.handle);
   function exposedHeaders(response: request.Response): string[] {
@@ -35,9 +44,9 @@ describe('::Uploadx', () => {
       .send(file);
   }
 
-  beforeAll(async () => cleanup(directory));
+  beforeEach(async () => cleanup(directory));
 
-  afterAll(async () => cleanup(directory));
+  afterEach(async () => cleanup(directory));
 
   describe('default options', () => {
     it('should be defined', () => {
@@ -78,9 +87,8 @@ describe('::Uploadx', () => {
 
     it('should 201 (x-headers)', async () => {
       const res = await create(file1).expect(201).expect('x-upload-expires', /.*/);
-      uri1 = res.header.location as string;
       expect(exposedHeaders(res)).toEqual(expect.arrayContaining(['location', 'x-upload-expires']));
-      expect(uri1).toBeDefined();
+      expect(res.headers.location).toBeDefined();
     });
 
     it('should 201 (metadata)', async () => {
@@ -89,9 +97,8 @@ describe('::Uploadx', () => {
         .send(file2)
         .expect(201)
         .expect('x-upload-expires', /.*/);
-      uri2 = res.header.location as string;
       expect(exposedHeaders(res)).toEqual(expect.arrayContaining(['location', 'x-upload-expires']));
-      expect(uri2).toBeDefined();
+      expect(res.header.location).toBeDefined();
     });
 
     it('should 201 (query)', async () => {
@@ -106,17 +113,17 @@ describe('::Uploadx', () => {
 
   describe('PATCH', () => {
     it('update metadata', async () => {
-      uri2 ||= (await create(file2)).header.location;
-      const res = await request(app).patch(uri2).send({ name: 'newname.mp4' }).expect(200);
+      const uri = (await create(file2)).header.location as string;
+      const res = await request(app).patch(uri).send({ name: 'newname.mp4' }).expect(200);
       expect(res.body.name).toBe('newname.mp4');
     });
   });
 
   describe('PUT', () => {
     it('should 200 (simple request)', async () => {
-      uri2 ||= (await create(file2)).header.location;
+      const uri = (await create(file2)).header.location as string;
       const res = await request(app)
-        .put(uri2)
+        .put(uri)
         .set('Digest', `sha=${metadata.sha1}`)
         .send(testfile.asBuffer)
         .expect(200);
@@ -125,17 +132,16 @@ describe('::Uploadx', () => {
     });
 
     it('should 200 (chunks)', async () => {
-      uri1 ||= (await create(file1)).header.location;
-
+      const uri = (await create(file1)).header.location as string;
       function uploadChunks(): Promise<request.Response> {
         return new Promise(resolve => {
-          start = 0;
+          let start = 0;
           const readable = testfile.asReadable;
           // eslint-disable-next-line @typescript-eslint/no-misused-promises
           readable.on('data', async (chunk: { length: number }) => {
             readable.pause();
             const res = await request(app)
-              .put(uri1)
+              .put(uri)
               .redirects(0)
               .set('content-type', 'application/octet-stream')
               .set('content-range', `bytes ${start}-${start + chunk.length - 1}/${metadata.size}`)
@@ -224,17 +230,17 @@ describe('::Uploadx', () => {
 
   describe('GET', () => {
     it('should return info array', async () => {
-      uri1 ||= (await create(file1)).header.location;
-      uri2 ||= (await create(file2)).header.location;
+      await create(file1);
+      await create(file2);
       const res = await request(app).get(`${path1}`).expect(200);
-      expect(res.body.items.length).toBeGreaterThan(2);
+      expect(res.body.items).toHaveLength(2);
     });
   });
 
   describe('DELETE', () => {
     it('should 204', async () => {
-      uri2 ||= (await create(file2)).header.location;
-      await request(app).delete(uri2).expect(204);
+      const uri = (await create(file2)).header.location as string;
+      await request(app).delete(uri).expect(204);
     });
   });
 
@@ -244,6 +250,25 @@ describe('::Uploadx', () => {
     });
   });
 
+  describe('onError', () => {
+    it('should return custom eeror response', async () => {
+      const res = await request(app)
+        .post(path2)
+        .send({ ...file2, size: 10e10 });
+      expect(res.status).toBe(413);
+      expect(res.body).toMatchObject({
+        errors: [
+          {
+            detail: 'Request entity too large',
+            status: 413,
+            title: 'RequestEntityTooLarge'
+          }
+        ]
+      });
+      expect(res.type).toBe('application/vnd.api+json');
+    });
+  });
+
   describe('events', () => {
     it('should emit `created`', async () => {
       let event;