How to correctly type .toJSON() / .toObject() (e.g. in frontends)

[schwarmco]

Hi!

Given the example on the mongoose typescript documentation:

import { Schema, Types } from 'mongoose';

// 1. Create an interface representing a document in MongoDB.
interface IUser {
  name: string;
  email: string;
  // Use `Types.ObjectId` in document interface...
  organization: Types.ObjectId;
}

// 2. Create a Schema corresponding to the document interface.
const userSchema = new Schema<IUser>({
  name: { type: String, required: true },
  email: { type: String, required: true },
  // And `Schema.Types.ObjectId` in the schema definition.
  organization: { type: Schema.Types.ObjectId, ref: 'Organization' }
});

And i then send a user over a REST-API (where it gets JSON-stringified), the resulting object in the frontend ends up being like this:

const user = {
  _id: "65faccbc6b39af0ee006c7fd",
  name: "Test User",
  email: "test@user.com",
  organization: "65faccbc6b39af0ee006c7fe",
  createdAt: "2024-03-20T11:47:55.205Z",
  updatedAt: "2024-03-20T11:47:55.205Z""
}

How can i infer the type coming from IUser in the frontend, where ObjectIds and Dates are now strings?
Bonus Question: How can i infer the stringified HydratedDocument<IUser> so i have the virtuals like id in there too?

[vkarpov15]

Sorry for the very late reply, we missed this discussion when it came in.

Mongoose doesn't provide a utility to convert ObjectId and Date properties, but I think we should. Converting ObjectIds would look something like the following. Ideally we would wrap FlattenObjectIds with FlattenDates and FlattenMaps into one ToJSON helper.

type FlattenObjectIds<T> = T extends TreatAsPrimitives ? T : T extends Record<string, any> ? {
    [K in keyof T]: T[K] extends ObjectId
      ? string
      : T[K] extends (ObjectId | null | undefined)
        ? string | null | undefined
        : T[K] extends Types.DocumentArray<infer ItemType>
            ? Types.DocumentArray<FlattenObjectIds<ItemType>>
            : T[K] extends Types.Subdocument<unknown, unknown, infer SubdocType>
              ? HydratedSingleSubdocument<FlattenObjectIds<SubdocType>>
              : FlattenObjectIds<T[K]>;
  } : T;

In the future, we would ideally instead infer the JSON type from the schema rather than converting after the fact because of issues like #13523. So that would mean we would have to infer the following types from the schema: 1) raw doc type, 2) hydrated doc type, 3) JSON serialized doc type