feat(db-*): support atomic array $push db updates (#13453)

This PR adds **atomic** `$push` **support for array fields**. It makes
it possible to safely append new items to arrays, which is especially
useful when running tasks in parallel (like job queues) where multiple
processes might update the same record at the same time. By handling
pushes atomically, we avoid race conditions and keep data consistent -
especially on postgres, where the current implementation would nuke the
entire array table before re-inserting every single array item.

The feature works for both localized and unlocalized arrays, and
supports pushing either single or multiple items at once.

This PR is a requirement for reliably running parallel tasks in the job
queue - see https://github.com/payloadcms/payload/pull/13452.

Alongside documenting `$push`, this PR also adds documentation for
`$inc`.

## Changes to updatedAt behavior

https://github.com/payloadcms/payload/pull/13335 allows us to override
the updatedAt property instead of the db always setting it to the
current date.

However, we are not able to skip updating the updatedAt property
completely. This means, usage of $push results in 2 postgres db calls:
1. set updatedAt in main row
2. append array row in arrays table

This PR changes the behavior to only automatically set updatedAt if it's
undefined. If you explicitly set it to `null`, this now allows you to
skip the db adapter automatically setting updatedAt.

=> This allows us to use $push in just one single db call

## Usage Examples

### Pushing a single item to an array

```ts
const post = (await payload.db.updateOne({
  data: {
    array: {
      $push: {
        text: 'some text 2',
        id: new mongoose.Types.ObjectId().toHexString(),
      },
    },
  },
  collection: 'posts',
  id: post.id,
}))
```

### Pushing a single item to a localized array

```ts
const post = (await payload.db.updateOne({
  data: {
    arrayLocalized: {
      $push: {
        en: {
          text: 'some text 2',
          id: new mongoose.Types.ObjectId().toHexString(),
        },
        es: {
          text: 'some text 2 es',
          id: new mongoose.Types.ObjectId().toHexString(),
        },
      },
    },
  },
  collection: 'posts',
  id: post.id,
}))
```

### Pushing multiple items to an array

```ts
const post = (await payload.db.updateOne({
  data: {
    array: {
      $push: [
        {
          text: 'some text 2',
          id: new mongoose.Types.ObjectId().toHexString(),
        },
        {
          text: 'some text 3',
          id: new mongoose.Types.ObjectId().toHexString(),
        },
      ],
    },
  },
  collection: 'posts',
  id: post.id,
}))
```

### Pushing multiple items to a localized array

```ts
const post = (await payload.db.updateOne({
  data: {
    arrayLocalized: {
      $push: {
        en: {
          text: 'some text 2',
          id: new mongoose.Types.ObjectId().toHexString(),
        },
        es: [
          {
            text: 'some text 2 es',
            id: new mongoose.Types.ObjectId().toHexString(),
          },
          {
            text: 'some text 3 es',
            id: new mongoose.Types.ObjectId().toHexString(),
          },
        ],
      },
    },
  },
  collection: 'posts',
  id: post.id,
}))
```

---
- To see the specific tasks where the Asana app for GitHub is being
used, see below:
  - https://app.asana.com/0/0/1211110462564647

test/database/postgres-logs.int.spec.ts

@@ -2,9 +2,12 @@ import type { Payload } from 'payload'
 
 /* eslint-disable jest/require-top-level-describe */
 import assert from 'assert'
+import mongoose from 'mongoose'
 import path from 'path'
 import { fileURLToPath } from 'url'
 
+import type { Post } from './payload-types.js'
+
 import { initPayloadInt } from '../helpers/initPayloadInt.js'
 
 const filename = fileURLToPath(import.meta.url)
@@ -169,6 +172,53 @@ describePostgres('database - postgres logs', () => {
     })
 
     expect(allPosts.docs).toHaveLength(1)
-    expect(allPosts.docs[0].id).toEqual(doc1.id)
+    expect(allPosts.docs[0]?.id).toEqual(doc1.id)
+  })
+
+  it('ensure array update using $push is done in single db call', async () => {
+    const post = await payload.create({
+      collection: 'posts',
+      data: {
+        arrayWithIDs: [
+          {
+            text: 'some text',
+          },
+        ],
+        title: 'post',
+      },
+    })
+    const consoleCount = jest.spyOn(console, 'log').mockImplementation(() => {})
+
+    await payload.db.updateOne({
+      data: {
+        // Ensure db adapter does not automatically set updatedAt - one less db call
+        updatedAt: null,
+        arrayWithIDs: {
+          $push: {
+            text: 'some text 2',
+            id: new mongoose.Types.ObjectId().toHexString(),
+          },
+        },
+      },
+      collection: 'posts',
+      id: post.id,
+      returning: false,
+    })
+
+    // 1 Update:
+    // 1. (updatedAt for posts row.) - skipped because we explicitly set updatedAt to null
+    // 2. arrayWithIDs.$push for posts row
+    expect(consoleCount).toHaveBeenCalledTimes(1)
+    consoleCount.mockRestore()
+
+    const updatedPost = (await payload.db.findOne({
+      collection: 'posts',
+      where: { id: { equals: post.id } },
+    })) as unknown as Post
+
+    expect(updatedPost.title).toBe('post')
+    expect(updatedPost.arrayWithIDs).toHaveLength(2)
+    expect(updatedPost.arrayWithIDs?.[0]?.text).toBe('some text')
+    expect(updatedPost.arrayWithIDs?.[1]?.text).toBe('some text 2')
   })
 })