@vida-global/core 2.4.1 → 2.4.3

package/lib/appDependencies/index.js

@@ -12,6 +12,7 @@ class AppDependencies {
     setDependency(name, dependency) {
         this.#dependencies[name] = dependency;
         this.#defineAccessor(name);
+        this.#defineSingletonAccessor(name);
     }
 
 
@@ -26,6 +27,17 @@ class AppDependencies {
     }
 
 
+    #defineSingletonAccessor(name) {
+        if (Object.getOwnPropertyDescriptor(this, name)) return;
+        if (name in this) return;
+
+        Object.defineProperty(this, name, {
+            configurable: false,
+            get: () => this.get(name)
+        });
+    }
+
+
     // Registering after `installOn` still defines the accessor, so wiring order does not matter.
     // An existing property is left alone: a controller that defines the name itself wins.
     #defineAccessor(name) {

package/lib/server/controllerMixins/renderer.js

@@ -248,13 +248,53 @@ const InstanceMethods = {
         if (this.rendered)    return;
         if (this.isStreaming) return;
 
+        this._response.setHeader('Accept-Ranges', 'bytes');
+        const range = Buffer.isBuffer(body) ? this._requestedByteRange(body.length) : null;
+        if (range?.unsatisfiable) {
+            this._response.status(416);
+            this._response.setHeader('Content-Range', `bytes */${body.length}`);
+            this._send('');
+            this.markRendered();
+            return;
+        }
+
         this._response.setHeader('Content-Type', contentType);
         if (filename) this._response.attachment(filename);
+        if (range) {
+            this._response.status(206);
+            this._response.setHeader('Content-Range', `bytes ${range.start}-${range.end}/${body.length}`);
+            body = body.subarray(range.start, range.end + 1);
+        }
         this._send(body);
         this.markRendered();
     },
 
 
+    // Single-range only: a multi-range request gets the whole body, which media players handle
+    // better than a multipart/byteranges reply.
+    _requestedByteRange(totalBytes) {
+        const header = this._request.headers?.range;
+        if (typeof header !== 'string') return null;
+
+        const match = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
+        if (!match || (!match[1] && !match[2])) return null;
+
+        let start, end;
+        if (!match[1]) {
+            const suffix = Number(match[2]);
+            if (suffix === 0) return { unsatisfiable: true };
+            start = Math.max(0, totalBytes - suffix);
+            end   = totalBytes - 1;
+        } else {
+            start = Number(match[1]);
+            end   = match[2] ? Math.min(Number(match[2]), totalBytes - 1) : totalBytes - 1;
+        }
+
+        if (start >= totalBytes || start > end) return { unsatisfiable: true };
+        return { start, end };
+    },
+
+
     renderFile(filePath, { contentType, cacheControl, maxAge } = {}) {
         if (!filePath) throw new Error('renderFile requires a filePath');
         const resolvedType = contentType || guessContentType(filePath);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vida-global/core",
-    "version": "2.4.1",
+    "version": "2.4.3",
     "description": "Core libraries for supporting Vida development",
     "author": "",
     "license": "ISC",

package/test/appDependencies/appDependencies.test.js

@@ -46,6 +46,44 @@ describe('AppDependencies', () => {
     });
 
 
+    describe('singleton accessors', () => {
+        it ('exposes a registered name as a property on the singleton', () => {
+            const helper = { name: 'helper' };
+
+            AppDependencies.setDependency('singletonHelper', helper);
+
+            expect(AppDependencies.singletonHelper).toBe(helper);
+        });
+
+
+        it ('reads through, so a later replacement is picked up', () => {
+            AppDependencies.setDependency('replacedHelper', 'first');
+
+            AppDependencies.setDependency('replacedHelper', 'second');
+
+            expect(AppDependencies.replacedHelper).toBe('second');
+        });
+
+
+        it ('reads null after a reset', () => {
+            AppDependencies.setDependency('resetHelper', 'something');
+
+            AppDependencies.reset();
+
+            expect(AppDependencies.resetHelper).toBeNull();
+        });
+
+
+        // `get`, `reset`, and friends must survive a hostile dependency name.
+        it ('does not overwrite the singleton API', () => {
+            AppDependencies.setDependency('get', 'not a function');
+
+            expect(typeof AppDependencies.get).toBe('function');
+            expect(AppDependencies.get('get')).toBe('not a function');
+        });
+    });
+
+
     describe('#installOn', () => {
         it ('exposes what was registered before the install as a getter', () => {
             AppDependencies.setDependency('myHelper', 'early');

package/test/server/controllerMixins/renderer.test.js

@@ -758,11 +758,12 @@ describe('VidaServerController', () => {
 
 
         beforeEach(() => {
-            request    = {};
+            request    = { headers: {} };
             response   = {
                 setHeader:  jest.fn(),
                 attachment: jest.fn(),
                 send:       jest.fn(),
+                status:     jest.fn(),
             };
             controller = new FooController(request, response);
         });
@@ -774,6 +775,52 @@ describe('VidaServerController', () => {
             controller.renderBinary(body, { contentType: 'audio/wav' });
 
             expect(response.setHeader).toHaveBeenCalledWith('Content-Type', 'audio/wav');
+            expect(response.setHeader).toHaveBeenCalledWith('Accept-Ranges', 'bytes');
+            expect(response.status).not.toHaveBeenCalled();
+            expect(response.send).toHaveBeenCalledWith(body);
+        });
+
+
+        it.each([
+            ['a bounded range',      'bytes=2-5',  'bytes 2-5/10', '2345'],
+            ['an open-ended range',  'bytes=7-',   'bytes 7-9/10', '789'],
+            ['a suffix range',       'bytes=-3',   'bytes 7-9/10', '789'],
+            ['an overshooting end',  'bytes=8-99', 'bytes 8-9/10', '89'],
+        ])('serves %s as 206 Partial Content', (_label, range, contentRange, slice) => {
+            request.headers.range = range;
+
+            controller.renderBinary(Buffer.from('0123456789'), { contentType: 'audio/wav' });
+
+            expect(response.status).toHaveBeenCalledWith(206);
+            expect(response.setHeader).toHaveBeenCalledWith('Content-Range', contentRange);
+            expect(response.send).toHaveBeenCalledWith(Buffer.from(slice));
+        });
+
+
+        it ('answers an unsatisfiable range with 416 and the total size', () => {
+            request.headers.range = 'bytes=10-';
+
+            controller.renderBinary(Buffer.from('0123456789'), { contentType: 'audio/wav' });
+
+            expect(response.status).toHaveBeenCalledWith(416);
+            expect(response.setHeader).toHaveBeenCalledWith('Content-Range', 'bytes */10');
+            expect(response.send).toHaveBeenCalledWith('');
+            expect(controller.rendered).toBe(true);
+        });
+
+
+        it.each([
+            ['a multi-range request', 'bytes=0-1,5-9'],
+            ['an empty range',        'bytes=-'],
+            ['a non-byte unit',       'items=0-5'],
+            ['garbage',               'garbage'],
+        ])('serves the whole body for %s', (_label, range) => {
+            request.headers.range = range;
+            const body = Buffer.from('0123456789');
+
+            controller.renderBinary(body, { contentType: 'audio/wav' });
+
+            expect(response.status).not.toHaveBeenCalled();
             expect(response.send).toHaveBeenCalledWith(body);
         });