test: group relationships

* test: relationship fields inside groups and subgroup

* test: group nested relationships and arrays

* test: improves coverage for hooks

Co-authored-by: James <[email protected]>

Author: DanRibbens

test/fields-relationship/config.ts

@@ -1,4 +1,4 @@
-import type { CollectionConfig } from '../../../src/collections/config/types';
+import type { CollectionConfig } from '../../src/collections/config/types';
 import { buildConfig } from '../buildConfig';
 import { devUser } from '../credentials';
 import { mapAsync } from '../../src/utilities/mapAsync';
@@ -9,8 +9,6 @@ export const relationOneSlug = 'relation-one';
 export const relationTwoSlug = 'relation-two';
 export const relationRestrictedSlug = 'relation-restricted';
 export const relationWithTitleSlug = 'relation-with-title';
-export const groupWithNestedRelationship = 'group-nested-relation-with-title';
-export const nestedRelationship = 'nested-relation-with-title';
 
 export interface FieldsRelationship {
   id: string;
@@ -39,20 +37,6 @@ const baseRelationshipFields: CollectionConfig['fields'] = [
   },
 ];
 
-const groupWithNestedRelationshipFields = (relationTo: string): CollectionConfig['fields'] => ([
-  {
-    type: 'group',
-    name: 'group',
-    fields: [
-      {
-        name: 'relation',
-        type: 'relationship',
-        relationTo,
-      },
-    ],
-  },
-]);
-
 export default buildConfig({
   collections: [
     {
@@ -126,14 +110,6 @@ export default buildConfig({
       },
       fields: baseRelationshipFields,
     },
-    {
-      slug: groupWithNestedRelationship,
-      fields: groupWithNestedRelationshipFields(nestedRelationship),
-    },
-    {
-      slug: nestedRelationship,
-      fields: groupWithNestedRelationshipFields(relationWithTitleSlug),
-    },
   ],
   onInit: async (payload) => {
     await payload.create({

test/fields-relationship/int.spec.ts

@@ -97,7 +97,9 @@ export interface GroupNestedRelationWithTitle {
 export interface NestedRelationWithTitle {
   id: string;
   group?: {
-    relation?: string | RelationWithTitle;
+    subGroup?: {
+      relation?: string | RelationOne;
+    };
   };
   createdAt: string;
   updatedAt: string;

test/fields-relationship/payload-types.ts

@@ -58,6 +58,16 @@ const ArrayFields: CollectionConfig = {
         },
       ],
     },
+    {
+      type: 'array',
+      name: 'potentiallyEmptyArray',
+      fields: [
+        {
+          type: 'text',
+          name: 'text',
+        },
+      ],
+    },
   ],
 };
 

test/fields/collections/Array/index.ts

@@ -57,6 +57,16 @@ const GroupFields: CollectionConfig = {
         },
       ],
     },
+    {
+      name: 'potentiallyEmptyGroup',
+      type: 'group',
+      fields: [
+        {
+          name: 'text',
+          type: 'text',
+        },
+      ],
+    },
   ],
 };
 

test/fields/collections/Group/index.ts

@@ -4,7 +4,7 @@ import config from '../uploads/config';
 import payload from '../../src';
 import { pointDoc } from './collections/Point';
 import type { ArrayField, GroupField } from './payload-types';
-import { arrayFieldsSlug, arrayDefaultValue } from './collections/Array';
+import { arrayFieldsSlug, arrayDefaultValue, arrayDoc } from './collections/Array';
 import { groupFieldsSlug, groupDefaultChild, groupDefaultValue, groupDoc } from './collections/Group';
 import { defaultText } from './collections/Text';
 
@@ -89,6 +89,15 @@ describe('Fields', () => {
       });
     });
 
+    it('should return empty array for arrays when no data present', async () => {
+      const document = await payload.create<ArrayField>({
+        collection: arrayFieldsSlug,
+        data: arrayDoc,
+      });
+
+      expect(document.potentiallyEmptyArray).toEqual([]);
+    });
+
     it('should create with ids and nested ids', async () => {
       const docWithIDs = await payload.create<GroupField>({
         collection: groupFieldsSlug,
@@ -158,5 +167,14 @@ describe('Fields', () => {
       expect(document.group.defaultParent).toStrictEqual(groupDefaultValue);
       expect(document.group.defaultChild).toStrictEqual(groupDefaultChild);
     });
+
+    it('should return empty object for groups when no data present', async () => {
+      const doc = await payload.create<GroupField>({
+        collection: groupFieldsSlug,
+        data: groupDoc,
+      });
+
+      expect(doc.potentiallyEmptyGroup).toEqual({});
+    });
   });
 });

