fix(twenty-server): preserve input order in createMany response

[FelixMalfait]

Summary

• The createMany API was returning records in arbitrary order because fetchUpsertedRecords used WHERE id IN (...) without ORDER BY
• This caused flaky tests that assumed input order was preserved (e.g., people-merge-many.integration-spec.ts)
• Fixed by reordering the fetched records to match the original input order from generatedMaps

Root Cause

// Before: No ORDER BY, so SQL returns in arbitrary order
const upsertedRecords = await queryBuilder
  .where({ id: In(objectRecords.generatedMaps.map((record) => record.id)) })
  .getMany();  // Returns in arbitrary order!

Fix

// After: Reorder results to match original input order
const orderedIds = objectRecords.generatedMaps.map((record) => record.id);
const upsertedRecords = await queryBuilder
  .where({ id: In(orderedIds) })
  .getMany();

// Preserve original input order
const recordsById = new Map(upsertedRecords.map((record) => [record.id, record]));
return orderedIds
  .map((id) => recordsById.get(id))
  .filter((record) => record !== undefined);

Test plan

• Run people-merge-many.integration-spec.ts multiple times - passes consistently
• Lint passes

[greptile-apps]

Greptile Overview

Greptile Summary

This PR fixes a critical ordering bug in the createMany API where records were returned in arbitrary database order instead of preserving the original input order. The fix implements a Map-based reordering strategy in fetchUpsertedRecords that matches the returned records to the input order from generatedMaps.

Key Changes:

• Extracted orderedIds from generatedMaps before the database query to preserve the original insertion order
• Created a Map to enable O(1) lookup of records by ID after the unordered database fetch
• Used .map() and .filter() with a type predicate to reorder results and filter out any missing records

Impact:

• Resolves flaky test failures in people-merge-many.integration-spec.ts that relied on deterministic ordering
• Ensures API consumers can depend on response order matching input order, which is critical for merge operations with conflictPriorityIndex

Confidence Score: 5/5

• This PR is safe to merge with minimal risk
• The fix is well-structured, uses standard TypeScript patterns (Map for O(1) lookups, type predicates for filtering), and directly addresses the root cause identified in flaky tests. The logic is straightforward and adds minimal computational overhead while providing critical correctness guarantees for API consumers.
• No files require special attention

Important Files Changed

Filename	Overview
packages/twenty-server/src/engine/api/common/common-query-runners/common-create-many-query-runner/common-create-many-query-runner.service.ts	Fixed fetchUpsertedRecords to preserve original input order by reordering results to match generatedMaps IDs using a Map-based lookup

Sequence Diagram

sequenceDiagram
    participant Client
    participant CreateManyRunner
    participant Repository
    participant Database

    Client->>CreateManyRunner: createMany(data: [record1, record2, record3])
    CreateManyRunner->>Repository: insert/upsert records
    Repository->>Database: INSERT INTO table VALUES (...)
    Database-->>Repository: generatedMaps: [{id: "uuid-1"}, {id: "uuid-2"}, {id: "uuid-3"}]
    Repository-->>CreateManyRunner: InsertResult with ordered generatedMaps
    
    Note over CreateManyRunner: Extract orderedIds from generatedMaps<br/>to preserve input order
    
    CreateManyRunner->>Repository: WHERE id IN (uuid-1, uuid-2, uuid-3)
    Repository->>Database: SELECT * FROM table WHERE id IN (...)
    Database-->>Repository: Records in arbitrary order
    Repository-->>CreateManyRunner: upsertedRecords (unordered)
    
    Note over CreateManyRunner: Map records by ID<br/>recordsById.set(id, record)
    
    Note over CreateManyRunner: Reorder using orderedIds<br/>orderedIds.map(id => recordsById.get(id))
    
    CreateManyRunner-->>Client: [record1, record2, record3] (preserves input order)

Loading

[greptile-apps]

_{No files reviewed, no comments}

_{Edit Code Review Agent Settings | Greptile}

[cubic-dev-ai]

No issues found across 1 file

[github-actions]

🚀 Preview Environment Ready!

Your preview environment is available at: http://bore.pub:12634

This environment will automatically shut down when the PR is closed or after 5 hours.

[charlesBochet]

why not use sort method?

[charlesBochet]

i'm confused on how this will preserver the order in the input: objectRecords does not seem to be the input. I wonder if the sort method should be done in a parent method that stil has access to the input

[FelixMalfait]

For simple inserts, generatedMaps does preserve input order (TypeORM guarantee), so the current fix works. For upserts, you're right - the order is scrambled because updates are processed before inserts. Fixing that properly would require a bigger change, I don't think it's worth it. I will look into it but will likely merge like that if I find out it's too much code changes just for this upsert edge-case

[charlesBochet]

here it makes sense

[charlesBochet]

not useful :)

[charlesBochet]

left comments :)