feat(upgrade): adjust parse.getMessages signature

Author: gfortaine

src/fetch.ts

@@ -112,7 +112,8 @@ export function fetchEventSource(input: RequestInfo, {
 
                 await onopen(response);
 
-                await getBytes(response.body!, getLines(getMessages(id => {
+                await getBytes(response.body!, getLines(getMessages(onmessage,
+                   id => {
                     if (id) {
                         // store the id and send it back on the next retry:
                         headers[LastEventId] = id;
@@ -122,7 +123,7 @@ export function fetchEventSource(input: RequestInfo, {
                     }
                 }, retry => {
                     retryInterval = retry;
-                }, onmessage)));
+                })));
 
                 onclose?.();
                 dispose();

src/parse.spec.ts

@@ -190,18 +190,18 @@ describe('parse', () => {
         it('happy path', () => {
             // arrange:
             let msgNum = 0;
-            const next = parse.getMessages(id => {
-                expect(id).toEqual('abc');
-            }, retry => {
-                expect(retry).toEqual(42);
-            }, msg => {
+            const next = parse.getMessages(msg => {
                 ++msgNum;
                 expect(msg).toEqual({
                     retry: 42,
                     id: 'abc',
                     event: 'def',
                     data: 'ghi'
                 });
+            }, id => {
+                expect(id).toEqual('abc');
+            }, retry => {
+                expect(retry).toEqual(42);
             });
 
             // act:
@@ -217,18 +217,18 @@ describe('parse', () => {
 
         it('skip unknown fields', () => {
             let msgNum = 0;
-            const next = parse.getMessages(id => {
-                expect(id).toEqual('abc');
-            }, _retry => {
-                fail('retry should not be called');
-            }, msg => {
+            const next = parse.getMessages(msg => {
                 ++msgNum;
                 expect(msg).toEqual({
                     id: 'abc',
                     data: '',
                     event: '',
                     retry: undefined,
                 });
+            }, id => {
+                expect(id).toEqual('abc');
+            }, _retry => {
+                fail('retry should not be called');
             });
 
             // act:
@@ -242,18 +242,18 @@ describe('parse', () => {
 
         it('ignore non-integer retry', () => {
             let msgNum = 0;
-            const next = parse.getMessages(_id => {
-                fail('id should not be called');
-            }, _retry => {
-                fail('retry should not be called');
-            }, msg => {
+            const next = parse.getMessages(msg => {
                 ++msgNum;
                 expect(msg).toEqual({
                     id: '',
                     data: '',
                     event: '',
                     retry: undefined,
                 });
+            }, _id => {
+                fail('id should not be called');
+            }, _retry => {
+                fail('retry should not be called');
             });
 
             // act:
@@ -267,18 +267,18 @@ describe('parse', () => {
         it('skip comment-only messages', () => {
             // arrange:
             let msgNum = 0;
-            const next = parse.getMessages(id => {
-                expect(id).toEqual('123');
-            }, _retry => {
-                fail('retry should not be called');
-            }, msg => {
+            const next = parse.getMessages(msg => {
                 ++msgNum;
                 expect(msg).toEqual({
                     retry: undefined,
                     id: '123',
                     event: 'foo ',
                     data: '',
                 });
+            }, id => {
+                expect(id).toEqual('123');
+            }, _retry => {
+                fail('retry should not be called');
             });
 
             // act:
@@ -295,18 +295,18 @@ describe('parse', () => {
         it('should append data split across multiple lines', () => {
             // arrange:
             let msgNum = 0;
-            const next = parse.getMessages(_id => {
-                fail('id should not be called');
-            }, _retry => {
-                fail('retry should not be called');
-            }, msg => {
+            const next = parse.getMessages(msg => {
                 ++msgNum;
                 expect(msg).toEqual({
                     data: 'YHOO\n+2\n\n10',
                     id: '',
                     event: '',
                     retry: undefined,
                 });
+            }, _id => {
+                fail('id should not be called');
+            }, _retry => {
+                fail('retry should not be called');
             });
 
             // act:
@@ -325,19 +325,19 @@ describe('parse', () => {
             const expectedIds = ['foo', ''];
             let idsIdx = 0;
             let msgNum = 0;
-            const next = parse.getMessages(id => {
-                expect(id).toEqual(expectedIds[idsIdx]);
-                ++idsIdx;
-            }, _retry => {
-                fail('retry should not be called');
-            }, msg => {
+            const next = parse.getMessages(msg => {
                 ++msgNum;
                 expect(msg).toEqual({
                     data: '',
                     id: '',
                     event: '',
                     retry: undefined,
                 });
+            }, id => {
+                expect(id).toEqual(expectedIds[idsIdx]);
+                ++idsIdx;
+            }, _retry => {
+                fail('retry should not be called');
             });
 
             // act:

src/parse.ts

@@ -117,9 +117,9 @@ export function getLines(onLine: (line: Uint8Array, fieldLength: number) => void
  * @returns A function that should be called for each incoming line buffer.
  */
 export function getMessages(
-    onId: (id: string) => void,
-    onRetry: (retry: number) => void,
-    onMessage?: (msg: EventSourceMessage) => void
+    onMessage?: (msg: EventSourceMessage) => void,
+    onId?: (id: string) => void,
+    onRetry?: (retry: number) => void,
 ) {
     let message = newMessage();
     const decoder = new TextDecoder();
@@ -149,12 +149,12 @@ export function getMessages(
                     message.event = value;
                     break;
                 case 'id':
-                    onId(message.id = value);
+                    onId?.(message.id = value);
                     break;
                 case 'retry':
                     const retry = parseInt(value, 10);
                     if (!isNaN(retry)) { // per spec, ignore non-integers
-                        onRetry(message.retry = retry);
+                        onRetry?.(message.retry = retry);
                     }
                     break;
             }