test/fields/int.spec.ts

@@ -20,7 +20,11 @@ export interface ArrayField {
     text: string;
     id?: string;
   }[];
-  readOnly?: {
+  readOnly: {
+    text?: string;
+    id?: string;
+  }[];
+  potentiallyEmptyArray: {
     text?: string;
     id?: string;
   }[];
@@ -47,7 +51,7 @@ export interface BlockField {
         blockType: 'number';
       }
     | {
-        subBlocks?: (
+        subBlocks: (
           | {
               text: string;
               id?: string;
@@ -76,9 +80,9 @@ export interface BlockField {
 export interface CollapsibleField {
   id: string;
   text: string;
-  group?: {
+  group: {
     textWithinGroup?: string;
-    subGroup?: {
+    subGroup: {
       textWithinSubGroup?: string;
     };
   };
@@ -103,18 +107,21 @@ export interface ConditionalLogic {
  */
 export interface GroupField {
   id: string;
-  group?: {
+  group: {
     text: string;
     defaultParent?: string;
     defaultChild?: string;
-    subGroup?: {
+    subGroup: {
       textWithinGroup?: string;
-      arrayWithinGroup?: {
+      arrayWithinGroup: {
         textWithinArray?: string;
         id?: string;
       }[];
     };
   };
+  potentiallyEmptyGroup: {
+    text?: string;
+  };
   createdAt: string;
   updatedAt: string;
 }
@@ -134,7 +141,7 @@ export interface PointField {
    * @maxItems 2
    */
   localized?: [number, number];
-  group?: {
+  group: {
     /**
      * @minItems 2
      * @maxItems 2
@@ -192,7 +199,7 @@ export interface TabsField {
         blockType: 'number';
       }
     | {
-        subBlocks?: (
+        subBlocks: (
           | {
               text: string;
               id?: string;
@@ -211,7 +218,7 @@ export interface TabsField {
         blockType: 'subBlocks';
       }
   )[];
-  group?: {
+  group: {
     number: number;
   };
   textarea?: string;

test/fields/payload-types.ts

@@ -39,7 +39,7 @@ if (testConfigDir) {
 function setPaths(dir) {
   const configPath = path.resolve(dir, 'config.ts');
   const outputPath = path.resolve(dir, 'payload-types.ts');
-  if (fs.existsSync(configPath) && fs.existsSync(outputPath)) {
+  if (fs.existsSync(configPath)) {
     process.env.PAYLOAD_CONFIG_PATH = configPath;
     process.env.PAYLOAD_TS_OUTPUT_PATH = outputPath;
     return true;

test/generateTypes.js

@@ -95,6 +95,7 @@ const createHookOrder = [
   'collectionBeforeChange',
   'fieldBeforeChange',
   'fieldAfterRead',
+  'collectionAfterRead',
   'fieldAfterChange',
   'collectionAfterChange',
 ];

test/hooks/collections/Hook/index.ts

@@ -0,0 +1,68 @@
+import { CollectionConfig } from '../../../../src/collections/config/types';
+import { relationsSlug } from '../Relations';
+
+export const nestedAfterReadHooksSlug = 'nested-after-read-hooks';
+
+export const generatedAfterReadText = 'hello';
+
+const NestedAfterReadHooks: CollectionConfig = {
+  slug: nestedAfterReadHooksSlug,
+  fields: [
+    {
+      type: 'text',
+      name: 'text',
+    },
+    {
+      type: 'group',
+      name: 'group',
+      fields: [
+        {
+          type: 'array',
+          name: 'array',
+          fields: [
+            {
+              type: 'text',
+              name: 'input',
+            },
+            {
+              type: 'text',
+              name: 'afterRead',
+              hooks: {
+                afterRead: [(): string => {
+                  return generatedAfterReadText;
+                }],
+              },
+            },
+            {
+              name: 'shouldPopulate',
+              type: 'relationship',
+              relationTo: relationsSlug,
+            },
+          ],
+        },
+        {
+          type: 'group',
+          name: 'subGroup',
+          fields: [
+            {
+              name: 'afterRead',
+              type: 'text',
+              hooks: {
+                afterRead: [(): string => {
+                  return generatedAfterReadText;
+                }],
+              },
+            },
+            {
+              name: 'shouldPopulate',
+              type: 'relationship',
+              relationTo: relationsSlug,
+            },
+          ],
+        },
+      ],
+    },
+  ],
+};
+
+export default NestedAfterReadHooks;