snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-server/test/integration/graphql/suites/upsert/activity-target-upsert.integration-spec.ts

@@ -0,0 +1,109 @@
+import { randomUUID } from 'crypto';
+import { isDefined } from 'twenty-shared/utils';
+
+import { createManyOperationFactory } from 'test/integration/graphql/utils/create-many-operation-factory.util';
+import { createOneOperation } from 'test/integration/graphql/utils/create-one-operation.util';
+import { deleteOneOperationFactory } from 'test/integration/graphql/utils/delete-one-operation-factory.util';
+import { destroyOneOperationFactory } from 'test/integration/graphql/utils/destroy-one-operation-factory.util';
+import { findManyOperationFactory } from 'test/integration/graphql/utils/find-many-operation-factory.util';
+import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+
+describe('activity target upsert', () => {
+  it('keeps one live task target and restores it after deletion', async () => {
+    const taskId = randomUUID();
+    const personId = randomUUID();
+    let taskTargetId: string | undefined;
+
+    try {
+      await createOneOperation({
+        objectMetadataSingularName: 'task',
+        gqlFields: 'id',
+        input: { id: taskId, title: 'Activity target upsert task' },
+      });
+      await createOneOperation({
+        objectMetadataSingularName: 'person',
+        gqlFields: 'id',
+        input: {
+          id: personId,
+          name: { firstName: 'Activity target', lastName: 'upsert' },
+        },
+      });
+
+      const createTaskTarget = () =>
+        makeGraphqlAPIRequest(
+          createManyOperationFactory({
+            objectMetadataSingularName: 'taskTarget',
+            objectMetadataPluralName: 'taskTargets',
+            gqlFields: 'id deletedAt taskId targetPersonId',
+            data: [{ taskId, targetPersonId: personId }],
+            upsert: true,
+          }),
+        );
+
+      const firstCreateResponse = await createTaskTarget();
+      const createdTaskTargetId =
+        firstCreateResponse.body.data.createTaskTargets[0].id;
+
+      taskTargetId = createdTaskTargetId;
+
+      const repeatedCreateResponse = await createTaskTarget();
+
+      expect(repeatedCreateResponse.body.data.createTaskTargets[0]).toEqual(
+        expect.objectContaining({ id: createdTaskTargetId, deletedAt: null }),
+      );
+
+      await makeGraphqlAPIRequest(
+        deleteOneOperationFactory({
+          objectMetadataSingularName: 'taskTarget',
+          gqlFields: 'id',
+          recordId: createdTaskTargetId,
+        }),
+      );
+
+      const restoreResponse = await createTaskTarget();
+
+      expect(restoreResponse.body.data.createTaskTargets[0]).toEqual(
+        expect.objectContaining({ id: createdTaskTargetId, deletedAt: null }),
+      );
+
+      const findResponse = await makeGraphqlAPIRequest(
+        findManyOperationFactory({
+          objectMetadataSingularName: 'taskTarget',
+          objectMetadataPluralName: 'taskTargets',
+          gqlFields: 'id',
+          filter: {
+            taskId: { eq: taskId },
+            targetPersonId: { eq: personId },
+          },
+        }),
+      );
+
+      expect(findResponse.body.data.taskTargets.edges).toHaveLength(1);
+    } finally {
+      if (isDefined(taskTargetId)) {
+        await makeGraphqlAPIRequest(
+          destroyOneOperationFactory({
+            objectMetadataSingularName: 'taskTarget',
+            gqlFields: 'id',
+            recordId: taskTargetId,
+          }),
+        );
+      }
+
+      await makeGraphqlAPIRequest(
+        destroyOneOperationFactory({
+          objectMetadataSingularName: 'task',
+          gqlFields: 'id',
+          recordId: taskId,
+        }),
+      );
+      await makeGraphqlAPIRequest(
+        destroyOneOperationFactory({
+          objectMetadataSingularName: 'person',
+          gqlFields: 'id',
+          recordId: personId,
+        }),
+      );
+    }
+  });
+});

packages/twenty-server/test/integration/graphql/suites/upsert/composite-unique-index-upsert.integration-spec.ts

