Fcm GAPIC type conversion

src/generated/messaging/src/v1/fcm_service_client.ts

@@ -30,7 +30,9 @@ import jsonProtos = require('../../protos/protos.json');
  */
 import * as gapicConfig from './fcm_service_client_config.json';
 
-const version = require('../../../package.json').version;
+//! Temporary change, this modification should be avoidable with the suggested
+//  directory refactoring.
+const version = require('../../../../../package.json').version;
 
 /**
  *  Firebase Cloud Messaging service (FCM) to target cross-platform messaging.

src/messaging/messaging-errors-internal.ts

@@ -18,6 +18,22 @@ import { HttpError } from '../utils/api-request';
 import { FirebaseMessagingError, MessagingClientErrorCode } from '../utils/error';
 import * as validator from '../utils/validator';
 
+/**
+ * Creates a new FirebaseMessagingError by extracting the error code, message, and
+ * other relevant details from an error thrown by the generated GAPIC client.
+ *
+ * @param err
+ * @returns
+ */
+export function createFirebaseErrorFromGapicError(err: Error): FirebaseMessagingError {
+  const json = { error: err };
+
+  const errorCode = getErrorCode(json);
+  const errorMessage = getErrorMessage(json);
+
+  return FirebaseMessagingError.fromServerError(errorCode, errorMessage, json);
+}
+
 /**
  * Creates a new FirebaseMessagingError by extracting the error code, message and other relevant
  * details from an HTTP error response.

src/messaging/messaging.ts

@@ -22,6 +22,7 @@ import { validateMessage, BLACKLISTED_DATA_PAYLOAD_KEYS, BLACKLISTED_OPTIONS_KEY
 import { messaging } from './index';
 import { FirebaseMessagingRequestHandler } from './messaging-api-request-internal';
 import { ErrorInfo, MessagingClientErrorCode, FirebaseMessagingError } from '../utils/error';
+import { ServiceAccountCredential } from '../credential/credential-internal';
 import * as utils from '../utils';
 import * as validator from '../utils/validator';
 
@@ -41,6 +42,13 @@ import MessagingConditionResponse = messaging.MessagingConditionResponse;
 import DataMessagePayload = messaging.DataMessagePayload;
 import NotificationMessagePayload = messaging.NotificationMessagePayload;
 
+// GAPIC Generated client types
+import * as protos from '../generated/messaging/protos/protos';
+import { FcmServiceClient } from '../generated/messaging/src/v1/fcm_service_client'
+import ClientMessage = protos.google.firebase.fcm.v1.IMessage;
+import ClientSendRequest = protos.google.firebase.fcm.v1.ISendMessageRequest;
+import { createFirebaseErrorFromGapicError } from './messaging-errors-internal';
+
 /* eslint-disable @typescript-eslint/camelcase */
 
 // FCM endpoints
@@ -193,6 +201,7 @@ export class Messaging implements MessagingInterface {
   private urlPath: string;
   private readonly appInternal: FirebaseApp;
   private readonly messagingRequestHandler: FirebaseMessagingRequestHandler;
+  private fcmServiceClient: FcmServiceClient;
 
   /**
    * Gets the {@link messaging.Messaging `Messaging`} service for the
@@ -228,6 +237,63 @@ export class Messaging implements MessagingInterface {
     return this.appInternal;
   }
 
+
+  /**
+   * Converts from the public {@link messaging.Message `Message`} type to the
+   * internal/generated {@link protos.google.firebase.fcm.v1.Message `clientMessage`}
+   * type.
+   *
+   * @param message The {@link messaging.Message `Message`} to be converted
+   * @returns A {@link protos.google.firebase.fcm.v1.Message `clientMessage`},
+   * where like fields are the same as the inptuted message.
+   */
+  private convertToClientMessage(message: Message): ClientMessage {
+    //TODO: Add conversion for android, webpush, apns
+
+    const clientMessage: ClientMessage = {
+      data: message.data,
+      notification: message.notification,
+      fcmOptions: message.fcmOptions
+    }
+
+    if ('token' in message) {
+      clientMessage.token = message.token;
+    } else if ('topic' in message) {
+      clientMessage.topic = message.topic;
+    } else if ('condition' in message) {
+      clientMessage.condition = message.condition;
+    }
+
+    return clientMessage;
+  }
+
+  /**
+   * Method that returns a fully instantiated service client.
+   *
+   * @returns an instantiated service client with either the application's
+   * service account credentials or the default credentials
+   */
+  private getFcmServiceClient(): FcmServiceClient {
+    if (this.fcmServiceClient) {
+      this.fcmServiceClient;
+    }
+
+    const credential = this.app.options.credential;
+    const options: { credentials?: object; fallback: 'rest' } = {
+      fallback: 'rest'
+    };
+
+    if (credential instanceof ServiceAccountCredential) {
+      options.credentials = {
+        private_key: credential.privateKey,
+        client_email: credential.clientEmail
+      };
+    }
+
+    this.fcmServiceClient = new FcmServiceClient(options);
+    return this.fcmServiceClient;
+  }
+
   /**
    * Sends the given message via FCM.
    *
@@ -245,16 +311,26 @@ export class Messaging implements MessagingInterface {
       throw new FirebaseMessagingError(
         MessagingClientErrorCode.INVALID_ARGUMENT, 'dryRun must be a boolean');
     }
-    return this.getUrlPath()
-      .then((urlPath) => {
-        const request: { message: Message; validate_only?: boolean } = { message: copy };
-        if (dryRun) {
-          request.validate_only = true;
-        }
-        return this.messagingRequestHandler.invokeRequestHandler(FCM_SEND_HOST, urlPath, request);
+
+    const clientMessage = this.convertToClientMessage(copy);
+
+    const client = this.getFcmServiceClient();
+
+    return client.getProjectId()
+      .then((projectId) => {
+        const parent = `projects/${projectId}`;
+
+        const request: ClientSendRequest = {
+          parent: parent,
+          message: clientMessage,
+          validateOnly: dryRun
+        };
+        return client.sendMessage(request);
       })
-      .then((response) => {
-        return (response as any).name;
+      .then(([response]) => {
+        return response.name!;
+      }).catch(err => {
+        throw createFirebaseErrorFromGapicError(err);
       });
   }