fix(dataconnect): fix deserialization of emulator gRPC error codes into detailed errors (#3180)

* initial fix

* address reviewer comments

* update gitignore

* improve description of emulator grpc error code mapping const

Author: stephenarosaj

.gitignore

@@ -22,4 +22,5 @@ firebase-admin-*.tgz
 docgen/markdown/
 
 # Dataconnect integration test artifacts should not be checked in
-test/integration/dataconnect/dataconnect/.dataconnect
+test/integration/dataconnect/dataconnect/.dataconnect
+test/integration/dataconnect/*.log

src/data-connect/data-connect-api-client-internal.ts

@@ -21,7 +21,12 @@ import {
   HttpRequestConfig, HttpClient, RequestResponseError, AuthorizedHttpClient
 } from '../utils/api-request';
 import { FirebaseError, toHttpResponse } from '../utils/error';
-import { FirebaseDataConnectError, DataConnectErrorCode, DATA_CONNECT_ERROR_CODE_MAPPING } from './error';
+import {
+  FirebaseDataConnectError,
+  DataConnectErrorCode,
+  DATA_CONNECT_ERROR_CODE_MAPPING,
+  EMULATOR_GRPC_STATUS_CODE_TO_STRING
+} from './error';
 import * as utils from '../utils/index';
 import * as validator from '../utils/validator';
 import { ConnectorConfig, ExecuteGraphqlResponse, GraphqlOptions, OperationOptions } from './data-connect-api';
@@ -409,10 +414,19 @@ export class DataConnectApiClient {
       });
     }
 
-    const error: ServerError = (response.data as ErrorResponse).error || {};
+    const data = response.data as any;
+    const error: ServerError = (validator.isNonNullObject(data) && validator.isNonNullObject(data.error))
+      ? data.error
+      : (validator.isNonNullObject(data) ? data : {});
+        
+    let status = error.status;
+    if (!status && validator.isNumber(error.code)) {
+      status = EMULATOR_GRPC_STATUS_CODE_TO_STRING[error.code as number];
+    }
+
     let code: DataConnectErrorCode = DATA_CONNECT_ERROR_CODE_MAPPING.UNKNOWN;
-    if (error.status && error.status in DATA_CONNECT_ERROR_CODE_MAPPING) {
-      code = DATA_CONNECT_ERROR_CODE_MAPPING[error.status];
+    if (status && status in DATA_CONNECT_ERROR_CODE_MAPPING) {
+      code = DATA_CONNECT_ERROR_CODE_MAPPING[status];
     }
     const message = error.message || 'Unknown server error';
     return new FirebaseDataConnectError({
@@ -670,10 +684,6 @@ export function useEmulator(): boolean {
   return !!emulatorHost();
 }
 
-interface ErrorResponse {
-  error?: ServerError;
-}
-
 interface ServerError {
   code?: number;
   message?: string;

src/data-connect/error.ts

@@ -69,3 +69,28 @@ export class FirebaseDataConnectError extends FirebaseError {
     });
   }
 }
+
+/**
+ * Mappings from gRPC status codes to their string equivalents. Used to convert
+ * error codes from the emulator into the codes and statuses matching errors
+ * from production.
+ * @internal
+ */
+export const EMULATOR_GRPC_STATUS_CODE_TO_STRING: Record<number, string> = {
+  1: 'CANCELLED',
+  2: 'UNKNOWN',
+  3: 'INVALID_ARGUMENT',
+  4: 'DEADLINE_EXCEEDED',
+  5: 'NOT_FOUND',
+  6: 'ALREADY_EXISTS',
+  7: 'PERMISSION_DENIED',
+  8: 'RESOURCE_EXHAUSTED',
+  9: 'FAILED_PRECONDITION',
+  10: 'ABORTED',
+  11: 'OUT_OF_RANGE',
+  12: 'UNIMPLEMENTED',
+  13: 'INTERNAL',
+  14: 'UNAVAILABLE',
+  15: 'DATA_LOSS',
+  16: 'UNAUTHENTICATED',
+};

test/unit/data-connect/data-connect-api-client-internal.spec.ts

@@ -179,6 +179,27 @@ describe('DataConnectApiClient', () => {
           .and.have.property('cause', expected.cause);
       });
 
+      it('should reject when a gRPC-to-HTTP transcoded error response is received', () => {
+        const grpcError = {
+          code: 7,
+          message: 'Permission denied',
+        };
+        const mockErr = utils.errorFrom(grpcError, 403);
+        sandbox
+          .stub(HttpClient.prototype, 'send')
+          .rejects(mockErr);
+        const expected = new FirebaseDataConnectError({
+          code: 'permission-denied',
+          message: 'Permission denied',
+          httpResponse: toHttpResponse(mockErr.response),
+          cause: mockErr
+        });
+        return apiClient.executeGraphql('query', {})
+          .should.eventually.be.rejected
+          .and.deep.include(expected)
+          .and.have.property('cause', expected.cause);
+      });
+
       it('should reject with unknown-error when error code is not present', () => {
         const mockErr = utils.errorFrom({}, 404);
         sandbox