Add AppCheck public API (#23)

* Add AppCheck public API

* Add AppCheck public api unit tests

Author: lahirumaramba

.gitignore

@@ -14,6 +14,7 @@ node_modules/
 # Real key file should not be checked in
 test/resources/key.json
 test/resources/apikey.txt
+test/resources/appid.txt
 
 # Release tarballs should not be checked in
 firebase-admin-*.tgz

etc/firebase-admin.api.md

@@ -15,6 +15,8 @@ export function app(name?: string): app.App;
 // @public (undocumented)
 export namespace app {
     export interface App {
+        // (undocumented)
+        appCheck(): appCheck.AppCheck;
         // (undocumented)
         auth(): auth.Auth;
         // (undocumented)
@@ -41,6 +43,22 @@ export namespace app {
     }
 }
 
+// @public
+export function appCheck(app?: app.App): appCheck.AppCheck;
+
+// @public (undocumented)
+export namespace appCheck {
+    export interface AppCheck {
+        // (undocumented)
+        app: app.App;
+        createToken(appId: string): Promise<AppCheckToken>;
+    }
+    export interface AppCheckToken {
+        token: string;
+        ttlMillis: number;
+    }
+}
+
 // @public
 export interface AppOptions {
     credential?: credential.Credential;

src/firebase-app.ts

@@ -35,6 +35,7 @@ import { InstanceId } from './instance-id/instance-id';
 import { ProjectManagement } from './project-management/project-management';
 import { SecurityRules } from './security-rules/security-rules';
 import { RemoteConfig } from './remote-config/remote-config';
+import { AppCheck } from './app-check/app-check';
 
 import Credential = credential.Credential;
 import Database = database.Database;
@@ -318,6 +319,18 @@ export class FirebaseApp implements app.App {
     });
   }
 
+  /**
+   * Returns the AppCheck service instance associated with this app.
+   *
+   * @return The AppCheck service instance of this app.
+   */
+  public appCheck(): AppCheck {
+    return this.ensureService_('appCheck', () => {
+      const appCheckService: typeof AppCheck = require('./app-check/app-check').AppCheck;
+      return new appCheckService(this);
+    });
+  }
+
   /**
    * Returns the name of the FirebaseApp instance.
    *

src/firebase-namespace-api.ts

@@ -15,6 +15,7 @@
  */
 
 import { Agent } from 'http';
+import { appCheck } from './app-check/index';
 import { auth } from './auth/index';
 import { credential } from './credential/index';
 import { database } from './database/index';
@@ -222,6 +223,7 @@ export namespace app {
      */
     options: AppOptions;
 
+    appCheck(): appCheck.AppCheck;
     auth(): auth.Auth;
     database(url?: string): database.Database;
     firestore(): firestore.Firestore;

src/firebase-namespace.d.ts

@@ -16,6 +16,7 @@
 
 export * from './credential/index';
 export * from './firebase-namespace-api';
+export * from './app-check/index';
 export * from './auth/index';
 export * from './database/index';
 export * from './firestore/index';

src/firebase-namespace.ts

@@ -23,6 +23,7 @@ import { FirebaseApp } from './firebase-app';
 import { cert, refreshToken, applicationDefault } from './credential/credential';
 import { getApplicationDefault } from './credential/credential-internal';
 
+import { appCheck } from './app-check/index';
 import { auth } from './auth/index';
 import { database } from './database/index';
 import { firestore } from './firestore/index';
@@ -38,6 +39,7 @@ import * as validator from './utils/validator';
 import { getSdkVersion } from './utils/index';
 
 import App = app.App;
+import AppCheck = appCheck.AppCheck;
 import Auth = auth.Auth;
 import Database = database.Database;
 import Firestore = firestore.Firestore;
@@ -357,6 +359,18 @@ export class FirebaseNamespace {
     return Object.assign(fn, { RemoteConfig: remoteConfig });
   }
 
+  /**
+   * Gets the `AppCheck` service namespace. The returned namespace can be used to get the
+   * `AppCheck` service for the default app or an explicitly specified app.
+   */
+  get appCheck(): FirebaseServiceNamespace<AppCheck> {
+    const fn: FirebaseServiceNamespace<AppCheck> = (app?: App) => {
+      return this.ensureApp(app).appCheck();
+    };
+    const appCheck = require('./app-check/app-check').AppCheck;
+    return Object.assign(fn, { AppCheck: appCheck });
+  }
+
   // TODO: Change the return types to app.App in the following methods.
 
   /**

test/integration/app-check.spec.ts

@@ -0,0 +1,73 @@
+/*!
+ * Copyright 2021 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 * as _ from 'lodash';
+import * as admin from '../../lib/index';
+import * as chai from 'chai';
+import * as chaiAsPromised from 'chai-as-promised';
+import fs = require('fs');
+import path = require('path');
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const chalk = require('chalk');
+
+chai.should();
+chai.use(chaiAsPromised);
+
+const expect = chai.expect;
+
+let appId: string;
+
+describe('admin.appCheck', () => {
+  before(async () => {
+    try {
+      appId = fs.readFileSync(path.join(__dirname, '../resources/appId.txt')).toString().trim();
+    } catch (error) {
+      console.log(chalk.yellow(
+        'Unable to find an an App ID. Skipping tests that require a valid App ID.',
+        error,
+      ));
+    }
+  });
+
+  describe('createToken', () => {
+    it('should succeed with a vaild token', function() {
+      if (!appId) {
+        this.skip();
+      }
+      return admin.appCheck().createToken(appId as string)
+        .then((token) => {
+          expect(token).to.have.keys(['token', 'ttlMillis']);
+          expect(token.token).to.be.a('string').and.to.not.be.empty;
+          expect(token.ttlMillis).to.be.a('number');
+        });
+    });
+
+    it('should propagate API errors', () => {
+      // rejects with invalid-argument when appId is incorrect
+      return admin.appCheck().createToken('incorrect-app-id')
+        .should.eventually.be.rejected.and.have.property('code', 'app-check/invalid-argument');
+    });
+
+    const invalidAppIds = ['', null, NaN, 0, 1, true, false, [], {}, { a: 1 }, _.noop];
+    invalidAppIds.forEach((invalidAppId) => {
+      it(`should throw given an invalid appId: ${JSON.stringify(invalidAppId)}`, () => {
+        expect(() => admin.appCheck().createToken(invalidAppId as any))
+          .to.throw('appId` must be a non-empty string.');
+      });
+    });
+  });
+});

test/unit/firebase-app.spec.ts

@@ -41,6 +41,7 @@ import { instanceId } from '../../src/instance-id/index';
 import { projectManagement } from '../../src/project-management/index';
 import { securityRules } from '../../src/security-rules/index';
 import { remoteConfig } from '../../src/remote-config/index';
+import { appCheck } from '../../src/app-check/index';
 import { FirebaseAppError, AppErrorCodes } from '../../src/utils/error';
 
 import Auth = auth.Auth;
@@ -53,6 +54,7 @@ import InstanceId = instanceId.InstanceId;
 import ProjectManagement = projectManagement.ProjectManagement;
 import SecurityRules = securityRules.SecurityRules;
 import RemoteConfig = remoteConfig.RemoteConfig;
+import AppCheck = appCheck.AppCheck;
 
 chai.should();
 chai.use(sinonChai);
@@ -669,6 +671,32 @@ describe('FirebaseApp', () => {
     });
   });
 
+  describe('appCheck()', () => {
+    it('should throw if the app has already been deleted', () => {
+      const app = firebaseNamespace.initializeApp(mocks.appOptions, mocks.appName);
+
+      return app.delete().then(() => {
+        expect(() => {
+          return app.appCheck();
+        }).to.throw(`Firebase app named "${mocks.appName}" has already been deleted.`);
+      });
+    });
+
+    it('should return the AppCheck client', () => {
+      const app = firebaseNamespace.initializeApp(mocks.appOptions, mocks.appName);
+
+      const appCheck: AppCheck = app.appCheck();
+      expect(appCheck).to.not.be.null;
+    });
+
+    it('should return a cached version of AppCheck on subsequent calls', () => {
+      const app = firebaseNamespace.initializeApp(mocks.appOptions, mocks.appName);
+      const service1: AppCheck = app.appCheck();
+      const service2: AppCheck = app.appCheck();
+      expect(service1).to.equal(service2);
+    });
+  });
+
   describe('INTERNAL.getToken()', () => {
 
     it('throws a custom credential implementation which returns invalid access tokens', () => {

test/unit/firebase-namespace.spec.ts

@@ -56,7 +56,9 @@ import { instanceId } from '../../src/instance-id/index';
 import { projectManagement } from '../../src/project-management/index';
 import { securityRules } from '../../src/security-rules/index';
 import { remoteConfig } from '../../src/remote-config/index';
+import { appCheck } from '../../src/app-check/index';
 
+import { AppCheck as AppCheckImpl } from '../../src/app-check/app-check';
 import { Auth as AuthImpl } from '../../src/auth/auth';
 import { InstanceId as InstanceIdImpl } from '../../src/instance-id/instance-id';
 import { MachineLearning as MachineLearningImpl } from '../../src/machine-learning/machine-learning';
@@ -67,6 +69,7 @@ import { SecurityRules as SecurityRulesImpl } from '../../src/security-rules/sec
 import { Storage as StorageImpl } from '../../src/storage/storage';
 
 import App = app.App;
+import AppCheck = appCheck.AppCheck;
 import Auth = auth.Auth;
 import Database = database.Database;
 import Firestore = firestore.Firestore;
@@ -759,4 +762,42 @@ describe('FirebaseNamespace', () => {
       expect(service1).to.equal(service2);
     });
   });
+
+  describe('#appCheck()', () => {
+    it('should throw when called before initializing an app', () => {
+      expect(() => {
+        firebaseNamespace.appCheck();
+      }).to.throw(DEFAULT_APP_NOT_FOUND);
+    });
+
+    it('should throw when default app is not initialized', () => {
+      firebaseNamespace.initializeApp(mocks.appOptions, 'testApp');
+      expect(() => {
+        firebaseNamespace.appCheck();
+      }).to.throw(DEFAULT_APP_NOT_FOUND);
+    });
+
+    it('should return a valid namespace when the default app is initialized', () => {
+      const app: App = firebaseNamespace.initializeApp(mocks.appOptions);
+      const fac: AppCheck = firebaseNamespace.appCheck();
+      expect(fac.app).to.be.deep.equal(app);
+    });
+
+    it('should return a valid namespace when the named app is initialized', () => {
+      const app: App = firebaseNamespace.initializeApp(mocks.appOptions, 'testApp');
+      const fac: AppCheck = firebaseNamespace.appCheck(app);
+      expect(fac.app).to.be.deep.equal(app);
+    });
+
+    it('should return a reference to AppCheck type', () => {
+      expect(firebaseNamespace.appCheck.AppCheck).to.be.deep.equal(AppCheckImpl);
+    });
+
+    it('should return a cached version of AppCheck on subsequent calls', () => {
+      firebaseNamespace.initializeApp(mocks.appOptions);
+      const service1: AppCheck = firebaseNamespace.appCheck();
+      const service2: AppCheck = firebaseNamespace.appCheck();
+      expect(service1).to.equal(service2);
+    });
+  });
 });

test/unit/firebase.spec.ts

@@ -235,6 +235,21 @@ describe('Firebase', () => {
     });
   });
 
+  describe('#appCheck', () => {
+    it('should throw if the app has not been initialized', () => {
+      expect(() => {
+        return firebaseAdmin.appCheck();
+      }).to.throw('The default Firebase app does not exist.');
+    });
+
+    it('should return the appCheck service', () => {
+      firebaseAdmin.initializeApp(mocks.appOptions);
+      expect(() => {
+        return firebaseAdmin.appCheck();
+      }).not.to.throw();
+    });
+  });
+
   describe('#storage', () => {
     it('should throw if the app has not be initialized', () => {
       expect(() => {