@@ -0,0 +1,393 @@
+import { createManyOperationFactory } from 'test/integration/graphql/utils/create-many-operation-factory.util';
+import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import { buildBaseManifest } from 'test/integration/metadata/suites/application/utils/build-base-manifest.util';
+import { buildDefaultObjectManifest } from 'test/integration/metadata/suites/application/utils/build-default-object-manifest.util';
+import { cleanupApplicationAndAppRegistration } from 'test/integration/metadata/suites/application/utils/cleanup-application-and-app-registration.util';
+import { setupApplicationForSync } from 'test/integration/metadata/suites/application/utils/setup-application-for-sync.util';
+import { syncApplication } from 'test/integration/metadata/suites/application/utils/sync-application.util';
+import { type Manifest } from 'twenty-shared/application';
+import { FieldMetadataType } from 'twenty-shared/types';
+import { v4 as uuidv4 } from 'uuid';
+
+// A composite UNIQUE index can't be created through the public index API
+// (createOneIndex forces isUnique: false). Application manifest sync is the only
+// API-driven path that yields one: it runs the same validate/build/run migration
+// internally, provisioning a real composite unique index we can upsert against.
+const TEST_APP_ID = uuidv4();
+const TEST_ROLE_ID = uuidv4();
+const FIRST_FIELD_ID = uuidv4();
+const SECOND_FIELD_ID = uuidv4();
+const PAYLOAD_FIELD_ID = uuidv4();
+const INDEX_ID = uuidv4();
+
+const DUAL_A_FIRST_FIELD_ID = uuidv4();
+const DUAL_A_SECOND_FIELD_ID = uuidv4();
+const DUAL_B_FIRST_FIELD_ID = uuidv4();
+const DUAL_B_SECOND_FIELD_ID = uuidv4();
+const DUAL_PAYLOAD_FIELD_ID = uuidv4();
+const DUAL_INDEX_A_ID = uuidv4();
+const DUAL_INDEX_B_ID = uuidv4();
+
+const OBJECT = buildDefaultObjectManifest({
+  applicationUniversalIdentifier: TEST_APP_ID,
+  nameSingular: 'compositeUpsertRecord',
+  namePlural: 'compositeUpsertRecords',
+  labelSingular: 'Composite Upsert Record',
+  labelPlural: 'Composite Upsert Records',
+  description: 'Object to test composite unique index upsert',
+  icon: 'IconTestRecord',
+  additionalFields: [
+    {
+      universalIdentifier: FIRST_FIELD_ID,
+      type: FieldMetadataType.TEXT,
+      name: 'firstKey',
+      label: 'First Key',
+      isNullable: true,
+    },
+    {
+      universalIdentifier: SECOND_FIELD_ID,
+      type: FieldMetadataType.TEXT,
+      name: 'secondKey',
+      label: 'Second Key',
+      isNullable: true,
+    },
+    {
+      universalIdentifier: PAYLOAD_FIELD_ID,
+      type: FieldMetadataType.TEXT,
+      name: 'payload',
+      label: 'Payload',
+      isNullable: true,
+    },
+  ],
+});
+
+// Second object with TWO independent composite unique indexes
+// (indexA on aFirst+aSecond, indexB on bFirst+bSecond). This lets us exercise
+// upsert conflict resolution when a payload can match different rows through
+// different unique indexes.
+const DUAL_OBJECT = buildDefaultObjectManifest({
+  applicationUniversalIdentifier: TEST_APP_ID,
+  nameSingular: 'dualCompositeUpsertRecord',
+  namePlural: 'dualCompositeUpsertRecords',
+  labelSingular: 'Dual Composite Upsert Record',
+  labelPlural: 'Dual Composite Upsert Records',
+  description: 'Object to test upsert with two composite unique indexes',
+  icon: 'IconTestRecord',
+  additionalFields: [
+    {
+      universalIdentifier: DUAL_A_FIRST_FIELD_ID,
+      type: FieldMetadataType.TEXT,
+      name: 'aFirstKey',
+      label: 'A First Key',
+      isNullable: true,
+    },
+    {
+      universalIdentifier: DUAL_A_SECOND_FIELD_ID,
+      type: FieldMetadataType.TEXT,
+      name: 'aSecondKey',
+      label: 'A Second Key',
+      isNullable: true,
+    },
+    {
+      universalIdentifier: DUAL_B_FIRST_FIELD_ID,
+      type: FieldMetadataType.TEXT,
+      name: 'bFirstKey',
+      label: 'B First Key',
+      isNullable: true,
+    },
+    {
+      universalIdentifier: DUAL_B_SECOND_FIELD_ID,
+      type: FieldMetadataType.TEXT,
+      name: 'bSecondKey',
+      label: 'B Second Key',
+      isNullable: true,
+    },
+    {
+      universalIdentifier: DUAL_PAYLOAD_FIELD_ID,
+      type: FieldMetadataType.TEXT,
+      name: 'payload',
+      label: 'Payload',
+      isNullable: true,
+    },
+  ],
+});
+
+const manifest: Manifest = buildBaseManifest({
+  appId: TEST_APP_ID,
+  roleId: TEST_ROLE_ID,
+  overrides: {
+    objects: [OBJECT, DUAL_OBJECT],
+    fields: [],
+    indexes: [
+      {
+        universalIdentifier: INDEX_ID,
+        objectUniversalIdentifier: OBJECT.universalIdentifier,
+        isUnique: true,
+        fields: [
+          {
+            universalIdentifier: uuidv4(),
+            fieldUniversalIdentifier: FIRST_FIELD_ID,
+          },
+          {
+            universalIdentifier: uuidv4(),
+            fieldUniversalIdentifier: SECOND_FIELD_ID,
+          },
+        ],
+      },
+      {
+        universalIdentifier: DUAL_INDEX_A_ID,
+        objectUniversalIdentifier: DUAL_OBJECT.universalIdentifier,
+        isUnique: true,
+        fields: [
+          {
+            universalIdentifier: uuidv4(),
+            fieldUniversalIdentifier: DUAL_A_FIRST_FIELD_ID,
+          },
+          {
+            universalIdentifier: uuidv4(),
+            fieldUniversalIdentifier: DUAL_A_SECOND_FIELD_ID,
+          },
+        ],
+      },
+      {
+        universalIdentifier: DUAL_INDEX_B_ID,
+        objectUniversalIdentifier: DUAL_OBJECT.universalIdentifier,
+        isUnique: true,
+        fields: [
+          {
+            universalIdentifier: uuidv4(),
+            fieldUniversalIdentifier: DUAL_B_FIRST_FIELD_ID,
+          },
+          {
+            universalIdentifier: uuidv4(),
+            fieldUniversalIdentifier: DUAL_B_SECOND_FIELD_ID,
+          },
+        ],
+      },
+    ],
+  },
+});
+
+const GQL_FIELDS = `
+  id
+  firstKey
+  secondKey
+  payload
+`;
+
+const upsertRecords = (data: object[], upsert: boolean) =>
+  makeGraphqlAPIRequest(
+    createManyOperationFactory({
+      objectMetadataSingularName: OBJECT.nameSingular,
+      objectMetadataPluralName: OBJECT.namePlural,
+      gqlFields: GQL_FIELDS,
+      data,
+      upsert,
+    }),
+  );
+
+const getRecords = (response: { body: { data: Record<string, unknown> } }) =>
+  response.body.data.createCompositeUpsertRecords as {
+    id: string;
+    firstKey: string;
+    secondKey: string;
+    payload: string;
+  }[];
+
+const DUAL_GQL_FIELDS = `
+  id
+  aFirstKey
+  aSecondKey
+  bFirstKey
+  bSecondKey
+  payload
+`;
+
+const upsertDualRecords = (data: object[], upsert: boolean) =>
+  makeGraphqlAPIRequest(
+    createManyOperationFactory({
+      objectMetadataSingularName: DUAL_OBJECT.nameSingular,
+      objectMetadataPluralName: DUAL_OBJECT.namePlural,
+      gqlFields: DUAL_GQL_FIELDS,
+      data,
+      upsert,
+    }),
+  );
+
+const getDualRecords = (response: { body: { data: Record<string, unknown> } }) =>
+  response.body.data.createDualCompositeUpsertRecords as {
+    id: string;
+    aFirstKey: string;
+    aSecondKey: string;
+    bFirstKey: string;
+    bSecondKey: string;
+    payload: string;
+  }[];
+
+describe('upsert with composite unique index', () => {
+  beforeAll(async () => {
+    await setupApplicationForSync({
+      applicationUniversalIdentifier: TEST_APP_ID,
+      name: 'Composite Upsert App',
+      description: 'App for composite unique index upsert test',
+      sourcePath: 'test-composite-unique-upsert',
+    });
+
+    await syncApplication({ manifest, expectToFail: false });
+  }, 60000);
+
+  afterAll(async () => {
+    await cleanupApplicationAndAppRegistration({
+      applicationUniversalIdentifier: TEST_APP_ID,
+    });
+  }, 60000);
+
+  it('updates the existing record when the full composite key matches', async () => {
+    const recordId = uuidv4();
+
+    const created = getRecords(
+      await upsertRecords(
+        [{ id: recordId, firstKey: 'A', secondKey: 'B', payload: 'original' }],
+        false,
+      ),
+    )[0];
+
+    expect(created.id).toBe(recordId);
+    expect(created.payload).toBe('original');
+
+
+    const upserted = getRecords(
+      await upsertRecords(
+        [{ firstKey: 'A', secondKey: 'B', payload: 'updated' }],
+        true,
+      ),
+    );
+
+    expect(upserted).toHaveLength(1);
+    expect(upserted[0].id).toBe(recordId);
+    expect(upserted[0].payload).toBe('updated');
+  }, 60000);
+
+  it('inserts a new record when only part of the composite key matches', async () => {
+    const existingId = uuidv4();
+    const newId = uuidv4();
+
+    const created = getRecords(
+      await upsertRecords(
+        [{ id: existingId, firstKey: 'C', secondKey: 'D', payload: 'first' }],
+        false,
+      ),
+    )[0];
+
+    const upserted = getRecords(
+      await upsertRecords(
+        [{ id: newId, firstKey: 'C', secondKey: 'X', payload: 'second' }],
+        true,
+      ),
+    );
+
+    expect(upserted).toHaveLength(1);
+    expect(upserted[0].id).toBe(newId);
+    expect(upserted[0].id).not.toBe(created.id);
+    expect(upserted[0].payload).toBe('second');
+  }, 60000);
+
+  describe('with two composite unique indexes', () => {
+    it('updates the record when a single row matches on both composite indexes', async () => {
+      const recordId = uuidv4();
+
+      const created = getDualRecords(
+        await upsertDualRecords(
+          [
+            {
+              id: recordId,
+              aFirstKey: 'a1',
+              aSecondKey: 'a2',
+              bFirstKey: 'b1',
+              bSecondKey: 'b2',
+              payload: 'original',
+            },
+          ],
+          false,
+        ),
+      )[0];
+
+      expect(created.id).toBe(recordId);
+      expect(created.payload).toBe('original');
+
+      // The payload matches this single row through both composite indexes,
+      // so there is no ambiguity and the existing record is updated in place.
+      const upserted = getDualRecords(
+        await upsertDualRecords(
+          [
+            {
+              aFirstKey: 'a1',
+              aSecondKey: 'a2',
+              bFirstKey: 'b1',
+              bSecondKey: 'b2',
+              payload: 'updated',
+            },
+          ],
+          true,
+        ),
+      );
+
+      expect(upserted).toHaveLength(1);
+      expect(upserted[0].id).toBe(recordId);
+      expect(upserted[0].payload).toBe('updated');
+    }, 60000);
+
+    it('fails when the payload matches different rows across the two composite indexes', async () => {
+      const firstRecordId = uuidv4();
+      const secondRecordId = uuidv4();
+
+      getDualRecords(
+        await upsertDualRecords(
+          [
+            {
+              id: firstRecordId,
+              aFirstKey: 'c1',
+              aSecondKey: 'c2',
+              bFirstKey: 'd1',
+              bSecondKey: 'd2',
+              payload: 'first',
+            },
+            {
+              id: secondRecordId,
+              aFirstKey: 'e1',
+              aSecondKey: 'e2',
+              bFirstKey: 'f1',
+              bSecondKey: 'f2',
+              payload: 'second',
+            },
+          ],
+          false,
+        ),
+      );
+
+      // aFirst/aSecond match the first record via indexA while bFirst/bSecond
+      // match the second record via indexB. Two distinct rows match, so upsert
+      // cannot decide which one to update and must reject the operation.
+      const conflictingResponse = await upsertDualRecords(
+        [
+          {
+            aFirstKey: 'c1',
+            aSecondKey: 'c2',
+            bFirstKey: 'f1',
+            bSecondKey: 'f2',
+            payload: 'conflicting',
+          },
+        ],
+        true,
+      );
+
+      expect(conflictingResponse.body.errors).toBeDefined();
+      expect(conflictingResponse.body.errors[0].message).toContain(
+        'Multiple records found with the same unique field values',
+      );
+      expect(conflictingResponse.body.errors[0].extensions.code).toBe(
+        'BAD_USER_INPUT',
+      );
+    }, 60000);
+  });
+});

