Tree-Shakeable Serialization (#3231)

Author: schmidt-sebastian

packages/firestore/lite/test/dependencies.json

@@ -37,7 +37,13 @@ import { Code, FirestoreError } from '../util/error';
 import { isPlainObject, valueDescription } from '../util/input_validation';
 import { Dict, forEach, isEmpty } from '../util/obj';
 import { ObjectValue, ObjectValueBuilder } from '../model/object_value';
-import { JsonProtoSerializer } from '../remote/serializer';
+import {
+  JsonProtoSerializer,
+  toBytes,
+  toNumber,
+  toResourceName,
+  toTimestamp
+} from '../remote/serializer';
 import { Blob } from './blob';
 import { BaseFieldPath, fromDotSeparatedString } from './field_path';
 import { DeleteFieldValueImpl, SerializableFieldValue } from './field_value';
@@ -647,14 +653,16 @@ function parseScalarValue(
   if (value === null) {
     return { nullValue: 'NULL_VALUE' };
   } else if (typeof value === 'number') {
-    return context.serializer.toNumber(value);
+    return toNumber(context.serializer, value);
   } else if (typeof value === 'boolean') {
     return { booleanValue: value };
   } else if (typeof value === 'string') {
     return { stringValue: value };
   } else if (value instanceof Date) {
     const timestamp = Timestamp.fromDate(value);
-    return { timestampValue: context.serializer.toTimestamp(timestamp) };
+    return {
+      timestampValue: toTimestamp(context.serializer, timestamp)
+    };
   } else if (value instanceof Timestamp) {
     // Firestore backend truncates precision down to microseconds. To ensure
     // offline mode works the same with regards to truncation, perform the
@@ -663,7 +671,9 @@ function parseScalarValue(
       value.seconds,
       Math.floor(value.nanoseconds / 1000) * 1000
     );
-    return { timestampValue: context.serializer.toTimestamp(timestamp) };
+    return {
+      timestampValue: toTimestamp(context.serializer, timestamp)
+    };
   } else if (value instanceof GeoPoint) {
     return {
       geoPointValue: {
@@ -672,7 +682,7 @@ function parseScalarValue(
       }
     };
   } else if (value instanceof Blob) {
-    return { bytesValue: context.serializer.toBytes(value) };
+    return { bytesValue: toBytes(context.serializer, value) };
   } else if (value instanceof DocumentKeyReference) {
     const thisDb = context.databaseId;
     const otherDb = value._databaseId;
@@ -684,9 +694,9 @@ function parseScalarValue(
       );
     }
     return {
-      referenceValue: context.serializer.toResourceName(
-        value._key.path,
-        value._databaseId
+      referenceValue: toResourceName(
+        value._databaseId || context.databaseId,
+        value._key.path
       )
     };
   } else if (value === undefined && context.ignoreUndefinedProperties) {

packages/firestore/src/api/user_data_reader.ts

@@ -483,7 +483,7 @@ export class DbMutationBatch {
     /**
      * A list of mutations to apply. All mutations will be applied atomically.
      *
-     * Mutations are serialized via JsonProtoSerializer.toMutation().
+     * Mutations are serialized via toMutation().
      */
     public mutations: api.Write[]
   ) {}

packages/firestore/src/local/indexeddb_schema.ts

@@ -26,7 +26,17 @@ import {
 import { DocumentKey } from '../model/document_key';
 import { MutationBatch } from '../model/mutation_batch';
 import * as api from '../protos/firestore_proto_api';
-import { JsonProtoSerializer } from '../remote/serializer';
+import {
+  fromDocument,
+  fromDocumentsTarget,
+  fromMutation,
+  fromQueryTarget,
+  JsonProtoSerializer,
+  toDocument,
+  toDocumentsTarget,
+  toMutation,
+  toQueryTarget
+} from '../remote/serializer';
 import { debugAssert, fail } from '../util/assert';
 import { ByteString } from '../util/byte_string';
 import { Target } from '../core/target';
@@ -49,7 +59,8 @@ export class LocalSerializer {
   /** Decodes a remote document from storage locally to a Document. */
   fromDbRemoteDocument(remoteDoc: DbRemoteDocument): MaybeDocument {
     if (remoteDoc.document) {
-      return this.remoteSerializer.fromDocument(
+      return fromDocument(
+        this.remoteSerializer,
         remoteDoc.document,
         !!remoteDoc.hasCommittedMutations
       );
@@ -76,7 +87,7 @@ export class LocalSerializer {
     const dbReadTime = this.toDbTimestampKey(readTime);
     const parentPath = maybeDoc.key.path.popLast().toArray();
     if (maybeDoc instanceof Document) {
-      const doc = this.remoteSerializer.toDocument(maybeDoc);
+      const doc = toDocument(this.remoteSerializer, maybeDoc);
       const hasCommittedMutations = maybeDoc.hasCommittedMutations;
       return new DbRemoteDocument(
         /* unknownDocument= */ null,
@@ -140,10 +151,10 @@ export class LocalSerializer {
   /** Encodes a batch of mutations into a DbMutationBatch for local storage. */
   toDbMutationBatch(userId: string, batch: MutationBatch): DbMutationBatch {
     const serializedBaseMutations = batch.baseMutations.map(m =>
-      this.remoteSerializer.toMutation(m)
+      toMutation(this.remoteSerializer, m)
     );
     const serializedMutations = batch.mutations.map(m =>
-      this.remoteSerializer.toMutation(m)
+      toMutation(this.remoteSerializer, m)
     );
     return new DbMutationBatch(
       userId,
@@ -157,10 +168,10 @@ export class LocalSerializer {
   /** Decodes a DbMutationBatch into a MutationBatch */
   fromDbMutationBatch(dbBatch: DbMutationBatch): MutationBatch {
     const baseMutations = (dbBatch.baseMutations || []).map(m =>
-      this.remoteSerializer.fromMutation(m)
+      fromMutation(this.remoteSerializer, m)
     );
     const mutations = dbBatch.mutations.map(m =>
-      this.remoteSerializer.fromMutation(m)
+      fromMutation(this.remoteSerializer, m)
     );
     const timestamp = Timestamp.fromMillis(dbBatch.localWriteTimeMs);
     return new MutationBatch(
@@ -181,9 +192,9 @@ export class LocalSerializer {
 
     let target: Target;
     if (isDocumentQuery(dbTarget.query)) {
-      target = this.remoteSerializer.fromDocumentsTarget(dbTarget.query);
+      target = fromDocumentsTarget(dbTarget.query);
     } else {
-      target = this.remoteSerializer.fromQueryTarget(dbTarget.query);
+      target = fromQueryTarget(dbTarget.query);
     }
     return new TargetData(
       target,
@@ -211,9 +222,9 @@ export class LocalSerializer {
     );
     let queryProto: DbQuery;
     if (targetData.target.isDocumentQuery()) {
-      queryProto = this.remoteSerializer.toDocumentsTarget(targetData.target);
+      queryProto = toDocumentsTarget(this.remoteSerializer, targetData.target);
     } else {
-      queryProto = this.remoteSerializer.toQueryTarget(targetData.target);
+      queryProto = toQueryTarget(this.remoteSerializer, targetData.target);
     }
 
     // We can't store the resumeToken as a ByteString in IndexedDb, so we

packages/firestore/src/local/local_serializer.ts

@@ -19,13 +19,13 @@ import * as api from '../protos/firestore_proto_api';
 
 import { Timestamp } from '../api/timestamp';
 import { debugAssert } from '../util/assert';
-import { JsonProtoSerializer } from '../remote/serializer';
+import { JsonProtoSerializer, toDouble, toInteger } from '../remote/serializer';
 import {
-  valueEquals,
   isArray,
   isInteger,
   isNumber,
-  normalizeNumber
+  normalizeNumber,
+  valueEquals
 } from './values';
 import { serverTimestamp } from './server_timestamps';
 import { arrayEquals } from '../util/misc';
@@ -209,9 +209,9 @@ export class NumericIncrementTransformOperation implements TransformOperation {
     const baseValue = this.computeBaseValue(previousValue);
     const sum = this.asNumber(baseValue) + this.asNumber(this.operand);
     if (isInteger(baseValue) && isInteger(this.operand)) {
-      return this.serializer.toInteger(sum);
+      return toInteger(sum);
     } else {
-      return this.serializer.toDouble(sum);
+      return toDouble(this.serializer, sum);
     }
   }
 

packages/firestore/src/model/transform_operation.ts

@@ -57,7 +57,7 @@ export class BrowserPlatform implements Platform {
   }
 
   newSerializer(databaseId: DatabaseId): JsonProtoSerializer {
-    return new JsonProtoSerializer(databaseId, { useProto3Json: true });
+    return new JsonProtoSerializer(databaseId, /* useProto3Json= */ true);
   }
 
   formatJSON(value: unknown): string {

packages/firestore/src/platform_browser/browser_platform.ts

@@ -53,8 +53,8 @@ export class NodePlatform implements Platform {
     return new NoopConnectivityMonitor();
   }
 
-  newSerializer(partitionId: DatabaseId): JsonProtoSerializer {
-    return new JsonProtoSerializer(partitionId, { useProto3Json: false });
+  newSerializer(databaseId: DatabaseId): JsonProtoSerializer {
+    return new JsonProtoSerializer(databaseId, /* useProto3Json= */ false);
   }
 
   formatJSON(value: unknown): string {

packages/firestore/src/platform_node/node_platform.ts

@@ -16,14 +16,22 @@
  */
 
 import { CredentialsProvider } from '../api/credentials';
-import { MaybeDocument, Document } from '../model/document';
+import { Document, MaybeDocument } from '../model/document';
 import { DocumentKey } from '../model/document_key';
 import { Mutation } from '../model/mutation';
 import * as api from '../protos/firestore_proto_api';
 import { debugCast, hardAssert } from '../util/assert';
 import { Code, FirestoreError } from '../util/error';
 import { Connection } from './connection';
-import { JsonProtoSerializer } from './serializer';
+import {
+  fromDocument,
+  fromMaybeDocument,
+  getEncodedDatabaseId,
+  JsonProtoSerializer,
+  toMutation,
+  toName,
+  toQueryTarget
+} from './serializer';
 import {
   PersistentListenStream,
   PersistentWriteStream,
@@ -122,8 +130,8 @@ export async function invokeCommitRpc(
 ): Promise<void> {
   const datastoreImpl = debugCast(datastore, DatastoreImpl);
   const params = {
-    database: datastoreImpl.serializer.encodedDatabaseId,
-    writes: mutations.map(m => datastoreImpl.serializer.toMutation(m))
+    database: getEncodedDatabaseId(datastoreImpl.serializer),
+    writes: mutations.map(m => toMutation(datastoreImpl.serializer, m))
   };
   await datastoreImpl.invokeRPC('Commit', params);
 }
@@ -134,8 +142,8 @@ export async function invokeBatchGetDocumentsRpc(
 ): Promise<MaybeDocument[]> {
   const datastoreImpl = debugCast(datastore, DatastoreImpl);
   const params = {
-    database: datastoreImpl.serializer.encodedDatabaseId,
-    documents: keys.map(k => datastoreImpl.serializer.toName(k))
+    database: getEncodedDatabaseId(datastoreImpl.serializer),
+    documents: keys.map(k => toName(datastoreImpl.serializer, k))
   };
   const response = await datastoreImpl.invokeStreamingRPC<
     api.BatchGetDocumentsRequest,
@@ -144,7 +152,7 @@ export async function invokeBatchGetDocumentsRpc(
 
   const docs = new Map<string, MaybeDocument>();
   response.forEach(proto => {
-    const doc = datastoreImpl.serializer.fromMaybeDocument(proto);
+    const doc = fromMaybeDocument(datastoreImpl.serializer, proto);
     docs.set(doc.key.toString(), doc);
   });
   const result: MaybeDocument[] = [];
@@ -161,11 +169,12 @@ export async function invokeRunQueryRpc(
   query: Query
 ): Promise<Document[]> {
   const datastoreImpl = debugCast(datastore, DatastoreImpl);
-  const { structuredQuery, parent } = datastoreImpl.serializer.toQueryTarget(
+  const { structuredQuery, parent } = toQueryTarget(
+    datastoreImpl.serializer,
     query.toTarget()
   );
   const params = {
-    database: datastoreImpl.serializer.encodedDatabaseId,
+    database: getEncodedDatabaseId(datastoreImpl.serializer),
     parent,
     structuredQuery
   };
@@ -179,7 +188,9 @@ export async function invokeRunQueryRpc(
     response
       // Omit RunQueryResponses that only contain readTimes.
       .filter(proto => !!proto.document)
-      .map(proto => datastoreImpl.serializer.fromDocument(proto.document!))
+      .map(proto =>
+        fromDocument(datastoreImpl.serializer, proto.document!, undefined)
+      )
   );
 }