@axinom/mosaic-graphql-common 0.28.0-rc.8 → 0.28.0

package/src/plugins/bulk-edit/bulk-edit-async-plugin-factory.spec.ts

@@ -0,0 +1,1047 @@
+import { PerformItemChangeCommand } from '@axinom/mosaic-messages';
+import { StoreInboxMessage } from '@axinom/mosaic-transactional-inbox-outbox';
+import { DatabaseClient } from 'pg-transactional-outbox';
+import { asyncResolverImplementation } from './bulk-edit-async-plugin-factory';
+
+// Mock the dependencies
+jest.mock('@axinom/mosaic-db-common', () => ({
+  buildPgSettings: jest.fn(() => ({
+    role: 'test_role',
+    'mosaic.subject': 'test_user',
+  })),
+  transactionWithContext: jest.fn(
+    async (_pool, _isolationLevel, _pgSettings, callback) => {
+      // Execute the callback with a mock transaction client
+      const mockTxn = {} as DatabaseClient;
+      await callback(mockTxn);
+    },
+  ),
+}));
+
+describe('bulk-edit-async-plugin-factory', () => {
+  describe('asyncResolverImplementation', () => {
+    let capturedMessages: PerformItemChangeCommand[];
+    let mockStoreInboxMessage: jest.MockedFunction<StoreInboxMessage>;
+    let mockOwnerPool: any;
+    let mockEnvOwnerPool: any;
+    let mockConfig: any;
+    let mockSubject: any;
+
+    beforeEach(() => {
+      capturedMessages = [];
+
+      // Mock storeInboxMessage to capture messages
+      mockStoreInboxMessage = jest
+        .fn()
+        .mockImplementation(
+          async (
+            _aggregateId: string,
+            _messageSettings: any,
+            payload: PerformItemChangeCommand,
+            _client: DatabaseClient,
+            _options?: any,
+          ) => {
+            capturedMessages.push(payload);
+          },
+        );
+
+      mockOwnerPool = {};
+      mockEnvOwnerPool = {};
+      mockConfig = {
+        serviceId: 'test-service',
+        dbOwner: 'test_owner',
+        dbEnvOwner: 'test_env_owner',
+      };
+      mockSubject = {
+        userId: 'test-user-id',
+        tenantId: 'test-tenant-id',
+      };
+    });
+
+    afterEach(() => {
+      jest.clearAllMocks();
+    });
+
+    describe('SET_FIELD_VALUES action', () => {
+      it('should generate SET_FIELD_VALUES message with correct structure', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {
+              title: 'title',
+              description: 'description',
+            },
+            inputData: {
+              title: 'Updated Title',
+              description: 'Updated Description',
+            },
+          },
+          clears: {},
+          removals: {},
+          additions: {},
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['image-123'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'long-lived-token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert
+        expect(capturedMessages).toHaveLength(1);
+        expect(capturedMessages[0]).toEqual({
+          table_name: 'images',
+          action: 'SET_FIELD_VALUES',
+          stringified_condition: JSON.stringify({ id: 'image-123' }),
+          stringified_payload: JSON.stringify({
+            title: 'Updated Title',
+            description: 'Updated Description',
+          }),
+        });
+      });
+
+      it('should handle NULL values in SET_FIELD_VALUES', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {
+              description: 'description',
+            },
+            inputData: {
+              description: null,
+            },
+          },
+          clears: {},
+          removals: {},
+          additions: {},
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['image-123'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert
+        expect(capturedMessages).toHaveLength(1);
+        expect(JSON.parse(capturedMessages[0].stringified_payload)).toEqual({
+          description: null,
+        });
+      });
+    });
+
+    describe('CLEAR_RELATED_ENTITIES action', () => {
+      it('should generate CLEAR_RELATED_ENTITIES message with correct structure', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {},
+            inputData: undefined,
+          },
+          clears: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              shouldClear: true,
+            },
+          },
+          removals: {},
+          additions: {},
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['image-123'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert
+        expect(capturedMessages).toHaveLength(1);
+        expect(capturedMessages[0]).toEqual({
+          table_name: 'images_tags',
+          action: 'CLEAR_RELATED_ENTITIES',
+          stringified_condition: JSON.stringify({ image_id: 'image-123' }),
+          stringified_payload: JSON.stringify({}),
+        });
+      });
+
+      it('should support multiple relations cleared simultaneously', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'user_roles',
+            gqlFieldNameToColumnNameMap: {},
+            inputData: undefined,
+          },
+          clears: {
+            user_role_parent_assignments: {
+              parentKeyColumnName: 'user_role_id',
+              shouldClear: true,
+            },
+            user_role_permission_assignments: {
+              parentKeyColumnName: 'user_role_id',
+              shouldClear: true,
+            },
+            user_role_tag_assignments: {
+              parentKeyColumnName: 'user_role_id',
+              shouldClear: true,
+            },
+          },
+          removals: {},
+          additions: {},
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['role-1'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert
+        expect(capturedMessages).toHaveLength(3);
+        expect(
+          capturedMessages.every((m) => m.action === 'CLEAR_RELATED_ENTITIES'),
+        ).toBe(true);
+        capturedMessages.forEach((msg) => {
+          const condition = JSON.parse(msg.stringified_condition);
+          expect(condition.user_role_id).toBe('role-1');
+        });
+      });
+
+      it('should skip clear when shouldClear is false', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {},
+            inputData: undefined,
+          },
+          clears: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              shouldClear: false,
+            },
+          },
+          removals: {},
+          additions: {},
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['image-123'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert
+        expect(capturedMessages).toHaveLength(0);
+      });
+    });
+
+    describe('REMOVE_RELATED_ENTITY action', () => {
+      it('should generate REMOVE_RELATED_ENTITY message with correct structure', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {},
+            inputData: undefined,
+          },
+          clears: {},
+          removals: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              fkGqlFieldNameToColumnNameMap: {
+                name: 'name',
+              },
+              inputData: [{ name: 'tag-to-remove' }],
+            },
+          },
+          additions: {},
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['image-123'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert
+        expect(capturedMessages).toHaveLength(1);
+        expect(capturedMessages[0]).toEqual({
+          table_name: 'images_tags',
+          action: 'REMOVE_RELATED_ENTITY',
+          stringified_condition: '',
+          stringified_payload: JSON.stringify({
+            image_id: 'image-123',
+            name: 'tag-to-remove',
+          }),
+        });
+      });
+
+      it('should generate multiple REMOVE messages for multiple items', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {},
+            inputData: undefined,
+          },
+          clears: {},
+          removals: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              fkGqlFieldNameToColumnNameMap: {
+                name: 'name',
+              },
+              inputData: [{ name: 'tag1' }, { name: 'tag2' }, { name: 'tag3' }],
+            },
+          },
+          additions: {},
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['image-123'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert
+        expect(capturedMessages).toHaveLength(3);
+        expect(
+          capturedMessages.every((m) => m.action === 'REMOVE_RELATED_ENTITY'),
+        ).toBe(true);
+        expect(
+          capturedMessages.every((m) => m.table_name === 'images_tags'),
+        ).toBe(true);
+      });
+    });
+
+    describe('ADD_RELATED_ENTITY action', () => {
+      it('should generate ADD_RELATED_ENTITY message with correct structure', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {},
+            inputData: undefined,
+          },
+          clears: {},
+          removals: {},
+          additions: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              fkGqlFieldNameToColumnNameMap: {
+                name: 'name',
+              },
+              inputData: [{ name: 'new-tag' }],
+            },
+          },
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['image-123'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert
+        expect(capturedMessages).toHaveLength(1);
+        expect(capturedMessages[0]).toEqual({
+          table_name: 'images_tags',
+          action: 'ADD_RELATED_ENTITY',
+          stringified_condition: '',
+          stringified_payload: JSON.stringify({
+            image_id: 'image-123',
+            name: 'new-tag',
+          }),
+        });
+      });
+
+      it('should generate multiple ADD messages for multiple items', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {},
+            inputData: undefined,
+          },
+          clears: {},
+          removals: {},
+          additions: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              fkGqlFieldNameToColumnNameMap: {
+                name: 'name',
+              },
+              inputData: [{ name: 'tag1' }, { name: 'tag2' }],
+            },
+          },
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['image-123'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert
+        expect(capturedMessages).toHaveLength(2);
+        expect(
+          capturedMessages.every((m) => m.action === 'ADD_RELATED_ENTITY'),
+        ).toBe(true);
+      });
+    });
+
+    describe('Message ordering', () => {
+      it('should send messages in order: SET → CLEAR → REMOVE → ADD', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {
+              title: 'title',
+            },
+            inputData: {
+              title: 'Updated',
+            },
+          },
+          clears: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              shouldClear: true,
+            },
+          },
+          removals: {
+            images_casts: {
+              parentKeyColumnName: 'image_id',
+              fkGqlFieldNameToColumnNameMap: {
+                castId: 'cast_id',
+              },
+              inputData: [{ castId: 'cast-1' }],
+            },
+          },
+          additions: {
+            images_licenses: {
+              parentKeyColumnName: 'image_id',
+              fkGqlFieldNameToColumnNameMap: {
+                licenseId: 'license_id',
+              },
+              inputData: [{ licenseId: 'license-1' }],
+            },
+          },
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['img-1'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert
+        expect(capturedMessages).toHaveLength(4);
+        expect(capturedMessages[0].action).toBe('SET_FIELD_VALUES');
+        expect(capturedMessages[0].table_name).toBe('images');
+        expect(capturedMessages[1].action).toBe('CLEAR_RELATED_ENTITIES');
+        expect(capturedMessages[1].table_name).toBe('images_tags');
+        expect(capturedMessages[2].action).toBe('REMOVE_RELATED_ENTITY');
+        expect(capturedMessages[2].table_name).toBe('images_casts');
+        expect(capturedMessages[3].action).toBe('ADD_RELATED_ENTITY');
+        expect(capturedMessages[3].table_name).toBe('images_licenses');
+      });
+    });
+
+    describe('Optimization: Skip REMOVE when CLEAR is present', () => {
+      it('should skip REMOVE messages when CLEAR is present for same relation', async () => {
+        // Arrange - Both clear and remove specified for same relation
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {},
+            inputData: undefined,
+          },
+          clears: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              shouldClear: true,
+            },
+          },
+          removals: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              fkGqlFieldNameToColumnNameMap: {
+                name: 'name',
+              },
+              inputData: [{ name: 'tag1' }, { name: 'tag2' }],
+            },
+          },
+          additions: {},
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['image-123'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert - Only CLEAR message sent, no REMOVE messages
+        expect(capturedMessages).toHaveLength(1);
+        expect(capturedMessages[0].action).toBe('CLEAR_RELATED_ENTITIES');
+        expect(capturedMessages[0].table_name).toBe('images_tags');
+      });
+
+      it('should NOT skip REMOVE when CLEAR is for different relation', async () => {
+        // Arrange - Clear tags, remove casts
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {},
+            inputData: undefined,
+          },
+          clears: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              shouldClear: true,
+            },
+          },
+          removals: {
+            images_casts: {
+              parentKeyColumnName: 'image_id',
+              fkGqlFieldNameToColumnNameMap: {
+                castId: 'cast_id',
+              },
+              inputData: [{ castId: 'cast-1' }],
+            },
+          },
+          additions: {},
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['image-123'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert - Both CLEAR and REMOVE messages sent
+        expect(capturedMessages).toHaveLength(2);
+        expect(capturedMessages[0].action).toBe('CLEAR_RELATED_ENTITIES');
+        expect(capturedMessages[0].table_name).toBe('images_tags');
+        expect(capturedMessages[1].action).toBe('REMOVE_RELATED_ENTITY');
+        expect(capturedMessages[1].table_name).toBe('images_casts');
+      });
+    });
+
+    describe('Multi-entity operations', () => {
+      it('should process all entity IDs and send messages for each', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {
+              title: 'title',
+            },
+            inputData: {
+              title: 'Updated',
+            },
+          },
+          clears: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              shouldClear: true,
+            },
+          },
+          removals: {},
+          additions: {},
+        };
+
+        // Act - 3 entities
+        await asyncResolverImplementation(
+          payload,
+          ['img-1', 'img-2', 'img-3'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert - 2 messages per entity * 3 entities = 6 messages
+        expect(capturedMessages).toHaveLength(6);
+
+        // Verify messages for img-1
+        expect(capturedMessages[0].action).toBe('SET_FIELD_VALUES');
+        expect(JSON.parse(capturedMessages[0].stringified_condition).id).toBe(
+          'img-1',
+        );
+        expect(capturedMessages[1].action).toBe('CLEAR_RELATED_ENTITIES');
+        expect(
+          JSON.parse(capturedMessages[1].stringified_condition).image_id,
+        ).toBe('img-1');
+
+        // Verify messages for img-2
+        expect(capturedMessages[2].action).toBe('SET_FIELD_VALUES');
+        expect(JSON.parse(capturedMessages[2].stringified_condition).id).toBe(
+          'img-2',
+        );
+        expect(capturedMessages[3].action).toBe('CLEAR_RELATED_ENTITIES');
+        expect(
+          JSON.parse(capturedMessages[3].stringified_condition).image_id,
+        ).toBe('img-2');
+
+        // Verify messages for img-3
+        expect(capturedMessages[4].action).toBe('SET_FIELD_VALUES');
+        expect(JSON.parse(capturedMessages[4].stringified_condition).id).toBe(
+          'img-3',
+        );
+        expect(capturedMessages[5].action).toBe('CLEAR_RELATED_ENTITIES');
+        expect(
+          JSON.parse(capturedMessages[5].stringified_condition).image_id,
+        ).toBe('img-3');
+      });
+
+      it('should calculate correct message count for complex bulk operation', async () => {
+        // Arrange - Operation with all action types
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {
+              title: 'title',
+            },
+            inputData: {
+              title: 'Updated',
+            },
+          },
+          clears: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              shouldClear: true,
+            },
+          },
+          removals: {
+            images_casts: {
+              parentKeyColumnName: 'image_id',
+              fkGqlFieldNameToColumnNameMap: {
+                castId: 'cast_id',
+              },
+              inputData: [{ castId: 'cast-1' }],
+            },
+          },
+          additions: {
+            images_licenses: {
+              parentKeyColumnName: 'image_id',
+              fkGqlFieldNameToColumnNameMap: {
+                licenseId: 'license_id',
+              },
+              inputData: [{ licenseId: 'lic-1' }, { licenseId: 'lic-2' }],
+            },
+          },
+        };
+
+        // Act - 2 entities
+        await asyncResolverImplementation(
+          payload,
+          ['img-1', 'img-2'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert
+        // Per entity: 1 SET + 1 CLEAR + 1 REMOVE + 2 ADD = 5 messages
+        // 5 messages * 2 entities = 10 total
+        expect(capturedMessages).toHaveLength(10);
+      });
+    });
+
+    describe('Real-world use cases', () => {
+      it('should support "replace all tags" operation', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {},
+            inputData: undefined,
+          },
+          clears: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              shouldClear: true,
+            },
+          },
+          removals: {},
+          additions: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              fkGqlFieldNameToColumnNameMap: {
+                name: 'name',
+              },
+              inputData: [{ name: 'new-tag-1' }, { name: 'new-tag-2' }],
+            },
+          },
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['image-123'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert - CLEAR followed by 2 ADDs
+        expect(capturedMessages).toHaveLength(3);
+        expect(capturedMessages[0].action).toBe('CLEAR_RELATED_ENTITIES');
+        expect(capturedMessages[1].action).toBe('ADD_RELATED_ENTITY');
+        expect(capturedMessages[2].action).toBe('ADD_RELATED_ENTITY');
+        expect(
+          capturedMessages.every((m) => m.table_name === 'images_tags'),
+        ).toBe(true);
+      });
+
+      it('should support "reset permissions" operation', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'user_roles',
+            gqlFieldNameToColumnNameMap: {},
+            inputData: undefined,
+          },
+          clears: {
+            user_role_permission_assignments: {
+              parentKeyColumnName: 'user_role_id',
+              shouldClear: true,
+            },
+          },
+          removals: {},
+          additions: {
+            user_role_permission_assignments: {
+              parentKeyColumnName: 'user_role_id',
+              fkGqlFieldNameToColumnNameMap: {
+                permissionId: 'permission_id',
+              },
+              inputData: [
+                { permissionId: 'perm-read' },
+                { permissionId: 'perm-write' },
+              ],
+            },
+          },
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['role-admin'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert
+        expect(capturedMessages).toHaveLength(3);
+        expect(capturedMessages[0].action).toBe('CLEAR_RELATED_ENTITIES');
+        expect(capturedMessages[1].action).toBe('ADD_RELATED_ENTITY');
+        expect(capturedMessages[2].action).toBe('ADD_RELATED_ENTITY');
+      });
+
+      it('should support "update and clear multiple relations" operation', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {
+              title: 'title',
+              description: 'description',
+            },
+            inputData: {
+              title: 'Updated Title',
+              description: null,
+            },
+          },
+          clears: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              shouldClear: true,
+            },
+            images_casts: {
+              parentKeyColumnName: 'image_id',
+              shouldClear: true,
+            },
+          },
+          removals: {},
+          additions: {},
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['image-123'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert
+        expect(capturedMessages).toHaveLength(3);
+        expect(capturedMessages[0].action).toBe('SET_FIELD_VALUES');
+        expect(capturedMessages[0].table_name).toBe('images');
+        expect(capturedMessages[1].action).toBe('CLEAR_RELATED_ENTITIES');
+        expect(capturedMessages[2].action).toBe('CLEAR_RELATED_ENTITIES');
+        expect(capturedMessages[1].table_name).not.toBe(
+          capturedMessages[2].table_name,
+        );
+      });
+    });
+
+    describe('Field name mapping', () => {
+      it('should map GraphQL field names to SQL column names', async () => {
+        // Arrange - GraphQL uses camelCase, SQL uses snake_case
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {
+              originalTitle: 'original_title',
+              externalId: 'external_id',
+            },
+            inputData: {
+              originalTitle: 'Test',
+              externalId: 'ext-123',
+            },
+          },
+          clears: {},
+          removals: {},
+          additions: {},
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['img-1'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert
+        expect(capturedMessages).toHaveLength(1);
+        const payload_parsed = JSON.parse(
+          capturedMessages[0].stringified_payload,
+        );
+        expect(payload_parsed).toEqual({
+          original_title: 'Test',
+          external_id: 'ext-123',
+        });
+      });
+
+      it('should map GraphQL field names in FK additions', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {},
+            inputData: undefined,
+          },
+          clears: {},
+          removals: {},
+          additions: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              fkGqlFieldNameToColumnNameMap: {
+                tagName: 'name',
+                tagValue: 'value',
+              },
+              inputData: [{ tagName: 'genre', tagValue: 'action' }],
+            },
+          },
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['img-1'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert
+        const payload_parsed = JSON.parse(
+          capturedMessages[0].stringified_payload,
+        );
+        expect(payload_parsed).toEqual({
+          image_id: 'img-1',
+          name: 'genre',
+          value: 'action',
+        });
+      });
+    });
+
+    describe('Edge cases', () => {
+      it('should handle empty entity IDs array', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {
+              title: 'title',
+            },
+            inputData: {
+              title: 'Updated',
+            },
+          },
+          clears: {},
+          removals: {},
+          additions: {},
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          [], // Empty array
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert - No messages sent
+        expect(capturedMessages).toHaveLength(0);
+      });
+
+      it('should handle undefined inputData arrays', async () => {
+        // Arrange
+        const payload = {
+          set: {
+            mainTableName: 'images',
+            gqlFieldNameToColumnNameMap: {},
+            inputData: undefined,
+          },
+          clears: {},
+          removals: {
+            images_tags: {
+              parentKeyColumnName: 'image_id',
+              fkGqlFieldNameToColumnNameMap: {},
+              inputData: undefined, // undefined data
+            },
+          },
+          additions: {
+            images_licenses: {
+              parentKeyColumnName: 'image_id',
+              fkGqlFieldNameToColumnNameMap: {},
+              inputData: undefined, // undefined data
+            },
+          },
+        };
+
+        // Act
+        await asyncResolverImplementation(
+          payload,
+          ['img-1'],
+          mockConfig,
+          mockOwnerPool,
+          mockEnvOwnerPool,
+          'token',
+          mockSubject,
+          mockStoreInboxMessage,
+        );
+
+        // Assert - No messages sent since all inputData is undefined
+        expect(capturedMessages).toHaveLength(0);
+      });
+    });
+  });
+});