feat: conditional firebase services

Author: chrismclarke

.gitignore

@@ -74,7 +74,6 @@ yarn.auto-install
 supabase
 
 # Firebase
-src/environments/firebaseConfig.ts
 firebase.json
 .firebase
 .firebaserc

packages/scripts/src/commands/index.ts

@@ -50,8 +50,12 @@ export const parseCommand = async (cmd: string) => {
 };
 
 // Additional exports for direct consumption
-import { extendDeploymentConfig, generateDeploymentConfig } from "./deployment/common";
-export { extendDeploymentConfig, generateDeploymentConfig };
+import {
+  extendDeploymentConfig,
+  generateDeploymentConfig,
+  loadEncryptedConfig,
+} from "./deployment/common";
+export { extendDeploymentConfig, generateDeploymentConfig, loadEncryptedConfig };
 
 // Run the program directly when called via ts-node (e.g. start script)
 if (isTsNode) {

src/app/app.component.ts

@@ -112,11 +112,8 @@ export class AppComponent {
       this.hackSetDeveloperOptions();
       const isDeveloperMode = this.templateFieldService.getField("user_mode") === false;
       const user = this.userMetaService.userMeta;
-      // Authentication requires verified domain and app ids populated to firebase console
-      // Currently only run on native where specified (but can comment out for testing locally)
-      if (this.appAuthenticationDefaults.enforceLogin && Capacitor.isNativePlatform()) {
-        await this.ensureUserSignedIn();
-      }
+      await this.loadAuthConfig();
+
       if (!user.first_app_open) {
         await this.userMetaService.setUserMeta({ first_app_open: new Date().toISOString() });
       }
@@ -143,16 +140,26 @@ export class AppComponent {
     });
   }
 
