fix(core): restore injection for map record entries

zxch3n · zxch3n · commit 9050513685bd · 2025-09-25T14:59:52.000+08:00
diff --git a/packages/core/src/core/diff.ts b/packages/core/src/core/diff.ts
@@ -16,6 +16,7 @@ import {
     isRootSchemaType,
     LoroListSchema,
     LoroMapSchema,
+    LoroMapSchemaWithCatchall,
     LoroMovableListSchema,
     LoroTextSchemaType,
     LoroTreeSchema,
@@ -94,6 +95,33 @@ type CommonListItemInfo = {
 
 type IdSelector<T> = (item: T) => string | undefined;
 
+function getMapChildSchema(
+    schema:
+        | LoroMapSchema<Record<string, SchemaType>>
+        | LoroMapSchemaWithCatchall<Record<string, SchemaType>, SchemaType>
+        | RootSchemaType<Record<string, ContainerSchemaType>>
+        | undefined,
+    key: string,
+): SchemaType | ContainerSchemaType | undefined {
+    if (!schema) return undefined;
+    if (schema.type === "schema") {
+        return schema.definition[key];
+    }
+    if (schema.type === "loro-map") {
+        if (Object.prototype.hasOwnProperty.call(schema.definition, key)) {
+            return schema.definition[key];
+        }
+        const withCatchall = schema as LoroMapSchemaWithCatchall<
+            Record<string, SchemaType>,
+            SchemaType
+        > & { catchallType?: SchemaType };
+        if (withCatchall.catchallType) {
+            return withCatchall.catchallType;
+        }
+    }
+    return undefined;
+}
+
 /**
  * Diffs a container between two states
  *
@@ -980,9 +1008,17 @@ export function diffMap<S extends ObjectLike>(
             continue;
         }
         // Skip ignored fields defined in schema
-        const childSchemaForDelete = (
-            schema as LoroMapSchema<Record<string, SchemaType>> | undefined
-        )?.definition?.[key];
+        const childSchemaForDelete = getMapChildSchema(
+            schema as
+                | LoroMapSchema<Record<string, SchemaType>>
+                | LoroMapSchemaWithCatchall<
+                      Record<string, SchemaType>,
+                      SchemaType
+                  >
+                | RootSchemaType<Record<string, ContainerSchemaType>>
+                | undefined,
+            key,
+        );
         if (childSchemaForDelete && childSchemaForDelete.type === "ignore") {
             continue;
         }
@@ -1006,9 +1042,17 @@ export function diffMap<S extends ObjectLike>(
         const newItem = newStateObj[key];
 
         // Figure out if the modified new value is a container
-        const childSchema = (
-            schema as LoroMapSchema<Record<string, SchemaType>> | undefined
-        )?.definition?.[key];
+        const childSchema = getMapChildSchema(
+            schema as
+                | LoroMapSchema<Record<string, SchemaType>>
+                | LoroMapSchemaWithCatchall<
+                      Record<string, SchemaType>,
+                      SchemaType
+                  >
+                | RootSchemaType<Record<string, ContainerSchemaType>>
+                | undefined,
+            key,
+        );
 
         // Skip ignored fields defined in schema
         if (childSchema && childSchema.type === "ignore") {
diff --git a/packages/core/src/core/mirror.ts b/packages/core/src/core/mirror.ts
@@ -32,6 +32,7 @@ import {
     isLoroTreeSchema,
     LoroListSchema,
     LoroMapSchema,
+    LoroMapSchemaWithCatchall,
     RootSchemaType,
     SchemaType,
     validateSchema,
@@ -504,9 +505,18 @@ export class Mirror<S extends SchemaType> {
                     if (isContainer(value)) {
                         let nestedSchema: ContainerSchemaType | undefined;
                         if (parentSchema && isLoroMapSchema(parentSchema)) {
-                            nestedSchema = parentSchema.definition[
-                                key
-                            ] as ContainerSchemaType;
+                            const candidate = this.getSchemaForMapKey(
+                                parentSchema as
+                                    | LoroMapSchema<Record<string, SchemaType>>
+                                    | LoroMapSchemaWithCatchall<
+                                          Record<string, SchemaType>,
+                                          SchemaType
+                                      >,
+                                key,
+                            );
+                            if (candidate && isContainerSchema(candidate)) {
+                                nestedSchema = candidate;
+                            }
                         }
                         this.registerContainer(value.id, nestedSchema);
                     }
@@ -1419,16 +1429,19 @@ export class Mirror<S extends SchemaType> {
             if (!isObject(value)) {
                 return;
             }
+            const mapSchema = schema as
+                | LoroMapSchema<Record<string, SchemaType>>
+                | LoroMapSchemaWithCatchall<
+                      Record<string, SchemaType>,
+                      SchemaType
+                  >
+                | undefined;
             for (const [key, val] of Object.entries(value)) {
                 // Skip injected CID field
                 if (key === CID_KEY) continue;
-                const fieldSchema = (
-                    schema as
-                        | LoroMapSchema<Record<string, SchemaType>>
-                        | undefined
-                )?.definition[key];
+                const fieldSchema = this.getSchemaForMapKey(mapSchema, key);
 
-                if (isContainerSchema(fieldSchema)) {
+                if (fieldSchema && isContainerSchema(fieldSchema)) {
                     const ct = schemaToContainerType(fieldSchema);
                     if (ct && isValueOfContainerType(ct, val)) {
                         this.insertContainerIntoMap(map, fieldSchema, key, val);
@@ -1660,8 +1673,14 @@ export class Mirror<S extends SchemaType> {
     ) {
         if (key === CID_KEY) return; // Ignore CID in writes
         // Check if this field should be a container according to schema
-        if (schema && schema.type === "loro-map" && schema.definition) {
-            const fieldSchema = schema.definition[key];
+        if (schema && schema.type === "loro-map") {
+            const mapSchema = schema as
+                | LoroMapSchema<Record<string, SchemaType>>
+                | LoroMapSchemaWithCatchall<
+                      Record<string, SchemaType>,
+                      SchemaType
+                  >;
+            const fieldSchema = this.getSchemaForMapKey(mapSchema, key);
             if (fieldSchema && fieldSchema.type === "ignore") {
                 // Skip ignore fields: they live only in mirrored state
                 return;
@@ -1926,6 +1945,27 @@ export class Mirror<S extends SchemaType> {
         });
     }
 
+    private getSchemaForMapKey(
+        schema:
+            | LoroMapSchema<Record<string, SchemaType>>
+            | LoroMapSchemaWithCatchall<Record<string, SchemaType>, SchemaType>
+            | undefined,
+        key: string,
+    ): SchemaType | undefined {
+        if (!schema) return undefined;
+        if (Object.prototype.hasOwnProperty.call(schema.definition, key)) {
+            return schema.definition[key];
+        }
+        const withCatchall = schema as LoroMapSchemaWithCatchall<
+            Record<string, SchemaType>,
+            SchemaType
+        > & { catchallType?: SchemaType };
+        if (withCatchall.catchallType) {
+            return withCatchall.catchallType;
+        }
+        return undefined;
+    }
+
     private getContainerSchema(
         containerId: ContainerID,
     ): ContainerSchemaType | undefined {
@@ -1956,7 +1996,15 @@ export class Mirror<S extends SchemaType> {
         }
 
         if (isLoroMapSchema(containerSchema)) {
-            return containerSchema.definition[childKey];
+            return this.getSchemaForMapKey(
+                containerSchema as
+                    | LoroMapSchema<Record<string, SchemaType>>
+                    | LoroMapSchemaWithCatchall<
+                          Record<string, SchemaType>,
+                          SchemaType
+                      >,
+                String(childKey),
+            );
         } else if (
             isLoroListSchema(containerSchema) ||
             isLoroMovableListSchema(containerSchema)
diff --git a/packages/core/tests/issue.test.ts b/packages/core/tests/issue.test.ts
@@ -1,5 +1,5 @@
 import { it, expect } from "vitest";
-import { LoroDoc } from "loro-crdt";
+import { LoroDoc, LoroMap } from "loro-crdt";
 import { Mirror, schema } from "../src/";
 
 it("Applying remote event then calling setState immediately may cause an event apply order issue", async () => {
@@ -54,3 +54,35 @@ it("Reproduces 'Item ID cannot be null' when adding a new todo item using $cid-b
         todos: [{ text: "Buy milk", status: "todo" }],
     });
 });
+
+it("doc with map record containers misses $cid in initial getState (repro)", () => {
+    const doc = new LoroDoc();
+    const root = doc.getMap("root");
+    const todo = new LoroMap();
+    todo.set("text", "Buy eggs");
+    root.setContainer("todo-1", todo);
+    const list = doc.getList("list");
+    list.pushContainer(new LoroMap());
+    doc.commit();
+
+    const todoSchema = schema({
+        root: schema.LoroMapRecord(
+            schema.LoroMap({
+                text: schema.String(),
+            }),
+        ),
+        list: schema.LoroList(schema.LoroMap({})),
+    });
+
+    const m = new Mirror({
+        doc,
+        schema: todoSchema,
+    });
+
+    const state = m.getState() as any;
+    expect(state.root).toBeDefined();
+    expect(state.root["todo-1"]).toBeDefined();
+    // Bug: $cid is currently missing even though the container exists in the doc
+    expect(typeof state.root["todo-1"].$cid).toBe("string");
+    expect(typeof state.list[0].$cid).toBe("string");
+});
