Implement solution to replace error messages with error codes, instead of removing error messages.

Author: MarkDuckworth

packages/firestore/scripts/build-bundle.js

@@ -15,10 +15,15 @@
  * limitations under the License.
  */
 
+import { createHash } from 'crypto';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
 import * as ts from 'typescript';
 
 // Location of file that includes the asserts
 const ASSERT_LOCATION = 'packages/firestore/src/util/assert.ts';
+const ERROR_CODE_LOCATION = '../dist/error_codes.json';
 
 export function removeAsserts(
   program: ts.Program
@@ -31,7 +36,8 @@ export function removeAsserts(
 
 /**
  * Transformer that removes all "debugAssert" statements from the SDK and
- * removes the custom message for fail() and hardAssert().
+ * replaces the custom message for fail() and hardAssert() with shorter
+ * error codes
  */
 class RemoveAsserts {
   constructor(private readonly typeChecker: ts.TypeChecker) {}
@@ -63,22 +69,37 @@ class RemoveAsserts {
           declaration.getSourceFile().fileName.indexOf(ASSERT_LOCATION) >= 0
         ) {
           const method = declaration.name!.text;
+
           if (method === 'debugAssert') {
             updatedNode = ts.createOmittedExpression();
-          } else if (method === 'hardAssert') {
-            // Remove the log message but keep the assertion
-            updatedNode = ts.createCall(
-              declaration.name!,
-              /*typeArgs*/ undefined,
-              [node.arguments[0]]
-            );
-          } else if (method === 'fail') {
-            // Remove the log message
-            updatedNode = ts.createCall(
-              declaration.name!,
-              /*typeArgs*/ undefined,
-              []
-            );
+          } else if ((method === 'hardAssert') || (method === 'fail')) {
+            const messageIndex = (method === 'hardAssert') ? 1 : 0;
+            if ((node.arguments.length > messageIndex) && (node.arguments[messageIndex].kind === ts.SyntaxKind.StringLiteral)) {
+              const stringLiteral: ts.StringLiteral = node.arguments[messageIndex] as ts.StringLiteral;
+              const errorMessage = RemoveAsserts.trimErrorMessage(stringLiteral.getFullText());
+              const errorCode = RemoveAsserts.errorCode(errorMessage);
+
+              RemoveAsserts.saveErrorCode(errorCode, errorMessage);
+              const newArguments = [...node.arguments];
+              newArguments[messageIndex] = ts.createLiteral(errorCode);
+
+              // Replace the call with the full error message to a
+              // build with an error code
+              updatedNode = ts.createCall(
+                declaration.name!,
+                /*typeArgs*/ undefined,
+                newArguments
+              );
+            } else {
+              const newArguments = [...node.arguments];
+              newArguments[messageIndex] = ts.createLiteral('Unexpected error');
+              // Remove the log message but keep the assertion
+              updatedNode = ts.createCall(
+                declaration.name!,
+                /*typeArgs*/ undefined,
+                newArguments
+              );
+            }
           }
         }
       }
@@ -91,4 +112,40 @@ class RemoveAsserts {
       return node;
     }
   }
+
+  static trimErrorMessage(errorMessage: string): string {
+    return errorMessage.substring(
+      errorMessage.indexOf("'") + 1,
+      errorMessage.lastIndexOf("'"));
+  }
+
+  static errorCode(errorMessage: string): string {
+    // Create a sha256 hash from the parameter names and types.
+    const hash = createHash('sha256');
+    hash.update(errorMessage);
+
+    // Use the first 7 characters of the hash for a more compact code.
+    const paramHash = hash.digest('hex').substring(0, 7);
+
+    return paramHash;
+  }
+
+  static saveErrorCode(errorCode: string, errorMessage: string): void {
+    const errorCodes = RemoveAsserts.getErrorCodes();
+    errorCodes[errorCode] = errorMessage;
+    RemoveAsserts.saveErrorCodes(errorCodes);
+  }
+
+  static getErrorCodes(): Record<string, string> {
+    const path = join(module.path, ERROR_CODE_LOCATION);
+    if (!existsSync(path)){
+      return {};
+    }
+    return JSON.parse(readFileSync(path, 'utf-8'));
+  }
+
+  static saveErrorCodes(errorCodes: Record<string, string>): void {
+    const path = join(module.path, ERROR_CODE_LOCATION);
+    writeFileSync(path, JSON.stringify(errorCodes, undefined, 4), {encoding: "utf-8", });
+  }
 }

packages/firestore/scripts/remove-asserts.js