-  private async ensureUserSignedIn() {
-    const authUser = await this.authService.getCurrentUser();
-    if (!authUser) {
-      const templatename = this.appAuthenticationDefaults.signInTemplate;
-      const { modal } = await this.templateService.runStandaloneTemplate(templatename, {
-        showCloseButton: false,
-        waitForDismiss: false,
-      });
-      await this.authService.waitForSignInComplete();
-      await modal.dismiss();
+  /**
+   * Authentication requires verified domain and app ids populated to firebase console
+   * Currently only run on native where specified (but can comment out for testing locally)
+   */
+  private async loadAuthConfig() {
+    const { firebase } = environment.deploymentConfig;
+    const { enforceLogin } = this.appAuthenticationDefaults;
+    const ensureLogin = firebase.config && enforceLogin && Capacitor.isNativePlatform();
+    if (ensureLogin) {
+      this.authService.ready();
+      const authUser = await this.authService.getCurrentUser();
+      if (!authUser) {
+        const templatename = this.appAuthenticationDefaults.signInTemplate;
+        const { modal } = await this.templateService.runStandaloneTemplate(templatename, {
+          showCloseButton: false,
+          waitForDismiss: false,
+        });
+        await this.authService.waitForSignInComplete();
+        await modal.dismiss();
+      }
     }
   }
 

src/app/app.module.ts

@@ -34,31 +34,34 @@ export function lottiePlayerFactory() {
   return player;
 }
 
+// Common imports
+const imports = [
+  BrowserModule,
+  BrowserAnimationsModule,
+  IonicModule.forRoot(),
+  AppRoutingModule,
+  HttpClientModule,
+  SharedModule,
+  FormsModule,
+  LottieModule.forRoot({ player: lottiePlayerFactory }),
+  // NOTE CC 2021-11-04 not sure if cache causes issues or not https://github.com/ngx-lottie/ngx-lottie/issues/115
+  // LottieCacheModule.forRoot(),
+  TemplateComponentsModule,
+  TourModule,
+  MatomoModule.forRoot({
+    siteId: environment.analytics.siteId,
+    trackerUrl: environment.analytics.endpoint,
+  }),
+  MatomoRouterModule,
+  ContextMenuModule,
+];
+
+// Deployment-specific imports
+loadFirebaseImports();
+
 @NgModule({
   declarations: [AppComponent],
-  imports: [
-    BrowserModule,
-    BrowserAnimationsModule,
-    IonicModule.forRoot(),
-    AppRoutingModule,
-    HttpClientModule,
-    SharedModule,
-    // Firebase
-    provideFirebaseApp(() => initializeApp(environment.firebaseConfig)),
-    provideAuth(() => getAuth()),
-    FormsModule,
-    LottieModule.forRoot({ player: lottiePlayerFactory }),
-    // NOTE CC 2021-11-04 not sure if cache causes issues or not https://github.com/ngx-lottie/ngx-lottie/issues/115
-    // LottieCacheModule.forRoot(),
-    TemplateComponentsModule,
-    TourModule,
-    MatomoModule.forRoot({
-      siteId: environment.analytics.siteId,
-      trackerUrl: environment.analytics.endpoint,
-    }),
-    MatomoRouterModule,
-    ContextMenuModule,
-  ],
+  imports,
   providers: [
     { provide: RouteReuseStrategy, useClass: IonicRouteStrategy },
     HTTP,
@@ -69,3 +72,32 @@ export function lottiePlayerFactory() {
   bootstrap: [AppComponent],
 })
 export class AppModule {}
+
+/**
+ * Configure app module imports dependent on what firebase features should be enabled
+ */
+function loadFirebaseImports() {
+  const { firebase } = environment.deploymentConfig;
+
+  // Check if any services are enabled, simply return if not
+  const enabledServices = Object.entries(firebase)
+    .filter(([key, v]) => v && v.constructor === {}.constructor && v["enabled"])
+    .map(([key]) => key);
+  if (enabledServices.length === 0) return;
+
+  // Check config exists if services are enabled
+  if (!firebase.config) {
+    console.warn(`[Firebase] config missing, services disabled:\n`, enabledServices.join(", "));
+    return;
+  }
+
+  // Add main firebase initialisation import
+  imports.push(
+    provideFirebaseApp(() => initializeApp(environment.deploymentConfig.firebase.config))
+  );
+
+  // Add feature-dependent imports
+  if (firebase.auth.enabled) {
+    imports.push(provideAuth(() => getAuth()));
+  }
+}

src/app/shared/services/auth/auth.service.ts

@@ -1,8 +1,8 @@
 import { Injectable } from "@angular/core";
-import { Auth } from "@angular/fire/auth";
 import { FirebaseAuthentication, User } from "@capacitor-firebase/authentication";
 import { BehaviorSubject, firstValueFrom } from "rxjs";
 import { filter } from "rxjs/operators";
+import { environment } from "src/environments/environment";
 import { IAppConfig } from "../../model";
 import { AppConfigService } from "../app-config/app-config.service";
 import { SyncServiceBase } from "../syncService.base";
@@ -17,17 +17,23 @@ export class AuthService extends SyncServiceBase {
 
   // include auth import to ensure app registered
   constructor(
-    auth: Auth,
     private appConfigService: AppConfigService,
     private templateActionRegistry: TemplateActionRegistry
   ) {
     super("Auth");
     this.initialise();
   }
   private initialise() {
-    this.subscribeToAppConfigChanges();
-    this.addAuthListeners();
-    this.registerTemplateActionHandlers();
+    const { firebase } = environment.deploymentConfig;
+    if (firebase?.auth?.enabled) {
+      if (!firebase?.config) {
+        console.warn("[Auth Service] cannot initialise, firebase config missing");
+        return;
+      }
+      this.subscribeToAppConfigChanges();
+      this.addAuthListeners();
+      this.registerTemplateActionHandlers();
+    }
   }
 
   /** Return a promise that resolves after a signed in user defined */

src/app/shared/services/error-handler/error-handler.service.ts

@@ -29,14 +29,15 @@ export class ErrorHandlerService extends ErrorHandler {
    * (although workaround required as cannot extend multiple services)
    */
   private async initialise() {
-    const { production, deploymentConfig, firebaseConfig } = environment;
-    if (production && deploymentConfig?.error_logging?.dsn) {
+    const { production, deploymentConfig } = environment;
+    const { error_logging, firebase } = deploymentConfig;
+    if (production && error_logging?.dsn) {
       await this.initialiseSentry();
       this.sentryEnabled = true;
     }
-    if (production && firebaseConfig?.apiKey && Capacitor.isNativePlatform()) {
+    if (production && firebase?.config?.apiKey && Capacitor.isNativePlatform()) {
       // crashlytics initialised in app component so omitted here
-      this.crashlyticsEnabled = true;
+      this.crashlyticsEnabled = firebase.crashlytics.enabled;
     }
     this.initialised = true;
   }