@mbc-cqrs-serverless/master 1.1.1 → 1.1.3

package/dist/services/master-data.service.spec.js

@@ -89,7 +89,9 @@ describe('MasterDataService', () => {
                 .mockResolvedValueOnce(mockDeletedSettings)
                 .mockResolvedValueOnce(mockItems);
             prismaService.master.count.mockResolvedValue(1);
-            const result = await service.listByRds(searchDto, { invokeContext: mockInvokeContext });
+            const result = await service.listByRds(searchDto, {
+                invokeContext: mockInvokeContext,
+            });
             expect(result).toBeInstanceOf(dto_1.MasterRdsListEntity);
             expect(result.total).toBe(1);
             expect(result.items).toHaveLength(1);
@@ -106,7 +108,9 @@ describe('MasterDataService', () => {
                 .mockResolvedValueOnce([])
                 .mockResolvedValueOnce([]);
             prismaService.master.count.mockResolvedValue(0);
-            const result = await service.listByRds(searchDto, { invokeContext: mockInvokeContext });
+            const result = await service.listByRds(searchDto, {
+                invokeContext: mockInvokeContext,
+            });
             expect(result.total).toBe(0);
             expect(result.items).toHaveLength(0);
         });
@@ -229,7 +233,9 @@ describe('MasterDataService', () => {
                 updatedAt: new Date(),
             };
             commandService.publishAsync.mockResolvedValue(mockCommandResult);
-            const result = await service.create(createDto, { invokeContext: mockInvokeContext });
+            const result = await service.create(createDto, {
+                invokeContext: mockInvokeContext,
+            });
             expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
             expect(commandService.publishAsync).toHaveBeenCalledWith(expect.objectContaining({
                 id: 'MASTER#TEST_TENANT#SETTING_CODE#DATA_CODE',
@@ -268,8 +274,7 @@ describe('MasterDataService', () => {
                 updatedAt: new Date(),
             };
             dataService.getItem.mockResolvedValue(existingData);
-            await expect(service.create(createDto, { invokeContext: mockInvokeContext }))
-                .rejects.toThrow('Master data already exists');
+            await expect(service.create(createDto, { invokeContext: mockInvokeContext })).rejects.toThrow('Master data already exists');
             expect(commandService.publishAsync).not.toHaveBeenCalled();
         });
         it('should create when existing data is deleted', async () => {
@@ -310,7 +315,9 @@ describe('MasterDataService', () => {
                 updatedAt: new Date(),
             };
             commandService.publishAsync.mockResolvedValue(mockCommandResult);
-            const result = await service.create(createDto, { invokeContext: mockInvokeContext });
+            const result = await service.create(createDto, {
+                invokeContext: mockInvokeContext,
+            });
             expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
             expect(commandService.publishAsync).toHaveBeenCalledWith(expect.objectContaining({
                 version: 2,
@@ -349,7 +356,9 @@ describe('MasterDataService', () => {
                 updatedAt: new Date(),
             };
             commandService.publishPartialUpdateAsync.mockResolvedValue(mockUpdateResult);
-            const result = await service.update(key, updateDto, { invokeContext: mockInvokeContext });
+            const result = await service.update(key, updateDto, {
+                invokeContext: mockInvokeContext,
+            });
             expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
             expect(commandService.publishPartialUpdateAsync).toHaveBeenCalledWith(expect.objectContaining({
                 id: existingData.id,
@@ -367,8 +376,7 @@ describe('MasterDataService', () => {
                 name: 'Updated Name',
             };
             dataService.getItem.mockResolvedValue(null);
-            await expect(service.update(key, updateDto, { invokeContext: mockInvokeContext }))
-                .rejects.toThrow('Master data not found');
+            await expect(service.update(key, updateDto, { invokeContext: mockInvokeContext })).rejects.toThrow('Master data not found');
             expect(commandService.publishPartialUpdateAsync).not.toHaveBeenCalled();
         });
         it('should preserve existing values when update fields are not provided', async () => {
@@ -430,7 +438,9 @@ describe('MasterDataService', () => {
                 updatedAt: new Date(),
             };
             commandService.publishPartialUpdateAsync.mockResolvedValue(mockDeleteResult);
-            const result = await service.delete(key, { invokeContext: mockInvokeContext });
+            const result = await service.delete(key, {
+                invokeContext: mockInvokeContext,
+            });
             expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
             expect(commandService.publishPartialUpdateAsync).toHaveBeenCalledWith(expect.objectContaining({
                 ...existingData,
@@ -440,8 +450,7 @@ describe('MasterDataService', () => {
         it('should throw NotFoundException when data does not exist', async () => {
             const key = { pk: 'MASTER#TEST_TENANT', sk: 'SETTING#DATA1' };
             dataService.getItem.mockResolvedValue(null);
-            await expect(service.delete(key, { invokeContext: mockInvokeContext }))
-                .rejects.toThrow('Master data not found');
+            await expect(service.delete(key, { invokeContext: mockInvokeContext })).rejects.toThrow('Master data not found');
             expect(commandService.publishPartialUpdateAsync).not.toHaveBeenCalled();
         });
         it('should throw BadRequestException when data is already deleted', async () => {
@@ -460,8 +469,7 @@ describe('MasterDataService', () => {
                 updatedAt: new Date(),
             };
             dataService.getItem.mockResolvedValue(existingData);
-            await expect(service.delete(key, { invokeContext: mockInvokeContext }))
-                .rejects.toThrow('This master data is already deleted');
+            await expect(service.delete(key, { invokeContext: mockInvokeContext })).rejects.toThrow('This master data is already deleted');
             expect(commandService.publishPartialUpdateAsync).not.toHaveBeenCalled();
         });
     });
@@ -575,7 +583,11 @@ describe('MasterDataService', () => {
                     masterTypeCode: createDto.settingCode,
                 },
             });
-            expect(createDto.attributes['seq']).toBe(6);
+            // Verify seq is passed to publishAsync without mutating the original DTO
+            expect(commandService.publishAsync).toHaveBeenCalledWith(expect.objectContaining({
+                attributes: expect.objectContaining({ seq: 6 }),
+                seq: 6,
+            }), expect.anything());
         });
         it('should create setting with provided sequence', async () => {
             const createDto = {
@@ -632,7 +644,11 @@ describe('MasterDataService', () => {
             };
             commandService.publishAsync.mockResolvedValue(mockCommandResult);
             await service.createSetting(createDto, mockInvokeContext);
-            expect(createDto.attributes['seq']).toBe(1);
+            // Verify seq is passed to publishAsync without mutating the original DTO
+            expect(commandService.publishAsync).toHaveBeenCalledWith(expect.objectContaining({
+                attributes: expect.objectContaining({ seq: 1 }),
+                seq: 1,
+            }), expect.anything());
         });
     });
     describe('updateSetting', () => {
@@ -669,6 +685,233 @@ describe('MasterDataService', () => {
             expect(commandService.publishPartialUpdateAsync).toHaveBeenCalledWith(expect.objectContaining(updateDto), { invokeContext: mockInvokeContext });
         });
     });
+    describe('upsert', () => {
+        it('should create new data when not exists', async () => {
+            const createDto = {
+                settingCode: 'SETTING_CODE',
+                code: 'DATA_CODE',
+                tenantCode: 'TEST_TENANT',
+                name: 'Test Data',
+                seq: 1,
+                attributes: { key: 'value' },
+            };
+            dataService.getItem.mockResolvedValue(null);
+            const mockCommandResult = {
+                id: 'MASTER#TEST_TENANT#SETTING_CODE#DATA_CODE',
+                pk: 'MASTER#TEST_TENANT',
+                sk: 'SETTING_CODE#DATA_CODE',
+                version: 1,
+                type: 'MASTER',
+                tenantCode: 'TEST_TENANT',
+                name: createDto.name,
+                code: createDto.code,
+                seq: createDto.seq,
+                attributes: createDto.attributes,
+                isDeleted: false,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+            commandService.publishAsync.mockResolvedValue(mockCommandResult);
+            const result = await service.upsert(createDto, {
+                invokeContext: mockInvokeContext,
+            });
+            expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
+            expect(commandService.publishAsync).toHaveBeenCalledWith(expect.objectContaining({
+                version: 0,
+                isDeleted: false,
+            }), { invokeContext: mockInvokeContext });
+        });
+        it('should update existing data when exists with changes', async () => {
+            const createDto = {
+                settingCode: 'SETTING_CODE',
+                code: 'DATA_CODE',
+                tenantCode: 'TEST_TENANT',
+                name: 'Updated Data',
+                seq: 2,
+                attributes: { key: 'new-value' },
+            };
+            const existingData = {
+                id: 'existing-id',
+                pk: 'MASTER#TEST_TENANT',
+                sk: 'SETTING_CODE#DATA_CODE',
+                code: 'DATA_CODE',
+                name: 'Original Data',
+                version: 2,
+                type: 'MASTER',
+                tenantCode: 'TEST_TENANT',
+                isDeleted: false,
+                attributes: { key: 'old-value' },
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+            dataService.getItem.mockResolvedValue(existingData);
+            const mockCommandResult = {
+                id: 'MASTER#TEST_TENANT#SETTING_CODE#DATA_CODE',
+                pk: 'MASTER#TEST_TENANT',
+                sk: 'SETTING_CODE#DATA_CODE',
+                version: 3,
+                type: 'MASTER',
+                tenantCode: 'TEST_TENANT',
+                name: createDto.name,
+                code: createDto.code,
+                seq: createDto.seq,
+                attributes: createDto.attributes,
+                isDeleted: false,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+            commandService.publishAsync.mockResolvedValue(mockCommandResult);
+            const result = await service.upsert(createDto, {
+                invokeContext: mockInvokeContext,
+            });
+            expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
+            expect(result.name).toBe('Updated Data');
+            expect(commandService.publishAsync).toHaveBeenCalledWith(expect.objectContaining({
+                version: 2,
+                isDeleted: false,
+            }), { invokeContext: mockInvokeContext });
+        });
+        it('should return existing data when data is identical (not dirty)', async () => {
+            const createDto = {
+                settingCode: 'SETTING_CODE',
+                code: 'DATA_CODE',
+                tenantCode: 'TEST_TENANT',
+                name: 'Same Data',
+                seq: 1,
+                attributes: { key: 'value' },
+            };
+            const existingData = {
+                id: 'existing-id',
+                pk: 'MASTER#TEST_TENANT',
+                sk: 'SETTING_CODE#DATA_CODE',
+                code: 'DATA_CODE',
+                name: 'Same Data',
+                version: 2,
+                type: 'MASTER',
+                tenantCode: 'TEST_TENANT',
+                isDeleted: false,
+                attributes: { key: 'value' },
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+            dataService.getItem.mockResolvedValue(existingData);
+            // publishAsync returns null when not dirty
+            commandService.publishAsync.mockResolvedValue(null);
+            const result = await service.upsert(createDto, {
+                invokeContext: mockInvokeContext,
+            });
+            expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
+            expect(result.name).toBe('Same Data');
+        });
+        it('should recreate when existing data is deleted', async () => {
+            const createDto = {
+                settingCode: 'SETTING_CODE',
+                code: 'DATA_CODE',
+                tenantCode: 'TEST_TENANT',
+                name: 'Recreated Data',
+                seq: 1,
+                attributes: { recreated: true },
+            };
+            const existingDeletedData = {
+                id: 'existing-id',
+                pk: 'MASTER#TEST_TENANT',
+                sk: 'SETTING_CODE#DATA_CODE',
+                code: 'DATA_CODE',
+                name: 'Deleted Data',
+                version: 3,
+                type: 'MASTER',
+                tenantCode: 'TEST_TENANT',
+                isDeleted: true,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+            dataService.getItem.mockResolvedValue(existingDeletedData);
+            const mockCommandResult = {
+                id: 'MASTER#TEST_TENANT#SETTING_CODE#DATA_CODE',
+                pk: 'MASTER#TEST_TENANT',
+                sk: 'SETTING_CODE#DATA_CODE',
+                version: 3,
+                type: 'MASTER',
+                tenantCode: 'TEST_TENANT',
+                name: createDto.name,
+                code: createDto.code,
+                seq: createDto.seq,
+                attributes: createDto.attributes,
+                isDeleted: false,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+            commandService.publishAsync.mockResolvedValue(mockCommandResult);
+            const result = await service.upsert(createDto, {
+                invokeContext: mockInvokeContext,
+            });
+            expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
+            expect(result.isDeleted).toBe(false);
+            expect(commandService.publishAsync).toHaveBeenCalledWith(expect.objectContaining({
+                version: 3,
+                isDeleted: false,
+            }), { invokeContext: mockInvokeContext });
+        });
+    });
+    describe('upsertBulk', () => {
+        it('should upsert multiple items', async () => {
+            const createDto1 = {
+                settingCode: 'SETTING_CODE',
+                name: 'Item 1',
+                code: 'CODE1',
+                seq: 1,
+                attributes: { key: 'value1' },
+            };
+            const createDto2 = {
+                settingCode: 'SETTING_CODE',
+                name: 'Item 2',
+                code: 'CODE2',
+                seq: 2,
+                attributes: { key: 'value2' },
+            };
+            prismaService.master.aggregate.mockResolvedValue({
+                _max: { seq: null },
+            });
+            dataService.getItem.mockResolvedValue(null);
+            const mockResult1 = {
+                id: 'id1',
+                pk: `MASTER#${mockUserContext.tenantCode}`,
+                sk: 'SETTING_CODE#CODE1',
+                version: 1,
+                type: 'MASTER',
+                tenantCode: mockUserContext.tenantCode,
+                name: 'Item 1',
+                code: 'CODE1',
+                seq: 1,
+                attributes: { key: 'value1' },
+                isDeleted: false,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+            const mockResult2 = {
+                id: 'id2',
+                pk: `MASTER#${mockUserContext.tenantCode}`,
+                sk: 'SETTING_CODE#CODE2',
+                version: 1,
+                type: 'MASTER',
+                tenantCode: mockUserContext.tenantCode,
+                name: 'Item 2',
+                code: 'CODE2',
+                seq: 2,
+                attributes: { key: 'value2' },
+                isDeleted: false,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+            commandService.publishAsync
+                .mockResolvedValueOnce(mockResult1)
+                .mockResolvedValueOnce(mockResult2);
+            const result = await service.upsertBulk({ items: [createDto1, createDto2] }, mockInvokeContext);
+            expect(result).toHaveLength(2);
+            expect(result[0]).toBeInstanceOf(entities_1.MasterDataEntity);
+            expect(result[1]).toBeInstanceOf(entities_1.MasterDataEntity);
+        });
+    });
     describe('deleteSetting', () => {
         it('should delete setting', async () => {
             const key = { pk: 'MASTER#TEST_TENANT', sk: 'SETTING#DATA1' };
@@ -718,8 +961,7 @@ describe('MasterDataService', () => {
                 const dbError = new Error('Database connection failed');
                 dbError.name = 'PrismaClientKnownRequestError';
                 dataService.getItem.mockRejectedValue(dbError);
-                await expect(service.create(createDto, { invokeContext: mockInvokeContext }))
-                    .rejects.toThrow('Database connection failed');
+                await expect(service.create(createDto, { invokeContext: mockInvokeContext })).rejects.toThrow('Database connection failed');
                 expect(commandService.publishAsync).not.toHaveBeenCalled();
             });
             it('should handle CommandService publish failures', async () => {
@@ -733,8 +975,7 @@ describe('MasterDataService', () => {
                 dataService.getItem.mockResolvedValue(null);
                 const commandError = new Error('Command publish failed');
                 commandService.publishAsync.mockRejectedValue(commandError);
-                await expect(service.create(createDto, { invokeContext: mockInvokeContext }))
-                    .rejects.toThrow('Command publish failed');
+                await expect(service.create(createDto, { invokeContext: mockInvokeContext })).rejects.toThrow('Command publish failed');
             });
             it('should handle concurrent creation attempts with version conflicts', async () => {
                 const createDto = {
@@ -748,8 +989,7 @@ describe('MasterDataService', () => {
                 const versionError = new Error('Version conflict');
                 versionError.name = 'ConditionalCheckFailedException';
                 commandService.publishAsync.mockRejectedValue(versionError);
-                await expect(service.create(createDto, { invokeContext: mockInvokeContext }))
-                    .rejects.toThrow('Version conflict');
+                await expect(service.create(createDto, { invokeContext: mockInvokeContext })).rejects.toThrow('Version conflict');
             });
         });
         describe('update - Error Handling', () => {
@@ -762,8 +1002,7 @@ describe('MasterDataService', () => {
                 const timeoutError = new Error('Query timeout');
                 timeoutError.name = 'PrismaClientKnownRequestError';
                 dataService.getItem.mockRejectedValue(timeoutError);
-                await expect(service.update(key, updateDto, { invokeContext: mockInvokeContext }))
-                    .rejects.toThrow('Query timeout');
+                await expect(service.update(key, updateDto, { invokeContext: mockInvokeContext })).rejects.toThrow('Query timeout');
                 expect(commandService.publishPartialUpdateAsync).not.toHaveBeenCalled();
             });
             it('should handle CommandService partial update failures', async () => {
@@ -788,8 +1027,7 @@ describe('MasterDataService', () => {
                 dataService.getItem.mockResolvedValue(existingData);
                 const updateError = new Error('Update command failed');
                 commandService.publishPartialUpdateAsync.mockRejectedValue(updateError);
-                await expect(service.update(key, updateDto, { invokeContext: mockInvokeContext }))
-                    .rejects.toThrow('Update command failed');
+                await expect(service.update(key, updateDto, { invokeContext: mockInvokeContext })).rejects.toThrow('Update command failed');
             });
         });
         describe('delete - Error Handling', () => {
@@ -798,8 +1036,7 @@ describe('MasterDataService', () => {
                 const accessError = new Error('Access denied');
                 accessError.name = 'PrismaClientKnownRequestError';
                 dataService.getItem.mockRejectedValue(accessError);
-                await expect(service.delete(key, { invokeContext: mockInvokeContext }))
-                    .rejects.toThrow('Access denied');
+                await expect(service.delete(key, { invokeContext: mockInvokeContext })).rejects.toThrow('Access denied');
                 expect(commandService.publishPartialUpdateAsync).not.toHaveBeenCalled();
             });
             it('should handle deletion command failures', async () => {
@@ -820,8 +1057,7 @@ describe('MasterDataService', () => {
                 dataService.getItem.mockResolvedValue(existingData);
                 const deleteError = new Error('Delete command failed');
                 commandService.publishPartialUpdateAsync.mockRejectedValue(deleteError);
-                await expect(service.delete(key, { invokeContext: mockInvokeContext }))
-                    .rejects.toThrow('Delete command failed');
+                await expect(service.delete(key, { invokeContext: mockInvokeContext })).rejects.toThrow('Delete command failed');
             });
         });
     });
@@ -858,7 +1094,9 @@ describe('MasterDataService', () => {
                     updatedAt: new Date(),
                 };
                 commandService.publishAsync.mockResolvedValue(mockCommandResult);
-                const result = await service.create(createDto, { invokeContext: mockInvokeContext });
+                const result = await service.create(createDto, {
+                    invokeContext: mockInvokeContext,
+                });
                 expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
                 expect(result.name).toBe('');
                 expect(result.code).toBe('');
@@ -873,7 +1111,7 @@ describe('MasterDataService', () => {
                     attributes: {
                         specialKey: 'value with 特殊文字',
                         unicodeKey: '🚀🎉',
-                        jsonString: '{"nested": "value"}'
+                        jsonString: '{"nested": "value"}',
                     },
                 };
                 dataService.getItem.mockResolvedValue(null);
@@ -893,7 +1131,9 @@ describe('MasterDataService', () => {
                     updatedAt: new Date(),
                 };
                 commandService.publishAsync.mockResolvedValue(mockCommandResult);
-                const result = await service.create(createDto, { invokeContext: mockInvokeContext });
+                const result = await service.create(createDto, {
+                    invokeContext: mockInvokeContext,
+                });
                 expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
                 expect(result.code).toBe('DATA_CODE_特殊文字@#$%');
                 expect(result.name).toBe('Test Data with 特殊文字 & symbols!');
@@ -928,7 +1168,9 @@ describe('MasterDataService', () => {
                     updatedAt: new Date(),
                 };
                 commandService.publishAsync.mockResolvedValue(mockCommandResult);
-                const result = await service.create(createDto, { invokeContext: mockInvokeContext });
+                const result = await service.create(createDto, {
+                    invokeContext: mockInvokeContext,
+                });
                 expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
                 expect(Object.keys(result.attributes)).toHaveLength(100);
             });
@@ -956,7 +1198,9 @@ describe('MasterDataService', () => {
                     updatedAt: new Date(),
                 };
                 commandService.publishAsync.mockResolvedValue(mockCommandResult);
-                const result = await service.create(createDto, { invokeContext: mockInvokeContext });
+                const result = await service.create(createDto, {
+                    invokeContext: mockInvokeContext,
+                });
                 expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
                 expect(result.seq).toBe(-1);
             });
@@ -990,7 +1234,9 @@ describe('MasterDataService', () => {
                     updatedAt: new Date(),
                 };
                 commandService.publishPartialUpdateAsync.mockResolvedValue(mockUpdateResult);
-                const result = await service.update(key, updateDto, { invokeContext: mockInvokeContext });
+                const result = await service.update(key, updateDto, {
+                    invokeContext: mockInvokeContext,
+                });
                 expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
                 expect(result.attributes).toBeNull();
             });
@@ -1020,7 +1266,9 @@ describe('MasterDataService', () => {
                     updatedAt: new Date(),
                 };
                 commandService.publishPartialUpdateAsync.mockResolvedValue(mockUpdateResult);
-                const result = await service.update(key, updateDto, { invokeContext: mockInvokeContext });
+                const result = await service.update(key, updateDto, {
+                    invokeContext: mockInvokeContext,
+                });
                 expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
                 expect(result.name).toBe(longName);
                 expect(result.name.length).toBe(1000);
@@ -1074,7 +1322,9 @@ describe('MasterDataService', () => {
                     updatedAt: new Date(),
                 };
                 commandService.publishAsync.mockResolvedValue(mockCommandResult);
-                const result = await service.create(createDto, { invokeContext: mockInvokeContext });
+                const result = await service.create(createDto, {
+                    invokeContext: mockInvokeContext,
+                });
                 expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
                 expect(result.version).toBe(3);
                 expect(result.isDeleted).toBe(false);
@@ -1127,7 +1377,9 @@ describe('MasterDataService', () => {
                     updatedAt: new Date(),
                 };
                 commandService.publishAsync.mockResolvedValue(mockCommandResult);
-                const result = await service.create(createDto, { invokeContext: mockInvokeContext });
+                const result = await service.create(createDto, {
+                    invokeContext: mockInvokeContext,
+                });
                 expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
                 expect(result.version).toBe(5);
                 expect(result.isDeleted).toBe(false);
@@ -1171,7 +1423,9 @@ describe('MasterDataService', () => {
                     updatedAt: new Date(),
                 };
                 commandService.publishAsync.mockResolvedValue(mockCommandResult);
-                const result = await service.create(createDto, { invokeContext: mockInvokeContext });
+                const result = await service.create(createDto, {
+                    invokeContext: mockInvokeContext,
+                });
                 expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
                 expect(result.createdAt).toEqual(originalCreatedAt);
                 expect(result.isDeleted).toBe(false);
@@ -1200,7 +1454,9 @@ describe('MasterDataService', () => {
                     updatedAt: new Date(),
                 };
                 commandService.publishAsync.mockResolvedValue(mockCommandResult);
-                const result = await service.create(createDto, { invokeContext: mockInvokeContext });
+                const result = await service.create(createDto, {
+                    invokeContext: mockInvokeContext,
+                });
                 expect(result).toBeInstanceOf(entities_1.MasterDataEntity);
                 expect(result.tenantCode).toBe('NEW_TENANT');
                 expect(result.version).toBe(1);
@@ -1278,9 +1534,10 @@ describe('MasterDataService', () => {
                 commandService.publishAsync
                     .mockResolvedValueOnce(mockCommandResult1)
                     .mockRejectedValueOnce(versionConflictError);
-                const result1 = await service.create(createDto1, { invokeContext: mockInvokeContext });
-                await expect(service.create(createDto2, { invokeContext: mockInvokeContext }))
-                    .rejects.toThrow('Version conflict');
+                const result1 = await service.create(createDto1, {
+                    invokeContext: mockInvokeContext,
+                });
+                await expect(service.create(createDto2, { invokeContext: mockInvokeContext })).rejects.toThrow('Version conflict');
                 expect(result1).toBeInstanceOf(entities_1.MasterDataEntity);
                 expect(result1.name).toBe('First Creation');
             });
@@ -1329,7 +1586,9 @@ describe('MasterDataService', () => {
                 commandService.publishPartialUpdateAsync.mockResolvedValue(mockDeleteResult);
                 commandService.publishAsync.mockResolvedValue(mockRecreateResult);
                 const deleteResult = await service.delete({ pk: existingData.pk, sk: existingData.sk }, { invokeContext: mockInvokeContext });
-                const recreateResult = await service.create(createDto, { invokeContext: mockInvokeContext });
+                const recreateResult = await service.create(createDto, {
+                    invokeContext: mockInvokeContext,
+                });
                 expect(deleteResult.isDeleted).toBe(true);
                 expect(recreateResult.isDeleted).toBe(false);
                 expect(recreateResult.version).toBe(3);
@@ -1372,9 +1631,10 @@ describe('MasterDataService', () => {
                 commandService.publishPartialUpdateAsync
                     .mockResolvedValueOnce(mockUpdateResult1)
                     .mockRejectedValueOnce(versionConflictError);
-                const result1 = await service.update(key, updateDto1, { invokeContext: mockInvokeContext });
-                await expect(service.update(key, updateDto2, { invokeContext: mockInvokeContext }))
-                    .rejects.toThrow('Version conflict');
+                const result1 = await service.update(key, updateDto1, {
+                    invokeContext: mockInvokeContext,
+                });
+                await expect(service.update(key, updateDto2, { invokeContext: mockInvokeContext })).rejects.toThrow('Version conflict');
                 expect(result1.name).toBe('First Update');
                 expect(result1.version).toBe(2);
             });