从键入导入 Any从 bson 导入 ObjectId从 pydantic_core 导入 core_schema 类 PyObjectId(ObjectId)：\'\'\'要创建一个验证 bson ObjectID 的 pydantic 对象&qu...

from typing import Any
from bson import ObjectId
from pydantic_core import core_schema


class PyObjectId(ObjectId):
    """To create a pydantic Object that validates bson ObjectID"""

    @classmethod
    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> core_schema.CoreSchema:
        return core_schema.json_or_python_schema(
            json_schema=core_schema.str_schema(),
            python_schema=core_schema.union_schema(
                [
                    core_schema.is_instance_schema(ObjectId),
                    core_schema.chain_schema(
                        [
                            core_schema.str_schema(),
                            core_schema.no_info_plain_validator_function(cls.validate),
                        ]
                    ),
                ]
            ),
            serialization=core_schema.plain_serializer_function_ser_schema(lambda x: str(x)),  # noqa W0108
        )

    @classmethod
    def validate(cls, value) -> ObjectId:
        if not ObjectId.is_valid(value):
            raise ValueError("Invalid ObjectId")
        return ObjectId(value)


class GoalRecordStored(BaseModel):
    """Goal Record Model."""

    player_id: PyObjectId = Field(..., validation_alias="Player ID")
    date: datetime = Field(validation_alias="Date")

我试图将 推送 player_id 为 ， ObjectId 但无法这样做，并且它被保存 MongoDB 为 string 而不是 ObjectId 。我该如何改变这种情况？

我尝试对类进行了很多更改，但都没有帮助。我一直尝试 player_id 以不同的方式推动，但它总是存储一个字符串，而不是我想要的方式。

