fix: types

Author: exaby73

spec/v2.spec.ts

@@ -1423,8 +1423,8 @@ describe('v2', () => {
     });
 
     describe('callable functions', () => {
-      it('return an error because they are not supported', () => {
-        const cloudFunction = https.onCall((data) => data);
+      it('should return correct data', () => {
+        const cloudFunction = https.onCall((req) => 'hello');
         cloudFunction.__endpoint = {
           platform: 'gcfv2',
           labels: {},
@@ -1434,14 +1434,9 @@ describe('v2', () => {
           region: ['us-west1', 'us-central1'],
         };
 
-        try {
-          const wrappedCF = wrapV2(cloudFunction as any);
-          wrappedCF();
-        } catch (e) {
-          expect(e.message).to.equal(
-            'Wrap function is not available for callableTriggers functions.'
-          );
-        }
+        const wrappedCF = wrapV2(cloudFunction);
+        const result = wrappedCF({} as any);
+        expect(result).equal('hello');
       });
     });
 

src/main.ts

@@ -21,8 +21,7 @@
 // SOFTWARE.
 
 import {
-  CloudFunction as CloudFunctionV1,
-  HttpsFunction,
+  CloudFunction as CloudFunctionV1, HttpsFunction,
   Runnable,
 } from 'firebase-functions';
 
@@ -31,15 +30,15 @@ import {
   CloudEvent,
 } from 'firebase-functions/v2';
 
-import { HttpsFunction as HttpsFunctionV2 } from 'firebase-functions/v2/https';
+import {CallableFunction, HttpsFunction as HttpsFunctionV2} from 'firebase-functions/v2/https';
 
 import { wrapV1, WrappedFunction, WrappedScheduledFunction } from './v1';
 
-import { wrapV2, WrappedV2Function, WrappedV2HttpsFunction } from './v2';
+import {wrapV2, WrappedV2Function, WrappedV2CallableFunction} from './v2';
 
-type HttpsFunctionOrCloudFunctionV1<T, U> = U extends HttpsFunction &
+type HttpsFunctionOrCloudFunctionV1<T, U> = U extends CallableFunction<any, T> &
   Runnable<T>
-  ? HttpsFunction & Runnable<T>
+  ? CallableFunction<any, T> & Runnable<T>
   : CloudFunctionV1<T>;
 
 // Re-exporting V1 (to reduce breakage)
@@ -59,7 +58,7 @@ export { WrappedV2Function } from './v2';
 export function wrap<T>(
   cloudFunction: HttpsFunction & Runnable<T>
 ): WrappedFunction<T, HttpsFunction & Runnable<T>>;
-export function wrap(cloudFunction: HttpsFunctionV2): WrappedV2HttpsFunction;
+export function wrap<T>(cloudFunction: CallableFunction<any, T>): WrappedV2CallableFunction<T>;
 export function wrap<T>(
   cloudFunction: CloudFunctionV1<T>
 ): WrappedScheduledFunction | WrappedFunction<T>;
@@ -72,7 +71,7 @@ export function wrap<T, V extends CloudEvent<unknown>>(
   | WrappedScheduledFunction
   | WrappedFunction<T>
   | WrappedV2Function<V>
-  | WrappedV2HttpsFunction {
+  | WrappedV2CallableFunction<T> {
   if (isV2CloudFunction<V>(cloudFunction)) {
     return wrapV2<V>(cloudFunction as CloudFunctionV2<V>);
   }

src/v2.ts

@@ -20,14 +20,14 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-import { CloudFunction, CloudEvent } from 'firebase-functions/v2';
+import {CloudFunction, CloudEvent} from 'firebase-functions/v2';
 import {
-  HttpsFunction as HttpsV2Function,
-  Request,
+  CallableFunction,
+  CallableRequest
 } from 'firebase-functions/v2/https';
 
-import { generateCombinedCloudEvent } from './cloudevent/generate';
-import { DeepPartial } from './cloudevent/types';
+import {generateCombinedCloudEvent} from './cloudevent/generate';
+import {DeepPartial} from './cloudevent/types';
 import * as express from 'express';
 
 /** A function that can be called with test data and optional override values for {@link CloudEvent}
@@ -37,19 +37,18 @@ export type WrappedV2Function<T extends CloudEvent<unknown>> = (
   cloudEventPartial?: DeepPartial<T | object>
 ) => any | Promise<any>;
 
-export type WrappedV2HttpsFunction = (
-  req: express.Request,
-  res: express.Response
-) => any | Promise<any>;
+export type WrappedV2CallableFunction<T> = (
+  data: CallableRequest,
+) => T | Promise<T>;
 
-function isHttpsV2Function<T extends CloudEvent<unknown>>(
-  cf: CloudFunction<T> | HttpsV2Function
-): cf is HttpsV2Function {
+function isCallableV2Function<T extends CloudEvent<unknown>>(
+  cf: CloudFunction<T> | CallableFunction<any, any>
+): cf is CallableFunction<any, any> {
   return !!cf?.__endpoint?.callableTrigger;
 }
 
 function assertIsCloudFunction<T extends CloudEvent<unknown>>(
-  cf: CloudFunction<T> | HttpsV2Function
+  cf: CloudFunction<T> | CallableFunction<any, any>
 ): asserts cf is CloudFunction<T> {
   if (!('run' in cf) || !cf.run) {
     throw new Error(
@@ -63,11 +62,23 @@ function assertIsCloudFunction<T extends CloudEvent<unknown>>(
  * which can be called in test code.
  */
 export function wrapV2<T extends CloudEvent<unknown>>(
-  cloudFunction: CloudFunction<T> | HttpsV2Function
-): WrappedV2Function<T> | WrappedV2HttpsFunction {
-  if (isHttpsV2Function(cloudFunction)) {
-    return (req: Request, res: express.Response) => {
-      return cloudFunction(req, res);
+  cloudFunction: CloudFunction<T>
+): WrappedV2Function<T>;
+
+/**
+ * Takes a v2 HTTP function to be tested, and returns a {@link WrappedV2HttpsFunction}
+ * which can be called in test code.
+ */
+export function wrapV2(
+  cloudFunction: CallableFunction<any, any>
+): WrappedV2CallableFunction<any>;
+
+export function wrapV2<T extends CloudEvent<unknown>>(
+  cloudFunction: CloudFunction<T> | CallableFunction<any, any>
+): WrappedV2Function<T> | WrappedV2CallableFunction<any> {
+  if (isCallableV2Function(cloudFunction)) {
+    return (req: CallableRequest) => {
+      return cloudFunction.run(req);
     };
   }