Merge branch 'main' into HEAD

test/fields/collections/Date/index.ts

@@ -115,6 +115,16 @@ const DateFields: CollectionConfig = {
         },
       ],
     },
+    {
+      type: 'array',
+      name: 'array',
+      fields: [
+        {
+          name: 'date',
+          type: 'date',
+        },
+      ],
+    },
   ],
 }
 

test/fields/collections/Group/e2e.spec.ts

@@ -0,0 +1,123 @@
+import type { Page } from '@playwright/test'
+
+import { expect, test } from '@playwright/test'
+import { addListFilter } from 'helpers/e2e/addListFilter.js'
+import path from 'path'
+import { wait } from 'payload/shared'
+import { fileURLToPath } from 'url'
+
+import type { PayloadTestSDK } from '../../../helpers/sdk/index.js'
+import type { Config } from '../../payload-types.js'
+
+import {
+  ensureCompilationIsDone,
+  initPageConsoleErrorCatch,
+  saveDocAndAssert,
+} from '../../../helpers.js'
+import { AdminUrlUtil } from '../../../helpers/adminUrlUtil.js'
+import { assertToastErrors } from '../../../helpers/assertToastErrors.js'
+import { initPayloadE2ENoConfig } from '../../../helpers/initPayloadE2ENoConfig.js'
+import { reInitializeDB } from '../../../helpers/reInitializeDB.js'
+import { RESTClient } from '../../../helpers/rest.js'
+import { TEST_TIMEOUT_LONG } from '../../../playwright.config.js'
+import { groupFieldsSlug } from '../../slugs.js'
+import { namedGroupDoc } from './shared.js'
+
+const filename = fileURLToPath(import.meta.url)
+const currentFolder = path.dirname(filename)
+const dirname = path.resolve(currentFolder, '../../')
+
+const { beforeAll, beforeEach, describe } = test
+
+let payload: PayloadTestSDK<Config>
+let client: RESTClient
+let page: Page
+let serverURL: string
+// If we want to make this run in parallel: test.describe.configure({ mode: 'parallel' })
+let url: AdminUrlUtil
+
+describe('Group', () => {
+  beforeAll(async ({ browser }, testInfo) => {
+    testInfo.setTimeout(TEST_TIMEOUT_LONG)
+    process.env.SEED_IN_CONFIG_ONINIT = 'false' // Makes it so the payload config onInit seed is not run. Otherwise, the seed would be run unnecessarily twice for the initial test run - once for beforeEach and once for onInit
+    ;({ payload, serverURL } = await initPayloadE2ENoConfig<Config>({
+      dirname,
+      // prebuild,
+    }))
+    url = new AdminUrlUtil(serverURL, groupFieldsSlug)
+
+    const context = await browser.newContext()
+    page = await context.newPage()
+    initPageConsoleErrorCatch(page)
+
+    await ensureCompilationIsDone({ page, serverURL })
+  })
+
+  beforeEach(async () => {
+    await reInitializeDB({
+      serverURL,
+      snapshotKey: 'fieldsTest',
+      uploadsDir: path.resolve(dirname, './collections/Upload/uploads'),
+    })
+    if (client) {
+      await client.logout()
+    }
+    client = new RESTClient({ defaultSlug: 'users', serverURL })
+    await client.login()
+    await ensureCompilationIsDone({ page, serverURL })
+  })
+
+  describe('Named', () => {
+    test('should display field in list view', async () => {
+      await page.goto(url.list)
+
+      const textCell = page.locator('.row-1 .cell-group')
+
+      await expect(textCell).toContainText(JSON.stringify(namedGroupDoc.group?.text), {
+        useInnerText: true,
+      })
+    })
+  })
+
+  describe('Unnamed', () => {
+    test('should display field in list view', async () => {
+      await page.goto(url.list)
+
+      const textCell = page.locator('.row-1 .cell-insideUnnamedGroup')
+
+      await expect(textCell).toContainText(namedGroupDoc?.insideUnnamedGroup ?? '', {
+        useInnerText: true,
+      })
+    })
+
+    test('should display field in list view deeply nested', async () => {
+      await page.goto(url.list)
+
+      const textCell = page.locator('.row-1 .cell-deeplyNestedGroup')
+
+      await expect(textCell).toContainText(JSON.stringify(namedGroupDoc.deeplyNestedGroup), {
+        useInnerText: true,
+      })
+    })
+
+    test('should display field visually within nested groups', async () => {
+      await page.goto(url.create)
+
+      // Makes sure the fields are rendered
+      await page.mouse.wheel(0, 2000)
+
+      const unnamedGroupSelector = `.field-type.group-field #field-insideUnnamedGroup`
+      const unnamedGroupField = page.locator(unnamedGroupSelector)
+
+      await expect(unnamedGroupField).toBeVisible()
+
+      // Makes sure the fields are rendered
+      await page.mouse.wheel(0, 2000)
+
+      // A bit repetitive but this selector should fail if the group is not nested
+      const unnamedNestedGroupSelector = `.field-type.group-field .field-type.group-field .field-type.group-field .field-type.group-field .field-type.group-field #field-deeplyNestedGroup__insideNestedUnnamedGroup`
+      const unnamedNestedGroupField = page.locator(unnamedNestedGroupSelector)
+      await expect(unnamedNestedGroupField).toBeVisible()
+    })
+  })
+})

