Fix lint errors.

Author: taeold

packages/functions/src/callable.test.ts

@@ -107,9 +107,8 @@ describe('Firebase Functions > Call', () => {
         long: 420
       });
     } catch (err) {
-      console.error(err)
+      console.error(err);
     }
-
   });
 
   it('scalars', async () => {
@@ -325,7 +324,7 @@ describe('Firebase Functions > Stream', () => {
 
   afterEach(() => {
     mockFetch.restore();
-  })
+  });
 
   it('successfully streams data and resolves final result', async () => {
     const mockResponse = new ReadableStream({
@@ -356,6 +355,34 @@ describe('Firebase Functions > Stream', () => {
     expect(await streamResult.data).to.equal('Final Result');
   });
 
+  it('successfully process request chunk with multiple events', async () => {
+    const mockResponse = new ReadableStream({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode('data: {"message":"Hello"}\n\ndata: {"message":"World"}\n'));
+        controller.enqueue(new TextEncoder().encode('data: {"result":"Final Result"}\n'));
+        controller.close();
+      }
+    });
+
+    mockFetch.resolves({
+      body: mockResponse,
+      headers: new Headers({ 'Content-Type': 'text/event-stream' }),
+      status: 200,
+      statusText: 'OK',
+    } as Response);
+
+    const func = httpsCallable<Record<string, any>, string, string>(functions, 'streamTest');
+    const streamResult = await func.stream({});
+
+    const messages: string[] = [];
+    for await (const message of streamResult.stream) {
+      messages.push(message);
+    }
+
+    expect(messages).to.deep.equal(['Hello', 'World']);
+    expect(await streamResult.data).to.equal('Final Result');
+  });
+
   it('handles network errors', async () => {
     mockFetch.rejects(new Error('Network error'));
 
@@ -372,7 +399,7 @@ describe('Firebase Functions > Stream', () => {
       expect((error as FunctionsError).code).to.equal(`${FUNCTIONS_TYPE}/internal`);
     }
     expect(errorThrown).to.be.true;
-    expectError(streamResult.data, "internal", "Internal");
+    await expectError(streamResult.data, "internal", "Internal");
   });
 
   it('handles server-side errors', async () => {
@@ -405,7 +432,7 @@ describe('Firebase Functions > Stream', () => {
     }
 
     expect(errorThrown).to.be.true;
-    expectError(streamResult.data, "invalid-argument", "Invalid input")
+    await expectError(streamResult.data, "invalid-argument", "Invalid input");
   });
 
   it('includes authentication and app check tokens in request headers', async () => {
@@ -497,7 +524,7 @@ describe('Firebase Functions > Stream', () => {
       expect((error as FunctionsError).code).to.equal(`${FUNCTIONS_TYPE}/cancelled`);
     }
     expect(errorThrown).to.be.true;
-    expectError(streamResult.data, "cancelled", "Request was cancelled")
+    await expectError(streamResult.data, "cancelled", "Request was cancelled");
   });
 
   it('aborts during streaming', async () => {
@@ -539,7 +566,7 @@ describe('Firebase Functions > Stream', () => {
       expect((error as FunctionsError).code).to.equal(`${FUNCTIONS_TYPE}/cancelled`);
     }
     expect(messages).to.deep.equal(['First']);
-    expectError(streamResult.data, "cancelled", "Request was cancelled")
+    await expectError(streamResult.data, "cancelled", "Request was cancelled");
   });
 
   it('fails immediately with pre-aborted signal', async () => {
@@ -564,7 +591,7 @@ describe('Firebase Functions > Stream', () => {
       expect((error as FunctionsError).code).to.equal(`${FUNCTIONS_TYPE}/cancelled`);
     }
     expect(errorThrown).to.be.true;
-    expectError(streamResult.data, "cancelled", "Request was cancelled")
+    await expectError(streamResult.data, "cancelled", "Request was cancelled");
   });
 
   it('properly handles AbortSignal.timeout()', async () => {
@@ -589,13 +616,13 @@ describe('Firebase Functions > Stream', () => {
     const streamResult = await func.stream({}, { signal });
 
     try {
-      for await (const message of streamResult.stream) {
+      for await (const _ of streamResult.stream) {
         // Should not execute
       }
       throw new Error('Stream should have timed out');
     } catch (error) {
       expect((error as FunctionsError).code).to.equal(`${FUNCTIONS_TYPE}/cancelled`);
     }
-    expectError(streamResult.data, "cancelled", "Request was cancelled")
+    await expectError(streamResult.data, "cancelled", "Request was cancelled");
   });
 });

packages/functions/src/public-types.ts

@@ -41,10 +41,10 @@ export interface HttpsCallableStreamResult<ResponseData = unknown, StreamData =
  * @param data - Data to be passed to callable function.
  * @public
  */
-export type HttpsCallable<RequestData = unknown, ResponseData = unknown, StreamData = unknown> = {
+export interface HttpsCallable<RequestData = unknown, ResponseData = unknown, StreamData = unknown> {
   (data?: RequestData | null): Promise<HttpsCallableResult<ResponseData>>;
   stream: (data?: RequestData | null, options?: HttpsCallableStreamOptions) => Promise<HttpsCallableStreamResult<ResponseData, StreamData>>;
-};
+}
 
 /**
  * An interface for metadata about how calls should be executed.

packages/functions/src/service.ts

@@ -184,7 +184,7 @@ export function httpsCallable<RequestData, ResponseData, StreamData = unknown>(
   name: string,
   options?: HttpsCallableOptions
 ): HttpsCallable<RequestData, ResponseData, StreamData> {
-  const callable = (data?: RequestData | null) => {
+  const callable = (data?: RequestData | null): Promise<HttpsCallableResult> => {
     return call(functionsInstance, name, data, options || {});
   };
 
@@ -205,7 +205,7 @@ export function httpsCallableFromURL<RequestData, ResponseData, StreamData = unk
   url: string,
   options?: HttpsCallableOptions
 ): HttpsCallable<RequestData, ResponseData, StreamData> {
-  const callable = (data?: RequestData | null) => {
+  const callable = (data?: RequestData | null): Promise<HttpsCallableResult> => {
     return callAtURL(functionsInstance, url, data, options || {});
   };
 
@@ -431,7 +431,7 @@ async function streamAtURL(
     // network error. There's no way to know, since an unhandled error on the
     // backend will fail to set the proper CORS header, and thus will be
     // treated as a network error by fetch.
-    const error = _errorForResponse(0, null)
+    const error = _errorForResponse(0, null);
     return {
       data: Promise.reject(error),
       // Return an empty async iterator
@@ -450,18 +450,18 @@ async function streamAtURL(
   const reader = response.body!.getReader();
   const decoder = new TextDecoder();
 
-  let pendingLines: string[] = [];
+  const pendingLines: string[] = [];
   let buffer = '';
   let resultResolver: (value: unknown) => void;
-  let resultRejecter: (reason: any) => void;
+  let resultRejecter: (reason: unknown) => void;
 
   const resultPromise = new Promise<unknown>((resolve, reject) => {
     resultResolver = resolve;
     resultRejecter = reject;
   });
 
   options?.signal?.addEventListener('abort', () => {
-    reader.cancel();
+    void reader.cancel();
     const error = new FunctionsError(
       'cancelled',
       'Request was cancelled.'
@@ -472,9 +472,9 @@ async function streamAtURL(
   const stream = {
     [Symbol.asyncIterator]() {
 
-      const processLine = (line: string | undefined) => {
+      const processLine = (line: string | undefined): { done: boolean, value: unknown } | null => {
         // ignore all other lines (newline, comments, etc.)
-        if (!line?.startsWith('data: ')) return null;
+        if (!line?.startsWith('data: ')) { return null; }
 
         try {
           const jsonData = JSON.parse(line.slice(6));
@@ -492,7 +492,7 @@ async function streamAtURL(
           }
           return null; // Unrecognize keys. Skip this line.
         } catch (error) {
-          // Not json. Skip this line.
+          return null;
         }
       };
       return {
@@ -502,13 +502,13 @@ async function streamAtURL(
               'cancelled',
               'Request was cancelled.'
             );
-            resultRejecter(error)
+            resultRejecter(error);
             throw error;
           }
 
           while (pendingLines.length > 0) {
             const result = processLine(pendingLines.shift());
-            if (result) return result;
+            if (result) { return result; }
           }
 
           while (true) {
@@ -517,7 +517,7 @@ async function streamAtURL(
             if (done) {
               if (buffer.trim()) {
                 const result = processLine(buffer);
-                if (result) return result;
+                if (result) { return result; }
               }
               return { done: true, value: undefined };
             }
@@ -529,7 +529,7 @@ async function streamAtURL(
 
             if (pendingLines.length > 0) {
               const result = processLine(pendingLines.shift());
-              if (result) return result;
+              if (result) { return result; }
             }
           }
         }
@@ -540,5 +540,5 @@ async function streamAtURL(
   return {
     stream,
     data: resultPromise,
-  }
+  };
 }