Fix CRDT plugin dropping composite primary key during conflict resolution (#8356)

The bulkInsert hook in the CRDT plugin captured the document fields for the
initial CRDT $set operation before RxDB computed the composite primary key.
As a result, rebuildFromCRDT (used during conflict resolution) produced a
document without the primary key, which could corrupt replicated state.

Also fill the composite primary key inside the CRDT bulkInsert hook so that
the computed key is captured in the initial CRDT operation body.

https://claude.ai/code/session_01V9mbvpPUfyWCtR2yfsUv4H

Co-authored-by: Claude <noreply@anthropic.com>

Author: pubkey

orga/changelog/fix-crdt-composite-primary-key.md

@@ -0,0 +1 @@
+- FIX CRDT plugin `bulkInsert` hook not including the composite primary key in CRDT operations, causing the primary key field to be lost during conflict resolution rebuild for schemas that use a composite primary key

src/plugins/crdt/index.ts

@@ -33,7 +33,7 @@ import {
     RxError
 } from '../../index.ts';
 import { mingoUpdater } from '../update/mingo-updater.ts';
-import { fillObjectWithDefaults } from '../../rx-schema-helper.ts';
+import { fillObjectWithDefaults, fillPrimaryKey } from '../../rx-schema-helper.ts';
 
 
 
@@ -523,6 +523,23 @@ export const RxDBcrdtPlugin: RxPlugin = {
                              */
                             fillObjectWithDefaults(collection.schema, docData);
 
+                            /**
+                             * Fill composite primary key before building the CRDT $set body.
+                             * When a schema uses a composite primary key, the value of the
+                             * primary key field is computed from other fields by RxDB and
+                             * is not provided by the user. Without this, the CRDT operation
+                             * would miss the primary key field and rebuildFromCRDT (used
+                             * during conflict resolution) would produce a document without
+                             * the primary key.
+                             */
+                            if (typeof collection.schema.jsonSchema.primaryKey !== 'string') {
+                                fillPrimaryKey(
+                                    collection.schema.primaryPath,
+                                    collection.schema.jsonSchema,
+                                    docData
+                                );
+                            }
+
                             const setMe: Partial<RxDocumentData<any>> = {};
                             Object.entries(docData).forEach(([key, value]) => {
                                 if (

test/unit/crdt.test.ts

@@ -475,6 +475,74 @@ describeParallel('crdt.test.ts', () => {
                 doc1.collection.database.close();
                 doc2.collection.database.close();
             });
+            it('should preserve the composite primary key during conflict resolution', async () => {
+                /**
+                 * When a schema uses a composite primary key, the value of the
+                 * primary key field is computed from the other fields by RxDB
+                 * and is not provided by the user during insert.
+                 * The CRDT operation must include the computed primary key,
+                 * otherwise rebuildFromCRDT (used during conflict resolution)
+                 * will produce a document with a missing primary key field.
+                 */
+                type CompositeDocType = {
+                    id: string;
+                    firstName: string;
+                    lastName: string;
+                    age: number;
+                };
+                const compositeSchema: RxJsonSchema<CompositeDocType> = {
+                    version: 0,
+                    primaryKey: {
+                        key: 'id',
+                        fields: ['firstName', 'age'],
+                        separator: '|'
+                    },
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', maxLength: 100 },
+                        firstName: { type: 'string', maxLength: 100 },
+                        lastName: { type: 'string' },
+                        age: { type: 'integer', minimum: 0, maximum: 150 }
+                    },
+                    required: ['id', 'firstName', 'lastName', 'age']
+                };
+
+                async function getDocFromNewDb() {
+                    const c = await getCRDTCollection<CompositeDocType>(compositeSchema);
+                    const doc = await c.insert({
+                        firstName: 'Alice',
+                        lastName: 'Smith',
+                        age: 25
+                        // id is NOT provided, must be auto-computed by RxDB
+                    } as CompositeDocType);
+                    return doc;
+                }
+                const doc1 = await getDocFromNewDb();
+                const doc2 = await getDocFromNewDb();
+
+                // Both must have the auto-computed composite primary key
+                assert.strictEqual(doc1.getLatest().id, 'Alice|25');
+                assert.strictEqual(doc2.getLatest().id, 'Alice|25');
+
+                // Resolve a conflict between the two versions.
+                const schemaFilled = enableCRDTinSchema(fillWithDefaultSettings(compositeSchema));
+                const handler = getCRDTConflictHandler<WithCRDTs<CompositeDocType>>(
+                    defaultHashSha256,
+                    schemaFilled
+                );
+
+                const resolved = await handler.resolve({
+                    newDocumentState: doc1.toMutableJSON(true) as any,
+                    realMasterState: doc2.toMutableJSON(true) as any
+                }, 'test-composite-primary');
+
+                // After conflict resolution, the composite primary key must be preserved.
+                assert.strictEqual((resolved as any).id, 'Alice|25',
+                    'Composite primary key "id" was lost during conflict resolution rebuild');
+
+                doc1.collection.database.close();
+                doc2.collection.database.close();
+            });
         });
         describe('conflicts during replication', () => {
             if (!config.storage.hasReplication) {