packages/twenty-server/test/integration/graphql/suites/upsert/upsert.integration-spec.ts

@@ -0,0 +1,423 @@
+import gql from 'graphql-tag';
+import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
+import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
+import { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';
+import { waitForAllJobsToFinish } from 'test/integration/utils/wait-for-all-jobs-to-finish.util';
+import { FieldMetadataType } from 'twenty-shared/types';
+
+const createRecordsQuery = gql`
+  mutation CreateRecords(
+    $data: [TestRecordObjectCreateInput!]!
+    $upsert: Boolean
+  ) {
+    createTestRecordObjects(data: $data, upsert: $upsert) {
+      id
+      firstUniqueTestField
+      secondUniqueTestField
+      name
+      deletedAt
+    }
+  }
+`;
+
+const deleteRecordsQuery = gql`
+  mutation DeleteRecords($filter: TestRecordObjectFilterInput!) {
+    deleteTestRecordObjects(filter: $filter) {
+      id
+      firstUniqueTestField
+      secondUniqueTestField
+      name
+      deletedAt
+    }
+  }
+`;
+
+const createRecordsWithPositionQuery = gql`
+  mutation CreateRecordsWithPosition(
+    $data: [TestRecordObjectCreateInput!]!
+    $upsert: Boolean
+  ) {
+    createTestRecordObjects(data: $data, upsert: $upsert) {
+      id
+      firstUniqueTestField
+      name
+      position
+    }
+  }
+`;
+
+describe('upsert (createMany with upsert:true)', () => {
+  let createdObjectMetadataId = '';
+
+  beforeEach(async () => {
+    const {
+      data: {
+        createOneObject: { id: objectMetadataId },
+      },
+    } = await createOneObjectMetadata({
+      input: {
+        nameSingular: 'testRecordObject',
+        namePlural: 'testRecordObjects',
+        labelSingular: 'Test Record Object',
+        labelPlural: 'Test Record Objects',
+        icon: 'IconTestRecord',
+      },
+    });
+
+    createdObjectMetadataId = objectMetadataId;
+
+    await createOneFieldMetadata({
+      input: {
+        name: 'firstUniqueTestField',
+        label: 'First Unique Test Field',
+        type: FieldMetadataType.TEXT,
+        objectMetadataId: createdObjectMetadataId,
+        isUnique: true,
+      },
+      gqlFields: `
+        id
+        name
+        label
+        type
+        isUnique
+      `,
+    });
+
+    await createOneFieldMetadata({
+      input: {
+        name: 'secondUniqueTestField',
+        label: 'Second Unique Test Field',
+        type: FieldMetadataType.TEXT,
+        objectMetadataId: createdObjectMetadataId,
+        isUnique: true,
+      },
+      gqlFields: `
+        id
+        name
+        label
+        type
+        isUnique
+      `,
+    });
+  });
+
+  afterEach(async () => {
+    // The global wait-for-jobs afterEach runs after this one, so drain jobs first or the deletion migration can deadlock against them.
+    await waitForAllJobsToFinish();
+
+    await updateOneObjectMetadata({
+      expectToFail: false,
+      input: {
+        idToUpdate: createdObjectMetadataId,
+        updatePayload: {
+          isActive: false,
+        },
+      },
+    });
+    await deleteOneObjectMetadata({
+      input: { idToDelete: createdObjectMetadataId },
+    });
+  });
+
+  it('should update many records', async () => {
+    await makeGraphqlAPIRequest({
+      query: createRecordsQuery,
+      variables: {
+        data: [
+          {
+            firstUniqueTestField: 'firstUniqueTestField1',
+            secondUniqueTestField: 'secondUniqueTestField1',
+            name: 'record1',
+          },
+          {
+            firstUniqueTestField: 'firstUniqueTestField2',
+            secondUniqueTestField: 'secondUniqueTestField2',
+            name: 'record2',
+          },
+        ],
+        upsert: false,
+      },
+    });
+
+    const updatedRecordsResponse = await makeGraphqlAPIRequest({
+      query: createRecordsQuery,
+      variables: {
+        data: [
+          {
+            firstUniqueTestField: 'firstUniqueTestField1',
+            name: 'updatedRecord1',
+          },
+          {
+            firstUniqueTestField: 'firstUniqueTestField2',
+            name: 'updatedRecord2',
+          },
+        ],
+        upsert: true,
+      },
+    });
+
+    const updatedRecords =
+      updatedRecordsResponse.body.data.createTestRecordObjects;
+
+    expect(updatedRecords).toHaveLength(2);
+
+    const record1 = updatedRecords.find(
+      (record: any) => record.firstUniqueTestField === 'firstUniqueTestField1',
+    );
+    const record2 = updatedRecords.find(
+      (record: any) => record.firstUniqueTestField === 'firstUniqueTestField2',
+    );
+
+    expect(record1).toEqual({
+      id: expect.any(String),
+      firstUniqueTestField: 'firstUniqueTestField1',
+      secondUniqueTestField: 'secondUniqueTestField1',
+      name: 'updatedRecord1',
+      deletedAt: null,
+    });
+
+    expect(record2).toEqual({
+      id: expect.any(String),
+      firstUniqueTestField: 'firstUniqueTestField2',
+      secondUniqueTestField: 'secondUniqueTestField2',
+      name: 'updatedRecord2',
+      deletedAt: null,
+    });
+  });
+
+  it('should throw an error when multiple records with the same unique field values are found', async () => {
+    await makeGraphqlAPIRequest({
+      query: createRecordsQuery,
+      variables: {
+        data: [
+          {
+            firstUniqueTestField: 'firstUniqueTestField1',
+            secondUniqueTestField: 'secondUniqueTestField1',
+            name: 'record1',
+          },
+          {
+            firstUniqueTestField: 'firstUniqueTestField2',
+            secondUniqueTestField: 'secondUniqueTestField2',
+            name: 'record2',
+          },
+        ],
+        upsert: false,
+      },
+    });
+
+    const upsertResponse = await makeGraphqlAPIRequest({
+      query: createRecordsQuery,
+      variables: {
+        data: [
+          {
+            firstUniqueTestField: 'firstUniqueTestField1',
+            secondUniqueTestField: 'secondUniqueTestField2',
+            name: 'conflictingRecord',
+          },
+        ],
+        upsert: true,
+      },
+    });
+
+    expect(upsertResponse.body.errors).toBeDefined();
+    expect(upsertResponse.body.errors[0].message).toContain(
+      'Multiple records found with the same unique field values',
+    );
+    expect(upsertResponse.body.errors[0].extensions.code).toBe(
+      'BAD_USER_INPUT',
+    );
+  });
+
+  it('should restore a soft-deleted record matched on its unique fields only', async () => {
+    const createResponse = await makeGraphqlAPIRequest({
+      query: createRecordsQuery,
+      variables: {
+        data: [
+          {
+            firstUniqueTestField: 'softDeletedByUniqueFields',
+            secondUniqueTestField: 'softDeletedByUniqueFieldsSecond',
+            name: 'originalRecord',
+          },
+        ],
+        upsert: false,
+      },
+    });
+
+    const createdRecord = createResponse.body.data.createTestRecordObjects[0];
+
+    await makeGraphqlAPIRequest({
+      query: deleteRecordsQuery,
+      variables: {
+        filter: { id: { eq: createdRecord.id } },
+      },
+    });
+
+    const upsertResponse = await makeGraphqlAPIRequest({
+      query: createRecordsQuery,
+      variables: {
+        data: [
+          {
+            firstUniqueTestField: 'softDeletedByUniqueFields',
+            secondUniqueTestField: 'softDeletedByUniqueFieldsSecond',
+          },
+        ],
+        upsert: true,
+      },
+    });
+
+    const upsertedRecord = upsertResponse.body.data.createTestRecordObjects[0];
+
+    expect(upsertedRecord.id).toEqual(createdRecord.id);
+    expect(upsertedRecord.deletedAt).toBeNull();
+    expect(upsertedRecord.name).toEqual('originalRecord');
+  });
+
+  it('should update and restore updated soft-deleted record', async () => {
+    const createResponse = await makeGraphqlAPIRequest({
+      query: createRecordsQuery,
+      variables: {
+        data: [
+          {
+            firstUniqueTestField: 'softDeletedRecord',
+            secondUniqueTestField: 'softDeletedSecondField',
+            name: 'originalRecord',
+          },
+        ],
+        upsert: false,
+      },
+    });
+
+    const createdRecord = createResponse.body.data.createTestRecordObjects[0];
+
+    const deleteResponse = await makeGraphqlAPIRequest({
+      query: deleteRecordsQuery,
+      variables: {
+        filter: { id: { eq: createdRecord.id } },
+      },
+    });
+
+    const updateResponse = await makeGraphqlAPIRequest({
+      query: createRecordsQuery,
+      variables: {
+        data: [{ id: createdRecord.id, name: 'updatedRecord' }],
+        upsert: true,
+      },
+    });
+
+    expect(
+      deleteResponse.body.data.deleteTestRecordObjects[0].deletedAt,
+    ).toEqual(expect.any(String));
+    expect(
+      updateResponse.body.data.createTestRecordObjects[0].deletedAt,
+    ).toBeNull();
+    expect(updateResponse.body.data.createTestRecordObjects[0].id).toEqual(
+      createdRecord.id,
+    );
+  });
+
+  it('should not change the position of an existing record when upserting without a position', async () => {
+    const createResponse = await makeGraphqlAPIRequest({
+      query: createRecordsWithPositionQuery,
+      variables: {
+        data: [
+          {
+            firstUniqueTestField: 'positionTestField',
+            secondUniqueTestField: 'positionTestSecondField',
+            name: 'originalRecord',
+          },
+        ],
+        upsert: false,
+      },
+    });
+
+    const createdRecord = createResponse.body.data.createTestRecordObjects[0];
+    const initialPosition = createdRecord.position;
+
+    expect(typeof initialPosition).toBe('number');
+
+    const upsertResponse = await makeGraphqlAPIRequest({
+      query: createRecordsWithPositionQuery,
+      variables: {
+        data: [
+          {
+            firstUniqueTestField: 'positionTestField',
+            name: 'updatedRecord',
+          },
+        ],
+        upsert: true,
+      },
+    });
+
+    const upsertedRecord = upsertResponse.body.data.createTestRecordObjects[0];
+
+    expect(upsertedRecord.id).toEqual(createdRecord.id);
+    expect(upsertedRecord.name).toEqual('updatedRecord');
+    expect(upsertedRecord.position).toEqual(initialPosition);
+  });
+
+  it('should auto-assign a position when an upsert creates a new record', async () => {
+    const upsertResponse = await makeGraphqlAPIRequest({
+      query: createRecordsWithPositionQuery,
+      variables: {
+        data: [
+          {
+            firstUniqueTestField: 'insertedViaUpsertField',
+            secondUniqueTestField: 'insertedViaUpsertSecondField',
+            name: 'insertedRecord',
+          },
+        ],
+        upsert: true,
+      },
+    });
+
+    const insertedRecord = upsertResponse.body.data.createTestRecordObjects[0];
+
+    expect(insertedRecord.id).toEqual(expect.any(String));
+    expect(typeof insertedRecord.position).toBe('number');
+  });
+
+  it('should update the position of an existing record when upserting with a position', async () => {
+    const createResponse = await makeGraphqlAPIRequest({
+      query: createRecordsWithPositionQuery,
+      variables: {
+        data: [
+          {
+            firstUniqueTestField: 'updatePositionTestField',
+            secondUniqueTestField: 'updatePositionTestSecondField',
+            name: 'originalRecord',
+            position: 1,
+          },
+        ],
+        upsert: false,
+      },
+    });
+
+    const createdRecord = createResponse.body.data.createTestRecordObjects[0];
+
+    expect(createdRecord.position).toEqual(1);
+
+    const newPosition = 5;
+
+    const upsertResponse = await makeGraphqlAPIRequest({
+      query: createRecordsWithPositionQuery,
+      variables: {
+        data: [
+          {
+            firstUniqueTestField: 'updatePositionTestField',
+            name: 'updatedRecord',
+            position: newPosition,
+          },
+        ],
+        upsert: true,
+      },
+    });
+
+    const upsertedRecord = upsertResponse.body.data.createTestRecordObjects[0];
+
+    expect(upsertedRecord.id).toEqual(createdRecord.id);
+    expect(upsertedRecord.name).toEqual('updatedRecord');
+    expect(upsertedRecord.position).toEqual(newPosition);
+  });
+});