Google Cloud Storage API [WIP] (#47)

* Adding the GCS API

* Fixing dependency declaration

* Integration tests for GCS API

* Updating the namespace decl

* Cleaning up GCS integration test

* Cleaned up integration test

* Deferring the import to GCS, and custom handling the import error

* Removing the check for non existing buckets

* Throwing an error if the credential is not supported

* Fixing some lint errors

* Adding GCS lib as a dependency

* Adding GCS lib as a dependency

* Added GCS typescript definitions

* Adding a new test case; Fixing some typos; Other minor improvements

Author: hiranya911

npm-shrinkwrap.json

@@ -47,6 +47,8 @@
     "del": "^2.2.1",
     "firebase": "^3.6.9",
     "firebase-token-generator": "^2.0.0",
+    "@google-cloud/storage": "^1.2.1",
+    "@types/google-cloud__storage": "^1.1.1",
     "gulp": "^3.9.1",
     "gulp-exit": "0.0.2",
     "gulp-header": "^1.8.8",

package.json

@@ -302,6 +302,14 @@ export class FirebaseApp {
     );
   }
 
+  /* istanbul ignore next */
+  public storage(): FirebaseServiceInterface {
+    throw new FirebaseAppError(
+      AppErrorCodes.INTERNAL_ERROR,
+      'INTERNAL ASSERT FAILED: Firebase storage() service has not been registered.',
+    );
+  }
+
   /**
    * Returns the name of the FirebaseApp instance.
    *

src/firebase-app.ts

@@ -300,6 +300,14 @@ export class FirebaseNamespace {
     );
   }
 
+  /* istanbul ignore next */
+  public storage(): FirebaseServiceFactory {
+    throw new FirebaseAppError(
+      AppErrorCodes.INTERNAL_ERROR,
+      'INTERNAL ASSERT FAILED: Firebase storage() service has not been registered.',
+    );
+  }
+
   /**
    * Initializes the FirebaseApp instance.
    *

src/firebase-namespace.ts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+ import {Bucket} from '@google-cloud/storage';
+
 declare namespace admin {
   interface FirebaseError {
     code: string;
@@ -53,6 +55,7 @@ declare namespace admin {
   function auth(app?: admin.app.App): admin.auth.Auth;
   function database(app?: admin.app.App): admin.database.Database;
   function messaging(app?: admin.app.App): admin.messaging.Messaging;
+  function storage(app?: admin.app.App): admin.storage.Storage;
   function initializeApp(options: admin.AppOptions, name?: string): admin.app.App;
 }
 
@@ -64,6 +67,7 @@ declare namespace admin.app {
     auth(): admin.auth.Auth;
     database(): admin.database.Database;
     messaging(): admin.messaging.Messaging;
+    storage(): admin.storage.Storage;
     delete(): Promise<void>;
   }
 }
@@ -381,6 +385,13 @@ declare namespace admin.messaging {
   }
 }
 
+declare namespace admin.storage {
+  interface Storage {
+    app: admin.app.App;
+    bucket(name?: string): Bucket;
+  }
+}
+
 declare module 'firebase-admin' {
   export = admin;
 }

src/index.d.ts

@@ -17,6 +17,7 @@
 import * as firebase from './default-namespace';
 import registerAuth from './auth/register-auth';
 import registerMessaging from './messaging/register-messaging';
+import registerStorage from './storage/register-storage';
 
 // Register the Database service
 // For historical reasons, the database code is included as minified code and registers itself
@@ -31,4 +32,7 @@ registerAuth();
 // Register the Messaging service
 registerMessaging();
 
+// Register the Storage service
+registerStorage();
+
 export = firebase;

src/index.ts

@@ -0,0 +1,36 @@
+import {Storage} from './storage';
+import {AppHook, FirebaseApp} from '../firebase-app';
+import {FirebaseServiceInterface} from '../firebase-service';
+import * as firebase from '../default-namespace';
+import {FirebaseServiceNamespace} from '../firebase-namespace';
+
+/**
+ * Factory function that creates a new Storage service.
+ *
+ * @param {Object} app The app for this service.
+ * @param {function(Object)} extendApp An extend function to extend the app namespace.
+ *
+ * @return {Storage} The Storage service for the specified app.
+ */
+function serviceFactory(app: FirebaseApp, extendApp: (props: Object) => void): FirebaseServiceInterface {
+  return new Storage(app);
+}
+
+/**
+ * Handles app life-cycle events.
+ *
+ * @param {string} event The app event that is occurring.
+ * @param {FirebaseApp} app The app for which the app hook is firing.
+ */
+let appHook: AppHook = (event: string, app: FirebaseApp) => {
+  return;
+};
+
+export default function(): FirebaseServiceNamespace<FirebaseServiceInterface> {
+  return firebase.INTERNAL.registerService(
+    'storage',
+    serviceFactory,
+    {Storage},
+    appHook
+  );
+}

