feat(functions): httpsCallable.stream support

.github/workflows/scripts/functions/src/index.ts

@@ -31,3 +31,10 @@ export { fetchAppCheckTokenV2 } from './fetchAppCheckToken';
 export { sendFCM } from './sendFCM';
 
 export { testFetchStream, testFetch } from './vertexaiFunctions';
+
+export {
+  testStreamingCallable,
+  testProgressStream,
+  testComplexDataStream,
+  testStreamWithError,
+} from './testStreamingCallable';

.github/workflows/scripts/functions/src/testStreamingCallable.ts

@@ -0,0 +1,159 @@
+import { onCall, CallableRequest, CallableResponse } from 'firebase-functions/v2/https';
+import { logger } from 'firebase-functions/v2';
+
+/**
+ * Test streaming callable function that sends multiple chunks of data
+ * This function demonstrates Server-Sent Events (SSE) streaming
+ */
+export const testStreamingCallable = onCall(
+  async (
+    req: CallableRequest<{ count?: number; delay?: number }>,
+    response?: CallableResponse<any>,
+  ) => {
+    const count = req.data.count || 5;
+    const delay = req.data.delay || 500;
+
+    logger.info('testStreamingCallable called', { count, delay });
+
+    // Send chunks of data over time
+    for (let i = 0; i < count; i++) {
+      // Wait for the specified delay
+      await new Promise(resolve => setTimeout(resolve, delay));
+
+      if (response) {
+        await response.sendChunk({
+          index: i,
+          message: `Chunk ${i + 1} of ${count}`,
+          timestamp: new Date().toISOString(),
+          data: {
+            value: i * 10,
+            isEven: i % 2 === 0,
+          },
+        });
+      }
+    }
+
+    // Return final result
+    return { totalCount: count, message: 'Stream complete' };
+  },
+);
+
+/**
+ * Test streaming callable that sends progressive updates
+ */
+export const testProgressStream = onCall(
+  async (
+    req: CallableRequest<{ task?: string }>,
+    response?: CallableResponse<any>,
+  ) => {
+    const task = req.data.task || 'Processing';
+
+    logger.info('testProgressStream called', { task });
+
+    const updates = [
+      { progress: 0, status: 'Starting...', task },
+      { progress: 25, status: 'Loading data...', task },
+      { progress: 50, status: 'Processing data...', task },
+      { progress: 75, status: 'Finalizing...', task },
+      { progress: 100, status: 'Complete!', task },
+    ];
+
+    for (const update of updates) {
+      await new Promise(resolve => setTimeout(resolve, 300));
+      if (response) {
+        await response.sendChunk(update);
+      }
+    }
+
+    return { success: true };
+  },
+);
+
+/**
+ * Test streaming with complex data types
+ */
+export const testComplexDataStream = onCall(
+  async (req: CallableRequest, response?: CallableResponse<any>) => {
+    logger.info('testComplexDataStream called');
+
+    const items = [
+      {
+        id: 1,
+        name: 'Item One',
+        tags: ['test', 'streaming', 'firebase'],
+        metadata: {
+          created: new Date().toISOString(),
+          version: '1.0.0',
+        },
+      },
+      {
+        id: 2,
+        name: 'Item Two',
+        tags: ['react-native', 'functions'],
+        metadata: {
+          created: new Date().toISOString(),
+          version: '1.0.1',
+        },
+      },
+      {
+        id: 3,
+        name: 'Item Three',
+        tags: ['cloud', 'streaming'],
+        metadata: {
+          created: new Date().toISOString(),
+          version: '2.0.0',
+        },
+      },
+    ];
+
+    // Stream each item individually
+    for (const item of items) {
+      await new Promise(resolve => setTimeout(resolve, 200));
+      if (response) {
+        await response.sendChunk(item);
+      }
+    }
+
+    // Return summary
+    return {
+      summary: {
+        totalItems: items.length,
+        processedAt: new Date().toISOString(),
+      },
+    };
+  },
+);
+
+/**
+ * Test streaming with error handling
+ */
+export const testStreamWithError = onCall(
+  async (
+    req: CallableRequest<{ shouldError?: boolean; errorAfter?: number }>,
+    response?: CallableResponse<any>,
+  ) => {
+    const shouldError = req.data.shouldError !== false;
+    const errorAfter = req.data.errorAfter || 2;
+
+    logger.info('testStreamWithError called', { shouldError, errorAfter });
+
+    for (let i = 0; i < 5; i++) {
+      if (shouldError && i === errorAfter) {
+        throw new Error('Simulated streaming error after chunk ' + errorAfter);
+      }
+
+      await new Promise(resolve => setTimeout(resolve, 300));
+      if (response) {
+        await response.sendChunk({
+          chunk: i,
+          message: `Processing chunk ${i + 1}`,
+        });
+      }
+    }
+
+    return {
+      success: true,
+      message: 'All chunks processed successfully',
+    };
+  },
+);

jest.setup.ts

@@ -144,6 +144,16 @@ jest.doMock('react-native', () => {
           checkForUpdate: jest.fn(),
           signOutTester: jest.fn(),
         },
+        RNFBFunctionsModule: {
+          httpsCallableStream: jest.fn(),
+          httpsCallableStreamFromUrl: jest.fn(),
+          removeFunctionsStreaming: jest.fn(),
+        },
+        NativeRNFBTurboFunctions: {
+          httpsCallableStream: jest.fn(),
+          httpsCallableStreamFromUrl: jest.fn(),
+          removeFunctionsStreaming: jest.fn(),
+        },
         RNFBCrashlyticsModule: {
           isCrashlyticsCollectionEnabled: false,
           checkForUnsentReports: jest.fn(),