test/fields/collections/Group/index.ts

@@ -8,6 +8,9 @@ export const groupDefaultChild = 'child takes priority'
 const GroupFields: CollectionConfig = {
   slug: groupFieldsSlug,
   versions: true,
+  admin: {
+    defaultColumns: ['id', 'group', 'insideUnnamedGroup', 'deeplyNestedGroup'],
+  },
   fields: [
     {
       label: 'Group Field',
@@ -301,6 +304,51 @@ const GroupFields: CollectionConfig = {
         },
       ],
     },
+    {
+      type: 'group',
+      label: 'Unnamed group',
+      fields: [
+        {
+          type: 'text',
+          name: 'insideUnnamedGroup',
+        },
+      ],
+    },
+    {
+      type: 'group',
+      label: 'Deeply nested group',
+      fields: [
+        {
+          type: 'group',
+          label: 'Deeply nested group',
+          fields: [
+            {
+              type: 'group',
+              name: 'deeplyNestedGroup',
+              label: 'Deeply nested group',
+              fields: [
+                {
+                  type: 'group',
+                  label: 'Deeply nested group',
+                  fields: [
+                    {
+                      type: 'group',
+                      label: 'Deeply nested group',
+                      fields: [
+                        {
+                          type: 'text',
+                          name: 'insideNestedUnnamedGroup',
+                        },
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
   ],
 }
 

test/fields/collections/Group/shared.ts

@@ -1,6 +1,6 @@
 import type { GroupField } from '../../payload-types.js'
 
-export const groupDoc: Partial<GroupField> = {
+export const namedGroupDoc: Partial<GroupField> = {
   group: {
     text: 'some text within a group',
     subGroup: {
@@ -12,4 +12,8 @@ export const groupDoc: Partial<GroupField> = {
       ],
     },
   },
+  insideUnnamedGroup: 'text in unnamed group',
+  deeplyNestedGroup: {
+    insideNestedUnnamedGroup: 'text in nested unnamed group',
+  },
 }

test/fields/int.spec.ts

@@ -15,7 +15,7 @@ import { arrayDefaultValue } from './collections/Array/index.js'
 import { blocksDoc } from './collections/Blocks/shared.js'
 import { dateDoc } from './collections/Date/shared.js'
 import { groupDefaultChild, groupDefaultValue } from './collections/Group/index.js'
-import { groupDoc } from './collections/Group/shared.js'
+import { namedGroupDoc } from './collections/Group/shared.js'
 import { defaultNumber } from './collections/Number/index.js'
 import { numberDoc } from './collections/Number/shared.js'
 import { pointDoc } from './collections/Point/shared.js'
@@ -600,6 +600,56 @@ describe('Fields', () => {
 
       expect(result.docs[0].id).toEqual(doc.id)
     })
+
+    // Function to generate random date between start and end dates
+    function getRandomDate(start: Date, end: Date): string {
+      const date = new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime()))
+      return date.toISOString()
+    }
+
+    // Generate sample data
+    const dataSample = Array.from({ length: 100 }, (_, index) => {
+      const startDate = new Date('2024-01-01')
+      const endDate = new Date('2025-12-31')
+
+      return {
+        array: Array.from({ length: 5 }, (_, listIndex) => {
+          return {
+            date: getRandomDate(startDate, endDate),
+          }
+        }),
+        ...dateDoc,
+      }
+    })
+
+    it('should query a date field inside an array field', async () => {
+      await payload.delete({ collection: 'date-fields', where: {} })
+      for (const doc of dataSample) {
+        await payload.create({
+          collection: 'date-fields',
+          data: doc,
+        })
+      }
+
+      const res = await payload.find({
+        collection: 'date-fields',
+        where: { 'array.date': { greater_than: new Date('2025-06-01').toISOString() } },
+      })
+
+      const filter = (doc: any) =>
+        doc.array.some((item) => new Date(item.date).getTime() > new Date('2025-06-01').getTime())
+
+      expect(res.docs.every(filter)).toBe(true)
+      expect(dataSample.filter(filter)).toHaveLength(res.totalDocs)
+      // eslint-disable-next-line jest/no-conditional-in-test
+      if (res.totalDocs > 10) {
+        // This is where postgres might fail! selectDistinct actually removed some rows here, because it distincts by:
+        // not only ID, but also created_at, updated_at, items_date
+        expect(res.docs).toHaveLength(10)
+      } else {
+        expect(res.docs.length).toBeLessThanOrEqual(res.totalDocs)
+      }
+    })
   })
 
   describe('select', () => {
@@ -1564,7 +1614,7 @@ describe('Fields', () => {
     it('should create with ids and nested ids', async () => {
       const docWithIDs = (await payload.create({
         collection: groupFieldsSlug,
-        data: groupDoc,
+        data: namedGroupDoc,
       })) as Partial<GroupField>
       expect(docWithIDs.group.subGroup.arrayWithinGroup[0].id).toBeDefined()
     })
@@ -1863,6 +1913,53 @@ describe('Fields', () => {
       })
     })
 
+    it('should work with unnamed group', async () => {
+      const groupDoc = await payload.create({
+        collection: groupFieldsSlug,
+        data: {
+          insideUnnamedGroup: 'Hello world',
+          deeplyNestedGroup: { insideNestedUnnamedGroup: 'Secondfield' },
+        },
+      })
+      expect(groupDoc).toMatchObject({
+        id: expect.anything(),
+        insideUnnamedGroup: 'Hello world',
+        deeplyNestedGroup: {
+          insideNestedUnnamedGroup: 'Secondfield',
+        },
+      })
+    })
+
+    it('should work with unnamed group - graphql', async () => {
+      const mutation = `mutation {
+              createGroupField(
+                data: {
+                  insideUnnamedGroup: "Hello world",
+                  deeplyNestedGroup: { insideNestedUnnamedGroup: "Secondfield" },
+                  group: {text: "hello"}
+                }
+              ) {
+                insideUnnamedGroup
+                deeplyNestedGroup {
+                  insideNestedUnnamedGroup
+                }
+              }
+            }`
+
+      const groupDoc = await restClient.GRAPHQL_POST({
+        body: JSON.stringify({ query: mutation }),
+      })
+
+      const data = (await groupDoc.json()).data.createGroupField
+
+      expect(data).toMatchObject({
+        insideUnnamedGroup: 'Hello world',
+        deeplyNestedGroup: {
+          insideNestedUnnamedGroup: 'Secondfield',
+        },
+      })
+    })
+
     it('should query a subfield within a localized group', async () => {
       const text = 'find this'
       const hit = await payload.create({
@@ -2307,7 +2404,7 @@ describe('Fields', () => {
     it('should return empty object for groups when no data present', async () => {
       const doc = await payload.create({
         collection: groupFieldsSlug,
-        data: groupDoc,
+        data: namedGroupDoc,
       })
 
       expect(doc.potentiallyEmptyGroup).toBeDefined()

test/fields/payload-types.ts

@@ -929,6 +929,12 @@ export interface DateField {
         id?: string | null;
       }[]
     | null;
+  array?:
+    | {
+        date?: string | null;
+        id?: string | null;
+      }[]
+    | null;
   updatedAt: string;
   createdAt: string;
 }
@@ -1074,6 +1080,10 @@ export interface GroupField {
         }[]
       | null;
   };
+  insideUnnamedGroup?: string | null;
+  deeplyNestedGroup?: {
+    insideNestedUnnamedGroup?: string | null;
+  };
   updatedAt: string;
   createdAt: string;
 }
@@ -1326,10 +1336,16 @@ export interface RelationshipField {
       } | null);
   relationshipDrawerHasMany?: (string | TextField)[] | null;
   relationshipDrawerHasManyPolymorphic?:
-    | {
-        relationTo: 'text-fields';
-        value: string | TextField;
-      }[]
+    | (
+        | {
+            relationTo: 'text-fields';
+            value: string | TextField;
+          }
+        | {
+            relationTo: 'array-fields';
+            value: string | ArrayField;
+          }
+      )[]
     | null;
   relationshipDrawerWithAllowCreateFalse?: (string | null) | TextField;
   relationshipDrawerWithFilterOptions?: {
@@ -2492,6 +2508,12 @@ export interface DateFieldsSelect<T extends boolean = true> {
         dayAndTime_tz?: T;
         id?: T;
       };
+  array?:
+    | T
+    | {
+        date?: T;
+        id?: T;
+      };
   updatedAt?: T;
   createdAt?: T;
 }
@@ -2658,6 +2680,12 @@ export interface GroupFieldsSelect<T extends boolean = true> {
     | {
         email?: T;
       };
+  insideUnnamedGroup?: T;
+  deeplyNestedGroup?:
+    | T
+    | {
+        insideNestedUnnamedGroup?: T;
+      };
   updatedAt?: T;
   createdAt?: T;
 }

test/fields/seed.ts

@@ -16,7 +16,7 @@ import { conditionalLogicDoc } from './collections/ConditionalLogic/shared.js'
 import { customRowID, customTabID, nonStandardID } from './collections/CustomID/shared.js'
 import { dateDoc } from './collections/Date/shared.js'
 import { anotherEmailDoc, emailDoc } from './collections/Email/shared.js'
-import { groupDoc } from './collections/Group/shared.js'
+import { namedGroupDoc } from './collections/Group/shared.js'
 import { jsonDoc } from './collections/JSON/shared.js'
 import { numberDoc } from './collections/Number/shared.js'
 import { pointDoc } from './collections/Point/shared.js'
@@ -223,7 +223,7 @@ export const seed = async (_payload: Payload) => {
 
   await _payload.create({
     collection: groupFieldsSlug,
-    data: groupDoc,
+    data: namedGroupDoc,
     depth: 0,
     overrideAccess: true,
   })