src/storage/register-storage.ts

@@ -0,0 +1,124 @@
+/*!
+ * 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 {FirebaseApp} from '../firebase-app';
+import {FirebaseError} from '../utils/error';
+import {FirebaseServiceInterface, FirebaseServiceInternalsInterface} from '../firebase-service';
+import {ApplicationDefaultCredential} from '../auth/credential';
+import {Bucket} from '@google-cloud/storage';
+
+import * as validator from '../utils/validator';
+
+/**
+ * Internals of a Storage instance.
+ */
+class StorageInternals implements FirebaseServiceInternalsInterface {
+  /**
+   * Deletes the service and its associated resources.
+   *
+   * @return {Promise<()>} An empty Promise that will be fulfilled when the service is deleted.
+   */
+  public delete(): Promise<void> {
+    // There are no resources to clean up.
+    return Promise.resolve();
+  }
+}
+
+/**
+ * Storage service bound to the provided app.
+ */
+export class Storage implements FirebaseServiceInterface {
+  public INTERNAL: StorageInternals = new StorageInternals();
+
+  private appInternal: FirebaseApp;
+  private storageClient: any;
+
+  /**
+   * @param {Object} app The app for this Storage service.
+   * @constructor
+   */
+  constructor(app: FirebaseApp) {
+    if (!validator.isNonNullObject(app) || !('options' in app)) {
+      throw new FirebaseError({
+        code: 'storage/invalid-argument',
+        message: 'First argument passed to admin.storage() must be a valid Firebase app instance.',
+      });
+    }
+
+    let storage;
+    try {
+      /* tslint:disable-next-line:no-var-requires */
+      storage = require('@google-cloud/storage');
+    } catch (e) {
+      throw new FirebaseError({
+        code: 'storage/missing-dependencies',
+        message: 'Failed to import the Cloud Storage client library for Node.js. '
+          + 'Make sure to install the "@google-cloud/storage" npm package.',
+      });
+    }
+
+    const cert = app.options.credential.getCertificate();
+    if (cert != null) {
+      // cert is available when the SDK has been initialized with a service account JSON file,
+      // or by setting the GOOGLE_APPLICATION_CREDENTIALS envrionment variable.
+      this.storageClient = storage({
+        credentials: {
+          private_key: cert.privateKey,
+          client_email: cert.clientEmail,
+        },
+      });
+    } else if (app.options.credential instanceof ApplicationDefaultCredential) {
+      // Try to use the Google application default credentials.
+      this.storageClient = storage();
+    } else {
+      throw new FirebaseError({
+        code: 'storage/invalid-credential',
+        message: 'Failed to initialize Google Cloud Storage client with the available credential. ' +
+          'Must initialize the SDK with a certificate credential or application default credentials ' +
+          'to use Cloud Storage API.',
+      });
+    }
+    this.appInternal = app;
+  }
+
+  public bucket(name?: string): Bucket {
+    let bucketName;
+    if (typeof name !== 'undefined') {
+      bucketName = name;
+    } else {
+      bucketName = this.appInternal.options.storageBucket;
+    }
+
+    if (validator.isNonEmptyString(bucketName)) {
+      return this.storageClient.bucket(bucketName);
+    }
+    throw new FirebaseError({
+      code: 'storage/invalid-argument',
+      message: 'Bucket name not specified or invalid. Specify a valid bucket name via the ' +
+                'storageBucket option when initializing the app, or specify the bucket name ' +
+                'explicitly when calling the getBucket() method.',
+    });
+  }
+
+  /**
+   * Returns the app associated with this Storage instance.
+   *
+   * @return {FirebaseApp} The app associated with this Storage instance.
+   */
+  get app(): FirebaseApp {
+    return this.appInternal;
+  }
+};

