Add ProtoJS types to generated proto types

Author: schmidt-sebastian

packages/firestore/src/api/user_data_writer.ts

@@ -78,7 +78,9 @@ export class UserDataWriter<T> {
   private convertServerTimestamp(value: ServerTimestampValue): unknown {
     switch (this.serverTimestampBehavior) {
       case 'previous':
-        return value.previousValue ? this.convertValue(value.previousValue) : null;
+        return value.previousValue
+          ? this.convertValue(value.previousValue)
+          : null;
       case 'estimate':
         return this.convertTimestamp(value.localWriteTime);
       default:

packages/firestore/src/model/proto_values.ts

@@ -17,26 +17,22 @@
 
 import * as api from '../protos/firestore_proto_api';
 
-import { TypeOrder } from './field_value';
-import { assert, fail } from '../util/assert';
-import { forEach, keys, size } from '../util/obj';
-import { ByteString } from '../util/byte_string';
+import {TypeOrder} from './field_value';
+import {assert, fail} from '../util/assert';
+import {forEach, keys, size} from '../util/obj';
+import {ByteString} from '../util/byte_string';
 import {
   numericComparator,
   numericEquals,
   primitiveComparator
 } from '../util/misc';
+import {TimestampValue} from "../remote/serializer";
 
 // A RegExp matching ISO 8601 UTC timestamps with optional fraction.
 const ISO_TIMESTAMP_REG_EXP = new RegExp(
   /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.(\d+))?Z$/
 );
 
-// Denotes the possible representations for timestamps in the Value type.
-type ProtoTimestampValue =
-  | string
-  | { seconds?: string | number; nanos?: number };
-
 /** Extracts the backend's type order for the provided value. */
 export function typeOrder(value: api.Value): TypeOrder {
   if ('nullValue' in value) {
@@ -236,8 +232,8 @@ function compareNumbers(left: api.Value, right: api.Value): number {
 }
 
 function compareTimestamps(
-  left: ProtoTimestampValue,
-  right: ProtoTimestampValue
+  left: TimestampValue,
+  right: TimestampValue
 ): number {
   if (typeof left === 'string' && typeof right === 'string') {
     // Use string ordering for ISO 8601 timestamps, but strip the timezone
@@ -376,7 +372,7 @@ function canonifyByteString(byteString: string | Uint8Array): string {
   return normalizeByteString(byteString).toBase64();
 }
 
-function canonifyTimestamp(timestamp: ProtoTimestampValue): string {
+function canonifyTimestamp(timestamp: TimestampValue): string {
   const normalizedTimestamp = normalizeTimestamp(timestamp);
   return `time(${normalizedTimestamp.seconds},${normalizedTimestamp.nanos})`;
 }
@@ -478,7 +474,7 @@ function estimateArrayByteSize(arrayValue: api.ArrayValue): number {
  * nanos" representation.
  */
 export function normalizeTimestamp(
-  date: ProtoTimestampValue
+  date: TimestampValue
 ): { seconds: number; nanos: number } {
   assert(!!date, 'Cannot normalize null or undefined timestamp.');
 
@@ -528,10 +524,10 @@ export function normalizeNumber(value: number | string | undefined): number {
 }
 
 /** Converts the possible Proto types for Blobs into a ByteString. */
-export function normalizeByteString(blob: string | Uint8Array): ByteString {
-  if (typeof blob === 'string') {
-    return ByteString.fromBase64String(blob);
+export function normalizeByteString(value: string | Uint8Array): ByteString {
+  if (typeof value === 'string') {
+    return ByteString.fromBase64String(value);
   } else {
-    return ByteString.fromUint8Array(blob);
+    return ByteString.fromUint8Array(value);
   }
 }

packages/firestore/src/protos/firestore_proto_api.d.ts

@@ -180,7 +180,7 @@ export declare namespace firestoreV1ApiClientInterfaces {
     name?: string;
     fields?: ApiClientObjectMap<Value>;
     createTime?: string;
-    updateTime?: string;
+    updateTime?: string | { seconds?: string | number; nanos?: number };
   }
   interface DocumentChange {
     document?: Document;
@@ -190,7 +190,7 @@ export declare namespace firestoreV1ApiClientInterfaces {
   interface DocumentDelete {
     document?: string;
     removedTargetIds?: number[];
-    readTime?: string;
+    readTime?: string | { seconds?: string | number; nanos?: number };
   }
   interface DocumentMask {
     fieldPaths?: string[];
@@ -290,7 +290,7 @@ export declare namespace firestoreV1ApiClientInterfaces {
   }
   interface Precondition {
     exists?: boolean;
-    updateTime?: string;
+    updateTime?: string | { seconds?: string | number; nanos?: number };
   }
   interface Projection {
     fields?: FieldReference[];
@@ -333,12 +333,12 @@ export declare namespace firestoreV1ApiClientInterfaces {
     startAt?: Cursor;
     endAt?: Cursor;
     offset?: number;
-    limit?: number;
+    limit?: number | { value: number };
   }
   interface Target {
     query?: QueryTarget;
     documents?: DocumentsTarget;
-    resumeToken?: string;
+    resumeToken?: string | Uint8Array;
     readTime?: string;
     targetId?: number;
     once?: boolean;
@@ -347,8 +347,8 @@ export declare namespace firestoreV1ApiClientInterfaces {
     targetChangeType?: TargetChangeTargetChangeType;
     targetIds?: number[];
     cause?: Status;
-    resumeToken?: string;
-    readTime?: string;
+    resumeToken?: string | Uint8Array;
+    readTime?: string | { seconds?: string | number; nanos?: number };
   }
   interface TransactionOptions {
     readOnly?: ReadOnly;
@@ -382,17 +382,17 @@ export declare namespace firestoreV1ApiClientInterfaces {
   interface WriteRequest {
     streamId?: string;
     writes?: Write[];
-    streamToken?: string;
+    streamToken?: string | Uint8Array;
     labels?: ApiClientObjectMap<string>;
   }
   interface WriteResponse {
     streamId?: string;
     streamToken?: string;
     writeResults?: WriteResult[];
-    commitTime?: string;
+    commitTime?: string | { seconds?: string | number; nanos?: number };
   }
   interface WriteResult {
-    updateTime?: string;
+    updateTime?: string | { seconds?: string | number; nanos?: number };
     transformResults?: Value[];
   }
 }

packages/firestore/src/remote/serializer.ts

@@ -15,10 +15,10 @@
  * limitations under the License.
  */
 
-import { Blob } from '../api/blob';
-import { GeoPoint } from '../api/geo_point';
-import { Timestamp } from '../api/timestamp';
-import { DatabaseId } from '../core/database_info';
+import {Blob} from '../api/blob';
+import {GeoPoint} from '../api/geo_point';
+import {Timestamp} from '../api/timestamp';
+import {DatabaseId} from '../core/database_info';
 import {
   Bound,
   Direction,
@@ -29,12 +29,12 @@ import {
   OrderBy,
   Query
 } from '../core/query';
-import { SnapshotVersion } from '../core/snapshot_version';
-import { Target } from '../core/target';
-import { TargetId } from '../core/types';
-import { TargetData, TargetPurpose } from '../local/target_data';
-import { Document, MaybeDocument, NoDocument } from '../model/document';
-import { DocumentKey } from '../model/document_key';
+import {SnapshotVersion} from '../core/snapshot_version';
+import {Target} from '../core/target';
+import {TargetId} from '../core/types';
+import {TargetData, TargetPurpose} from '../local/target_data';
+import {Document, MaybeDocument, NoDocument} from '../model/document';
+import {DocumentKey} from '../model/document_key';
 import * as fieldValue from '../model/field_value';
 import {
   DeleteMutation,
@@ -48,13 +48,13 @@ import {
   TransformMutation,
   VerifyMutation
 } from '../model/mutation';
-import { FieldPath, ResourcePath } from '../model/path';
+import {FieldPath, ResourcePath} from '../model/path';
 import * as api from '../protos/firestore_proto_api';
-import { assert, fail } from '../util/assert';
-import { Code, FirestoreError } from '../util/error';
+import {assert, fail} from '../util/assert';
+import {Code, FirestoreError} from '../util/error';
 import * as obj from '../util/obj';
-import { ByteString } from '../util/byte_string';
-import * as typeUtils from '../util/types';
+import {ByteString} from '../util/byte_string';
+import {isNullOrUndefined} from '../util/types';
 
 import {
   ArrayRemoveTransformOperation,
@@ -63,8 +63,8 @@ import {
   ServerTimestampTransform,
   TransformOperation
 } from '../model/transform_operation';
-import { ExistenceFilter } from './existence_filter';
-import { mapCodeFromRpcCode, mapRpcCodeFromCode } from './rpc_error';
+import {ExistenceFilter} from './existence_filter';
+import {mapCodeFromRpcCode, mapRpcCodeFromCode} from './rpc_error';
 import {
   DocumentWatchChange,
   ExistenceFilterChange,
@@ -99,15 +99,13 @@ const OPERATORS = (() => {
 })();
 
 function assertPresent(value: unknown, description: string): asserts value {
-  assert(!typeUtils.isNullOrUndefined(value), description + ' is missing');
+  assert(!isNullOrUndefined(value), description + ' is missing');
 }
 
-// This is a supplement to the generated proto interfaces, which fail to account
-// for the fact that a timestamp may be encoded as either a string OR this.
-interface TimestampProto {
-  seconds?: string | number;
-  nanos?: number;
-}
+// Denotes the possible representations for timestamps in the Value type.
+export type TimestampValue =
+  | string
+  | { seconds?: string | number; nanos?: number };
 
 export interface SerializerOptions {
   /**
@@ -148,46 +146,33 @@ export class JsonProtoSerializer {
    * our generated proto interfaces say Int32Value must be. But GRPC actually
    * expects a { value: <number> } struct.
    */
-  private toInt32Value(val: number | null): number | null {
-    if (this.options.useProto3Json || typeUtils.isNullOrUndefined(val)) {
+  private toInt32Value(val: number | null): number | { value: number } | null {
+    if (this.options.useProto3Json || isNullOrUndefined(val)) {
       return val;
     } else {
-      // ProtobufJS requires that we wrap Int32Values.
-      // Use any because we need to match generated Proto types.
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      return { value: val } as any;
+      return { value: val };
     }
   }
 
   /**
    * Returns a number (or null) from a google.protobuf.Int32Value proto.
-   * DO NOT USE THIS FOR ANYTHING ELSE.
-   * This method cheats. It's typed as accepting "number" because that's what
-   * our generated proto interfaces say Int32Value must be, but it actually
-   * accepts { value: number } to match our serialization in toInt32Value().
    */
-  private fromInt32Value(val: number | undefined): number | null {
+  private fromInt32Value(
+    val: number | { value: number } | undefined
+  ): number | null {
     let result;
     if (typeof val === 'object') {
-      // Use any because we need to match generated Proto types.
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      result = (val as any).value;
+      result = val.value;
     } else {
-      // We accept raw numbers (without the {value: ... } wrapper) for
-      // compatibility with legacy persisted data.
       result = val;
     }
-    return typeUtils.isNullOrUndefined(result) ? null : result;
+    return isNullOrUndefined(result) ? null : result;
   }
 
   /**
    * Returns a value for a Date that's appropriate to put into a proto.
-   * DO NOT USE THIS FOR ANYTHING ELSE.
-   * This method cheats. It's typed as returning "string" because that's what
-   * our generated proto interfaces say dates must be. But it's easier and safer
-   * to actually return a Timestamp proto.
    */
-  private toTimestamp(timestamp: Timestamp): string {
+  private toTimestamp(timestamp: Timestamp): TimestampValue {
     if (this.options.useProto3Json) {
       // Serialize to ISO-8601 date format, but with full nano resolution.
       // Since JS Date has only millis, let's only use it for the seconds and
@@ -208,25 +193,21 @@ export class JsonProtoSerializer {
     }
   }
 
-  private fromTimestamp(date: string | TimestampProto): Timestamp {
+  private fromTimestamp(date: TimestampValue): Timestamp {
     const timestamp = normalizeTimestamp(date);
     return new Timestamp(timestamp.seconds, timestamp.nanos);
   }
 
   /**
    * Returns a value for bytes that's appropriate to put in a proto.
-   * DO NOT USE THIS FOR ANYTHING ELSE.
-   * This method cheats. It's typed as returning "string" because that's what
-   * our generated proto interfaces say bytes must be. But it should return
-   * an Uint8Array in Node.
    *
    * Visible for testing.
    */
-  toBytes(bytes: Blob | ByteString): string {
+  toBytes(bytes: Blob | ByteString): string | Uint8Array {
     if (this.options.useProto3Json) {
       return bytes.toBase64();
     } else {
-      return (bytes.toUint8Array() as unknown) as string;
+      return bytes.toUint8Array();
     }
   }
 
@@ -249,11 +230,11 @@ export class JsonProtoSerializer {
     }
   }
 
-  toVersion(version: SnapshotVersion): string {
+  toVersion(version: SnapshotVersion): TimestampValue {
     return this.toTimestamp(version.toTimestamp());
   }
 
-  fromVersion(version: string): SnapshotVersion {
+  fromVersion(version: TimestampValue): SnapshotVersion {
     assert(!!version, "Trying to deserialize version that isn't set");
     return SnapshotVersion.fromTimestamp(this.fromTimestamp(version));
   }
@@ -844,7 +825,7 @@ export class JsonProtoSerializer {
 
   private fromWriteResult(
     proto: api.WriteResult,
-    commitTime: string
+    commitTime: TimestampValue
   ): MutationResult {
     // NOTE: Deletes don't have an updateTime.
     let version = proto.updateTime
@@ -871,7 +852,7 @@ export class JsonProtoSerializer {
 
   fromWriteResults(
     protos: api.WriteResult[] | undefined,
-    commitTime?: string
+    commitTime?: TimestampValue
   ): MutationResult[] {
     if (protos && protos.length > 0) {
       assert(

packages/firestore/src/util/types.ts

@@ -54,7 +54,7 @@ export const isInteger: (value: unknown) => boolean =
 /**
  * Returns whether a variable is either undefined or null.
  */
-export function isNullOrUndefined(value: unknown): boolean {
+export function isNullOrUndefined(value: unknown): value is null | undefined {
   return value === null || value === undefined;
 }