Merge and squash platform updates

Author: hsubox76

.vscode/settings.json

@@ -9,5 +9,6 @@
     // Exclude installed dependencies from searches too
     "**/node_modules": true
   },
-  "typescript.tsdk": "node_modules/typescript/lib"
+  "typescript.tsdk": "node_modules/typescript/lib",
+  "eslint.enable": true
 }

config/.eslintrc.json

@@ -24,6 +24,18 @@
                 "no-unused-expressions": "off",
                 "@typescript-eslint/no-explicit-any": "off"
             }
+        },
+        {
+            "files": "rollup.config.js",
+            "rules": {
+                "import/no-default-export": "off",
+                "import/no-extraneous-dependencies": [
+                    "error",
+                    {
+                        "devDependencies": true
+                    }
+                ]
+            }
         }
     ],
     "rules": {

config/tsconfig.base.json

@@ -17,6 +17,7 @@
     ],
     "module": "ES2015",
     "moduleResolution": "node",
+    "resolveJsonModule": true,
     "sourceMap": true,
     "target": "es5",
     "typeRoots": [

packages/analytics/index.ts

@@ -57,6 +57,8 @@ export function registerAnalytics(instance: _FirebaseNamespace): void {
     new Component('analytics-internal', internalFactory, ComponentType.PRIVATE)
   );
 
+  instance.INTERNAL.registerVersionComponent(ANALYTICS_TYPE, version);
+
   function internalFactory(
     container: ComponentContainer
   ): FirebaseAnalyticsInternal {
@@ -88,3 +90,11 @@ declare module '@firebase/app-types' {
     analytics(): FirebaseAnalytics;
   }
 }
+
+declare module '@firebase/component' {
+  interface ComponentContainer {
+    getProvider(name: typeof ANALYTICS_TYPE): Provider<FirebaseAnalytics>;
+  }
+
+  interface Provider<T> {}
+}

packages/analytics/package.json

@@ -45,6 +45,7 @@
     "rollup-plugin-commonjs": "10.1.0",
     "rollup-plugin-json": "4.0.0",
     "rollup-plugin-node-resolve": "5.2.0",
+    "rollup-plugin-typescript2": "0.24.3",
     "rollup-plugin-uglify": "6.0.3",
     "sinon": "7.5.0",
     "sinon-chai": "3.3.0",

packages/app-types/private.d.ts

@@ -56,6 +56,10 @@ export interface FirebaseServiceFactory {
   ): FirebaseService;
 }
 
+export interface PlatformLoggerService {
+  getPlatformInfoString(): string;
+}
+
 /**
  * All ServiceNamespaces extend from FirebaseServiceNamespace
  */
@@ -107,6 +111,11 @@ export interface _FirebaseNamespace extends FirebaseNamespace {
       component: Component
     ): FirebaseServiceNamespace<FirebaseService> | null;
 
+    registerVersionComponent(
+      library: string,
+      version: string
+    ): FirebaseServiceNamespace<FirebaseService> | null;
+
     /**
      * Just used for testing to start from a fresh namespace.
      */

packages/app/src/constants.ts

@@ -16,3 +16,17 @@
  */
 
 export const DEFAULT_ENTRY_NAME = '[DEFAULT]';
+
+export const platformLogString: { [key: string]: string } = {
+  'firebase': 'fire-js',
+  'app': 'fire-core',
+  'analytics': 'fire-analytics',
+  'auth': 'fire-auth',
+  'database': 'fire-rtdb',
+  'functions': 'fire-fn',
+  'messaging': 'fire-fcm',
+  'performance': 'fire-perf',
+  'remote-config': 'fire-rc',
+  'storage': 'fire-gcs',
+  'firestore': 'fire-fst'
+};

packages/app/src/firebaseApp.ts

