feat(functions): httpsCallable.stream support

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

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

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

@@ -0,0 +1,205 @@
+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',
+    };
+  },
+);
+
+/**
+ * Test streaming callable that returns the type of data sent
+ * Similar to Dart's testStreamResponse - sends back the type of input data
+ */
+export const testStreamResponse = onCall(
+  async (req: CallableRequest<any>, response?: CallableResponse<any>) => {
+    logger.info('testStreamResponse called', { data: req.data });
+
+    // Determine the type of the input data
+    let partialData: string;
+    if (req.data === null || req.data === undefined) {
+      partialData = 'null';
+    } else if (typeof req.data === 'string') {
+      partialData = 'string';
+    } else if (typeof req.data === 'number') {
+      partialData = 'number';
+    } else if (typeof req.data === 'boolean') {
+      partialData = 'boolean';
+    } else if (Array.isArray(req.data)) {
+      partialData = 'array';
+    } else if (typeof req.data === 'object') {
+      // For deep maps, check if it has the expected structure
+      if (req.data.type === 'deepMap' && req.data.inputData) {
+        partialData = req.data.inputData;
+      } else {
+        partialData = 'object';
+      }
+    } else {
+      partialData = 'unknown';
+    }
+
+    // Send chunk with the type information
+    if (response) {
+      await response.sendChunk({
+        partialData,
+      });
+    }
+
+    // Return final result
+    return {
+      partialData,
+      type: typeof req.data,
+    };
+  },
+);

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(),

packages/functions/RNFBFunctions.podspec

@@ -27,10 +27,29 @@ Pod::Spec.new do |s|
   s.ios.deployment_target = firebase_ios_target
   s.macos.deployment_target = firebase_macos_target
   s.tvos.deployment_target = firebase_tvos_target
+  s.swift_version = '5.0'
+  # Exclude Swift from source_files to avoid C++ dependency scanner issues
+  # Swift files must be added via Podfile post_install hook (see README or Podfile example)
+  # This is required because CocoaPods doesn't support automatic hooks from podspecs
   s.source_files        = 'ios/**/*.{h,m,mm,cpp}'
   s.exclude_files       = 'ios/generated/RCTThirdPartyComponentsProvider.*', 'ios/generated/RCTAppDependencyProvider.*', 'ios/generated/RCTModuleProviders.*', 'ios/generated/RCTModulesConformingToProtocolsProvider.*', 'ios/generated/RCTUnstableModulesRequiringMainQueueSetupProvider.*'
+
+  # Preserve Swift files so they're available for the Podfile hook
+  s.preserve_paths = 'ios/**/*.swift'
+
   # Turbo modules require these compiler flags
-  s.compiler_flags      = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -DFOLLY_CFG_NO_COROUTINES=1'
+  s.compiler_flags      = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -DFOLLY_CFG_NO_COROUTINES=1 -std=c++20'
+  # Swift requires modules to be enabled, so we keep CLANG_ENABLE_MODULES=YES
+  # Only disable explicit modules to avoid libclang.dylib warnings
+  # C++ standard library headers should be found via the C++20 standard setting
+  s.pod_target_xcconfig = {
+    'CLANG_CXX_LIBRARY' => 'libc++',
+    'CLANG_CXX_LANGUAGE_STANDARD' => 'c++20',
+    'CLANG_ENABLE_MODULES' => 'YES',
+    'CLANG_ENABLE_MODULES_EXPLICIT' => 'NO',
+    'OTHER_CPLUSPLUSFLAGS' => '$(inherited) -DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -DFOLLY_CFG_NO_COROUTINES=1 -std=c++20',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
+  }
 
   # React Native dependencies
   s.dependency          'React-Core'