Replace string errorCodes with numeric errorIds to make the bundles smaller.

Author: MarkDuckworth

packages/firestore/scripts/remove-asserts.js

@@ -79,25 +79,26 @@ class RemoveAsserts {
               const errorMessage = RemoveAsserts.trimErrorMessage(stringLiteral.getFullText());
               const errorCode = RemoveAsserts.errorCode(errorMessage);
 
+              let errorId: number = -1;
               try {
-                RemoveAsserts.saveErrorCode(errorCode, errorMessage);
+                errorId = RemoveAsserts.saveErrorCode(errorCode, errorMessage);
               }
               catch (e) {
                 console.log('Failed to save error code ' + JSON.stringify(e));
               }
               const newArguments = [...node.arguments];
-              newArguments[messageIndex] = ts.createLiteral(errorCode);
+              newArguments[messageIndex] = ts.factory.createNumericLiteral(errorId);
 
               // Replace the call with the full error message to a
               // build with an error code
-              updatedNode = ts.createCall(
+              updatedNode = ts.factory.createCallExpression(
                 declaration.name!,
                 /*typeArgs*/ undefined,
                 newArguments
               );
             } else {
               const newArguments = [...node.arguments];
-              newArguments[messageIndex] = ts.createLiteral('Unexpected error');
+              newArguments[messageIndex] = ts.factory.createNumericLiteral(-1);
               // Remove the log message but keep the assertion
               updatedNode = ts.createCall(
                 declaration.name!,
@@ -135,22 +136,41 @@ class RemoveAsserts {
     return paramHash;
   }
 
-  static saveErrorCode(errorCode: string, errorMessage: string): void {
+
+
+  static saveErrorCode(errorCode: string, errorMessage: string): number {
     const errorCodes = RemoveAsserts.getErrorCodes();
-    errorCodes[errorCode] = errorMessage;
+
+    const existingErrorCode: Error | undefined = errorCodes[errorCode];
+    if (existingErrorCode)
+      {return existingErrorCode.id;}
+
+    const id = Object.keys(errorCodes).length;
+    errorCodes[errorCode] = {
+      message: errorMessage,
+      id
+    };
+
     RemoveAsserts.saveErrorCodes(errorCodes);
+
+    return id;
   }
 
-  static getErrorCodes(): Record<string, string> {
+  static getErrorCodes(): Record<string, Error> {
     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 {
+  static saveErrorCodes(errorCodes: Record<string, Error>): void {
     const path = join(module.path, ERROR_CODE_LOCATION);
     writeFileSync(path, JSON.stringify(errorCodes, undefined, 4), {encoding: "utf-8", });
   }
 }
+
+interface Error {
+  id: number,
+  message: string
+};

packages/firestore/scripts/remove-asserts.ts

@@ -28,16 +28,13 @@ import { logError } from './log';
  * let futureVar = fail('not implemented yet');
  */
 export function fail(
-  failure: string = 'Unexpected state',
+  failure: string | number,
   context: unknown = undefined
 ): never {
   _fail(failure, context);
 }
 
-function _fail(
-  failure: string = 'Unexpected state',
-  context: unknown = undefined
-): never {
+function _fail(failure: string | number, context: unknown = undefined): never {
   // Log the failure in addition to throw an exception, just in case the
   // exception is swallowed.
   let message = `FIRESTORE (${SDK_VERSION}) INTERNAL ASSERTION FAILED: ${failure}`;
@@ -65,7 +62,7 @@ function _fail(
  */
 export function hardAssert(
   assertion: boolean,
-  message?: string,
+  message: string | number,
   context?: unknown
 ): asserts assertion {
   if (!assertion) {

packages/firestore/src/util/assert.ts

@@ -248,7 +248,9 @@ function getBytes(val: unknown): { asc: Uint8Array; desc: Uint8Array } {
     ascWriter.writeUtf8Ascending(val);
     descWriter.writeUtf8Descending(val);
   } else {
-    hardAssert(val instanceof Uint8Array);
+    hardAssert(val instanceof Uint8Array, 'val is not instance of Uint8Array', {
+      val
+    });
     ascWriter.writeBytesAscending(ByteString.fromUint8Array(val));
     descWriter.writeBytesDescending(ByteString.fromUint8Array(val));
   }