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

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

@@ -1,919 +0,0 @@
-import { beforeEach, describe, expect, it, mock } from 'bun:test'
-import { MockBookSchema } from '../models/mock-book-models'
-import { MockMemoryRepository } from './mock-memory-repository'
-import { z } from 'zod/v4'
-import { ZodModel } from '@declaro/zod'
-
-describe('MockMemoryRepository', () => {
-    const mockSchema = MockBookSchema
-
-    let repository: MockMemoryRepository<typeof mockSchema>
-
-    beforeEach(() => {
-        repository = new MockMemoryRepository({ schema: mockSchema })
-    })
-
-    it('should create an item', async () => {
-        const input = { id: 42, title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
-        const createdItem = await repository.create(input)
-
-        expect(createdItem).toEqual(input)
-        expect(await repository.load({ id: createdItem.id })).toEqual(createdItem)
-    })
-
-    it('should throw an error when creating an item with duplicate primary key', async () => {
-        const input = { id: 42, title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
-        const createdItem = await repository.create(input)
-
-        await expect(repository.create({ ...input, id: createdItem.id })).rejects.toThrow(
-            'Item with the same primary key already exists',
-        )
-    })
-
-    it('should update an existing item', async () => {
-        const input = { id: 42, title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
-        const createdItem = await repository.create(input)
-
-        const updatedInput = { title: 'Updated Book', author: 'Updated Author', publishedDate: new Date() }
-        const updatedItem = await repository.update({ id: createdItem.id }, updatedInput)
-
-        expect(updatedItem).toEqual({ id: createdItem.id, ...updatedInput })
-        expect(await repository.load({ id: createdItem.id })).toEqual({ id: createdItem.id, ...updatedInput })
-    })
-
-    it('should throw an error when updating a non-existent item', async () => {
-        const input = { id: 42, title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
-
-        await expect(repository.update({ id: 999 }, input)).rejects.toThrow('Item not found')
-    })
-
-    it('should remove an item', async () => {
-        const input = { id: 42, title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
-        const createdItem = await repository.create(input)
-
-        const removedItem = await repository.remove({ id: createdItem.id })
-
-        expect(removedItem).toEqual(input)
-        const loadedItem = await repository.load({ id: createdItem.id })
-        expect(loadedItem).toBeNull()
-    })
-
-    it('should restore a removed item', async () => {
-        const input = { id: 42, title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
-        const createdItem = await repository.create(input)
-        await repository.remove({ id: createdItem.id })
-
-        const restoredItem = await repository.restore({ id: createdItem.id })
-
-        expect(restoredItem).toEqual(input)
-        expect(await repository.load({ id: createdItem.id })).toEqual(input)
-    })
-
-    it('should throw an error when restoring a non-existent item', async () => {
-        await expect(repository.restore({ id: 999 })).rejects.toThrow('Item not found in trash')
-    })
-
-    it('should allow me to create an item without a primary key', async () => {
-        const input = { title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
-        const createdItem = await repository.create(input)
-
-        expect(createdItem.id).toBeDefined()
-        expect(createdItem.title).toBe(input.title)
-        expect(createdItem.author).toBe(input.author)
-        expect(await repository.load({ id: createdItem.id })).toEqual(createdItem)
-    })
-
-    it('should increment ids when creating items without a primary key', async () => {
-        const input1 = { title: 'Test Book 1', author: 'Author Name 1', publishedDate: new Date() }
-        const input2 = { title: 'Test Book 2', author: 'Author Name 2', publishedDate: new Date() }
-
-        const createdItem1 = await repository.create(input1)
-        const createdItem2 = await repository.create(input2)
-
-        expect(createdItem1.id).toBe(1)
-        expect(createdItem2.id).toBe(2)
-        expect(await repository.load({ id: createdItem1.id })).toEqual(createdItem1)
-        expect(await repository.load({ id: createdItem2.id })).toEqual(createdItem2)
-    })
-
-    it('should return null when loading a non-existent item', async () => {
-        const result = await repository.load({ id: 999 })
-        expect(result).toBeNull()
-    })
-
-    it('should be able to load items from a custom filter', async () => {
-        // Creating a hypothetical schema with a custom filter, and a title lookup attribute
-        const repository = new MockMemoryRepository({
-            schema: mockSchema.custom({
-                lookup: (h) =>
-                    new ZodModel(
-                        h.name,
-                        z.object({
-                            id: z.number().optional(),
-                            title: z.string().optional(),
-                        }),
-                    ),
-            }),
-            lookup: (data, lookup) =>
-                data.id === lookup.id || data.title?.toLowerCase() === lookup.title?.toLowerCase(),
-        })
-
-        const input = { title: 'Test Book', author: 'Author Name', publishedDate: new Date() }
-        const createdItem = await repository.create(input)
-
-        const loadedItem = await repository.load({ id: createdItem.id })
-        const titleLoadedItem = await repository.load({ title: createdItem.title })
-        expect(loadedItem).toEqual(createdItem)
-        expect(titleLoadedItem).toEqual(createdItem)
-    })
-
-    describe('search functionality', () => {
-        it('should search for all items when no filter is provided', async () => {
-            const input1 = { title: 'Book One', author: 'Author A', publishedDate: new Date('2023-01-01') }
-            const input2 = { title: 'Book Two', author: 'Author B', publishedDate: new Date('2023-02-01') }
-            const input3 = { title: 'Book Three', author: 'Author C', publishedDate: new Date('2023-03-01') }
-
-            const item1 = await repository.create(input1)
-            const item2 = await repository.create(input2)
-            const item3 = await repository.create(input3)
-
-            const results = await repository.search({})
-
-            expect(results.results).toHaveLength(3)
-            expect(results.results).toEqual(expect.arrayContaining([item1, item2, item3]))
-            expect(results.pagination.total).toBe(3)
-            expect(results.pagination.page).toBe(1)
-            expect(results.pagination.pageSize).toBe(25)
-            expect(results.pagination.totalPages).toBe(1)
-        })
-
-        it('should filter items using custom filter function', async () => {
-            const repositoryWithFilter = new MockMemoryRepository({
-                schema: mockSchema,
-                filter: (data, filters) => {
-                    if (filters.text) {
-                        return (
-                            data.title.toLowerCase().includes(filters.text.toLowerCase()) ||
-                            data.author.toLowerCase().includes(filters.text.toLowerCase())
-                        )
-                    }
-                    return true
-                },
-            })
-
-            const input1 = { title: 'JavaScript Guide', author: 'John Doe', publishedDate: new Date() }
-            const input2 = { title: 'Python Handbook', author: 'Jane Smith', publishedDate: new Date() }
-            const input3 = { title: 'Java Programming', author: 'John Johnson', publishedDate: new Date() }
-
-            const item1 = await repositoryWithFilter.create(input1)
-            const item2 = await repositoryWithFilter.create(input2)
-            const item3 = await repositoryWithFilter.create(input3)
-
-            // Search by title
-            const titleResults = await repositoryWithFilter.search({ text: 'JavaScript' })
-            expect(titleResults.results).toEqual([item1])
-
-            // Search by author
-            const authorResults = await repositoryWithFilter.search({ text: 'John' })
-            expect(authorResults.results).toHaveLength(2)
-            expect(authorResults.results).toEqual(expect.arrayContaining([item1, item3]))
-
-            // Search with no matches
-            const noResults = await repositoryWithFilter.search({ text: 'Ruby' })
-            expect(noResults.results).toEqual([])
-            expect(noResults.pagination.total).toBe(0)
-        })
-
-        it('should handle pagination correctly', async () => {
-            // Create 10 items
-            for (let i = 1; i <= 10; i++) {
-                const input = { title: `Book ${i}`, author: `Author ${i}`, publishedDate: new Date() }
-                await repository.create(input)
-            }
-
-            // Test first page with pageSize 3
-            const page1 = await repository.search(
-                {},
-                {
-                    pagination: { page: 1, pageSize: 3 },
-                },
-            )
-            expect(page1.results).toHaveLength(3)
-            expect(page1.pagination.page).toBe(1)
-            expect(page1.pagination.pageSize).toBe(3)
-            expect(page1.pagination.total).toBe(10)
-            expect(page1.pagination.totalPages).toBe(4)
-
-            // Test second page
-            const page2 = await repository.search(
-                {},
-                {
-                    pagination: { page: 2, pageSize: 3 },
-                },
-            )
-            expect(page2.results).toHaveLength(3)
-            expect(page2.pagination.page).toBe(2)
-            expect(page2.pagination.pageSize).toBe(3)
-
-            // Test last page (should have 1 item)
-            const page4 = await repository.search(
-                {},
-                {
-                    pagination: { page: 4, pageSize: 3 },
-                },
-            )
-            expect(page4.results).toHaveLength(1)
-            expect(page4.pagination.page).toBe(4)
-
-            // Test page beyond available data
-            const pageEmpty = await repository.search(
-                {},
-                {
-                    pagination: { page: 5, pageSize: 3 },
-                },
-            )
-            expect(pageEmpty.results).toHaveLength(0)
-        })
-
-        it('should use default pagination when not provided', async () => {
-            // Create 30 items to test default pagination
-            for (let i = 1; i <= 30; i++) {
-                await repository.create({ title: `Book ${i}`, author: `Author ${i}`, publishedDate: new Date() })
-            }
-
-            const results = await repository.search({})
-            expect(results.pagination.page).toBe(1)
-            expect(results.pagination.pageSize).toBe(25)
-            expect(results.pagination.total).toBe(30)
-            expect(results.pagination.totalPages).toBe(2)
-            expect(results.results).toHaveLength(25)
-        })
-
-        it('should handle edge cases with pagination', async () => {
-            // Test with empty repository
-            const emptyResults = await repository.search(
-                {},
-                {
-                    pagination: { page: 1, pageSize: 10 },
-                },
-            )
-            expect(emptyResults.results).toEqual([])
-            expect(emptyResults.pagination.total).toBe(0)
-            expect(emptyResults.pagination.totalPages).toBe(0)
-
-            // Test with page 0 (results in empty due to slice calculation)
-            await repository.create({ title: 'Test Book', author: 'Test Author', publishedDate: new Date() })
-            const page0Results = await repository.search(
-                {},
-                {
-                    pagination: { page: 0, pageSize: 10 },
-                },
-            )
-            expect(page0Results.pagination.page).toBe(0)
-            expect(page0Results.results).toHaveLength(0) // slice(-10, 0) returns empty array
-        })
-
-        it('should handle sorting correctly', async () => {
-            const input1 = { title: 'C Book', author: 'Author Z', publishedDate: new Date('2023-03-01') }
-            const input2 = { title: 'A Book', author: 'Author Y', publishedDate: new Date('2023-01-01') }
-            const input3 = { title: 'B Book', author: 'Author X', publishedDate: new Date('2023-02-01') }
-
-            const item1 = await repository.create(input1)
-            const item2 = await repository.create(input2)
-            const item3 = await repository.create(input3)
-
-            // Sort by title ascending
-            const titleAscResults = await repository.search(
-                {},
-                {
-                    sort: [{ title: 'asc' }],
-                },
-            )
-            expect(titleAscResults.results.map((r) => r.title)).toEqual(['A Book', 'B Book', 'C Book'])
-
-            // Sort by title descending
-            const titleDescResults = await repository.search(
-                {},
-                {
-                    sort: [{ title: 'desc' }],
-                },
-            )
-            expect(titleDescResults.results.map((r) => r.title)).toEqual(['C Book', 'B Book', 'A Book'])
-
-            // Sort by author ascending
-            const authorAscResults = await repository.search(
-                {},
-                {
-                    sort: [{ author: 'asc' }],
-                },
-            )
-            expect(authorAscResults.results.map((r) => r.author)).toEqual(['Author X', 'Author Y', 'Author Z'])
-
-            // Multiple field sort: title asc, then author desc
-            const multiSortResults = await repository.search(
-                {},
-                {
-                    sort: [{ title: 'asc' }, { author: 'desc' }],
-                },
-            )
-            expect(multiSortResults.results.map((r) => r.title)).toEqual(['A Book', 'B Book', 'C Book'])
-        })
-
-        it('should handle sorting with pagination', async () => {
-            for (let i = 1; i <= 5; i++) {
-                await repository.create({
-                    title: `Book ${String.fromCharCode(69 - i)}`, // D, C, B, A, @
-                    author: `Author ${i}`,
-                    publishedDate: new Date(),
-                })
-            }
-
-            // Sort by title ascending and get first page
-            const sortedPage1 = await repository.search(
-                {},
-                {
-                    sort: [{ title: 'asc' }],
-                    pagination: { page: 1, pageSize: 2 },
-                },
-            )
-            expect(sortedPage1.results.map((r) => r.title)).toEqual(['Book @', 'Book A'])
-            expect(sortedPage1.pagination.totalPages).toBe(3)
-
-            // Get second page with same sort
-            const sortedPage2 = await repository.search(
-                {},
-                {
-                    sort: [{ title: 'asc' }],
-                    pagination: { page: 2, pageSize: 2 },
-                },
-            )
-            expect(sortedPage2.results.map((r) => r.title)).toEqual(['Book B', 'Book C'])
-        })
-
-        it('should handle combined filtering, sorting, and pagination', async () => {
-            const repositoryWithFilter = new MockMemoryRepository({
-                schema: mockSchema,
-                filter: (data, filters) => {
-                    if (filters.text) {
-                        return data.title.toLowerCase().includes(filters.text.toLowerCase())
-                    }
-                    return true
-                },
-            })
-
-            await repositoryWithFilter.create({ title: 'Test Z Book', author: 'Author 1', publishedDate: new Date() })
-            await repositoryWithFilter.create({ title: 'Test A Book', author: 'Author 2', publishedDate: new Date() })
-            await repositoryWithFilter.create({ title: 'Other Book', author: 'Author 3', publishedDate: new Date() })
-            await repositoryWithFilter.create({ title: 'Test B Book', author: 'Author 4', publishedDate: new Date() })
-
-            const results = await repositoryWithFilter.search(
-                { text: 'Test' },
-                {
-                    sort: [{ title: 'asc' }],
-                    pagination: { page: 1, pageSize: 2 },
-                },
-            )
-
-            expect(results.results).toHaveLength(2)
-            expect(results.results.map((r) => r.title)).toEqual(['Test A Book', 'Test B Book'])
-            expect(results.pagination.total).toBe(3) // 3 "Test" books total
-            expect(results.pagination.totalPages).toBe(2)
-        })
-    })
-
-    describe('count functionality', () => {
-        it('should count all items when no filter is provided', async () => {
-            // Create test data
-            await repository.create({ title: 'Book 1', author: 'Author 1', publishedDate: new Date() })
-            await repository.create({ title: 'Book 2', author: 'Author 2', publishedDate: new Date() })
-            await repository.create({ title: 'Book 3', author: 'Author 3', publishedDate: new Date() })
-
-            const count = await repository.count({})
-            expect(count).toBe(3)
-        })
-
-        it('should count filtered items when filter function is provided', async () => {
-            const repositoryWithFilter = new MockMemoryRepository({
-                schema: mockSchema,
-                filter: (data, filters) => {
-                    if (filters.text) {
-                        return data.title.toLowerCase().includes(filters.text.toLowerCase())
-                    }
-                    return true
-                },
-            })
-
-            // Create test data
-            await repositoryWithFilter.create({ title: 'Test Book A', author: 'Author 1', publishedDate: new Date() })
-            await repositoryWithFilter.create({ title: 'Test Book B', author: 'Author 2', publishedDate: new Date() })
-            await repositoryWithFilter.create({ title: 'Other Book', author: 'Author 3', publishedDate: new Date() })
-            await repositoryWithFilter.create({ title: 'Another Book', author: 'Author 4', publishedDate: new Date() })
-
-            // Count all items
-            const totalCount = await repositoryWithFilter.count({})
-            expect(totalCount).toBe(4)
-
-            // Count filtered items
-            const filteredCount = await repositoryWithFilter.count({ text: 'Test' })
-            expect(filteredCount).toBe(2)
-
-            // Count with no matches
-            const noMatchCount = await repositoryWithFilter.count({ text: 'Ruby' })
-            expect(noMatchCount).toBe(0)
-        })
-
-        it('should count items correctly after CRUD operations', async () => {
-            const repositoryWithFilter = new MockMemoryRepository({
-                schema: mockSchema,
-                filter: (data, filters) => {
-                    if (filters.text) {
-                        return data.title.toLowerCase().includes(filters.text.toLowerCase())
-                    }
-                    return true
-                },
-            })
-
-            // Initial count should be 0
-            expect(await repositoryWithFilter.count({})).toBe(0)
-
-            // Create items
-            const book1 = await repositoryWithFilter.create({
-                title: 'Test Book 1',
-                author: 'Author 1',
-                publishedDate: new Date(),
-            })
-            const book2 = await repositoryWithFilter.create({
-                title: 'Other Book',
-                author: 'Author 2',
-                publishedDate: new Date(),
-            })
-
-            // Count after creation
-            expect(await repositoryWithFilter.count({})).toBe(2)
-            expect(await repositoryWithFilter.count({ text: 'Test' })).toBe(1)
-
-            // Remove an item
-            await repositoryWithFilter.remove({ id: book1.id })
-
-            // Count after removal
-            expect(await repositoryWithFilter.count({})).toBe(1)
-            expect(await repositoryWithFilter.count({ text: 'Test' })).toBe(0)
-
-            // Restore the item
-            await repositoryWithFilter.restore({ id: book1.id })
-
-            // Count after restore
-            expect(await repositoryWithFilter.count({})).toBe(2)
-            expect(await repositoryWithFilter.count({ text: 'Test' })).toBe(1)
-        })
-    })
-
-    describe('upsert functionality', () => {
-        it('should create a new item when no existing item with primary key exists', async () => {
-            const input = { id: 42, title: 'New Book', author: 'Author Name', publishedDate: new Date() }
-
-            const upsertedItem = await repository.upsert(input)
-
-            expect(upsertedItem).toEqual(input)
-            expect(await repository.load({ id: 42 })).toEqual(input)
-        })
-
-        it('should update an existing item when primary key matches', async () => {
-            // Create initial item
-            const initial = {
-                id: 42,
-                title: 'Original Book',
-                author: 'Original Author',
-                publishedDate: new Date('2023-01-01'),
-            }
-            await repository.create(initial)
-
-            // Upsert with same ID but different data
-            const update = {
-                id: 42,
-                title: 'Updated Book',
-                author: 'Updated Author',
-                publishedDate: new Date('2023-12-01'),
-            }
-            const upsertedItem = await repository.upsert(update)
-
-            expect(upsertedItem).toEqual(update)
-            expect(await repository.load({ id: 42 })).toEqual(update)
-        })
-
-        it('should generate primary key when upserting without one', async () => {
-            const input = { title: 'Book Without ID', author: 'Author Name', publishedDate: new Date() }
-
-            const upsertedItem = await repository.upsert(input)
-
-            expect(upsertedItem.id).toBeDefined()
-            expect(upsertedItem.title).toBe(input.title)
-            expect(upsertedItem.author).toBe(input.author)
-            expect(await repository.load({ id: upsertedItem.id })).toEqual(upsertedItem)
-        })
-
-        it('should merge with existing item properties when updating', async () => {
-            // Create initial item with multiple properties
-            const initial = {
-                id: 42,
-                title: 'Original Book',
-                author: 'Original Author',
-                publishedDate: new Date('2023-01-01'),
-            }
-            await repository.create(initial)
-
-            // Upsert with partial update (only title) - need to provide required fields
-            const partialUpdate = {
-                id: 42,
-                title: 'Updated Title',
-                author: 'Original Author', // Keep original
-                publishedDate: new Date('2023-01-01'), // Keep original
-            }
-            const upsertedItem = await repository.upsert(partialUpdate)
-
-            // Should have updated title but kept other properties
-            expect(upsertedItem.id).toBe(42)
-            expect(upsertedItem.title).toBe('Updated Title')
-            expect(upsertedItem.author).toBe('Original Author')
-            expect(upsertedItem.publishedDate).toEqual(initial.publishedDate)
-        })
-
-        it('should handle upsert with null/undefined primary key', async () => {
-            const input = {
-                id: undefined,
-                title: 'Book With Undefined ID',
-                author: 'Author Name',
-                publishedDate: new Date(),
-            }
-
-            const upsertedItem = await repository.upsert(input)
-
-            expect(upsertedItem.id).toBeDefined()
-            expect(typeof upsertedItem.id).toBe('number')
-            expect(upsertedItem.title).toBe(input.title)
-        })
-
-        it('should increment auto-generated IDs correctly', async () => {
-            const input1 = { title: 'Book 1', author: 'Author 1', publishedDate: new Date() }
-            const input2 = { title: 'Book 2', author: 'Author 2', publishedDate: new Date() }
-
-            const item1 = await repository.upsert(input1)
-            const item2 = await repository.upsert(input2)
-
-            expect(item1.id).toBe(1)
-            expect(item2.id).toBe(2)
-        })
-    })
-
-    describe('bulkUpsert functionality', () => {
-        it('should upsert multiple new items', async () => {
-            const inputs = [
-                { id: 1, title: 'Book 1', author: 'Author 1', publishedDate: new Date('2023-01-01') },
-                { id: 2, title: 'Book 2', author: 'Author 2', publishedDate: new Date('2023-02-01') },
-                { id: 3, title: 'Book 3', author: 'Author 3', publishedDate: new Date('2023-03-01') },
-            ]
-
-            const upsertedItems = await repository.bulkUpsert(inputs)
-
-            expect(upsertedItems).toHaveLength(3)
-            expect(upsertedItems).toEqual(inputs)
-
-            // Verify all items were created
-            for (const input of inputs) {
-                expect(await repository.load({ id: input.id })).toEqual(input)
-            }
-        })
-
-        it('should update existing items and create new ones in same operation', async () => {
-            // Create some initial items
-            const existing1 = {
-                id: 1,
-                title: 'Original Book 1',
-                author: 'Original Author 1',
-                publishedDate: new Date('2023-01-01'),
-            }
-            const existing2 = {
-                id: 2,
-                title: 'Original Book 2',
-                author: 'Original Author 2',
-                publishedDate: new Date('2023-02-01'),
-            }
-            await repository.create(existing1)
-            await repository.create(existing2)
-
-            // Bulk upsert with mix of updates and new items
-            const upsertInputs = [
-                { id: 1, title: 'Updated Book 1', author: 'Updated Author 1', publishedDate: new Date('2023-06-01') }, // Update
-                { id: 2, title: 'Updated Book 2', author: 'Updated Author 2', publishedDate: new Date('2023-07-01') }, // Update
-                { id: 3, title: 'New Book 3', author: 'New Author 3', publishedDate: new Date('2023-08-01') }, // Create
-                { id: 4, title: 'New Book 4', author: 'New Author 4', publishedDate: new Date('2023-09-01') }, // Create
-            ]
-
-            const upsertedItems = await repository.bulkUpsert(upsertInputs)
-
-            expect(upsertedItems).toHaveLength(4)
-            expect(upsertedItems).toEqual(upsertInputs)
-
-            // Verify all items have the updated/new values
-            for (const input of upsertInputs) {
-                expect(await repository.load({ id: input.id })).toEqual(input)
-            }
-        })
-
-        it('should handle bulk upsert with items without primary keys', async () => {
-            const inputs = [
-                { title: 'Book Without ID 1', author: 'Author 1', publishedDate: new Date() },
-                { title: 'Book Without ID 2', author: 'Author 2', publishedDate: new Date() },
-                { title: 'Book Without ID 3', author: 'Author 3', publishedDate: new Date() },
-            ]
-
-            const upsertedItems = await repository.bulkUpsert(inputs)
-
-            expect(upsertedItems).toHaveLength(3)
-
-            // All items should have generated IDs
-            expect(upsertedItems[0].id).toBe(1)
-            expect(upsertedItems[1].id).toBe(2)
-            expect(upsertedItems[2].id).toBe(3)
-
-            // Verify content is preserved
-            for (let i = 0; i < inputs.length; i++) {
-                expect(upsertedItems[i].title).toBe(inputs[i].title)
-                expect(upsertedItems[i].author).toBe(inputs[i].author)
-                expect(await repository.load({ id: upsertedItems[i].id })).toEqual(upsertedItems[i])
-            }
-        })
-
-        it('should handle empty bulk upsert', async () => {
-            const upsertedItems = await repository.bulkUpsert([])
-
-            expect(upsertedItems).toEqual([])
-        })
-
-        it('should handle bulk upsert with partial updates', async () => {
-            // Create initial items
-            const initial1 = {
-                id: 1,
-                title: 'Original Book 1',
-                author: 'Original Author 1',
-                publishedDate: new Date('2023-01-01'),
-            }
-            const initial2 = {
-                id: 2,
-                title: 'Original Book 2',
-                author: 'Original Author 2',
-                publishedDate: new Date('2023-02-01'),
-            }
-            await repository.create(initial1)
-            await repository.create(initial2)
-
-            // Updates with all required fields but only changing title
-            const partialUpdates = [
-                { id: 1, title: 'Updated Title 1', author: 'Original Author 1', publishedDate: new Date('2023-01-01') },
-                { id: 2, title: 'Updated Title 2', author: 'Original Author 2', publishedDate: new Date('2023-02-01') },
-            ]
-
-            const upsertedItems = await repository.bulkUpsert(partialUpdates)
-
-            expect(upsertedItems).toHaveLength(2)
-
-            // Should have updated titles but kept other properties
-            expect(upsertedItems[0].title).toBe('Updated Title 1')
-            expect(upsertedItems[0].author).toBe('Original Author 1')
-            expect(upsertedItems[0].publishedDate).toEqual(initial1.publishedDate)
-
-            expect(upsertedItems[1].title).toBe('Updated Title 2')
-            expect(upsertedItems[1].author).toBe('Original Author 2')
-            expect(upsertedItems[1].publishedDate).toEqual(initial2.publishedDate)
-        })
-
-        it('should handle large bulk operations efficiently', async () => {
-            // Create a large number of items to test performance
-            const inputs: Array<{ id: number; title: string; author: string; publishedDate: Date }> = []
-            for (let i = 1; i <= 100; i++) {
-                inputs.push({
-                    id: i,
-                    title: `Book ${i}`,
-                    author: `Author ${i}`,
-                    publishedDate: new Date(`2023-${String((i % 12) + 1).padStart(2, '0')}-01`),
-                })
-            }
-
-            const startTime = Date.now()
-            const upsertedItems = await repository.bulkUpsert(inputs)
-            const endTime = Date.now()
-
-            expect(upsertedItems).toHaveLength(100)
-            expect(endTime - startTime).toBeLessThan(1000) // Should complete in under 1 second
-
-            // Verify a few random items
-            expect(await repository.load({ id: 1 })).toEqual(inputs[0])
-            expect(await repository.load({ id: 50 })).toEqual(inputs[49])
-            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)
-        })
-    })
-})