@declaro/data 2.0.0-beta.96 → 2.0.0-beta.98

package/src/test/mock/repositories/mock-memory-repository.test.ts

@@ -712,4 +712,208 @@ describe('MockMemoryRepository', () => {
             expect(await repository.load({ id: 100 })).toEqual(inputs[99])
         })
     })
+
+    describe('assign functionality', () => {
+        it('should use default Object.assign for create when no custom assign function is provided', async () => {
+            const input = { title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
+            const createdItem = await repository.create(input)
+
+            expect(createdItem).toMatchObject(input)
+            expect(createdItem.id).toBeDefined()
+        })
+
+        it('should use default Object.assign for update when no custom assign function is provided', async () => {
+            const input = { id: 42, title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
+            const createdItem = await repository.create(input)
+
+            const updateInput = { title: 'Updated Book', author: 'Updated Author', publishedDate: new Date() }
+            const updatedItem = await repository.update({ id: createdItem.id }, updateInput)
+
+            expect(updatedItem).toEqual({
+                id: createdItem.id,
+                title: 'Updated Book',
+                author: 'Updated Author',
+                publishedDate: updateInput.publishedDate,
+            })
+        })
+
+        it('should use default Object.assign for upsert when no custom assign function is provided', async () => {
+            const input = { id: 42, title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
+            const upsertedItem = await repository.upsert(input)
+
+            expect(upsertedItem).toEqual(input)
+
+            const updateInput = { id: 42, title: 'Updated Book', author: 'Updated Author', publishedDate: new Date() }
+            const updatedItem = await repository.upsert(updateInput)
+
+            expect(updatedItem).toEqual(updateInput)
+        })
+
+        it('should use custom assign function for create operation', async () => {
+            const customAssignMock = mock((existing: any, input: any) => ({
+                ...existing,
+                ...input,
+                customField: 'custom_create_value',
+            }))
+
+            const customRepository = new MockMemoryRepository({
+                schema: mockSchema,
+                assign: customAssignMock,
+            })
+
+            const input = { title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
+            const createdItem = await customRepository.create(input)
+
+            expect(customAssignMock).toHaveBeenCalledWith({}, input)
+            expect((createdItem as any).customField).toBe('custom_create_value')
+            expect(createdItem).toMatchObject(input)
+        })
+
+        it('should use custom assign function for update operation', async () => {
+            const customAssignMock = mock((existing: any, input: any) => ({
+                ...existing,
+                ...input,
+                customField: 'custom_update_value',
+                lastModified: new Date('2023-01-01'),
+            }))
+
+            const customRepository = new MockMemoryRepository({
+                schema: mockSchema,
+                assign: customAssignMock,
+            })
+
+            const input = { id: 42, title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
+            const createdItem = await customRepository.create(input)
+
+            const updateInput = { title: 'Updated Book', author: 'Updated Author', publishedDate: new Date() }
+            const updatedItem = await customRepository.update({ id: createdItem.id }, updateInput)
+
+            expect(customAssignMock).toHaveBeenCalledWith(createdItem, updateInput)
+            expect((updatedItem as any).customField).toBe('custom_update_value')
+            expect((updatedItem as any).lastModified).toEqual(new Date('2023-01-01'))
+            expect(updatedItem.title).toBe('Updated Book')
+        })
+
+        it('should use custom assign function for upsert operation on existing item', async () => {
+            const customAssignMock = mock((existing: any, input: any) => ({
+                ...existing,
+                ...input,
+                mergeTimestamp: new Date('2023-01-01'),
+                isUpserted: true,
+            }))
+
+            const customRepository = new MockMemoryRepository({
+                schema: mockSchema,
+                assign: customAssignMock,
+            })
+
+            const input = { id: 42, title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
+            const createdItem = await customRepository.create(input)
+
+            const upsertInput = { id: 42, title: 'Upserted Book', author: 'Upserted Author', publishedDate: new Date() }
+            const upsertedItem = await customRepository.upsert(upsertInput)
+
+            // Should have been called twice: once for create, once for upsert
+            expect(customAssignMock).toHaveBeenCalledTimes(2)
+            expect(customAssignMock).toHaveBeenLastCalledWith(createdItem, upsertInput)
+            expect((upsertedItem as any).mergeTimestamp).toEqual(new Date('2023-01-01'))
+            expect((upsertedItem as any).isUpserted).toBe(true)
+            expect(upsertedItem.title).toBe('Upserted Book')
+        })
+
+        it('should use custom assign function for upsert operation on new item', async () => {
+            const customAssignMock = mock((existing: any, input: any) => ({
+                ...existing,
+                ...input,
+                createdViaUpsert: true,
+            }))
+
+            const customRepository = new MockMemoryRepository({
+                schema: mockSchema,
+                assign: customAssignMock,
+            })
+
+            const input = { id: 42, title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
+            const upsertedItem = await customRepository.upsert(input)
+
+            expect(customAssignMock).toHaveBeenCalledWith({}, input)
+            expect((upsertedItem as any).createdViaUpsert).toBe(true)
+            expect(upsertedItem).toMatchObject(input)
+        })
+
+        it('should use custom assign function for bulkUpsert operation', async () => {
+            const customAssignMock = mock((existing: any, input: any) => ({
+                ...existing,
+                ...input,
+                bulkProcessed: true,
+            }))
+
+            const customRepository = new MockMemoryRepository({
+                schema: mockSchema,
+                assign: customAssignMock,
+            })
+
+            const inputs = [
+                { id: 1, title: 'Book 1', author: 'Author 1', publishedDate: new Date() },
+                { id: 2, title: 'Book 2', author: 'Author 2', publishedDate: new Date() },
+            ]
+
+            const results = await customRepository.bulkUpsert(inputs)
+
+            expect(customAssignMock).toHaveBeenCalledTimes(2)
+            expect((results[0] as any).bulkProcessed).toBe(true)
+            expect((results[1] as any).bulkProcessed).toBe(true)
+            expect(results[0]).toMatchObject(inputs[0])
+            expect(results[1]).toMatchObject(inputs[1])
+        })
+
+        it('should handle complex custom assign logic with conditional merging', async () => {
+            const customAssign = (existing: any, input: any) => {
+                const result = { ...existing, ...input }
+
+                // Custom logic: preserve original author if input doesn't have one
+                if (!input.author && existing.author) {
+                    result.author = existing.author
+                }
+
+                // Custom logic: track modification count
+                result.modificationCount = (existing.modificationCount || 0) + 1
+
+                return result
+            }
+
+            const customRepository = new MockMemoryRepository({
+                schema: mockSchema,
+                assign: customAssign,
+            })
+
+            const input = { id: 42, title: 'Test Book', author: 'Original Author', publishedDate: new Date() }
+            const createdItem = await customRepository.create(input)
+
+            expect((createdItem as any).modificationCount).toBe(1)
+
+            // Update with partial data - use existing values for required fields
+            const updateInput = {
+                title: 'Updated Book',
+                author: createdItem.author,
+                publishedDate: createdItem.publishedDate,
+            }
+            const updatedItem = await customRepository.update({ id: createdItem.id }, updateInput)
+
+            expect(updatedItem.author).toBe('Original Author')
+            expect(updatedItem.title).toBe('Updated Book')
+            expect((updatedItem as any).modificationCount).toBe(2)
+
+            // Update with new author
+            const updateWithAuthor = {
+                title: updatedItem.title,
+                author: 'New Author',
+                publishedDate: updatedItem.publishedDate,
+            }
+            const finalItem = await customRepository.update({ id: createdItem.id }, updateWithAuthor)
+
+            expect(finalItem.author).toBe('New Author')
+            expect((finalItem as any).modificationCount).toBe(3)
+        })
+    })
 })

package/src/test/mock/repositories/mock-memory-repository.ts

@@ -17,6 +17,7 @@ export interface IMockMemoryRepositoryArgs<TSchema extends AnyModelSchema> {
     schema: TSchema
     lookup?: (data: InferDetail<TSchema>, lookup: InferLookup<TSchema>) => boolean
     filter?: (data: InferSummary<TSchema>, filters: InferFilters<TSchema>) => boolean
+    assign?: (data: InferDetail<TSchema>, input: InferInput<TSchema>) => InferDetail<TSchema>
 }
 
 export class MockMemoryRepository<TSchema extends AnyModelSchema> implements IRepository<TSchema> {
@@ -140,17 +141,16 @@ export class MockMemoryRepository<TSchema extends AnyModelSchema> implements IRe
             throw new Error('Item with the same primary key already exists')
         }
 
-        const payload = {
-            ...(input as any),
-        }
+        const baseData = {} as InferDetail<TSchema>
+        const payload = this.assignInput(baseData, input)
 
         if (!payload[this.entityMetadata.primaryKey]) {
             // Generate a new primary key if not provided
             payload[this.entityMetadata.primaryKey!] = await this.generatePrimaryKey()
         }
 
-        this.data.set(payload[this.entityMetadata.primaryKey!], payload as InferDetail<TSchema>)
-        return payload as InferDetail<TSchema>
+        this.data.set(payload[this.entityMetadata.primaryKey!], payload)
+        return payload
     }
 
     async update(lookup: InferLookup<TSchema>, input: InferInput<TSchema>): Promise<InferDetail<TSchema>> {
@@ -167,7 +167,7 @@ export class MockMemoryRepository<TSchema extends AnyModelSchema> implements IRe
             throw new Error('Item not found')
         }
 
-        const updatedItem = Object.assign({}, existingItem, input) as InferDetail<TSchema>
+        const updatedItem = this.assignInput(existingItem, input)
         this.data.set(primaryKeyValue, updatedItem)
         return updatedItem
     }
@@ -179,13 +179,13 @@ export class MockMemoryRepository<TSchema extends AnyModelSchema> implements IRe
 
     async upsert(input: InferInput<TSchema>, options?: ICreateOptions | IUpdateOptions): Promise<InferDetail<TSchema>> {
         const primaryKeyValue = input[this.entityMetadata.primaryKey]
-        let existingItem: InferDetail<TSchema> | undefined = undefined
+        let existingItem: InferDetail<TSchema> = {} as InferDetail<TSchema>
 
         if (primaryKeyValue) {
-            existingItem = this.data.get(primaryKeyValue) ?? {}
+            existingItem = this.data.get(primaryKeyValue) ?? ({} as InferDetail<TSchema>)
         }
 
-        const updatedItem = Object.assign({}, existingItem, input) as InferDetail<TSchema>
+        const updatedItem = this.assignInput(existingItem, input)
         if (!updatedItem[this.entityMetadata.primaryKey!]) {
             updatedItem[this.entityMetadata.primaryKey!] = await this.generatePrimaryKey()
         }
@@ -218,6 +218,21 @@ export class MockMemoryRepository<TSchema extends AnyModelSchema> implements IRe
         })
     }
 
+    /**
+     * Assign input data to existing data using the provided assign function or default Object.assign
+     * @param existingData - The existing data to merge with
+     * @param input - The input data to assign
+     * @returns The merged data
+     */
+    protected assignInput(existingData: InferDetail<TSchema>, input: InferInput<TSchema>): InferDetail<TSchema> {
+        if (typeof this.args.assign === 'function') {
+            return this.args.assign(existingData, input)
+        } else {
+            // Default implementation using Object.assign
+            return Object.assign({}, existingData, input) as InferDetail<TSchema>
+        }
+    }
+
     protected async generatePrimaryKey() {
         const lookupModel: Model<any, any> = this.args.schema.definition.lookup
         const lookupMeta = await lookupModel.toJSONSchema()