@@ -206,7 +206,8 @@ export class LiteAuthCredentialsProvider implements CredentialsProvider<User> {
       if (tokenData) {
         hardAssert(
           typeof tokenData.accessToken === 'string',
-          'Invalid tokenData returned from getToken():' + tokenData
+          'Invalid tokenData returned from getToken()',
+          { tokenData }
         );
         return new OAuthToken(
           tokenData.accessToken,
@@ -350,7 +351,8 @@ export class FirebaseAuthCredentialsProvider
         if (tokenData) {
           hardAssert(
             typeof tokenData.accessToken === 'string',
-            'Invalid tokenData returned from getToken():' + tokenData
+            'Invalid tokenData returned from getToken()',
+            { tokenData }
           );
           return new OAuthToken(tokenData.accessToken, this.currentUser);
         } else {
@@ -378,7 +380,8 @@ export class FirebaseAuthCredentialsProvider
     const currentUid = this.auth && this.auth.getUid();
     hardAssert(
       currentUid === null || typeof currentUid === 'string',
-      'Received invalid UID: ' + currentUid
+      'Received invalid UID',
+      { currentUid }
     );
     return new User(currentUid);
   }
@@ -564,7 +567,8 @@ export class FirebaseAppCheckTokenProvider
       if (tokenResult) {
         hardAssert(
           typeof tokenResult.token === 'string',
-          'Invalid tokenResult returned from getToken():' + tokenResult
+          'Invalid tokenResult returned from getToken()',
+          { tokenResult }
         );
         this.latestAppCheckToken = tokenResult.token;
         return new AppCheckToken(tokenResult.token);
@@ -625,7 +629,8 @@ export class LiteAppCheckTokenProvider implements CredentialsProvider<string> {
       if (tokenResult) {
         hardAssert(
           typeof tokenResult.token === 'string',
-          'Invalid tokenResult returned from getToken():' + tokenResult
+          'Invalid tokenResult returned from getToken()',
+          { tokenResult }
         );
         return new AppCheckToken(tokenResult.token);
       } else {

packages/firestore/scripts/remove-asserts.ts

@@ -749,7 +749,7 @@ export function resultChangeType(type: ChangeType): DocumentChangeType {
     case ChangeType.Removed:
       return 'removed';
     default:
-      return fail('Unknown change type: ' + type);
+      return fail('Unknown change type', { type });
   }
 }
 

packages/firestore/src/api/credentials.ts

@@ -168,7 +168,7 @@ export class FieldFilter extends Filter {
       case Operator.GREATER_THAN_OR_EQUAL:
         return comparison >= 0;
       default:
-        return fail('Unknown FieldFilter operator: ' + this.op);
+        return fail('Unknown FieldFilter operator', { operator: this.op });
     }
   }
 

packages/firestore/src/api/snapshot.ts

@@ -578,6 +578,6 @@ export function compareDocs(
     case Direction.DESCENDING:
       return -1 * comparison;
     default:
-      return fail('Unknown direction: ' + orderBy.dir);
+      return fail('Unknown direction', { direction: orderBy.dir });
   }
 }

packages/firestore/src/core/filter.ts

@@ -992,7 +992,7 @@ function updateTrackedLimbos(
         removeLimboTarget(syncEngineImpl, limboChange.key);
       }
     } else {
-      fail('Unknown limbo change: ' + JSON.stringify(limboChange));
+      fail('Unknown limbo change', { limboChange });
     }
   }
 }
@@ -1309,7 +1309,7 @@ export async function syncEngineApplyBatchState(
       batchId
     );
   } else {
-    fail(`Unknown batchState: ${batchState}`);
+    fail(`Unknown batchState`, { batchState });
   }
 
   await syncEngineEmitNewSnapsAndNotifyLocalStore(syncEngineImpl, documents);
@@ -1552,7 +1552,7 @@ export async function syncEngineApplyTargetState(
         break;
       }
       default:
-        fail('Unexpected target state: ' + state);
+        fail('Unexpected target state', state);
     }
   }
 }

packages/firestore/src/core/query.ts

@@ -124,7 +124,9 @@ export class Transaction {
       // Represent a deleted doc using SnapshotVersion.min().
       docVersion = SnapshotVersion.min();
     } else {
-      throw fail('Document in a transaction was a ' + doc.constructor.name);
+      throw fail('Document in a transaction was a ', {
+        documentName: doc.constructor.name
+      });
     }
 
     const existingVersion = this.readVersions.get(doc.key.toString());

packages/firestore/src/core/sync_engine_impl.ts

@@ -505,7 +505,7 @@ function compareChangeType(c1: ChangeType, c2: ChangeType): number {
       case ChangeType.Removed:
         return 0;
       default:
-        return fail('Unknown ChangeType: ' + change);
+        return fail('Unknown ChangeType', { change });
     }
   };