test(json-api): add repeated hasMany patch regression

Author: alexraputa

tests/json-api/tests/integration/cache/mutation-request-test.ts

@@ -6,7 +6,7 @@ import type { Type } from '@warp-drive/core/types/symbols';
 import { module, test, todo } from '@warp-drive/diagnostic';
 import type { TestContext } from '@warp-drive/diagnostic/-types';
 import { MockServerHandler } from '@warp-drive/holodeck';
-import { POST } from '@warp-drive/holodeck/mock';
+import { PATCH, POST } from '@warp-drive/holodeck/mock';
 import { JSONAPICache } from '@warp-drive/json-api';
 import { buildBaseURL } from '@warp-drive/utilities';
 
@@ -22,6 +22,14 @@ interface ExistingUser {
   id: string;
   firstName: string;
   lastName: string;
+  pets: ExistingPet[];
+}
+
+interface ExistingPet {
+  [Type]: 'pet';
+  id: string;
+  name: string;
+  owner: ExistingUser | null;
 }
 
 interface CustomContext extends TestContext {
@@ -39,6 +47,24 @@ module<CustomContext>('mutation-request', function (hooks) {
           fields: [
             { name: 'firstName', kind: 'field' },
             { name: 'lastName', kind: 'field' },
+            {
+              name: 'pets',
+              kind: 'hasMany',
+              type: 'pet',
+              options: { inverse: 'owner', async: false, linksMode: true },
+            },
+          ],
+        }),
+        withDefaults({
+          type: 'pet',
+          fields: [
+            { name: 'name', kind: 'field' },
+            {
+              name: 'owner',
+              kind: 'belongsTo',
+              type: 'user',
+              options: { inverse: 'pets', async: false, linksMode: true },
+            },
           ],
         }),
       ],
@@ -108,6 +134,174 @@ module<CustomContext>('mutation-request', function (hooks) {
     assert.equal(user2?.id, 'id2', 'second record has correct id');
   });
 
+  test<CustomContext>('update hasMany with repeated patch', async function (assert) {
+    const { store } = this;
+    const url = buildBaseURL({ resourcePath: 'api/user/1' });
+
+    store.push({
+      data: [
+        {
+          type: 'user',
+          id: '1',
+          attributes: { firstName: 'Chris', lastName: 'Thoburn' },
+          relationships: {
+            pets: {
+              links: {
+                self: '/api/user/1/relationships/pets',
+                related: '/api/user/1/pets',
+              },
+              data: [{ type: 'pet', id: '1' }],
+            },
+          },
+        },
+        {
+          type: 'user',
+          id: '2',
+          attributes: { firstName: 'Tom', lastName: 'Dale' },
+          relationships: {
+            pets: {
+              links: {
+                self: '/api/user/2/relationships/pets',
+                related: '/api/user/2/pets',
+              },
+              data: [{ type: 'pet', id: '2' }],
+            },
+          },
+        },
+      ],
+      included: [
+        {
+          type: 'pet',
+          id: '1',
+          attributes: { name: 'Rey' },
+          relationships: {
+            owner: {
+              links: {
+                self: '/api/pet/1/relationships/owner',
+                related: '/api/pet/1/owner',
+              },
+              data: { type: 'user', id: '1' },
+            },
+          },
+        },
+        {
+          type: 'pet',
+          id: '2',
+          attributes: { name: 'Pixel' },
+          relationships: {
+            owner: {
+              links: {
+                self: '/api/pet/2/relationships/owner',
+                related: '/api/pet/2/owner',
+              },
+              data: { type: 'user', id: '2' },
+            },
+          },
+        },
+      ],
+    });
+
+    const pet1 = store.peekRecord<ExistingPet>('pet', '1');
+    const pet2 = store.peekRecord<ExistingPet>('pet', '2');
+    const user1 = store.peekRecord<ExistingUser>('user', '1');
+    const user2 = store.peekRecord<ExistingUser>('user', '2');
+
+    const lid = recordIdentifierFor(user1);
+
+    const patchUser1 = async (petIds: string[]) => {
+      const reqBody = JSON.stringify({
+        data: {
+          type: 'user',
+          id: '1',
+          relationships: {
+            pets: {
+              data: petIds.map((id) => ({ type: 'pet', id })),
+            },
+          },
+        },
+      });
+
+      await PATCH(
+        this,
+        '/api/user/1',
+        () => {
+          return {
+            data: {
+              type: 'user',
+              id: '1',
+              attributes: { firstName: 'Chris', lastName: 'Thoburn' },
+              relationships: {
+                pets: {
+                  links: {
+                    self: '/api/user/1/relationships/pets',
+                    related: '/api/user/1/pets',
+                  },
+                  data: petIds.map((id) => ({ type: 'pet', id })),
+                },
+              },
+            },
+          };
+        },
+        {
+          body: reqBody,
+        }
+      );
+
+      await this.store.request(
+        withReactiveResponse<ExistingUser>({
+          op: 'updateRecord',
+          url,
+          method: 'PATCH',
+          body: reqBody,
+          records: [lid],
+        })
+      );
+    };
+
+    assert.equal(pet1?.owner?.id, '1', 'first pet starts on the first user');
+    assert.equal(pet2?.owner?.id, '2', 'second pet starts on the second user');
+    assert.deepEqual(
+      user1?.pets.map((value) => value.id),
+      ['1'],
+      'first user starts with the first pet'
+    );
+    assert.deepEqual(
+      user2?.pets.map((value) => value.id),
+      ['2'],
+      'second user starts with the second pet'
+    );
+
+    await patchUser1(['1', '2']);
+
+    assert.equal(pet1?.owner?.id, '1', 'first pet stays on the first user after the first patch');
+    assert.equal(pet2?.owner?.id, '1', 'second pet moves to the first user after the first patch');
+    assert.deepEqual(
+      user1?.pets.map((value) => value.id),
+      ['1', '2'],
+      'first user has both pets after the first patch'
+    );
+    assert.deepEqual(
+      user2?.pets.map((value) => value.id),
+      [],
+      'second user pets are cleared after the first patch'
+    );
+
+    await patchUser1(['1']);
+
+    assert.equal(pet1?.owner?.id, '1', 'first pet stays on the first user after the second patch');
+    assert.equal(pet2?.owner, null, 'second pet owner is cleared after the second patch');
+    assert.deepEqual(
+      user1?.pets.map((value) => value.id),
+      ['1'],
+      'first user is reduced to the first pet'
+    );
+    assert.deepEqual(
+      user2?.pets.map((value) => value.id),
+      [],
+      'second user still has no pets after the second patch'
+    );
+  });
+
   todo('bulk delete', function (assert) {});
   todo('bulk update with 204 response', function (assert) {});
   todo('bulk-delete with 204 response', function (assert) {});