first attempt

Author: DellaBitta

packages/firestore/src/lite-api/snapshot.ts

@@ -38,6 +38,7 @@ import {
   UntypedFirestoreDataConverter
 } from './user_data_reader';
 import { AbstractUserDataWriter } from './user_data_writer';
+import { Timestamp } from '../lite-api/timestamp';
 
 /**
  * Converter used by `withConverter()` to transform user objects of type
@@ -329,6 +330,18 @@ export class DocumentSnapshot<
     );
   }
 
+  get createTime(): Timestamp | undefined {
+    return this._document?.createTime.toTimestamp();
+  }
+
+  get updateTime(): Timestamp | undefined {
+    return this._document?.updateTime.toTimestamp();
+  }
+
+  get readTime(): Timestamp | undefined {
+    return this._document?.readTime.toTimestamp();
+  }
+
   /**
    * Signals whether or not the document at the snapshot's location exists.
    *

packages/firestore/src/model/path.ts

@@ -22,11 +22,22 @@ import { Code, FirestoreError } from '../util/error';
 
 export const DOCUMENT_KEY_NAME = '__name__';
 
+/*!
+ * A regular expression to verify an absolute Resource Path in Firestore. It
+ * extracts the project ID, the database name and the relative resource path
+ * if available.
+ *
+ * @type {RegExp}
+ */
+const RESOURCE_PATH_RE =
+  // Note: [\s\S] matches all characters including newlines.
+  /^projects\/([^/]*)\/databases\/([^/]*)(?:\/documents\/)?([\s\S]*)$/;
+
 /**
  * Path represents an ordered sequence of string segments.
  */
 abstract class BasePath<B extends BasePath<B>> {
-  private segments: string[];
+  protected segments: string[];
   private offset: number;
   private len: number;
 
@@ -257,6 +268,21 @@ export class ResourcePath extends BasePath<ResourcePath> {
     return this.toArray().map(encodeURIComponent).join('/');
   }
 
+  /**
+   * Converts this path to a fully qualified ResourcePath.
+   *
+   * @private
+   * @internal
+   * @param projectId The project ID of the current Firestore project.
+   * @return A fully-qualified resource path pointing to the same element.
+   */
+  toQualifiedResourcePath(
+    projectId: string,
+    databaseId: string
+  ): QualifiedResourcePath {
+    return new QualifiedResourcePath(projectId, databaseId, ...this.segments);
+  }
+
   /**
    * Creates a resource path from the given slash-delimited string. If multiple
    * arguments are provided, all components are combined. Leading and trailing
@@ -287,6 +313,183 @@ export class ResourcePath extends BasePath<ResourcePath> {
   }
 }
 
+/**
+ * A slash-separated path that includes a project and database ID for referring
+ * to resources in any Firestore project.
+ *
+ * @private
+ * @internal
+ */
+export class QualifiedResourcePath extends ResourcePath {
+  /**
+   * The project ID of this path.
+   */
+  readonly projectId: string;
+
+  /**
+   * The database ID of this path.
+   */
+  readonly databaseId: string;
+
+  /**
+   * Constructs a Firestore Resource Path.
+   *
+   * @private
+   * @internal
+   * @param projectId The Firestore project id.
+   * @param databaseId The Firestore database id.
+   * @param segments Sequence of names of the parts of the path.
+   */
+  constructor(projectId: string, databaseId: string, ...segments: string[]) {
+    super(segments);
+
+    this.projectId = projectId;
+    this.databaseId = databaseId;
+  }
+
+  /**
+   * String representation of the path relative to the database root.
+   * @private
+   * @internal
+   */
+  get relativeName(): string {
+    return this.segments.join('/');
+  }
+
+  /**
+   * Creates a resource path from an absolute Firestore path.
+   *
+   * @private
+   * @internal
+   * @param absolutePath A string representation of a Resource Path.
+   * @returns The new ResourcePath.
+   */
+  static fromSlashSeparatedString(absolutePath: string): QualifiedResourcePath {
+    const elements = RESOURCE_PATH_RE.exec(absolutePath);
+
+    if (elements) {
+      const project = elements[1];
+      const database = elements[2];
+      const path = elements[3];
+      return new QualifiedResourcePath(project, database).append(path);
+    }
+
+    throw new Error(`Resource name '${absolutePath}' is not valid.`);
+  }
+
+  /**
+   * Create a child path beneath the current level.
+   *
+   * @private
+   * @internal
+   * @param relativePath Relative path to append to the current path.
+   * @returns The new path.
+   */
+  append(relativePath: ResourcePath | string): QualifiedResourcePath {
+    // `super.append()` calls `QualifiedResourcePath.construct()` when invoked
+    // from here and returns a QualifiedResourcePath.
+    return super.append(relativePath) as QualifiedResourcePath;
+  }
+
+  /**
+   * Create a child path beneath the current level.
+   *
+   * @private
+   * @internal
+   * @returns The new path.
+   */
+  parent(): QualifiedResourcePath | null {
+    return super.parent() as QualifiedResourcePath | null;
+  }
+
+  /**
+   * String representation of a ResourcePath as expected by the API.
+   *
+   * @private
+   * @internal
+   * @returns The representation as expected by the API.
+   */
+  get formattedName(): string {
+    const components = [
+      'projects',
+      this.projectId,
+      'databases',
+      this.databaseId,
+      'documents',
+      ...this.segments
+    ];
+    return components.join('/');
+  }
+
+  /**
+   * Constructs a new instance of ResourcePath. We need this instead of using
+   * the normal constructor because polymorphic 'this' doesn't work on static
+   * methods.
+   *
+   * @private
+   * @internal
+   * @param segments Sequence of names of the parts of the path.
+   * @returns The newly created QualifiedResourcePath.
+   */
+  construct(segments: string[]): QualifiedResourcePath {
+    return new QualifiedResourcePath(
+      this.projectId,
+      this.databaseId,
+      ...segments
+    );
+  }
+
+  /**
+   * Convenience method to match the ResourcePath API. This method always
+   * returns the current instance.
+   *
+   * @private
+   * @internal
+   */
+  toQualifiedResourcePath(): QualifiedResourcePath {
+    return this;
+  }
+
+  /**
+   * Compare the current path against another ResourcePath object.
+   *
+   * @private
+   * @internal
+   * @param other The path to compare to.
+   * @returns -1 if current < other, 1 if current > other, 0 if equal
+   */
+  compareTo(other: ResourcePath): number {
+    if (other instanceof QualifiedResourcePath) {
+      if (this.projectId < other.projectId) {
+        return -1;
+      }
+      if (this.projectId > other.projectId) {
+        return 1;
+      }
+
+      if (this.databaseId < other.databaseId) {
+        return -1;
+      }
+      if (this.databaseId > other.databaseId) {
+        return 1;
+      }
+    }
+
+    return super.compareTo(other);
+  }
+
+  /**
+   * Converts this ResourcePath to the Firestore Proto representation.
+   * @private
+   * @internal
+   */
+  toProto(): api.IValue {
+    return {
+      referenceValue: this.formattedName
+    };
+  }
+}
+
 const identifierRegExp = /^[_a-zA-Z][_a-zA-Z0-9]*$/;
 
 /**

packages/firestore/src/util/bundle_builder.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+import {
+  BundleElement,
+  BundleMetadata
+} from '../protos/firestore_bundle_proto';
+import { JsonProtoSerializer } from '../remote/serializer';
+import { SizedBundleElement } from '../util/bundle_reader';
+
+
+/**
+ * A class that can serialize Firestore results into a Firestore bundle.
+ *
+ */
+export interface BundleBuilder {
+  serializer: JsonProtoSerializer;
+
+  close(): Promise<void>;
+
+  getMetadata(): Promise<BundleMetadata>;
+
+  nextElement(): Promise<SizedBundleElement | null>;
+}