@@ -35,6 +35,10 @@ import {
 import { AppError, ERROR_FACTORY } from './errors';
 import { DEFAULT_ENTRY_NAME } from './constants';
 import { logger } from './logger';
+import { PlatformLoggerService } from './platformLoggerService';
+import { VersionService } from './version-service';
+
+import { version } from '../package.json';
 
 /**
  * Global context object for a collection of services using
@@ -60,6 +64,20 @@ export class FirebaseAppImpl implements FirebaseApp {
 
     // add itself to container
     this._addComponent(new Component('app', () => this, ComponentType.PUBLIC));
+    this._addComponent(
+      new Component(
+        'platform-logger',
+        container => new PlatformLoggerService(container),
+        ComponentType.PRIVATE
+      )
+    );
+    this._addComponent(
+      new Component(
+        'app-version',
+        () => new VersionService('app', version),
+        ComponentType.VERSION
+      )
+    );
     // populate ComponentContainer with existing components
     for (const component of this.firebase_.INTERNAL.components.values()) {
       this._addComponent(component);

packages/app/src/firebaseNamespaceCore.ts

@@ -35,6 +35,7 @@ import { DEFAULT_ENTRY_NAME } from './constants';
 import { version } from '../../firebase/package.json';
 import { logger } from './logger';
 import { Component, ComponentType } from '@firebase/component';
+import { VersionService } from './version-service';
 
 /**
  * Because auth can't share code with other components, we attach the utility functions
@@ -64,6 +65,7 @@ export function createFirebaseNamespaceCore(
     SDK_VERSION: version,
     INTERNAL: {
       registerComponent,
+      registerVersionComponent,
       removeApp,
       components,
       useAsService
@@ -234,6 +236,22 @@ export function createFirebaseNamespaceCore(
       : null;
   }
 
+
+function registerVersionComponent(
+  library: string,
+  version: string
+): FirebaseServiceNamespace<FirebaseService> | null {
+  return registerComponent(
+    new Component(
+      `${library}-version`,
+      () => {
+        return new VersionService(library, version);
+      },
+      ComponentType.VERSION
+    )
+  );
+    }
+
   // Map the requested service to a registered service name
   // (used to map auth to serverAuth service when needed).
   function useAsService(app: FirebaseApp, name: string): string | null {

packages/app/src/platformLoggerService.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2019 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ComponentContainer, ComponentType } from '@firebase/component';
+import { VersionService } from './version-service';
+import { platformLogString } from './constants';
+
+export class PlatformLoggerService {
+  constructor(private container: ComponentContainer) {}
+  // In initial implementation, this will be called by installations on
+  // auth token refresh, and installations will send this string.
+  getPlatformInfoString(): string {
+    const providers = this.container.getProviders();
+    // Loop through providers and get library/version pairs from any that are
+    // version components.
+    return providers
+      .map(provider => {
+        const service = provider.getImmediate();
+        const component = provider.getComponent();
+        if (service && component && component.type === ComponentType.VERSION) {
+          const platformString =
+            platformLogString[(service as VersionService).library] ||
+            (service as VersionService).library;
+          return `${platformString}/${(service as VersionService).version}`;
+        } else {
+          return null;
+        }
+      })
+      .filter((logString: string | null) => logString)
+      .join(' ');
+  }
+}

packages/app/src/version-service.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2019 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export class VersionService {
+  constructor(readonly library: string, readonly version: string) {}
+}

packages/app/test/platformLogger.test.ts

@@ -0,0 +1,105 @@
+/**
+ * @license
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { FirebaseNamespace } from '@firebase/app-types';
+import { _FirebaseApp, _FirebaseNamespace } from '@firebase/app-types/private';
+import { createFirebaseNamespace } from '../src/firebaseNamespace';
+import { expect } from 'chai';
+import './setup';
+import { PlatformLoggerService } from '../src/platformLoggerService';
+import {
+  Component,
+  ComponentType,
+  ComponentContainer
+} from '@firebase/component';
+import { VersionService } from '../src/version-service';
+
+describe('Platform Logger Service Unit Tests', () => {
+  it(`logs core version`, () => {
+    const container = new ComponentContainer('testContainer');
+    container.addComponent(
+      new Component(
+        'comp1',
+        () => new VersionService('comp1', '1.2.3'),
+        ComponentType.VERSION
+      )
+    );
+    container.addComponent(
+      new Component(
+        'comp2',
+        () => new VersionService('comp2', '3.02.01'),
+        ComponentType.VERSION
+      )
+    );
+    const platformLoggerService = new PlatformLoggerService(container);
+    const platformInfoString = platformLoggerService.getPlatformInfoString();
+    expect(platformInfoString).to.include('comp1/1.2.3');
+    expect(platformInfoString).to.include('comp2/3.02.01');
+  });
+});
+
+describe('Platform Logger Service Integration Tests', () => {
+  let firebase: FirebaseNamespace;
+
+  beforeEach(() => {
+    firebase = createFirebaseNamespace();
+  });
+
+  it(`logs core version`, () => {
+    firebase.initializeApp({});
+    (firebase as _FirebaseNamespace).INTERNAL.registerComponent(
+      new Component(
+        'test',
+        async (container: ComponentContainer) => {
+          const platformLoggerProvider = container.getProvider(
+            'platform-logger'
+          );
+          const platformLogger = (await platformLoggerProvider.get()) as PlatformLoggerService;
+          const platformInfoString = platformLogger.getPlatformInfoString();
+          expect(platformInfoString).to.include('fire-core');
+          return {};
+        },
+        ComponentType.PUBLIC
+      )
+    );
+    (firebase as any).test();
+  });
+
+  it(`logs other components' versions`, () => {
+    firebase.initializeApp({});
+    (firebase as _FirebaseNamespace).INTERNAL.registerVersionComponent(
+      'analytics',
+      '1.2.3'
+    );
+    (firebase as _FirebaseNamespace).INTERNAL.registerComponent(
+      new Component(
+        'test',
+        async (container: ComponentContainer) => {
+          const platformLoggerProvider = container.getProvider(
+            'platform-logger'
+          );
+          const platformLogger = (await platformLoggerProvider.get()) as PlatformLoggerService;
+          const platformInfoString = platformLogger.getPlatformInfoString();
+          expect(platformInfoString).to.include('fire-analytics/1.2.3');
+          return {};
+        },
+        ComponentType.PUBLIC
+      )
+    );
+    (firebase as any).test();
+  });
+});

packages/component/src/provider.ts

@@ -100,7 +100,6 @@ export class Provider<T extends Name> {
         }
         throw Error(`Service ${this.name} is not available`);
       }
-
       return instance;
     } catch (e) {
       if (optional) {
@@ -111,6 +110,10 @@ export class Provider<T extends Name> {
     }
   }
 
+  getComponent(): Component<T> | null {
+    return this.component;
+  }
+
   setComponent(component: Component<T>): void {
     if (component.name !== this.name) {
       throw Error(

packages/component/src/types.ts

@@ -32,7 +32,8 @@ export const enum InstantiationMode {
  */
 export const enum ComponentType {
   PUBLIC = 'PUBLIC',
-  PRIVATE = 'PRIVATE'
+  PRIVATE = 'PRIVATE',
+  VERSION = 'VERSION'
 }
 
 /**

packages/firebase/app/index.ts

@@ -16,4 +16,11 @@
  */
 
 import firebase from '@firebase/app';
+import { _FirebaseNamespace } from '@firebase/app-types/private';
+
+(firebase as _FirebaseNamespace).INTERNAL.registerVersionComponent(
+  'firebase',
+  firebase.SDK_VERSION
+);
+
 export default firebase;