尝试在打字稿模式模型中使用“ref”，会出现“ObjectId”类型上不存在属性“不存在”错误

Question

下面是我的代码的一部分。我是从 js 转向 typescript 的。尝试将我现有的 js 代码转换为打字稿。我似乎无法弄清楚这个错误。 错误

Property 'uniqueAddress' does not exist on type 'ObjectId'.

我确实知道 mongoose.Types.ObjectID 自从我创建以来就没有我的属性 uniqueaddress 但我该如何使用 Populate 和 ref ？

代码如下

import mongoose, { Document, Model } from 'mongoose';

export interface TagToSync {
    name: string,
    createdBy: string,
}

interface UserDocument extends Document {
  uniqueAddress: string;
  submittedContent: Array<mongoose.Types.ObjectId>;
  createdAt: Date;
  updatedAt: Date;
  synced: boolean;
}

interface TagDocument extends Document {
  name: string;
  content: Array<mongoose.Types.ObjectId>; // comes from content schema not posting here
  createdBy: mongoose.Types.ObjectId; 
  synced: boolean;
}

const UserSchema = new mongoose.Schema<UserDocument>({
  uniqueAddress: {
    type: String,
    required: true,
    unique: true,
  },
  submittedContent: [{
    type: mongoose.Schema.Types.ObjectId,
    ref: 'Content',
  }],
  createdAt: {
    type: Date,
    default: Date.now,
  },
  updatedAt: {
    type: Date,
    default: Date.now,
  },
  synced: {
    type: Boolean,
    default: false,
  },
});
const User: Model<UserDocument> = mongoose.model('User', UserSchema);


const TagSchema = new mongoose.Schema<TagDocument>({
  name: {
    type: String,
    required: true,
    unique: true,
  },
  contents: [{
    type: mongoose.Schema.Types.ObjectId,
    ref: 'Content',
  }],
  createdBy: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User',
    required: true,
  },
  synced: {
    type: Boolean,
    default: false,
  },
});

const Tag: Model<TagDocument> = mongoose.model('Tag', TagSchema);


export const getTagsToSync = async () : Promise<TagToSync[]> => {
  return Tag.find({ synced: false })
    .populate({
      path: 'createdBy',
      model: 'User',
      select: 'uniqueAddress'
    })
    .then(tags => tags.map(tag => ({
      name: tag.name,
      createdBy: tag.createdBy.uniqueAddress
    })));
}

Answer 1

所以我了解到，我不能直接将其转换为 UserDocument，而是先转换为 Unknown，然后再转换为 UserDocument：

return Tag.find({ synced: false })
        .populate({
        path: 'createdBy',
        model: 'User',
        select: 'uniqueAddress'
        })
        .then(tags => tags.map(tag => {
            const createdBy = (tag.createdBy as unknown) as UserDocument
            return {
                name: tag.name,
                createdBy: createdBy.uniqueAddress,
            }
        }))