`TransactionWithMutations` is missing operation based type when used with array methods

[godiagonal]

• I've validated the bug against the latest version of DB packages

Describe the bug
Some type information gets lost in TransactionWithMutations['mutations'] when used with array methods such as .map().

To Reproduce

const schema = z.object({
  id: z.string(),
  title: z.string(),
  completed: z.boolean(),
});

const todosCollection = createCollection(
  electricCollectionOptions({
    id: 'todos',
    schema,
    getKey: (item) => item.id,
    shapeOptions: {
      url: '/api/todos',
      params: { table: 'todos' },
    },
    onDelete: async ({ transaction }) => {
      await Promise.all(
        transaction.mutations.map((mutation) =>
          // ❌ `original` is typed as `{} | { id: string; title: string; completed: boolean; }`
          api.todos.delete(mutation.original.id),
        ),
      );

      // ✅ `original` is typed as `{ id: string; title: string; completed: boolean; }`
      await api.todos.delete(transaction.mutations[0].original.id);

      // ✅ `original` is typed as `{ id: string; title: string; completed: boolean; }`
      await api.todos.delete(transaction.mutations[1]!.original.id);
    },
  }),
);

Expected behavior
The type of transaction.mutations.map((mutation) => mutation.original)[0] should match transaction.mutations[0].original.

Additional context
Omitting mutations from Transaction<T> in TransactionWithMutations does the trick:

export type TransactionWithMutations<T extends object = Record<string, unknown>, TOperation extends OperationType = OperationType> = Omit<Transaction<T>, 'mutations'> & {
    mutations: NonEmptyArray<PendingMutation<T, TOperation>>;
};

[godiagonal]

My workaround currently:

await Promise.all(
  transaction.mutations.map((mutation: (typeof transaction.mutations)[0]) =>
    api.todos.delete(mutation.original.id),
  ),
);

[kevin-dp]

Hi @godiagonal,

Thanks for the detailed report and reproducible example. I added a unit test that reproduces this type error. Looking into a fix now. I'll keep you posted when it's solved.

[kevin-dp]

Thanks for this tip:

Omitting mutations from Transaction in TransactionWithMutations does the trick:

This is indeed the root cause of the issue because Transaction<T> defines mutations: Array<PendingMutation<T>> which is then intersected with mutations: NonEmptyArray<PendingMutation<T, TOperation>> leading to typescript not being able to infer the precise type. Omitting mutations from Transaction<T> avoids this problem as it now correctly types the mutations based on the right hand side of the intersection.