src/storage/storage.ts

@@ -39,22 +39,26 @@ var app = require('./app');
 var auth = require('./auth');
 var database = require('./database');
 var messaging = require('./messaging');
+var storage = require('./storage');
 
 var apiRequest = require('../../lib/utils/api-request');
 var url = require('url');
 
 var serviceAccount = utils.getCredential();
 var databaseURL = 'https://' + utils.getProjectId() + '.firebaseio.com';
+var storageBucket = utils.getProjectId() + '.appspot.com';
 
 var defaultApp = admin.initializeApp({
   credential: admin.credential.cert(serviceAccount),
   databaseURL: databaseURL,
+  storageBucket: storageBucket,
 });
 
 var nullApp = admin.initializeApp({
   credential: admin.credential.cert(serviceAccount),
   databaseURL: databaseURL,
   databaseAuthVariableOverride: null,
+  storageBucket: storageBucket,
 }, 'null');
 
 var nonNullApp = admin.initializeApp({
@@ -63,6 +67,7 @@ var nonNullApp = admin.initializeApp({
   databaseAuthVariableOverride: {
     uid: utils.generateRandomString(20),
   },
+  storageBucket: storageBucket,
 }, 'nonNull');
 
 
@@ -206,6 +211,7 @@ return promptForUpdateRules(flags['overwrite'])
   .then(_.partial(auth.test, utils))
   .then(_.partial(database.test, utils))
   .then(_.partial(messaging.test, utils))
+  .then(_.partial(storage.test, utils))
   .then(utils.logResults)
   .catch(function(error) {
     console.log(chalk.red('\nSOMETHING WENT WRONG!', error));

test/integration/index.js

@@ -0,0 +1,99 @@
+/*!
+ * 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.
+ */
+
+var admin = require('../../lib/index');
+var stream = require('stream');
+
+function test(utils) {
+  console.log('\nStorage:');
+  
+  function testDefaultBucket() {
+    const bucket = admin.storage().bucket();
+    return verifyBucket(bucket, 'storage().bucket()')
+      .then(() => {
+        utils.logSuccess('storage().bucket()');
+      })
+      .catch((error) => {
+        handleError(error, 'storage().bucket()');
+      });
+  }
+
+  function testCustomBucket() {
+    const bucket = admin.storage().bucket(utils.getProjectId() + '.appspot.com');
+    return verifyBucket(bucket, 'storage().bucket(string)')
+      .then(() => {
+        utils.logSuccess('storage().bucket(string)');
+      })
+      .catch((error) => {
+        handleError(error, 'storage().bucket(string)');
+      });
+  }
+
+  function testNonExistingBucket() {
+    const bucket = admin.storage().bucket('non.existing');
+    return bucket.exists()
+      .then((data) => {
+        utils.assert(!data[0], 'storage().bucket("non.existing").exists() returned true');
+      })
+      .catch((error) => {
+        handleError(error, 'storage().bucket("non.existing")');
+      });
+  }
+
+  function verifyBucket(bucket, testName) {
+    const expected = 'Hello World: ' + testName;
+    const file = bucket.file('data_' + Date.now() + '.txt');
+    return file.save(expected)
+      .then(() => {
+        return file.download();
+      })
+      .then((data) => {
+        if (data[0].toString() != expected) {
+          return Promise.reject('Data read from GCS does not match expected');
+        }
+        return file.delete();
+      })
+      .then((resp) => {
+        return file.exists();
+      })
+      .then((data) => {
+        if (data[0]) {
+          return Promise.reject('Failed to delete file from GCS');
+        }
+      });
+  }
+
+  function handleError(error, testName) {
+    let reason;
+    if (error.message) {
+        reason = error.message;
+    } else {
+        reason = JSON.stringify(error);
+    }
+    utils.logFailure(
+        testName, 
+        'Error while interacting with bucket: ' + reason);    
+  }
+
+  return Promise.resolve()
+    .then(testDefaultBucket)
+    .then(testCustomBucket)
+    .then(testNonExistingBucket);
+}
+
+module.exports = {
+  test: test
+}