对于按 _id 分片的普通用户数据库，sh.status() 将给出如下结果：performance63m.users shard key: { \'_id\' : 1 } ...

对于按 _id 分片的普通用户数据库，sh.status() 将给出如下结果：

performance63m.users
                        shard key: { "_id" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                mongodb-shards-3301 1
                                mongodb-shards-9901 1
                                shard-462j3x    2
                                shard-tlvu1m    1
                        { "_id" : { "$minKey" : 1 } } -->> { "_id" : ObjectId("668ccef5df83652ac424d9e7") } on : mongodb-shards-9901 Timestamp(2, 0)
                        { "_id" : ObjectId("668ccef5df83652ac424d9e7") } -->> { "_id" : ObjectId("668ccef5df83652ac427dcea") } on : shard-tlvu1m Timestamp(3, 0)
                        { "_id" : ObjectId("668ccef5df83652ac427dcea") } -->> { "_id" : ObjectId("668ccef6df83652ac42adfed") } on : mongodb-shards-3301 Timestamp(4, 0)
                        { "_id" : ObjectId("668ccef6df83652ac42adfed") } -->> { "_id" : ObjectId("668ccef6df83652ac42de2f0") } on : shard-462j3x Timestamp(4, 1)
                        { "_id" : ObjectId("668ccef6df83652ac42de2f0") } -->> { "_id" : { "$maxKey" : 1 } } on : shard-462j3x Timestamp(1, 4)

另一个示例是按字符串字段 country 对集合进行分片，如下所示：

flowers.users
                        shard key: { "country" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                shard-462j3x    1
                                shard-tlvu1m    4
                        { "country" : { "$minKey" : 1 } } -->> { "country" : "France" } on : shard-462j3x Timestamp(2, 0)
                        { "country" : "France" } -->> { "country" : "Germany" } on : shard-tlvu1m Timestamp(2, 1)
                        { "country" : "Germany" } -->> { "country" : "South Korea" } on : shard-tlvu1m Timestamp(1, 2)
                        { "country" : "South Korea" } -->> { "country" : "United States" } on : shard-tlvu1m Timestamp(1, 3)
                        { "country" : "United States" } -->> { "country" : { "$maxKey" : 1 } } on : shard-tlvu1m Timestamp(1, 4)

但是有一个 'config.system.sessions' 集合的块信息看起来很特别，它包含一个嵌套的 _id 结构：

                        { "_id" : { "id" : UUID("f1400000-0000-0000-0000-000000000000") } } -->> { "_id" : { "id" : UUID("f1800000-0000-0000-0000-000000000000") } } on : mongodb-shards-3301 Timestamp(1, 966)
                        { "_id" : { "id" : UUID("f1800000-0000-0000-0000-000000000000") } } -->> { "_id" : { "id" : UUID("f1c00000-0000-0000-0000-000000000000") } } on : mongodb-shards-3301 Timestamp(1, 967)

和 min 的可变性 max 使得解析它们变得很困难，有人能解释一下为什么 的分片键 config.system.sessions 看起来如此奇怪吗？有没有什么方法可以干净利落地解析它们？

{
            min: {
              _id: ObjectId('668ccef6df83652ac42de2f0')
            },
            max: {
              _id: MaxKey()
            },
            'on shard': 'shard-462j3x',
            'last modified': Timestamp({ t: 1, i: 4 })
          }

动机 ：我正在编写一个脚本来自动删除分片。为此，我需要解析 min 和 max 值。这些值用于确定要移动哪些巨型块（moveChunk）。只有在移动完所有巨型块后，才能删除包含它们的分片。

@user20042973 是的，我和你一样担心，但更愿意关注问题的范围。然而，“对动机感到紧张”让我很开心。我偷用这句话 =)

是的，除了问题本身之外，OP 说的“使得解析它们变得困难”的部分让我对这里的动机感到紧张......

如果您想了解更多信息，请添加以下链接：developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

config.system.sessions 是 mongodb 用于实现因果一致性的内部集合。更多详细信息请访问： https://www.mongodb.com/docs/manual/reference/config-database/#mongodb-data-config.system.sessions

该集合的 _id 字段是一个具有以下结构的对象：

{
  id: <UUID>
  uid: <Binary>
}

分片键仅使用索引的“id”部分，这为您提供了“有线”格式。

请注意，这是一个系统收集，并且文档明确警告：

请勿手动修改或删除这些集合。

错误 ReferenceError: Cannot access 'parsePayload' before initializing 发生，因为您尝试在其自己的初始化行中使用 parsePayload。这在 app.post 和 app.put 路由中都会发生。

尝试类似这样的操作

const express = require("express");
const { createToDo, updateToDo } = require("./types");
const { todo } = require("./db");

const app = express();

app.use(express.json());

app.post('/to-do', async function(req, res) {
    const createPayload = req.body;
    const parseResult = createToDo.safeParse(createPayload); // Corrected line

    if (!parseResult.success) {
        res.status(411).json({
            "msg": "you sent the wrong input"
        });
        return;
    }

    const validPayload = parseResult.data;

    await todo.create({
        title: validPayload.title,
        description: validPayload.description,
        completed: false
    });

    res.json({
        "msg": "To Do Created"
    });
});

app.get('/to-do', async function(req, res) {
    const todos = await todo.find();
    console.log(todos);

    res.json({
        todos
    });
});

app.put('/to-do', async function(req, res) {
    const updatePayload = req.body;
    const parseResult = updateToDo.safeParse(updatePayload); // Corrected line

    if (!parseResult.success) {
        res.status(411).json({
            "msg": "you sent the wrong id or input"
        });
        return;
    }

    const validPayload = parseResult.data;

    await todo.update({
        _id: validPayload.id
    }, {
        completed: true
    });

    res.json({
        "msg": "todo marked updated"
    });
});

app.listen(3000, () => {
    console.log("Server is running on port 3000");
});

第 13 行和第 38 行：将 const parsePayload = createToDo.safeParse(parsePayload); 更改为 const parseResult = createToDo.safeParse(createPayload); 以确保将正确的有效负载传递给 safeParse。

使用 parseResult 代替 parsePayload：将变量重命名为 parseResult 以避免混淆。解析后，使用 parseResult.data 访问经过验证的有效负载。

这应该可以解决 ReferenceError 并正确解析输入负载。