Add custom domain support to callable functions

packages/functions/index.ts

@@ -32,6 +32,6 @@ declare module '@firebase/app-types' {
     };
   }
   interface FirebaseApp {
-    functions?(region?: string): types.FirebaseFunctions;
+    functions?(regionOrCustomDomain?: string): types.FirebaseFunctions;
   }
 }

packages/functions/src/api/service.ts

@@ -86,17 +86,21 @@ export class Service implements FirebaseFunctions, FirebaseService {
   private emulatorOrigin: string | null = null;
   private cancelAllRequests: Promise<void>;
   private deleteService!: () => void;
+  private region: string;
+  private customDomain: string | null = null;
 
   /**
-   * Creates a new Functions service for the given app and (optional) region.
+   * Creates a new Functions service for the given app and (optional) region or custom domain.
    * @param app_ The FirebaseApp to use.
-   * @param region_ The region to call functions in.
+   * @param regionOrCustomDomain_ one of:
+   *   a) A region to call functions from, such as us-central1
+   *   b) A custom domain to use as a functions prefix, such as https://mydomain.com
    */
   constructor(
     private app_: FirebaseApp,
     authProvider: Provider<FirebaseAuthInternalName>,
     messagingProvider: Provider<FirebaseMessagingName>,
-    private region_: string = 'us-central1',
+    regionOrCustomDomain_: string = 'us-central1',
     readonly fetchImpl: typeof fetch
   ) {
     this.contextProvider = new ContextProvider(authProvider, messagingProvider);
@@ -106,6 +110,15 @@ export class Service implements FirebaseFunctions, FirebaseService {
         return resolve();
       };
     });
+
+    // Resolve the region or custom domain overload by attempting to parse it.
+    try {
+      const url = new URL(regionOrCustomDomain_);
+      this.customDomain = url.origin;
+      this.region = 'us-central1';
+    } catch (e) {
+      this.region = regionOrCustomDomain_;
+    }
   }
 
   get app(): FirebaseApp {
@@ -124,11 +137,16 @@ export class Service implements FirebaseFunctions, FirebaseService {
    */
   _url(name: string): string {
     const projectId = this.app_.options.projectId;
-    const region = this.region_;
+    const region = this.region;
     if (this.emulatorOrigin !== null) {
       const origin = this.emulatorOrigin;
       return `${origin}/${projectId}/${region}/${name}`;
     }
+
+    if (this.customDomain !== null) {
+      return `${this.customDomain}/${name}`;
+    }
+
     return `https://${region}-${projectId}.cloudfunctions.net/${name}`;
   }
 

packages/functions/src/config.ts

@@ -37,14 +37,14 @@ export function registerFunctions(
     Functions: Service
   };
 
-  function factory(container: ComponentContainer, region?: string): Service {
+  function factory(container: ComponentContainer, regionOrCustomDomain?: string): Service {
     // Dependencies
     const app = container.getProvider('app').getImmediate();
     const authProvider = container.getProvider('auth-internal');
     const messagingProvider = container.getProvider('messaging');
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return new Service(app, authProvider, messagingProvider, region, fetchImpl);
+    return new Service(app, authProvider, messagingProvider, regionOrCustomDomain, fetchImpl);
   }
   instance.INTERNAL.registerComponent(
     new Component(FUNCTIONS_TYPE, factory, ComponentType.PUBLIC)

packages/functions/test/service.test.ts

@@ -40,6 +40,31 @@ describe('Firebase Functions > Service', () => {
         'http://localhost:5005/my-project/us-central1/foo'
       );
     });
+
+    it('can use custom region', () => {
+      const customRegionService = createTestService(app, 'us-west2');     
+      assert.equal(
+        customRegionService._url('foo'),
+        'https://us-west2-my-project.cloudfunctions.net/foo'
+      );
+    });
+
+    it('can use custom domain', () => {
+      const customDomainService = createTestService(app, 'https://mydomain.com');
+      assert.equal(
+        customDomainService._url('foo'),
+        'https://mydomain.com/foo'
+      );
+    });
+
+    it('prefers emulator to custom domain', () => {
+      const customDomainService = createTestService(app, 'https://mydomain.com');
+      customDomainService.useFunctionsEmulator('http://localhost:5005');
+      assert.equal(
+        customDomainService._url('foo'),
+        'http://localhost:5005/my-project/us-central1/foo'
+      );
+    });
   });
 
   describe('custom region constructor', () => {

packages/functions/test/utils.ts

@@ -43,7 +43,7 @@ export function makeFakeApp(options: FirebaseOptions = {}): FirebaseApp {
 
 export function createTestService(
   app: FirebaseApp,
-  region?: string,
+  regionOrCustomDomain?: string,
   authProvider = new Provider<FirebaseAuthInternalName>(
     'auth-internal',
     new ComponentContainer('test')
@@ -59,7 +59,7 @@ export function createTestService(
     app,
     authProvider,
     messagingProvider,
-    region,
+    regionOrCustomDomain,
     fetchImpl
   );
   const useEmulator = !!process.env.FIREBASE_FUNCTIONS_EMULATOR_ORIGIN;