Redesign stores for better separation of concerns (#186)

Co-authored-by: Merlijn Vos <merlijn@soverin.net>
Co-authored-by: Marius <marius.kleidl@gmail.com>

Author: 3 people

README.md

@@ -15,15 +15,14 @@ $ npm install tus-node-server
 - **Local File Storage**
     ```js
     server.datastore = new tus.FileStore({
-        path: '/files'
+        directory: './files'
     });
     ```
 
 - **Google Cloud Storage**
     ```js
 
     server.datastore = new tus.GCSDataStore({
-        path: '/files',
         projectId: 'project-id',
         keyFilename: 'path/to/your/keyfile.json',
         bucket: 'bucket-name',
@@ -34,13 +33,11 @@ $ npm install tus-node-server
     ```js
 
     server.datastore = new tus.S3Store({
-        path: '/files',
         bucket: 'bucket-name',
         accessKeyId: 'access-key-id',
         secretAccessKey: 'secret-access-key',
         region: 'eu-west-1',
         partSize: 8 * 1024 * 1024, // each uploaded part will have ~8MB,
-        tmpDirPrefix: 'tus-s3-store',
     });
     ```
 
@@ -56,10 +53,8 @@ $ docker run -p 1080:8080 -d bhstahl/tus-node-deploy
 ```js
 const tus = require('tus-node-server');
 
-const server = new tus.Server();
-server.datastore = new tus.FileStore({
-    path: '/files'
-});
+const server = new tus.Server({ path: '/files' });
+server.datastore = new tus.FileStore({ directory: './files' });
 
 const host = '127.0.0.1';
 const port = 1080;
@@ -72,10 +67,8 @@ server.listen({ host, port }, () => {
 
 ```js
 const tus = require('tus-node-server');
-const server = new tus.Server();
-server.datastore = new tus.FileStore({
-    path: '/files'
-});
+const server = new tus.Server({ path: '/files' });
+server.datastore = new tus.FileStore({ directory: './files' });
 
 const express = require('express');
 const app = express();
@@ -95,15 +88,14 @@ const http = require('http');
 const url = require('url');
 const Koa = require('koa')
 const tus = require('tus-node-server');
-const tusServer = new tus.Server();
+
+const tusServer = new tus.Server({ path: '/files' });
+tusServer.datastore = new tus.FileStore({ directory: './files' });
 
 const app = new Koa();
 const appCallback = app.callback();
 const port = 1080;
 
-tusServer.datastore = new tus.FileStore({
-    path: '/files',
-});
 
 const server = http.createServer((req, res) => {
     const urlPath = url.parse(req.url).pathname;
@@ -123,15 +115,13 @@ server.listen(port)
 
 ```js
 const tus = require('tus-node-server');
-const tusServer = new tus.Server();
-tusServer.datastore = new tus.FileStore({
-    path: '/files',
-});
+const tusServer = new tus.Server({ path: '/files' });
+tusServer.datastore = new tus.FileStore({ directory: './files' });
 
 const fastify = require('fastify')({ logger: true });
 
 /**
- * add new content-type to fastify forewards request 
+ * add new content-type to fastify forewards request
  * without any parser to leave body untouched
  * @see https://www.fastify.io/docs/latest/Reference/ContentTypeParser/
  */
@@ -140,7 +130,7 @@ fastify.addContentTypeParser(
 );
 
 /**
- * let tus handle preparation and filehandling requests 
+ * let tus handle preparation and filehandling requests
  * fastify exposes raw nodejs http req/res via .raw property
  * @see https://www.fastify.io/docs/latest/Reference/Request/
  * @see https://www.fastify.io/docs/latest/Reference/Reply/#raw
@@ -166,10 +156,12 @@ fastify.listen(3000, (err) => {
 Execute code when lifecycle events happen by adding event handlers to your server.
 
 ```js
-const Server = require('tus-node-server').Server;
+const tus = require('tus-node-server');
 const EVENTS = require('tus-node-server').EVENTS;
 
-const server = new Server();
+const server = new tus.Server({ path: '/files' });
+server.datastore = new tus.FileStore({ directory: './files' });
+
 server.on(EVENTS.EVENT_UPLOAD_COMPLETE, (event) => {
     console.log(`Upload complete for file ${event.file.id}`);
 });
@@ -209,24 +201,26 @@ server.on(EVENTS.EVENT_UPLOAD_COMPLETE, (event) => {
         }
     }
     ```
-    
+
 - `EVENT_FILE_DELETED`: Fired when a `DELETE` request finishes deleting the file
 
     _Example payload:_
     ```
     {
         file_id: '7b26bf4d22cf7198d3b3706bf0379794'
-           
+
     }
     ```
 
 #### Custom `GET` handlers:
 Add custom `GET` handlers to suit your needs, similar to [Express routing](https://expressjs.com/en/guide/routing.html).
 ```js
-const server = new Server();
+const server = new tus.Server({ path: '/files' });
+server.datastore = new tus.FileStore({ directory: './files' });
+
 server.get('/uploads', (req, res) => {
     // Read from your DataStore
-    fs.readdir(server.datastore.path, (err, files) => {
+    fs.readdir(server.datastore.directory, (err, files) => {
         // Format the JSON response and send it
     }
 });
@@ -235,7 +229,6 @@ server.get('/uploads', (req, res) => {
 #### Custom file names:
 
 The default naming of files is a random crypto hex string. When using your own `namingFunction`, make sure to create URL friendly names such as removing spaces.
-
 ```js
 const crypto = require('crypto');
 
@@ -245,9 +238,9 @@ const randomString = (req) => {
     return crypto.randomBytes(16).toString('hex');
 }
 
-server.datastore = new tus.FileStore({
+const server = new tus.Server({
     path: '/files',
-    namingFunction: randomString
+    namingFunction: randomString,
 });
 ```
 

demo/server.js

@@ -10,14 +10,15 @@ const GCSDataStore = require('../index').GCSDataStore;
 const S3Store = require('../index').S3Store;
 const EVENTS = require('../index').EVENTS;
 
-const server = new Server();
+const options = { path: '/files' };
+
+const server = new Server(options);
 
 const data_store = process.env.DATA_STORE || 'FileStore';
 
 switch (data_store) {
     case 'GCSDataStore':
         server.datastore = new GCSDataStore({
-            path: '/files',
             projectId: 'vimeo-open-source',
             keyFilename: path.resolve(__dirname, '../keyfile.json'),
             bucket: 'tus-node-server',
@@ -31,7 +32,6 @@ switch (data_store) {
         assert.ok(process.env.AWS_REGION, 'environment variable `AWS_REGION` must be set');
 
         server.datastore = new S3Store({
-            path: '/files',
             bucket: process.env.AWS_BUCKET,
             accessKeyId: process.env.AWS_ACCESS_KEY_ID,
             secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
@@ -41,9 +41,7 @@ switch (data_store) {
         break;
 
     default:
-        server.datastore = new FileStore({
-            path: '/files',
-        });
+        server.datastore = new FileStore({ directory: './files' });
 }
 
 /**

index.d.ts

@@ -2,17 +2,27 @@ import { EventEmitter } from "events";
 import * as fs from "fs";
 import * as http from "http";
 
+declare interface Configstore {
+    get(key: string) : Promise<IFile | undefined> | IFile | undefined;
+    set(key: string, value: IFile) : Promise<void> | void;
+    delete(key: string) : Promise<boolean> | boolean;
+}
+
+declare interface ServerOptions {
+    path: string;
+    relativeLocation?: boolean;
+    namingFunction?: () => string;
+}
+
 /**
  * arguments of constructor which in class extend DataStore
  */
 declare interface DataStoreOptions {
-    path: string;
-    namingFunction?: (req: http.IncomingMessage) => string;
-    relativeLocation?: boolean;
 }
 
 declare interface FileStoreOptions extends DataStoreOptions {
-    directory?: string;
+    directory: string;
+    configstore?: Configstore;
 }
 
 declare interface GCStoreOptions extends DataStoreOptions {
@@ -26,20 +36,22 @@ declare interface S3StoreOptions extends DataStoreOptions {
     secretAccessKey: string;
     bucket: string;
     region?: string;
-    tmpDirPrefix: string;
     partSize: number;
 }
 
-declare class File {
+declare interface IFile {
     id: string;
-    upload_length: any;
-    upload_defer_length: any;
-    upload_metadata: any;
+    upload_length: string;
+    upload_defer_length: string;
+    upload_metadata: string;
+}
+
+declare class File implements IFile {
     constructor(
         file_id: string,
-        upload_length: any,
-        upload_defer_length: any,
-        upload_metadata: any
+        upload_length: string,
+        upload_defer_length: string,
+        upload_metadata: string
     );
 }
 
@@ -48,24 +60,26 @@ declare class File {
  */
 export declare class DataStore extends EventEmitter {
     constructor(options: DataStoreOptions);
-    get extensions(): any;
-    set extensions(extensions_array: any);
-    create(req: Partial<http.IncomingMessage>): Promise<any>;
+    get extensions(): string;
+    set extensions(extensions_array: string[]);
+    hasExtension(extension: string): boolean;
+    create(file: File): Promise<IFile>;
+    remove(file_id: string) : Promise<any>;
     write(
-        req: http.IncomingMessage,
-        file_id?: string,
-        offset?: number
-    ): Promise<any>;
-    getOffset(file_id: string): Promise<any>;
+        stream: stream.Readable,
+        file_id: string,
+        offset: number
+    ): Promise<number>;
+    getOffset(file_id: string): Promise<IFile>;
 }
 
 /**
  * file store in local storage
  */
 export declare class FileStore extends DataStore {
     constructor(options: FileStoreOptions);
-    read(file_id: string): fs.ReadStream;
-    getOffset(file_id: string): Promise<fs.Stats & File>;
+    read(file_id: string): stream.Readable;
+    getOffset(file_id: string): Promise<fs.Stats & IFile>;
 }
 
 /**
@@ -80,14 +94,13 @@ export declare class GCSDataStore extends DataStore {
  */
 export declare class S3Store extends DataStore {
     constructor(options: S3StoreOptions);
-    getOffset(file_id: string, with_parts?: boolean): Promise<any>;
 }
 
 /**
  * Tus protocol server implements
  */
 export declare class Server extends EventEmitter {
-    constructor();
+    constructor(options: ServerOptions);
     get datastore(): DataStore;
     set datastore(store: DataStore);
     get(path: string, callback: (...args: any[]) => any): any;
@@ -117,6 +130,10 @@ export declare const ERRORS: {
         status_code: number;
         body: string;
     };
+    INVALID_PATH: {
+        status_code: number;
+        body: string;
+    },
     INVALID_OFFSET: {
         status_code: number;
         body: string;

lib/Server.js

@@ -9,24 +9,34 @@
 const http = require('http');
 const EventEmitter = require('events');
 
-const DataStore = require('./stores/DataStore');
 const GetHandler = require('./handlers/GetHandler');
 const HeadHandler = require('./handlers/HeadHandler');
 const OptionsHandler = require('./handlers/OptionsHandler');
 const PatchHandler = require('./handlers/PatchHandler');
 const PostHandler = require('./handlers/PostHandler');
 const DeleteHandler = require('./handlers/DeleteHandler');
 const RequestValidator = require('./validators/RequestValidator');
+const ERRORS = require('./constants').ERRORS;
 const EXPOSED_HEADERS = require('./constants').EXPOSED_HEADERS;
 const REQUEST_METHODS = require('./constants').REQUEST_METHODS;
 const TUS_RESUMABLE = require('./constants').TUS_RESUMABLE;
 const debug = require('debug');
 const log = debug('tus-node-server');
 class TusServer extends EventEmitter {
 
-    constructor() {
+    constructor(options) {
         super();
 
+        if (!options) {
+            throw new Error('\'options\' must be defined');
+        }
+        if (!options.path) {
+            throw new Error('\'path\' is not defined; must have a path');
+        }
+
+        this.options = { ...options };
+
+
         // Any handlers assigned to this object with the method as the key
         // will be used to repond to those requests. They get set/re-set
         // when a datastore is assigned to the server.
@@ -67,25 +77,21 @@ class TusServer extends EventEmitter {
      * @param  {DataStore} store Store for uploaded files
      */
     set datastore(store) {
-        if (!(store instanceof DataStore)) {
-            throw new Error(`${store} is not a DataStore`);
-        }
-
         this._datastore = store;
 
         this.handlers = {
             // GET handlers should be written in the implementations
             // eg.
             //      const server = new tus.Server();
             //      server.get('/', (req, res) => { ... });
-            GET: new GetHandler(store),
+            GET: new GetHandler(store, this.options),
 
             // These methods are handled under the tus protocol
-            HEAD: new HeadHandler(store),
-            OPTIONS: new OptionsHandler(store),
-            PATCH: new PatchHandler(store),
-            POST: new PostHandler(store),
-            DELETE: new DeleteHandler(store),
+            HEAD: new HeadHandler(store, this.options),
+            OPTIONS: new OptionsHandler(store, this.options),
+            PATCH: new PatchHandler(store, this.options),
+            POST: new PostHandler(store, this.options),
+            DELETE: new DeleteHandler(store, this.options),
         };
     }
 
@@ -122,7 +128,14 @@ class TusServer extends EventEmitter {
 
 
         if (req.method === 'GET') {
-            return this.handlers.GET.send(req, res);
+            const handler = this.handlers.GET;
+            return handler.send(req, res)
+                .catch((error) => {
+                    log(`[${handler.constructor.name}]`, error);
+                    const status_code = error.status_code || ERRORS.UNKNOWN_ERROR.status_code;
+                    const body = error.body || `${ERRORS.UNKNOWN_ERROR.body}${error.message || ''}\n`;
+                    return handler.write(res, status_code, {}, body);
+                });
         }
 
         // The Tus-Resumable header MUST be included in every request and
@@ -168,8 +181,15 @@ class TusServer extends EventEmitter {
         }
 
         // Invoke the handler for the method requested
-        if (this.handlers[req.method]) {
-            return this.handlers[req.method].send(req, res);
+        const handler = this.handlers[req.method];
+        if (handler) {
+            return handler.send(req, res)
+                .catch((error) => {
+                    log(`[${handler.constructor.name}]`, error);
+                    const status_code = error.status_code || ERRORS.UNKNOWN_ERROR.status_code;
+                    const body = error.body || `${ERRORS.UNKNOWN_ERROR.body}${error.message || ''}\n`;
+                    return handler.write(res, status_code, {}, body);
+                });
         }
 
         // 404 Anything else

lib/configstores/MemoryConfigstore.js

@@ -0,0 +1,33 @@
+'use strict';
+
+/**
+ * @fileOverview
+ * Memory based configstore.
+ * Used mostly for unit tests.
+ *
+ * @author Mitja Puzigaća <mitjap@gmail.com>
+ */
+
+class MemoryConfigstore {
+    constructor() {
+        this.data = new Map();
+    }
+
+    async get(key) {
+        let value = this.data.get(key);
+        if (value !== undefined) {
+            value = JSON.parse(value);
+        }
+        return value;
+    }
+
+    async set(key, value) {
+        this.data.set(key, JSON.stringify(value));
+    }
+
+    async delete(key) {
+        return this.data.delete(key);
+    }
+}
+
+module.exports = MemoryConfigstore;

lib/constants.js

@@ -5,6 +5,7 @@ const REQUEST_METHODS = [
     'HEAD',
     'PATCH',
     'OPTIONS',
+    'DELETE',
 ];
 
 const HEADERS = [
@@ -59,6 +60,10 @@ const ERRORS = {
         status_code: 500,
         body: 'Something went wrong receiving the file\n',
     },
+    UNSUPPORTED_CONCATENATION_EXTENSION: {
+        status_code: 501,
+        body: 'Concatenation extension is not (yet) supported. Disable parallel uploads in the tus client.\n',
+    },
 };
 
 const EVENT_ENDPOINT_CREATED = 'EVENT_ENDPOINT_CREATED';

lib/handlers/BaseHandler.js

@@ -1,16 +1,18 @@
 'use strict';
 
-const DataStore = require('../stores/DataStore');
 const EventEmitter = require('events');
 
 
 class BaseHandler extends EventEmitter {
-    constructor(store) {
+    constructor(store, options) {
         super();
-        if (!(store instanceof DataStore)) {
-            throw new Error(`${store} is not a DataStore`);
+
+        if (!store) {
+            throw new Error('Store must be defined');
         }
+
         this.store = store;
+        this.options = options;
     }
 
     /**
@@ -22,7 +24,7 @@ class BaseHandler extends EventEmitter {
      * @param  {string} body
      * @return {ServerResponse}
      */
-    send(res, status, headers = {}, body) {
+    write(res, status, headers = {}, body) {
         body = body ? body : '';
         headers = status === 204 ? headers : { ...headers, 'Content-Length': body.length };
 
@@ -31,14 +33,18 @@ class BaseHandler extends EventEmitter {
         return res.end();
     }
 
+    generateUrl(req, file_id) {
+        return this.options.relativeLocation ? `${req.baseUrl || ''}${this.options.path}/${file_id}` : `//${req.headers.host}${req.baseUrl || ''}${this.options.path}/${file_id}`;
+    }
+
     /**
      * Extract the file id from the request
      *
      * @param  {object} req http.incomingMessage
      * @return {bool|string}
      */
     getFileIdFromRequest(req) {
-        const re = new RegExp(`${req.baseUrl || ''}${this.store.path}\\/(\\S+)\\/?`); // eslint-disable-line prefer-template
+        const re = new RegExp(`${req.baseUrl || ''}${this.options.path}\\/(\\S+)\\/?`); // eslint-disable-line prefer-template
         const match = (req.originalUrl || req.url).match(re);
         if (!match) {
             return false;

lib/handlers/DeleteHandler.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const BaseHandler = require('./BaseHandler');
-const ERRORS = require('../constants').ERRORS;
+const { ERRORS, EVENTS } = require('../constants');
 
 class DeleteHandler extends BaseHandler {
     /**
@@ -11,22 +11,16 @@ class DeleteHandler extends BaseHandler {
      * @param  {object} res http.ServerResponse
      * @return {function}
      */
-    send(req, res) {
+    async send(req, res) {
         const file_id = this.getFileIdFromRequest(req);
-        if (!file_id) {
-            console.warn('[DeleteHandler]: not a valid path');
-            return Promise.resolve(super.send(res, 404, {}, 'Invalid path name\n'));
+        if (file_id === false) {
+            throw ERRORS.FILE_NOT_FOUND;
         }
-        req.file_id = file_id;
-        return this.store.remove(req)
-            .then(() => {
-                return super.send(res, 204, {});
-            })
-            .catch((error) => {
-                const status_code = error.status_code || ERRORS.UNKNOWN_ERROR.status_code;
-                const body = error.body || `${ERRORS.UNKNOWN_ERROR.body}${error.message || ''}\n`;
-                return super.send(res, status_code, {}, body);
-            });
+
+        await this.store.remove(file_id);
+        this.emit(EVENTS.EVENT_FILE_DELETED, { file_id });
+
+        return this.write(res, 204, {});
     }
 }
 

lib/handlers/GetHandler.js

@@ -8,8 +8,8 @@ const debug = require('debug');
 const log = debug('tus-node-server:handlers:get');
 
 class GetHandler extends BaseHandler {
-    constructor(store) {
-        super(store);
+    constructor(store, options) {
+        super(store, options);
 
         this.paths = new Map();
     }
@@ -25,49 +25,38 @@ class GetHandler extends BaseHandler {
      * @param  {object} res http.ServerResponse
      * @return {function}
      */
-    send(req, res) {
+    async send(req, res) {
         // Check if this url has been added to allow GET requests, with an
         // appropriate callback to handle the request
         if (this.paths.has(req.url)) {
             // invoke the callback
             return this.paths.get(req.url)(req, res);
         }
 
-        return Promise.resolve()
-            .then(() => {
-                if (!('read' in this.store)) {
-                    return Promise.reject(ERRORS.FILE_NOT_FOUND);
-                }
+        if (!('read' in this.store)) {
+            throw ERRORS.FILE_NOT_FOUND;
+        }
 
-                const file_id = this.getFileIdFromRequest(req);
-                if (file_id === false) {
-                    return Promise.reject(ERRORS.FILE_NOT_FOUND);
-                }
+        const file_id = this.getFileIdFromRequest(req);
+        if (file_id === false) {
+            throw ERRORS.FILE_NOT_FOUND;
+        }
 
-                return this.store.getOffset(file_id)
-                    .then((stats) => {
-                        const upload_length = parseInt(stats.upload_length, 10);
-                        if (stats.size !== upload_length) {
-                            log(`[GetHandler] send: File is not yet fully uploaded (${stats.size}/${upload_length})`);
-                            return Promise.reject(ERRORS.FILE_NOT_FOUND);
-                        }
+        const stats = await this.store.getOffset(file_id);
+        const upload_length = parseInt(stats.upload_length, 10);
+        if (stats.size !== upload_length) {
+            log(`[GetHandler] send: File is not yet fully uploaded (${stats.size}/${upload_length})`);
+            throw ERRORS.FILE_NOT_FOUND;
+        }
 
-                        const file_stream = this.store.read(file_id);
-                        const headers = {
-                            'Content-Length': stats.size,
-                        };
-                        res.writeHead(200, headers);
-                        return stream.pipeline(file_stream, res, (err) => {
-                            // we have no need to handle streaming errors
-                        });
-                    });
-            })
-            .catch((error) => {
-                log('[GetHandler]', error);
-                const status_code = error.status_code || ERRORS.UNKNOWN_ERROR.status_code;
-                const body = error.body || `${ERRORS.UNKNOWN_ERROR.body}${error.message || ''}\n`;
-                return super.send(res, status_code, {}, body);
-            });
+        const file_stream = this.store.read(file_id);
+        const headers = {
+            'Content-Length': stats.size,
+        };
+        res.writeHead(200, headers);
+        return stream.pipeline(file_stream, res, (err) => {
+            // we have no need to handle streaming errors
+        });
     }
 }
 

lib/handlers/HeadHandler.js

@@ -2,8 +2,6 @@
 
 const BaseHandler = require('./BaseHandler');
 const ERRORS = require('../constants').ERRORS;
-const debug = require('debug');
-const log = debug('tus-node-server:handlers:head');
 class HeadHandler extends BaseHandler {
     /**
      * Send the bytes received for a given file.
@@ -12,49 +10,42 @@ class HeadHandler extends BaseHandler {
      * @param  {object} res http.ServerResponse
      * @return {function}
      */
-    send(req, res) {
+    async send(req, res) {
         const file_id = this.getFileIdFromRequest(req);
         if (file_id === false) {
-            return super.send(res, ERRORS.FILE_NOT_FOUND.status_code, {}, ERRORS.FILE_NOT_FOUND.body);
+            throw ERRORS.FILE_NOT_FOUND;
         }
 
-        return this.store.getOffset(file_id)
-            .then((file) => {
-                // The Server MUST prevent the client and/or proxies from
-                // caching the response by adding the Cache-Control: no-store
-                // header to the response.
-                res.setHeader('Cache-Control', 'no-store');
-
-                // The Server MUST always include the Upload-Offset header in
-                // the response for a HEAD request, even if the offset is 0
-                res.setHeader('Upload-Offset', file.size);
-
-                if (file.upload_length !== undefined) {
-                    // If the size of the upload is known, the Server MUST include
-                    // the Upload-Length header in the response.
-                    res.setHeader('Upload-Length', file.upload_length);
-                }
-
-                if (!('upload_length' in file) && file.upload_defer_length !== undefined) {
-                    //  As long as the length of the upload is not known, the Server
-                    //  MUST set Upload-Defer-Length: 1 in all responses to HEAD requests.
-                    res.setHeader('Upload-Defer-Length', file.upload_defer_length);
-                }
-
-                if (file.upload_metadata !== undefined) {
-                    // If the size of the upload is known, the Server MUST include
-                    // the Upload-Length header in the response.
-                    res.setHeader('Upload-Metadata', file.upload_metadata);
-                }
-
-                return res.end();
-            })
-            .catch((error) => {
-                log('[HeadHandler]', error);
-                const status_code = error.status_code || ERRORS.UNKNOWN_ERROR.status_code;
-                const body = error.body || `${ERRORS.UNKNOWN_ERROR.body}${error.message || ''}\n`;
-                return super.send(res, status_code, {}, body);
-            });
+        const file = await this.store.getOffset(file_id);
+
+        // The Server MUST prevent the client and/or proxies from
+        // caching the response by adding the Cache-Control: no-store
+        // header to the response.
+        res.setHeader('Cache-Control', 'no-store');
+
+        // The Server MUST always include the Upload-Offset header in
+        // the response for a HEAD request, even if the offset is 0
+        res.setHeader('Upload-Offset', file.size);
+
+        if (file.upload_length !== undefined) {
+            // If the size of the upload is known, the Server MUST include
+            // the Upload-Length header in the response.
+            res.setHeader('Upload-Length', file.upload_length);
+        }
+
+        if (!('upload_length' in file) && file.upload_defer_length !== undefined) {
+            //  As long as the length of the upload is not known, the Server
+            //  MUST set Upload-Defer-Length: 1 in all responses to HEAD requests.
+            res.setHeader('Upload-Defer-Length', file.upload_defer_length);
+        }
+
+        if (file.upload_metadata !== undefined) {
+            // If the size of the upload is known, the Server MUST include
+            // the Upload-Length header in the response.
+            res.setHeader('Upload-Metadata', file.upload_metadata);
+        }
+
+        return res.end();
     }
 }
 

lib/handlers/OptionsHandler.js

@@ -16,7 +16,7 @@ class OptionsHandler extends BaseHandler {
      * @param  {object} res http.ServerResponse
      * @return {function}
      */
-    send(req, res) {
+    async send(req, res) {
         // Preflight request
         res.setHeader('Access-Control-Allow-Methods', ALLOWED_METHODS);
         res.setHeader('Access-Control-Allow-Headers', ALLOWED_HEADERS);
@@ -27,7 +27,7 @@ class OptionsHandler extends BaseHandler {
             res.setHeader('Tus-Extension', this.store.extensions);
         }
 
-        return super.send(res, 204);
+        return this.write(res, 204);
     }
 }
 

lib/handlers/PatchHandler.js

@@ -1,7 +1,8 @@
 'use strict';
 
 const BaseHandler = require('./BaseHandler');
-const ERRORS = require('../constants').ERRORS;
+const File = require('../models/File');
+const { ERRORS, EVENTS } = require('../constants');
 const debug = require('debug');
 const log = debug('tus-node-server:handlers:patch');
 class PatchHandler extends BaseHandler {
@@ -12,50 +13,45 @@ class PatchHandler extends BaseHandler {
      * @param  {object} res http.ServerResponse
      * @return {function}
      */
-    send(req, res) {
+    async send(req, res) {
         const file_id = this.getFileIdFromRequest(req);
         if (file_id === false) {
-            return super.send(res, ERRORS.FILE_NOT_FOUND.status_code, {}, ERRORS.FILE_NOT_FOUND.body);
+            throw ERRORS.FILE_NOT_FOUND;
         }
 
         // The request MUST include a Upload-Offset header
         let offset = req.headers['upload-offset'];
         if (offset === undefined) {
-            return super.send(res, ERRORS.MISSING_OFFSET.status_code, {}, ERRORS.MISSING_OFFSET.body);
+            throw ERRORS.MISSING_OFFSET;
         }
 
         // The request MUST include a Content-Type header
         const content_type = req.headers['content-type'];
         if (content_type === undefined) {
-            return super.send(res, ERRORS.INVALID_CONTENT_TYPE.status_code, {}, ERRORS.INVALID_CONTENT_TYPE.body);
+            throw ERRORS.INVALID_CONTENT_TYPE;
         }
 
         offset = parseInt(offset, 10);
 
-        return this.store.getOffset(file_id)
-            .then((stats) => {
-                if (stats.size !== offset) {
-                    // If the offsets do not match, the Server MUST respond with the 409 Conflict status without modifying the upload resource.
-                    log(`[PatchHandler] send: Incorrect offset - ${offset} sent but file is ${stats.size}`);
-                    return Promise.reject(ERRORS.INVALID_OFFSET);
-                }
-
-                return this.store.write(req, file_id, offset);
-            })
-            .then((new_offset) => {
-                //  It MUST include the Upload-Offset header containing the new offset.
-                const headers = {
-                    'Upload-Offset': new_offset,
-                };
-                // The Server MUST acknowledge successful PATCH requests with the 204
-                return super.send(res, 204, headers);
-            })
-            .catch((error) => {
-                log('[PatchHandler]', error);
-                const status_code = error.status_code || ERRORS.UNKNOWN_ERROR.status_code;
-                const body = error.body || `${ERRORS.UNKNOWN_ERROR.body}${error.message || ''}\n`;
-                return super.send(res, status_code, {}, body);
-            });
+        const stats = await this.store.getOffset(file_id);
+        if (stats.size !== offset) {
+            // If the offsets do not match, the Server MUST respond with the 409 Conflict status without modifying the upload resource.
+            log(`[PatchHandler] send: Incorrect offset - ${offset} sent but file is ${stats.size}`);
+            throw ERRORS.INVALID_OFFSET;
+        }
+
+        const new_offset = await this.store.write(req, file_id, offset);
+        if (`${new_offset}` === stats.upload_length) {
+            this.emit(EVENTS.EVENT_UPLOAD_COMPLETE, { file: new File(file_id, stats.upload_length, stats.upload_defer_length, stats.upload_metadata) });
+        }
+
+        //  It MUST include the Upload-Offset header containing the new offset.
+        const headers = {
+            'Upload-Offset': new_offset,
+        };
+
+        // The Server MUST acknowledge successful PATCH requests with the 204
+        return this.write(res, 204, headers);
     }
 }
 

lib/handlers/PostHandler.js

@@ -1,46 +1,73 @@
 'use strict';
 
 const BaseHandler = require('./BaseHandler');
+const File = require('../models/File');
+const Uid = require('../models/Uid');
 const RequestValidator = require('../validators/RequestValidator');
-const ERRORS = require('../constants').ERRORS;
-const EVENT_ENDPOINT_CREATED = require('../constants').EVENT_ENDPOINT_CREATED;
+const { EVENTS, ERRORS } = require('../constants');
 const debug = require('debug');
 const log = debug('tus-node-server:handlers:post');
 class PostHandler extends BaseHandler {
+
+    constructor(store, options) {
+        if (options.namingFunction && typeof options.namingFunction !== 'function') {
+            throw new Error('\'namingFunction\' must be a function');
+        }
+
+        if (!options.namingFunction) {
+            options.namingFunction = Uid.rand;
+        }
+
+        super(store, options);
+    }
+
     /**
      * Create a file in the DataStore.
      *
      * @param  {object} req http.incomingMessage
      * @param  {object} res http.ServerResponse
      * @return {function}
      */
-    send(req, res) {
+    async send(req, res) {
         if ('upload-concat' in req.headers && !this.store.hasExtension('concatentation')) {
-            return Promise.resolve(super.send(res, 501, {}, 'Concatenation extension is not (yet) supported. Disable parallel uploads in the tus client. '));
+            throw ERRORS.UNSUPPORTED_CONCATENATION_EXTENSION;
+        }
+
+        const upload_length = req.headers['upload-length'];
+        const upload_defer_length = req.headers['upload-defer-length'];
+        const upload_metadata = req.headers['upload-metadata'];
+
+        if ((upload_length === undefined) === (upload_defer_length === undefined)) {
+            throw ERRORS.INVALID_LENGTH;
+        }
+
+        let file_id;
+
+        try {
+            file_id = this.options.namingFunction(req);
+        }
+        catch (err) {
+            log('create: check your `namingFunction`. Error', err);
+            throw ERRORS.FILE_WRITE_ERROR;
         }
 
-        return this.store.create(req)
-            .then(async(File) => {
-                const url = this.store.relativeLocation ? `${req.baseUrl || ''}${this.store.path}/${File.id}` : `//${req.headers.host}${req.baseUrl || ''}${this.store.path}/${File.id}`;
+        const file = new File(file_id, upload_length, upload_defer_length, upload_metadata);
 
-                this.emit(EVENT_ENDPOINT_CREATED, { url });
+        const obj = await this.store.create(file);
+        this.emit(EVENTS.EVENT_FILE_CREATED, { file: obj });
 
-                const optional_headers = {};
+        const url = this.generateUrl(req, file.id);
+        this.emit(EVENTS.EVENT_ENDPOINT_CREATED, { url });
 
-                // The request MIGHT include a Content-Type header when using creation-with-upload extension
-                if (!RequestValidator.isInvalidHeader('content-type', req.headers['content-type'])) {
-                    const new_offset = await this.store.write(req, File.id, 0);
-                    optional_headers['Upload-Offset'] = new_offset;
-                }
+        const optional_headers = {};
+
+        // The request MIGHT include a Content-Type header when using creation-with-upload extension
+        if (!RequestValidator.isInvalidHeader('content-type', req.headers['content-type'])) {
+            const new_offset = await this.store.write(req, file.id, 0);
+            optional_headers['Upload-Offset'] = new_offset;
+        }
 
-                return super.send(res, 201, { Location: url, ...optional_headers });
-            })
-            .catch((error) => {
-                log('[PostHandler]', error);
-                const status_code = error.status_code || ERRORS.UNKNOWN_ERROR.status_code;
-                const body = error.body || `${ERRORS.UNKNOWN_ERROR.body}${error.message || ''}\n`;
-                return super.send(res, status_code, {}, body);
-            });
+        return this.write(res, 201, { Location: url, ...optional_headers });
     }
 }
 

lib/stores/DataStore.js

@@ -7,26 +7,8 @@
  * @author Ben Stahl <bhstahl@gmail.com>
  */
 
-const Uid = require('../models/Uid');
-const File = require('../models/File');
 const EventEmitter = require('events');
-const ERRORS = require('../constants').ERRORS;
-const EVENTS = require('../constants').EVENTS;
-const debug = require('debug');
-const log = debug('tus-node-server:stores');
 class DataStore extends EventEmitter {
-    constructor(options) {
-        super();
-        if (!options || !options.path) {
-            throw new Error('Store must have a path');
-        }
-        if (options.namingFunction && typeof options.namingFunction !== 'function') {
-            throw new Error('namingFunction must be a function');
-        }
-        this.path = options.path;
-        this.generateFileName = options.namingFunction || Uid.rand;
-        this.relativeLocation = options.relativeLocation || false;
-    }
 
     get extensions() {
         if (!this._extensions) {
@@ -52,40 +34,22 @@ class DataStore extends EventEmitter {
      *
      * http://tus.io/protocols/resumable-upload.html#creation
      *
-     * @param  {object} req http.incomingMessage
-     * @return {Promise}
+     * @param  {File} file
+     * @return {Promise} offset
      */
-    create(req) {
-        return new Promise((resolve, reject) => {
-            const upload_length = req.headers['upload-length'];
-            const upload_defer_length = req.headers['upload-defer-length'];
-            const upload_metadata = req.headers['upload-metadata'];
-
-            if (upload_length === undefined && upload_defer_length === undefined) {
-                return reject(ERRORS.INVALID_LENGTH);
-            }
-
-            const file_id = this.generateFileName(req);
-            const file = new File(file_id, upload_length, upload_defer_length, upload_metadata);
-
-            this.emit(EVENTS.EVENT_FILE_CREATED, { file });
-            return resolve(file);
-        });
+    create(file) {
+        return Promise.resolve(file);
     }
 
     /**
      * Called in DELETE requests. This method just deletes the file from the store.
      * http://tus.io/protocols/resumable-upload.html#termination
      *
-     * @param  {object} req http.incomingMessage
+     * @param {string} file_id Name of the file
      * @return {Promise}
      */
-    remove(req) {
-        return new Promise((resolve, reject) => {
-            const file_id = req.file_id;
-            this.emit(EVENTS.EVENT_FILE_DELETED, { file_id });
-            return resolve();
-        });
+    remove(file_id) {
+        return Promise.resolve();
     }
 
 
@@ -96,36 +60,25 @@ class DataStore extends EventEmitter {
      *
      * http://tus.io/protocols/resumable-upload.html#concatenation
      *
-     * @param  {object} req http.incomingMessage
+     * @param {object} stream stream.Readable
+     * @param {string} file_id Name of file
+     * @param {integer} offset starting offset
      * @return {Promise}
      */
-    write(req) {
-        log('[DataStore] write');
-        return new Promise((resolve, reject) => {
-            // Stub resolve for tests
-            const offset = 0;
-
-            this.emit(EVENTS.EVENT_UPLOAD_COMPLETE, { file: null });
-            return resolve(offset);
-        });
+    write(stream, file_id, offset) {
+        return Promise.resolve(0);
     }
 
     /**
      * Called in HEAD requests. This method should return the bytes
      * writen to the DataStore, for the client to know where to resume
      * the upload.
      *
-     * @param  {string} id     filename
-     * @return {Promise}       bytes written
+     * @param {string} file_id Name of file
+     * @return {Promise} bytes written
      */
-    getOffset(id) {
-        return new Promise((resolve, reject) => {
-            if (!id) {
-                return reject(ERRORS.FILE_NOT_FOUND);
-            }
-
-            return resolve({ size: 0, upload_length: 1 });
-        });
+    getOffset(file_id) {
+        return Promise.resolve({ size: 0, upload_length: 0 });
     }
 }
 

lib/stores/FileStore.js

@@ -1,16 +1,15 @@
 'use strict';
 
 const DataStore = require('./DataStore');
-const File = require('../models/File');
 const fs = require('fs');
+const path = require('path');
 const stream = require('stream');
 const Configstore = require('configstore');
 const pkg = require('../../package.json');
 const MASK = '0777';
 const IGNORED_MKDIR_ERROR = 'EEXIST';
 const FILE_DOESNT_EXIST = 'ENOENT';
-const ERRORS = require('../constants').ERRORS;
-const EVENTS = require('../constants').EVENTS;
+const { ERRORS } = require('../constants');
 const debug = require('debug');
 const log = debug('tus-node-server:stores:filestore');
 
@@ -24,10 +23,14 @@ const log = debug('tus-node-server:stores:filestore');
 class FileStore extends DataStore {
     constructor(options) {
         super(options);
-        this.directory = options.directory || options.path.replace(/^\//, '');
+        this.directory = options.directory;
+        this.configstore = options.configstore;
+
+        if (!this.configstore) {
+            this.configstore = new Configstore(`${pkg.name}-${pkg.version}`);
+        }
 
         this.extensions = ['creation', 'creation-with-upload', 'creation-defer-length', 'termination'];
-        this.configstore = new Configstore(`${pkg.name}-${pkg.version}`);
         this._checkOrCreateDirectory();
     }
 
@@ -45,45 +48,25 @@ class FileStore extends DataStore {
     /**
      * Create an empty file.
      *
-     * @param  {object} req http.incomingMessage
      * @param  {File} file
      * @return {Promise}
      */
-    create(req) {
+    create(file) {
         return new Promise((resolve, reject) => {
-            const upload_length = req.headers['upload-length'];
-            const upload_defer_length = req.headers['upload-defer-length'];
-            const upload_metadata = req.headers['upload-metadata'];
-
-            if (upload_length === undefined && upload_defer_length === undefined) {
-                return reject(ERRORS.INVALID_LENGTH);
-            }
-
-            let file_id;
-            try {
-                file_id = this.generateFileName(req);
-            }
-            catch (generateError) {
-                log('[FileStore] create: check your namingFunction. Error', generateError);
-                return reject(ERRORS.FILE_WRITE_ERROR);
-            }
-
-            const file = new File(file_id, upload_length, upload_defer_length, upload_metadata);
-            return fs.open(`${this.directory}/${file.id}`, 'w', (err, fd) => {
+            return fs.open(path.join(this.directory, file.id), 'w', async(err, fd) => {
                 if (err) {
                     log('[FileStore] create: Error', err);
                     return reject(err);
                 }
 
-                this.configstore.set(file.id, file);
+                await this.configstore.set(file.id, file);
 
                 return fs.close(fd, (exception) => {
                     if (exception) {
                         log('[FileStore] create: Error', exception);
                         return reject(exception);
                     }
 
-                    this.emit(EVENTS.EVENT_FILE_CREATED, { file });
                     return resolve(file);
                 });
             });
@@ -92,76 +75,72 @@ class FileStore extends DataStore {
 
     /** Get file from filesystem
      *
-     * @param {string} file_id    Name of the file
+     * @param {string} file_id  Name of the file
      *
      * @return {stream.Readable}
      */
     read(file_id) {
-        const path = `${this.directory}/${file_id}`;
-        return fs.createReadStream(path);
+        return fs.createReadStream(path.join(this.directory, file_id));
     }
 
     /**
      * Deletes a file.
      *
-     * @param  {object} req http.incomingMessage
+     * @param {string} file_id  Name of the file
      * @return {Promise}
      */
-    remove(req) {
+    remove(file_id) {
         return new Promise((resolve, reject) => {
-            const file_id = req.file_id;
-            return fs.unlink(`${this.directory}/${file_id}`, (err, fd) => {
+            return fs.unlink(`${this.directory}/${file_id}`, async(err, fd) => {
                 if (err) {
-                    console.warn('[FileStore] delete: Error', err);
-                    return reject(ERRORS.FILE_NOT_FOUND);
+                    log('[FileStore] delete: Error', err);
+                    reject(ERRORS.FILE_NOT_FOUND);
+                    return;
+                }
+
+                try {
+                    resolve(await this.configstore.delete(file_id));
+                }
+                catch (error) {
+                    reject(error);
                 }
-                this.emit(EVENTS.EVENT_FILE_DELETED, { file_id });
-                this.configstore.delete(file_id);
-                return resolve();
             });
         });
     }
 
     /**
      * Write to the file, starting at the provided offset
      *
-     * @param  {object} req http.incomingMessage
-     * @param  {string} file_id   Name of file
-     * @param  {integer} offset     starting offset
+     * @param {object} readable stream.Readable
+     * @param {string} file_id Name of file
+     * @param {integer} offset starting offset
      * @return {Promise}
      */
-    write(req, file_id, offset) {
-        return new Promise((resolve, reject) => {
-            const path = `${this.directory}/${file_id}`;
-            const options = {
-                flags: 'r+',
-                start: offset,
-            };
-
-            const write_stream = fs.createWriteStream(path, options);
-            if (!write_stream || req.destroyed) {
-                reject(ERRORS.FILE_WRITE_ERROR);
-                return;
-            }
+    write(readable, file_id, offset) {
+        const writeable = fs.createWriteStream(path.join(this.directory, file_id), {
+            flags: 'r+',
+            start: offset,
+        });
 
-            let new_offset = 0;
-            req.on('data', (buffer) => {
-                new_offset += buffer.length;
-            });
+        let bytes_received = 0;
+        const transform = new stream.Transform({
+            transform(chunk, encoding, callback) {
+                bytes_received += chunk.length;
+                callback(null, chunk);
+            }
+        });
 
-            stream.pipeline(req, write_stream, (err) => {
+        return new Promise((resolve, reject) => {
+            stream.pipeline(readable, transform, writeable, (err) => {
                 if (err) {
                     log('[FileStore] write: Error', err);
                     return reject(ERRORS.FILE_WRITE_ERROR);
                 }
 
-                offset += new_offset;
+                log(`[FileStore] write: ${bytes_received} bytes written to ${path}`);
+                offset += bytes_received;
                 log(`[FileStore] write: File is now ${offset} bytes`);
 
-                const config = this.configstore.get(file_id);
-                if (config && parseInt(config.upload_length, 10) === offset) {
-                    this.emit(EVENTS.EVENT_UPLOAD_COMPLETE, { file: config });
-                }
                 return resolve(offset);
             });
         });
@@ -173,8 +152,8 @@ class FileStore extends DataStore {
      * @param  {string} file_id name of the file
      * @return {object}           fs stats
      */
-    getOffset(file_id) {
-        const config = this.configstore.get(file_id);
+    async getOffset(file_id) {
+        const config = await this.configstore.get(file_id);
         return new Promise((resolve, reject) => {
             const file_path = `${this.directory}/${file_id}`;
             fs.stat(file_path, (error, stats) => {

lib/stores/GCSDataStore.js

@@ -1,12 +1,9 @@
 'use strict';
 
 const DataStore = require('./DataStore');
-const File = require('../models/File');
 const { Storage } = require('@google-cloud/storage');
 const stream = require('stream');
-const ERRORS = require('../constants').ERRORS;
-const EVENTS = require('../constants').EVENTS;
-const TUS_RESUMABLE = require('../constants').TUS_RESUMABLE;
+const { ERRORS, TUS_RESUMABLE } = require('../constants');
 const DEFAULT_CONFIG = {
     scopes: ['https://www.googleapis.com/auth/devstorage.full_control'],
 };
@@ -69,40 +66,24 @@ class GCSDataStore extends DataStore {
     /**
      * Create an empty file in GCS to store the metatdata.
      *
-     * @param  {object} req http.incomingMessage
      * @param  {File} file
      * @return {Promise}
      */
-    create(req) {
+    create(file) {
         return new Promise((resolve, reject) => {
-            const upload_length = req.headers['upload-length'];
-            const upload_defer_length = req.headers['upload-defer-length'];
-            const upload_metadata = req.headers['upload-metadata'];
-
-            if (upload_length === undefined && upload_defer_length === undefined) {
-                reject(ERRORS.INVALID_LENGTH);
-                return;
-            }
-
-            let file_id;
-            try {
-                file_id = this.generateFileName(req);
-            }
-            catch (generateError) {
-                log('[FileStore] create: check your namingFunction. Error', generateError);
-                reject(ERRORS.FILE_WRITE_ERROR);
+            if (!file.id) {
+                reject(ERRORS.FILE_NOT_FOUND);
                 return;
             }
 
-            const file = new File(file_id, upload_length, upload_defer_length, upload_metadata);
             const gcs_file = this.bucket.file(file.id);
             const options = {
                 metadata: {
                     metadata: {
-                        upload_length: file.upload_length,
                         tus_version: TUS_RESUMABLE,
-                        upload_metadata,
-                        upload_defer_length,
+                        upload_length: file.upload_length,
+                        upload_metadata: file.upload_metadata,
+                        upload_defer_length: file.upload_defer_length,
                     },
                 },
             };
@@ -112,7 +93,6 @@ class GCSDataStore extends DataStore {
             fake_stream.pipe(gcs_file.createWriteStream(options))
                 .on('error', reject)
                 .on('finish', () => {
-                    this.emit(EVENTS.EVENT_FILE_CREATED, { file });
                     resolve(file);
                 });
         });
@@ -132,12 +112,12 @@ class GCSDataStore extends DataStore {
      * Get the file metatata from the object in GCS, then upload a new version
      * passing through the metadata to the new version.
      *
-     * @param  {object} req         http.incomingMessage
-     * @param  {string} file_id     Name of file
-     * @param  {integer} offset     starting offset
+     * @param {object} readable stream.Readable
+     * @param  {string} file_id Name of file
+     * @param  {integer} offset starting offset
      * @return {Promise}
      */
-    write(req, file_id, offset) {
+    write(readable, file_id, offset) {
         // GCS Doesn't persist metadata within versions,
         // get that metadata first
         return this.getOffset(file_id)
@@ -160,17 +140,17 @@ class GCSDataStore extends DataStore {
                     };
 
                     const write_stream = destination.createWriteStream(options);
-                    if (!write_stream || req.destroyed) {
+                    if (!write_stream || readable.destroyed) {
                         reject(ERRORS.FILE_WRITE_ERROR);
                         return;
                     }
 
-                    let new_offset = data.size;
-                    req.on('data', (buffer) => {
-                        new_offset += buffer.length;
+                    let bytes_received = data.size;
+                    readable.on('data', (buffer) => {
+                        bytes_received += buffer.length;
                     });
 
-                    stream.pipeline(req, write_stream, async(e) => {
+                    stream.pipeline(readable, write_stream, async(e) => {
                         if (e) {
                             log(e);
                             try {
@@ -181,19 +161,15 @@ class GCSDataStore extends DataStore {
                             }
                         }
                         else {
-                            log(`${new_offset} bytes written`);
+                            log(`${bytes_received} bytes written`);
 
                             try {
                                 if (file !== destination) {
                                     await this.bucket.combine([file, destination], file);
                                     await Promise.all([file.setMetadata(options.metadata), destination.delete({ ignoreNotFound: true })]);
                                 }
 
-                                if (data.upload_length === new_offset) {
-                                    this.emit(EVENTS.EVENT_UPLOAD_COMPLETE, { file });
-                                }
-
-                                resolve(new_offset);
+                                resolve(bytes_received);
                             }
                             catch (err) {
                                 log(err);
@@ -238,11 +214,11 @@ class GCSDataStore extends DataStore {
                 }
 
                 if (metadata.metadata.upload_length) {
-                    data.upload_length = parseInt(metadata.metadata.upload_length, 10);
+                    data.upload_length = metadata.metadata.upload_length;
                 }
 
                 if (metadata.metadata.upload_defer_length) {
-                    data.upload_defer_length = parseInt(metadata.metadata.upload_defer_length, 10);
+                    data.upload_defer_length = metadata.metadata.upload_defer_length;
                 }
 
                 if (metadata.metadata.upload_metadata) {

lib/stores/S3Store.js

@@ -2,13 +2,11 @@
 
 const assert = require('assert');
 const os = require('os');
-const File = require('../models/File');
+
 const DataStore = require('./DataStore');
 const { FileStreamSplitter } = require('../models/StreamSplitter');
 const aws = require('aws-sdk');
-const ERRORS = require('../constants').ERRORS;
-const EVENTS = require('../constants').EVENTS;
-const TUS_RESUMABLE = require('../constants').TUS_RESUMABLE;
+const { ERRORS, TUS_RESUMABLE } = require('../constants');
 
 const debug = require('debug');
 const fs = require('fs');
@@ -59,7 +57,6 @@ class S3Store extends DataStore {
         assert.ok(options.secretAccessKey, '[S3Store] `secretAccessKey` must be set');
         assert.ok(options.bucket, '[S3Store] `bucket` must be set');
 
-        this.tmp_dir_prefix = options.tmpDirPrefix || 'tus-s3-store';
         this.bucket_name = options.bucket;
         this.part_size = options.partSize || 8 * 1024 * 1024;
 
@@ -160,7 +157,9 @@ class S3Store extends DataStore {
 
                 return data.UploadId;
             })
-            .then((upload_id) => this._saveMetadata(file, upload_id))
+            .then((upload_id) => {
+                return this._saveMetadata(file, upload_id);
+            })
             .catch((err) => {
                 throw err;
             });
@@ -253,15 +252,14 @@ class S3Store extends DataStore {
         if (!metadata_string) {
             return {};
         }
-
         const kv_pair_list = metadata_string.split(',');
 
         return kv_pair_list.reduce((metadata, kv_pair) => {
             const [key, base64_value] = kv_pair.split(' ');
 
             metadata[key] = {
                 encoded: base64_value,
-                decoded: base64_value ? Buffer.from(base64_value, 'base64').toString('ascii') : undefined,
+                decoded: base64_value === undefined ? undefined : Buffer.from(base64_value, 'base64').toString('ascii'),
             };
 
             return metadata;
@@ -458,41 +456,27 @@ class S3Store extends DataStore {
         delete this.cache[file_id];
     }
 
-    async create(req) {
-        const upload_length = req.headers['upload-length'];
-        const upload_defer_length = req.headers['upload-defer-length'];
-        const upload_metadata = req.headers['upload-metadata'];
-
-        if (upload_length === undefined && upload_defer_length === undefined) {
-            throw ERRORS.INVALID_LENGTH;
-        }
-
-        let file_id;
-
-        try {
-            file_id = this.generateFileName(req);
-        }
-        catch (err) {
-            log('create: check your `namingFunction`. Error', err);
-            throw ERRORS.FILE_WRITE_ERROR;
-        }
-
-        const file = new File(file_id, upload_length, upload_defer_length, upload_metadata);
-
+    create(file) {
         return this._bucketExists()
-            .then(() => this._initMultipartUpload(file))
-            .then((data) => {
-                this.emit(EVENTS.EVENT_FILE_CREATED, data);
-
-                return data.file;
+            .then(() => {
+                return this._initMultipartUpload(file);
             })
+            .then(() => file)
             .catch((err) => {
-                this._clearCache(file_id);
+                this._clearCache(file.id);
                 throw err;
             });
     }
 
-    write(req, file_id) {
+    /**
+     * Write to the file, starting at the provided offset
+     *
+     * @param {object} readable stream.Readable
+     * @param {string} file_id Name of file
+     * @param {integer} offset starting offset
+     * @return {Promise}
+     */
+    write(readable, file_id) {
         return this._getMetadata(file_id)
             .then((metadata) => {
                 return Promise.all([metadata, this._countParts(file_id), this.getOffset(file_id)]);
@@ -501,22 +485,14 @@ class S3Store extends DataStore {
                 const [metadata, part_number, initial_offset] = results;
                 const next_part_number = part_number + 1;
 
-                return Promise.allSettled(
-                    await this._processUpload(metadata, req, next_part_number, initial_offset.size)
+                return Promise.all(
+                    await this._processUpload(metadata, readable, next_part_number, initial_offset.size)
                 )
                     .then(() => this.getOffset(file_id))
                     .then((current_offset) => {
                         if (parseInt(metadata.file.upload_length, 10) === current_offset.size) {
                             return this._finishMultipartUpload(metadata, current_offset.parts)
-                                .then((location) => {
-                                    log(`[${metadata.file.id}] finished uploading: ${location}`);
-
-                                    this.emit(EVENTS.EVENT_UPLOAD_COMPLETE, {
-                                        file: Object.assign({}, metadata.file, {
-                                            location,
-                                        }),
-                                    });
-
+                                .then(() => {
                                     this._clearCache(file_id);
 
                                     return current_offset.size;

test/Test-BaseHandler.js

@@ -28,33 +28,33 @@ describe('BaseHandler', () => {
         done();
     });
 
-    it('send() should end the response', (done) => {
-        handler.send(res, 200, {});
+    it('write() should end the response', (done) => {
+        handler.write(res, 200, {});
         assert.equal(res.finished, true)
         done();
     });
 
-    it('send() should set a response code', (done) => {
-        handler.send(res, 201, {});
+    it('write() should set a response code', (done) => {
+        handler.write(res, 201, {});
         assert.equal(res.statusCode, 201)
         done();
     });
 
-    it('send() should set headers', (done) => {
+    it('write() should set headers', (done) => {
         let headers = {
             'Access-Control-Allow-Methods': 'GET, OPTIONS',
         };
-        handler.send(res, 200, headers);
+        handler.write(res, 200, headers);
         for (let header of Object.keys(headers)) {
             assert.equal(res.getHeader(header), headers[header]);
         }
         done();
     });
 
 
-    it('send() should write the body', (done) => {
+    it('write() should write the body', (done) => {
         const body = 'Hello tus!'
-        handler.send(res, 200, {}, body);
+        handler.write(res, 200, {}, body);
         let output = res._getData();
         assert.equal(output.match(/Hello tus!$/).index, output.length - body.length)
         done();

test/Test-DataStore.js

@@ -10,21 +10,6 @@ const File = require('../lib/models/File');
 describe('DataStore', () => {
     const datastore = new DataStore({path: '/test/output'});
 
-    it('constructor must require a path', (done) => {
-        assert.throws(() => { new DataStore() }, Error);
-        done();
-    });
-
-    it('constructor must require the namingFunction to be a function, if it is provided', (done) => {
-        assert.throws(() => { new DataStore({ path: '/test/output', namingFunction: {} }) }, Error);
-        done();
-    });
-
-    it('relativeLocation option must be boolean', (done) => {
-        assert.equal(typeof datastore.relativeLocation, 'boolean');
-        done();
-    });
-
     it('should provide extensions', (done) => {
         datastore.should.have.property('extensions');
         assert.equal(datastore.extensions, null);

test/Test-DeleteHandler.js

@@ -3,54 +3,53 @@
 
 const assert = require('assert');
 const http = require('http');
-const fs = require('fs');
-const FileStore = require('../lib/stores/FileStore');
+
+const sinon = require('sinon');
+const should = require('should');
+
+const DataStore = require('../lib/stores/DataStore');
 const DeleteHandler = require('../lib/handlers/DeleteHandler');
+const { ERRORS, EVENTS } = require('../lib/constants');
 
 describe('DeleteHandler', () => {
-    let res = null;
     const path = '/test/output';
-    const pathClean = path.replace(/^\//, '');
-    const namingFunction = (req) => req.url.replace(/\//g, '-');
-    const store = new FileStore({ path, namingFunction});
-    const handler = new DeleteHandler(store);
-    const filePath = "/1234";
-    const req = { headers: {}, url: path+filePath};
-
-    beforeEach((done) => {
-        res = new http.ServerResponse({ method: 'DELETE' });
-        done();
+    const fake_store = sinon.createStubInstance(DataStore);
+    let handler;
+
+    let req = null;
+    let res = null;
+
+    beforeEach(() => {
+        fake_store.remove.resetHistory();
+        handler = new DeleteHandler(fake_store, { relativeLocation: true, path });
+
+        req = { headers: {}, url: handler.generateUrl({}, '1234') };
+        res = new http.ServerResponse({ method: 'HEAD' });
+    });
+
+    it('should 404 if no file id match', () => {
+        fake_store.remove.rejects(ERRORS.FILE_NOT_FOUND);
+        return assert.rejects(() => handler.send(req, res), { status_code: 404 });
+    });
+
+    it('should 404 if no file ID', async () => {
+        sinon.stub(handler, "getFileIdFromRequest").returns(false);
+        await assert.rejects(() => handler.send(req, res), { status_code: 404 });
+        assert.equal(fake_store.remove.callCount, 0);
+    });
+
+    it('must acknowledge successful DELETE requests with the 204', async () => {
+        fake_store.remove.resolves();
+        await handler.send(req, res);
+        assert.equal(res.statusCode, 204);
     });
 
-    describe('send()', () => {
-        it('must be 404 if no file found', (done) => {
-            handler.send(req, res)
-                   .then(() => {
-                        assert.equal(res.statusCode, 404);
-                        return done();
-                    })
-                    .catch(done);
-        });
-
-        it('must be 404 if invalid path', (done) => {
-            let new_req = Object.assign({}, req);
-            new_req.url = '/test/should/not/work/1234';
-            handler.send(new_req, res)
-                   .then(() => {
-                       assert.equal(res.statusCode, 404);
-                       return done();
-                   })
-                   .catch(done);
-        });
-
-        it('must acknowledge successful DELETE requests with the 204', (done) => {
-            fs.closeSync(fs.openSync(pathClean+filePath, 'w'));
-            handler.send(req, res)
-                   .then(() => {
-                       assert.equal(res.statusCode, 204);
-                       return done();
-                   })
-                   .catch(done);
-        });
+    it(`must fire the ${EVENTS.EVENT_FILE_DELETED} event`, (done) => {
+        fake_store.remove.resolves();
+        handler.on(EVENTS.EVENT_FILE_DELETED, (event) => {
+            assert.equal(event.file_id, '1234');
+            done();
+        })
+        handler.send(req, res);
     });
 });

test/Test-EndToEnd.js

@@ -46,9 +46,11 @@ describe('EndToEnd', () => {
         let file_id;
         let deferred_file_id;
         before(() => {
-            server = new Server();
+            server = new Server({
+                path: STORE_PATH
+            });
             server.datastore = new FileStore({
-                path: STORE_PATH,
+                directory: `./${STORE_PATH}`
             });
             listener = server.listen();
             agent = request.agent(listener);
@@ -251,12 +253,14 @@ describe('EndToEnd', () => {
 
     describe('FileStore with relativeLocation', () => {
         before(() => {
-            server = new Server();
-            server.datastore = new FileStore({
+            server = new Server({
                 path: STORE_PATH,
                 // configure the store to return relative path in Location Header
                 relativeLocation: true
             });
+            server.datastore = new FileStore({
+                directory: `./${STORE_PATH}`
+            });
             listener = server.listen();
             agent = request.agent(listener);
         });
@@ -292,9 +296,10 @@ describe('EndToEnd', () => {
         let deferred_file_id;
         const files_created = [];
         before(() => {
-            server = new Server();
+            server = new Server({
+                path: STORE_PATH
+            });
             server.datastore = new GCSDataStore({
-                path: STORE_PATH,
                 projectId: PROJECT_ID,
                 keyFilename: KEYFILE,
                 bucket: BUCKET,

test/Test-FileStore.js

@@ -2,13 +2,20 @@
 const assert = require('assert')
 const fs = require('fs')
 const path = require('path')
-const Server = require('../lib/Server')
+
+const sinon = require('sinon')
+const should = require('should')
+
 const FileStore = require('../lib/stores/FileStore')
+const MemoryConfigstore = require('../lib/configstores/MemoryConfigstore')
+const File = require('../lib/models/File')
+const { ERRORS, EVENTS } = require('../lib/constants')
+
 
 const shared = require('./Test-Stores.shared')
 
 describe('FileStore', function () {
-  before(function() {
+  before(function () {
     this.testFileSize = 960244
     this.testFileName = 'test.mp4'
     this.storePath = '/test/output'
@@ -17,22 +24,63 @@ describe('FileStore', function () {
   })
 
   beforeEach(function () {
-    this.server = new Server()
-    this.server.datastore = new FileStore({ path: this.storePath })
+    sinon.spy(fs, "mkdir")
+
+    this.datastore = new FileStore({
+      directory: `${this.storePath.substring(1)}`,
+      configstore: new MemoryConfigstore(),
+    })
   })
 
-  it('should create a directory for the files', function (done) {
-    const stats = fs.lstatSync(this.filesDirectory)
-    assert.equal(stats.isDirectory(), true)
-    done()
+  this.afterEach(function () {
+    fs.mkdir.restore()
   })
 
-  it('should reject when the directory doesnt exist', function (done) {
-    this.server.datastore.directory = 'some_new_path'
-    assert.throws(() => this.server.datastore.create(req))
+  it('should create a directory for the files', function (done) {
+    assert(fs.mkdir.calledOnce);
+    assert.equal(this.datastore.directory, fs.mkdir.getCall(0).args[0]);
     done()
   })
 
+  describe('create', function () {
+    const file = new File('1234', '1000');
+
+    it('should reject when the directory doesnt exist', function () {
+      this.datastore.directory = 'some_new_path';
+      return this.datastore.create(file).should.be.rejected()
+    });
+
+    it('should resolve when the directory exists', function () {
+      return this.datastore.create(file).should.be.fulfilled();
+    });
+
+    it('should create an empty file', async function () {
+      // TODO: this test would pass even if `datastore.create` would not create any file
+      // as the file probably already exists from other tests
+      await this.datastore.create(file);
+      const stats = fs.statSync(path.join(this.datastore.directory, file.id));
+      assert.equal(stats.size, 0);
+    });
+  });
+
+  describe('write', function () {
+    const file = new File('1234', `${this.testFileSize}`, undefined, 'filename d29ybGRfZG9taW5hdGlvbl9wbGFuLnBkZg==,is_confidential');
+
+    it('created file\'s size should match \'upload_length\'', async function () {
+      await this.datastore.create(file);
+      await this.datastore.write(fs.createReadStream(this.testFilePath), file.id, 0);
+
+      const stats = fs.statSync(this.testFilePath);
+      assert.equal(stats.size, this.testFileSize);
+    });
+  });
+
+  describe('getOffset', function () {
+    it('should reject directories', function () {
+      return this.datastore.getOffset('').should.be.rejected();
+    });
+  });
+
   shared.shouldHaveStoreMethods()
   shared.shouldCreateUploads()
   shared.shouldRemoveUploads() // termination extension

test/Test-GCSDataStore.js

@@ -1,7 +1,6 @@
 'use strict'
 const path = require('path')
 
-const Server = require('../lib/Server')
 const GCSDataStore = require('../lib/stores/GCSDataStore')
 
 const shared = require('./Test-Stores.shared')
@@ -15,9 +14,7 @@ describe('GCSDataStore', () => {
   })
 
   beforeEach(function () {
-    this.server = new Server()
-    this.server.datastore = new GCSDataStore({
-      path: this.storePath,
+    this.datastore = new GCSDataStore({
       projectId: 'tus-node-server',
       keyFilename: path.resolve(__dirname, '../keyfile.json'),
       bucket: 'tus-node-server-ci',

test/Test-GetHandler.js

@@ -9,6 +9,7 @@ const should = require('should');
 const sinon = require('sinon');
 const GetHandler = require('../lib/handlers/GetHandler');
 const DataStore = require('../lib/stores/DataStore');
+const FileStore = require('../lib/stores/FileStore');
 const { spy } = require('sinon');
 
 const hasHeader = (res, header) => {
@@ -18,7 +19,7 @@ const hasHeader = (res, header) => {
 
 describe('GetHandler', () => {
     const path = '/test/output';
-    let req = null;    
+    let req = null;
     let res = null;
 
     beforeEach((done) => {
@@ -30,135 +31,113 @@ describe('GetHandler', () => {
     describe('test error responses', () => {
 
         it('should 404 when file does not exist', async() => {
-            const store = new DataStore({ path });
-            store.read = () => {};
+            const store = sinon.createStubInstance(FileStore)
+            store.getOffset.rejects({ status_code: 404 });
 
-            const fakeStore = sinon.stub(store)
-            fakeStore.getOffset.rejects({ status_code: 404 });
-    
-            const handler = new GetHandler(fakeStore);
+            const handler = new GetHandler(store, { path });
             const spy_getFileIdFromRequest = sinon.spy(handler, 'getFileIdFromRequest');
-    
+
             req.url = `${path}/1234`;
-            await handler.send(req, res)
-            assert.equal(res.statusCode, 404);
+            await assert.rejects(() => handler.send(req, res), { status_code: 404 });
             assert.equal(spy_getFileIdFromRequest.calledOnceWith(req), true);
         });
-    
+
         it('should 404 for non registered path', async() => {
-            const store = new DataStore({ path });
-            store.read = () => {};
+            const store = sinon.createStubInstance(FileStore)
 
-            const fakeStore = sinon.stub(store)
-    
-            const handler = new GetHandler(fakeStore);
+            const handler = new GetHandler(store, { path });
             const spy_getFileIdFromRequest = sinon.spy(handler, 'getFileIdFromRequest');
-    
-            req.url = `/not_a_valid_file_path`;
-            await handler.send(req, res)
-            assert.equal(res.statusCode, 404);
 
+            req.url = `/not_a_valid_file_path`;
+            await assert.rejects(() => handler.send(req, res), { status_code: 404 });
             assert.equal(spy_getFileIdFromRequest.callCount, 1);
         });
-    
+
         it('should 404 when file is not complete', async() => {
-            const store = new DataStore({ path });
-            store.read = () => {};
+            const store = sinon.createStubInstance(FileStore)
+            store.getOffset.resolves({ size: 512, upload_length: '1024' });
+
+            const handler = new GetHandler(store, { path });
 
-            const fakeStore = sinon.stub(store)
-            fakeStore.getOffset.resolves({ size: 512, upload_length: '1024' });
-    
-            const handler = new GetHandler(fakeStore);
-    
             const fileId = '1234';
             req.url = `${path}/${fileId}`;
-            await handler.send(req, res)
-            assert.equal(res.statusCode, 404);
-            assert.equal(fakeStore.getOffset.calledWith(fileId), true);
+            await assert.rejects(() => handler.send(req, res), { status_code: 404 });
+            assert.equal(store.getOffset.calledWith(fileId), true);
         });
-    
-        it('should 500 on error store.getOffset error', async() => {
+
+        it('should 500 on error store.getOffset error', () => {
             const store = new DataStore({ path });
             store.read = () => {};
 
             const fakeStore = sinon.stub(store)
-            fakeStore.getOffset.rejects({});
-    
+            fakeStore.getOffset.rejects();
+
             const handler = new GetHandler(fakeStore);
-    
+
             req.url = `${path}/1234`;
-            await handler.send(req, res);
-            assert.equal(res.statusCode, 500);
+            return assert.rejects(() => handler.send(req, res));
         });
 
         it('test invalid stream', async() => {
-            const store = new DataStore({ path });
-            store.read = () => {};
+            const store = sinon.createStubInstance(FileStore)
 
-            const fakeStore = sinon.stub(store)
-            
             const size = 512;
-            fakeStore.getOffset.resolves({ size, upload_length: size.toString() });
-            fakeStore.read.returns(stream.Readable.from(fs.createReadStream('invalid_path')));
-            
-            const handler = new GetHandler(fakeStore);
-    
+            store.getOffset.resolves({ size, upload_length: size.toString() });
+            store.read.returns(stream.Readable.from(fs.createReadStream('invalid_path')));
+
+            const handler = new GetHandler(store, { path });
+
             const fileId = '1234';
             req.url = `${path}/${fileId}`;
             await handler.send(req, res);
 
             assert.equal(res.statusCode, 200);
-            assert.equal(fakeStore.getOffset.calledWith(fileId), true);
-            assert.equal(fakeStore.read.calledWith(fileId), true);
+            assert.equal(store.getOffset.calledWith(fileId), true);
+            assert.equal(store.read.calledWith(fileId), true);
         });
     })
 
     describe('send()', () => {
 
         it('test if `file_id` is properly passed to store', async() => {
-            const store = new DataStore({ path });
-            store.read = () => {};
+            const store = sinon.createStubInstance(FileStore);
+
+            store.getOffset.resolves({ size: 512, upload_length: '512' });
+            store.read.returns(stream.Readable.from(Buffer.alloc(512)));
+
+            const handler = new GetHandler(store, { path });
 
-            const fakeStore = sinon.stub(store)            
-            fakeStore.getOffset.resolves({ size: 512, upload_length: '512' });
-            fakeStore.read.returns(stream.Readable.from(Buffer.alloc(512)));
-            
-            const handler = new GetHandler(fakeStore);
-    
             const fileId = '1234'
             req.url = `${path}/${fileId}`;
             await handler.send(req, res);
-            
-            assert.equal(fakeStore.getOffset.calledWith(fileId), true);
-            assert.equal(fakeStore.read.calledWith(fileId), true);
+
+            assert.equal(store.getOffset.calledWith(fileId), true);
+            assert.equal(store.read.calledWith(fileId), true);
         });
 
         it('test successful response', async() => {
-            const store = new DataStore({ path });
-            store.read = () => {};
+            const store = sinon.createStubInstance(FileStore);
 
-            const fakeStore = sinon.stub(store)
-    
             const size = 512;
-            fakeStore.getOffset.resolves({ size, upload_length: size.toString() });
-            fakeStore.read.returns(stream.Readable.from(Buffer.alloc(size), { objectMode: false }));
-            
-            const handler = new GetHandler(fakeStore);
-    
+            store.getOffset.resolves({ size, upload_length: size.toString() });
+            store.read.returns(stream.Readable.from(Buffer.alloc(size), { objectMode: false }));
+
+            const handler = new GetHandler(store, { path });
+
             const fileId = '1234';
             req.url = `${path}/${fileId}`;
             await handler.send(req, res);
-            
+
             assert(res.statusCode, 200);
             assert(hasHeader(res, { 'Content-Length': size }), true);
-            assert(fakeStore.getOffset.calledOnceWith(fileId), true);
-            assert(fakeStore.read.calledOnceWith(fileId), true);
+            assert(store.getOffset.calledOnceWith(fileId), true);
+            assert(store.read.calledOnceWith(fileId), true);
         });
     });
 
     describe('registerPath()', () => {
         it('should call registered path handler', async() => {
-            const fakeStore = sinon.stub(new DataStore({ path }))
+            const fakeStore = sinon.stub(new DataStore())
             const handler = new GetHandler(fakeStore);
 
             const customPath1 = `/path1`;
@@ -168,7 +147,7 @@ describe('GetHandler', () => {
             const customPath2 = `/path2`;
             const pathHandler2 = sinon.spy();
             handler.registerPath(customPath2, pathHandler2);
-    
+
             req.url = `${customPath1}`;
             await handler.send(req, res)
             assert.equal(pathHandler1.calledOnceWith(req, res), true);
@@ -181,14 +160,14 @@ describe('GetHandler', () => {
         });
 
         it('should not call DataStore when path matches registered path', async() => {
-            const fakeStore = sinon.stub(new DataStore({ path }))
+            const fakeStore = sinon.stub(new DataStore())
             const handler = new GetHandler(fakeStore);
-            
+
             const spy_getFileIdFromRequest = sinon.spy(handler, 'getFileIdFromRequest');
 
             const customPath = `/path`;
             handler.registerPath(customPath, () => {});
-    
+
             req.url = `${customPath}`;
             await handler.send(req, res)
             assert.equal(spy_getFileIdFromRequest.callCount, 0);
@@ -199,15 +178,13 @@ describe('GetHandler', () => {
     describe('DataStore without `read` method', () => {
 
         it('should 404 if not implemented', async() => {
-            const fakeStore = sinon.stub(new DataStore({ path }))
+            const fakeStore = sinon.stub(new DataStore())
             fakeStore.getOffset.resolves({ size: 512, upload_length: '512' });
 
             const handler = new GetHandler(fakeStore);
-    
-            req.url = `/${path}/1234`;
-            await handler.send(req, res);
 
-            assert.equal(res.statusCode, 404);
+            req.url = `/${path}/1234`;
+            await assert.rejects(() => handler.send(req, res), { status_code: 404 });
         });
     })
 

test/Test-HeadHandler.js

@@ -3,8 +3,12 @@
 
 const assert = require('assert');
 const http = require('http');
-const HeadHandler = require('../lib/handlers/HeadHandler');
+
+const sinon = require('sinon');
+
 const DataStore = require('../lib/stores/DataStore');
+const HeadHandler = require('../lib/handlers/HeadHandler');
+const { ERRORS } = require('../lib/constants');
 
 const hasHeader = (res, header) => {
     const key = Object.keys(header)[0];
@@ -13,43 +17,67 @@ const hasHeader = (res, header) => {
 
 describe('HeadHandler', () => {
     const path = '/test/output';
+    const fake_store = sinon.createStubInstance(DataStore);
+    const handler = new HeadHandler(fake_store, { relativeLocation: true, path });
+
+    let req = null;
     let res = null;
-    const store = new DataStore({ path });
-    const handler = new HeadHandler(store);
-    const req = { headers: {} };
 
-    beforeEach((done) => {
+    beforeEach(() => {
+        req = { headers: {}, url: handler.generateUrl({}, '1234') };
         res = new http.ServerResponse({ method: 'HEAD' });
-        done();
     });
 
-    it('should 404 if no file id match', (done) => {
-        req.headers = {};
-        req.url = '/null';
-        handler.send(req, res);
-        assert.equal(res.statusCode, 404);
-        done();
+    it('should 404 if no file id match', () => {
+        fake_store.getOffset.rejects(ERRORS.FILE_NOT_FOUND);
+        return assert.rejects(() => handler.send(req, res), { status_code: 404 });
     });
 
-    it('should 404 if no file ID ', (done) => {
-        req.headers = {};
+    it('should 404 if no file ID', () => {
         req.url = `${path}/`;
-        handler.send(req, res);
-        assert.equal(res.statusCode, 404);
-        done();
-    });
-
-    it('should resolve with the offset', (done) => {
-        req.headers = { 'upload-offset': 0 };
-        req.url = `${path}/1234`;
-        handler.send(req, res)
-            .then(() => {
-                assert.equal(hasHeader(res, { 'Upload-Offset': 0 }), true);
-                assert.equal(hasHeader(res, { 'Upload-Length': 1 }), true);
-                assert.equal(res.statusCode, 200);
-                return;
-            })
-            .then(done)
-            .catch(done);
+        return assert.rejects(() => handler.send(req, res), { status_code: 404 });
+    });
+
+    it('should resolve with the offset and cache-control', async () => {
+        fake_store.getOffset.resolves({ id: '1234', size: 0, upload_length: 1 });
+        await handler.send(req, res);
+
+        assert.equal(hasHeader(res, { 'Upload-Offset': 0 }), true);
+        assert.equal(hasHeader(res, { 'Cache-Control': 'no-store' }), true);
+        assert.equal(res.statusCode, 200);
+    });
+
+    it('should resolve with upload-length', async () => {
+        const file = { id: '1234', size: 0, upload_length: '1', upload_metadata: 'filename d29ybGRfZG9taW5hdGlvbl9wbGFuLnBkZg==,is_confidential' };
+        fake_store.getOffset.resolves(file);
+        await handler.send(req, res);
+
+        assert.equal(hasHeader(res, { 'Upload-Length': file.upload_length }), true);
+        assert.equal(res.hasHeader('Upload-Defer-Length'), false);
+    });
+
+    it('should resolve with upload-defer-length', async () => {
+        const file = { id: '1234', size: 0, upload_defer_length: '1', upload_metadata: 'filename d29ybGRfZG9taW5hdGlvbl9wbGFuLnBkZg==,is_confidential' };
+        fake_store.getOffset.resolves(file);
+        await handler.send(req, res);
+
+        assert.equal(hasHeader(res, { 'Upload-Defer-Length': file.upload_defer_length }), true);
+        assert.equal(res.hasHeader('Upload-Length'), false);
+    });
+
+    it('should resolve with metadata', async () => {
+        const file = { id: '1234', size: 0, upload_length: '1', upload_metadata: 'filename d29ybGRfZG9taW5hdGlvbl9wbGFuLnBkZg==,is_confidential' };
+        fake_store.getOffset.resolves(file);
+        await handler.send(req, res);
+
+        assert.equal(hasHeader(res, { 'Upload-Metadata': file.upload_metadata }), true);
+    });
+
+    it('should resolve without metadata', async () => {
+        const file = { id: '1234', size: 0, upload_length: '1' };
+        fake_store.getOffset.resolves(file);
+        await handler.send(req, res);
+
+        assert.equal(res.hasHeader('Upload-Metadata'), false);
     });
 });

test/Test-PatchHandler.js

@@ -18,55 +18,48 @@ const hasHeader = (res, header) => {
 describe('PatchHandler', () => {
     const path = '/test/output';
     let res = null;
-    const store = new DataStore({ path });
-    const handler = new PatchHandler(store);
+    const store = new DataStore();
+    const handler = new PatchHandler(store, { path });
     const req = { headers: {} };
 
     beforeEach((done) => {
         res = new http.ServerResponse({ method: 'PATCH' });
         done();
     });
 
-    it('should 403 if no Content-Type header', (done) => {
+    it('should 403 if no Content-Type header', () => {
         req.headers = {};
         req.url = `${path}/1234`;
-        handler.send(req, res);
-        assert.equal(res.statusCode, 403);
-        done();
+        return assert.rejects(() => handler.send(req, res), { status_code: 403 });
     });
 
-    it('should 403 if no Upload-Offset header', (done) => {
+    it('should 403 if no Upload-Offset header', () => {
         req.headers = { 'content-type': 'application/offset+octet-stream' };
         req.url = `${path}/1234`;
-        handler.send(req, res);
-        assert.equal(res.statusCode, 403);
-        done();
+        return assert.rejects(() => handler.send(req, res), { status_code: 403 });
     });
 
     describe('send()', () => {
 
         it('should 404 urls without a path', () => {
             req.url = `${path}/`;
-            handler.send(req, res);
-            assert.equal(res.statusCode, 404);
+            return assert.rejects(() => handler.send(req, res), { status_code: 404 });
         });
 
         it('should 403 if the offset is omitted', () => {
             req.headers = {
                 'content-type': 'application/offset+octet-stream',
             };
             req.url = `${path}/file`;
-            handler.send(req, res);
-            assert.equal(res.statusCode, 403);
+            return assert.rejects(() => handler.send(req, res), { status_code: 403 });
         });
 
         it('should 403 the content-type is omitted', () => {
             req.headers = {
                 'upload-offset': 0,
             };
             req.url = `${path}/file`;
-            handler.send(req, res);
-            assert.equal(res.statusCode, 403);
+            return assert.rejects(() => handler.send(req, res), { status_code: 403 });
         });
 
         it('must return a promise if the headers validate', () => {
@@ -85,26 +78,21 @@ describe('PatchHandler', () => {
             };
             req.url = `${path}/1234`;
 
-            return handler.send(req, res)
-                .then(() => {
-                    assert.equal(res.statusCode, 409);
-                });
+            return assert.rejects(() => handler.send(req, res), { status_code: 409 });
         });
 
-        it('must acknowledge successful PATCH requests with the 204', () => {
+        it('must acknowledge successful PATCH requests with the 204', async () => {
             req.headers = {
                 'upload-offset': 0,
                 'content-type': 'application/offset+octet-stream',
             };
             req.url = `${path}/1234`;
 
-            return handler.send(req, res)
-                .then(() => {
-                    assert.equal(hasHeader(res, { 'Upload-Offset': 0 }), true);
-                    assert.equal(hasHeader(res, 'Content-Length'), false);
-                    assert.equal(res.statusCode, 204);
-                });
+            await handler.send(req, res)
+
+            assert.equal(hasHeader(res, { 'Upload-Offset': 0 }), true);
+            assert.equal(hasHeader(res, 'Content-Length'), false);
+            assert.equal(res.statusCode, 204);
         });
     });
-
 });

test/Test-PostHandler.js

@@ -2,60 +2,148 @@
 'use strict';
 
 const assert = require('assert');
-const should = require('should');
 const http = require('http');
+
+const should = require('should');
+const sinon = require('sinon');
+
 const DataStore = require('../lib/stores/DataStore');
 const PostHandler = require('../lib/handlers/PostHandler');
+const { EVENTS } = require('../lib/constants');
 
 const hasHeader = (res, header) => {
     const key = Object.keys(header)[0];
     return res._header.indexOf(`${key}: ${header[key]}`) > -1;
 };
 
 describe('PostHandler', () => {
-    const path = '/test/output';
+    let req = null;
     let res = null;
-    const namingFunction = (req) => req.url.replace(/\//g, '-');
-    const store = new DataStore({ path, namingFunction });
-    const handler = new PostHandler(store);
-    const req = { headers: {}, url: '/test/output' };
+
+    const fake_store = sinon.createStubInstance(DataStore);
 
     beforeEach((done) => {
+        req = { headers: {}, url: '/files', host: 'localhost:3000' };
         res = new http.ServerResponse({ method: 'POST' });
         done();
     });
 
+    describe('constructor()', () => {
+        it('must check for naming function', () => {
+            assert.throws(() => { new PostHandler(fake_store); }, Error);
+            assert.doesNotThrow(() => { new PostHandler(fake_store, { namingFunction: () => '1234' }); })
+        })
+    });
+
     describe('send()', () => {
-        it('must 412 if the Upload-Length and Upload-Defer-Length headers are both missing', (done) => {
-            req.headers = {};
-            handler.send(req, res).then(() => {
-                assert.equal(res.statusCode, 412);
-                return done();
+
+        describe('test errors', () => {
+            it('must 412 if the Upload-Length and Upload-Defer-Length headers are both missing', async() => {
+                const handler = new PostHandler(fake_store, { namingFunction: () => '1234' });
+
+                req.headers = {};
+                return assert.rejects(() => handler.send(req, res), { status_code: 412 });
+            });
+
+            it('must 412 if the Upload-Length and Upload-Defer-Length headers are both present', async() => {
+                const handler = new PostHandler(fake_store, { namingFunction: () => '1234' });
+                req.headers = { 'upload-length': '512', 'upload-defer-length': '1'};
+                return assert.rejects(() => handler.send(req, res), { status_code: 412 });
+            });
+
+            it('must 501 if the \'concatenation\' extension is not supported', async() => {
+                const handler = new PostHandler(fake_store, { namingFunction: () => '1234' });
+                req.headers = { 'upload-concat': 'partial' };
+                return assert.rejects(() => handler.send(req, res), { status_code: 501 });
+            });
+
+            it('should send error when naming function throws', async() => {
+                const fake_store = sinon.createStubInstance(DataStore);
+                const handler = new PostHandler(fake_store, { namingFunction: sinon.stub().throws() });
+
+                req.headers = { 'upload-length': 1000 };
+                return assert.rejects(() => handler.send(req, res), { status_code: 500 });
+            });
+
+            it('should call custom namingFunction', async() => {
+                const fake_store = sinon.createStubInstance(DataStore);
+                const namingFunction = sinon.stub().returns('1234');
+                const handler = new PostHandler(fake_store, { namingFunction });
+
+                req.headers = { 'upload-length': 1000 };
+                await handler.send(req, res);
+                assert.equal(namingFunction.calledOnce, true);
+            });
+
+            it('should send error when store rejects', () => {
+                const fake_store = sinon.createStubInstance(DataStore);
+                fake_store.create.rejects({ status_code: 500 });
+
+                const handler = new PostHandler(fake_store, { namingFunction: () => '1234' });
+
+                req.headers = { 'upload-length': 1000 };
+                return assert.rejects(() => handler.send(req, res), { status_code: 500 });
+            });
+        })
+
+        describe('test successful scenarios', () => {
+            it('must acknowledge successful POST requests with the 201', async () => {
+                const handler = new PostHandler(fake_store, { path: '/test/output', namingFunction: () => '1234' });
+                req.headers = { 'upload-length': 1000, host: 'localhost:3000' };
+                await handler.send(req, res)
+                assert.equal(hasHeader(res, { 'Location': '//localhost:3000/test/output/1234' }), true);
+                assert.equal(res.statusCode, 201);
+            });
+        })
+
+        describe('events', () => {
+            it(`must fire the ${EVENTS.EVENT_FILE_CREATED} event`, (done) => {
+                const fake_store = sinon.createStubInstance(DataStore);
+
+                const file = {};
+                fake_store.create.resolves(file);
+
+                const handler = new PostHandler(fake_store, { namingFunction: () => '1234' });
+                handler.on(EVENTS.EVENT_FILE_CREATED, (obj) => {
+                    assert.strictEqual(obj.file, file);
+                    done();
+                });
+
+                req.headers = { 'upload-length': 1000 };
+                handler.send(req, res);
             })
-            .catch(done);
-        });
 
-        it('must 501 if the \'concatenation\' extension is not supported', (done) => {
-            req.headers = { 'upload-concat': 'partial' };
-            handler.send(req, res).then(() => {
-                assert.equal(res.statusCode, 501);
-                return done();
+            it(`must fire the ${EVENTS.EVENT_ENDPOINT_CREATED} event with absolute URL`, (done) => {
+                const fake_store = sinon.createStubInstance(DataStore);
+
+                const file = {};
+                fake_store.create.resolves(file);
+
+                const handler = new PostHandler(fake_store, { path: '/test/output', namingFunction: () => '1234' });
+                handler.on(EVENTS.EVENT_ENDPOINT_CREATED, (obj) => {
+                    assert.strictEqual(obj.url, '//localhost:3000/test/output/1234');
+                    done();
+                });
+
+                req.headers = { 'upload-length': 1000, host: 'localhost:3000' };
+                handler.send(req, res);
             })
-            .catch(done);
-        });
 
-        it('must acknowledge successful POST requests with the 201', (done) => {
-            req.headers = { 'upload-length': 1000, host: 'localhost:3000' };
+            it(`must fire the ${EVENTS.EVENT_ENDPOINT_CREATED} event with relative URL`, (done) => {
+                const fake_store = sinon.createStubInstance(DataStore);
 
-            handler.send(req, res)
-                .then(() => {
-                    assert.equal(hasHeader(res, { 'Location': '//localhost:3000/test/output/-test-output' }), true);
-                    assert.equal(res.statusCode, 201);
-                    return done();
-                })
-                .catch(done);
-        });
+                const file = {};
+                fake_store.create.resolves(file);
 
-    });
+                const handler = new PostHandler(fake_store, { path: '/test/output', relativeLocation: true, namingFunction: () => '1234' });
+                handler.on(EVENTS.EVENT_ENDPOINT_CREATED, (obj) => {
+                    assert.strictEqual(obj.url, '/test/output/1234');
+                    done();
+                });
 
-});
+                req.headers = { 'upload-length': 1000, host: 'localhost:3000' };
+                handler.send(req, res);
+            })
+        });
+    });
+});

test/Test-S3DataStore.js

@@ -15,9 +15,7 @@ describe('S3DataStore', function () {
   })
 
   beforeEach(function() {
-    this.server = new Server()
-    this.server.datastore = new S3Store({
-      path: this.storePath,
+    this.datastore = new S3Store({
       bucket: process.env.AWS_BUCKET,
       accessKeyId: process.env.AWS_ACCESS_KEY_ID,
       secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,

test/Test-Server.js

@@ -4,7 +4,9 @@
 const request = require('supertest');
 const assert = require('assert');
 const http = require('http');
-const fs = require('fs');
+
+const should = require('should');
+
 const Server = require('../lib/Server');
 const FileStore = require('../lib/stores/FileStore');
 const DataStore = require('../lib/stores/DataStore');
@@ -18,20 +20,27 @@ const hasHeader = (res, header) => {
 
 describe('Server', () => {
     describe('instantiation', () => {
-        it('datastore setter must require a DataStore subclass', (done) => {
+        it('constructor must require options', () => {
+            assert.throws(() => { new Server(); }, Error);
+            assert.throws(() => { new Server({}); }, Error);
+        });
+
+        it('should accept valid options', () => {
+            assert.doesNotThrow(() => { new Server({ path: '/files' }); });
+            assert.doesNotThrow(() => { new Server({ path: '/files', namingFunction: () => { return "1234"; } }); });
+        });
+
+        it('should throw on invalid namingFunction', () => {
             assert.throws(() => {
-                const server = new Server();
-                server.datastore = {};
+                const server = new Server({ path: '/files', namingFunction: '1234' });
+                server.datastore = new DataStore();
             }, Error);
-            done();
         });
 
         it('setting the DataStore should attach handlers', (done) => {
-            const server = new Server();
+            const server = new Server({ path: '/files' });
             server.handlers.should.be.empty();
-            server.datastore = new DataStore({
-                path: '/test/output',
-            });
+            server.datastore = new DataStore();
             server.handlers.should.have.property('HEAD');
             server.handlers.should.have.property('OPTIONS');
             server.handlers.should.have.property('POST');
@@ -40,13 +49,12 @@ describe('Server', () => {
             done();
         });
     });
+
     describe('listen', () => {
         let server;
         before(() => {
-            server = new Server();
-            server.datastore = new DataStore({
-                path: '/test/output',
-            });
+            server = new Server({ path: '/test/output' });
+            server.datastore = new DataStore();
         });
 
         it('should create an instance of http.Server', (done) => {
@@ -61,10 +69,8 @@ describe('Server', () => {
         let server;
         let listener;
         before(() => {
-            server = new Server();
-            server.datastore = new DataStore({
-                path: '/test/output',
-            });
+            server = new Server({ path: '/test/output' });
+            server.datastore = new DataStore();
 
             server.get('/some_url', (req, res) => {
                 res.writeHead(200);
@@ -96,9 +102,9 @@ describe('Server', () => {
         let server;
         let listener;
         before(() => {
-            server = new Server();
+            server = new Server({ path: '/test/output' });
             server.datastore = new FileStore({
-                path: '/test/output',
+                directory: './test/output',
             });
 
             listener = server.listen();
@@ -136,30 +142,30 @@ describe('Server', () => {
 
         it('POST should require Upload-Length header', (done) => {
             request(listener)
-              .post(server.datastore.path)
+              .post(server.options.path)
               .set('Tus-Resumable', TUS_RESUMABLE)
               .expect(412, {}, done);
         });
 
         it('POST should require non negative Upload-Length number', (done) => {
             request(listener)
-              .post(server.datastore.path)
+              .post(server.options.path)
               .set('Tus-Resumable', TUS_RESUMABLE)
               .set('Upload-Length', -3)
               .expect(412, 'Invalid upload-length\n', done);
         });
 
         it('POST should validate the metadata header', (done) => {
             request(listener)
-              .post(server.datastore.path)
+              .post(server.options.path)
               .set('Tus-Resumable', TUS_RESUMABLE)
               .set('Upload-Metadata', '')
               .expect(412, 'Invalid upload-metadata\n', done);
         });
 
         it('DELETE should return 404 when file does not exist', (done) => {
             request(server.listen())
-                .delete(server.datastore.path + "/123")
+                .delete(server.options.path + "/123")
                 .set('Tus-Resumable', TUS_RESUMABLE)
                 .expect(404, 'The file for this url was not found\n', done);
         });
@@ -168,12 +174,12 @@ describe('Server', () => {
             request(server.listen())
                 .delete("/this/is/wrong/123")
                 .set('Tus-Resumable', TUS_RESUMABLE)
-                .expect(404, 'Invalid path name\n', done);
+                .expect(404, 'The file for this url was not found\n', done);
         });
 
         it('DELETE should return 204 on proper deletion', (done) => {
             request(server.listen())
-                .post(server.datastore.path)
+                .post(server.options.path)
                 .set('Tus-Resumable', TUS_RESUMABLE)
                 .set('Upload-Length', 12345678)
                 .then((res)=>{
@@ -185,7 +191,7 @@ describe('Server', () => {
 
         it('POST should ignore invalid Content-Type header', (done) => {
             request(listener)
-              .post(server.datastore.path)
+              .post(server.options.path)
               .set('Tus-Resumable', TUS_RESUMABLE)
               .set('Upload-Length', 300)
               .set('Upload-Metadata', 'foo aGVsbG8=, bar d29ynGQ=')
@@ -227,9 +233,9 @@ describe('Server', () => {
         let server;
         let listener;
         beforeEach(() => {
-            server = new Server();
+            server = new Server({ path: '/test/output' });
             server.datastore = new FileStore({
-                path: '/test/output',
+                directory: './test/output',
             });
 
             listener = server.listen();
@@ -246,7 +252,7 @@ describe('Server', () => {
             });
 
             request(listener)
-              .post(server.datastore.path)
+              .post(server.options.path)
               .set('Tus-Resumable', TUS_RESUMABLE)
               .set('Upload-Length', 12345678)
               .end((err) => { if(err) done(err) });
@@ -259,10 +265,10 @@ describe('Server', () => {
             });
 
             request(listener)
-              .post(server.datastore.path)
+              .post(server.options.path)
               .set('Tus-Resumable', TUS_RESUMABLE)
               .set('Upload-Length', 12345678)
-              .end((err) => { if(err) done(err) });
+              .end((err) => { if (err) done(err) });
         });
 
         it('should fire when a file is deleted', (done) => {
@@ -272,14 +278,14 @@ describe('Server', () => {
             });
 
             request(server.listen())
-                .post(server.datastore.path)
+                .post(server.options.path)
                 .set('Tus-Resumable', TUS_RESUMABLE)
                 .set('Upload-Length', 12345678)
                 .then((res)=>{
                     request(server.listen())
                         .delete(res.headers.location)
                         .set('Tus-Resumable', TUS_RESUMABLE)
-                        .end((err,res)=>{});
+                        .end((err) => { if (err) done(err) });
                 });
         });
 
@@ -290,7 +296,7 @@ describe('Server', () => {
             });
 
             request(server.listen())
-                .post(server.datastore.path)
+                .post(server.options.path)
                 .set('Tus-Resumable', TUS_RESUMABLE)
                 .set('Upload-Length', Buffer.byteLength('test', 'utf8'))
                 .then((res) => {
@@ -300,7 +306,7 @@ describe('Server', () => {
                         .set('Tus-Resumable', TUS_RESUMABLE)
                         .set('Upload-Offset', 0)
                         .set('Content-Type', 'application/offset+octet-stream')
-                        .end((err,res)=>{});
+                        .end((err) => { if (err) done(err) });
                 })
         });
     })