Why are time stamps passed as Timestamp and not Date?

[akauppi]

I know this forum is for @exp API and this subject is more general in nature (applies to current 8.x API as well).

---

When I do a Firestore subscription, data that is stored in the database as time stamps are provided as Timestamp objects ({ seconds: ..., nanoseconds: ... }).

This is not a native JavaScript date and forces the application programmer to either learn new tricks, or manually convert with the .toDate() method.

While the method is sweet, it covers the code with if-this-field-then-convert code, for which reason I prefer to bulk-scan all the 1st level values for Timestamp under the (application's) hood.

I would like to ask:

• Do other clients (IOS, Android, ...) also provide the Timestamp, or do they use the platform's native representation of date/time?
• What is the thinking behind selecting Timestamp?

I grasp the benefit of using one type for storage and transmission, but would like to see them converted to Date, by the Firestore JS client.

If you regard this as a Good Thing, one can also think of a hybrid Timestamp+Date instance that fulfils the prototype of both. This would provide backwards compatibility.

Here's the code I use for conversion ('Ref' is the Vue.js 3 reactivity type):

function docRef(_D) {   // ( DocumentReference ) => [Ref of undefined | null | { ..document fields }, () => ()]
  const ref = shallowRef();

  const unsub = onSnapshot( _D, (ss) => {
    const data = ss.data();
    ref.value = data ? convTimestamps(data) : null;    // <----- HERE
  }, (err) => {   // (FirestoreError) => ()
    central.error(`Failure listening to '${_D.path}':`, err);
  });

  return [ref, unsub];
}

function convTimestamps(o) {
  const o2= oMap(o, v => {
    return v instanceof Timestamp ? v.toDate() : v;
  });
  return o2;
}

function oMap(o,vf) {
  const arr = Object.entries(o).map(([k,v]) => [k, vf(v)]);
  return Object.fromEntries(arr);
}

[Feiyang1]

@schmidt-sebastian Can you share some insights on this?

[schmidt-sebastian]

Firestore stores all timestamps with microsecond precision. Using JavaScript Dates truncates this precision to milliseconds, which can yield unforeseen consequences. Consider the following:

const collRef = doc(db, 'coll');
const docRef = doc(collRef, 'doc');
await set(docRef, { time: serverTimestamp() } );
const doc = await getDoc(docRef);
query(collRef, where("time", "==", doc.get("time")).then(...)

This would likely return no documents if we used Date, since the microseconds would be off.

All platforms use Timestamps for this reason.

If you automatically want to convert between Timestamp and Date, you could look at Firestore Converters (withConverter).

[akauppi]

I see.

The important part for me was that "all platforms use Timestamps for this reason".

You could - if you wanted - pass the apps an object that fulfils both Timestamp and Date interface. That would be convenient, but deviate from other platforms.