@declaro/data 2.0.0-beta.12 → 2.0.0-beta.120

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

@@ -0,0 +1,265 @@
+import { beforeEach, describe, expect, it } from 'bun:test'
+import { MockBookSchema } from '../models/mock-book-models'
+import { MockMemoryRepository } from './mock-memory-repository'
+
+describe('MockMemoryRepository - Search Functionality', () => {
+    const mockSchema = MockBookSchema
+
+    let repository: MockMemoryRepository<typeof mockSchema>
+
+    beforeEach(() => {
+        repository = new MockMemoryRepository({ schema: mockSchema })
+    })
+
+    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)
+    })
+})

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

@@ -0,0 +1,301 @@
+import type { AnyModelSchema, IModelEntityMetadata, JSONSchema, Model } from '@declaro/core'
+import type { IRepository } from '../../../domain/interfaces/repository'
+import type { IPaginationInput } from '../../../domain/models/pagination'
+import type {
+    InferDetail,
+    InferFilters,
+    InferInput,
+    InferLookup,
+    InferSearchResults,
+    InferSummary,
+} from '../../../shared/utils/schema-inference'
+import { v4 as uuid } from 'uuid'
+import type { ISearchOptions } from '../../../domain/services/read-only-model-service'
+import type { ICreateOptions, IUpdateOptions } from '../../../domain/services/model-service'
+
+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> {
+    protected data = new Map<string, InferDetail<TSchema>>()
+    protected trash = new Map<string, InferDetail<TSchema>>()
+    protected entityMetadata: IModelEntityMetadata
+    protected nextId: number = 0
+
+    constructor(protected args: IMockMemoryRepositoryArgs<TSchema>) {
+        this.entityMetadata = this.args.schema.getEntityMetadata()
+        if (!this.entityMetadata?.primaryKey) {
+            throw new Error('Primary key must be specified for MockMemoryRepository')
+        }
+    }
+
+    async load(input: InferLookup<TSchema>): Promise<InferDetail<TSchema> | null> {
+        if (!this.entityMetadata?.primaryKey) {
+            throw new Error('Primary key is not defined in the schema metadata')
+        }
+
+        let item: InferDetail<TSchema> | undefined
+        if (typeof this.args.lookup === 'function') {
+            item = Array.from(this.data.values()).find((data) => this.args.lookup!(data, input))
+        } else {
+            // Default lookup by primary key
+            item = await this.data.get(input[this.entityMetadata.primaryKey])
+        }
+
+        return item || null
+    }
+    async loadMany(inputs: InferLookup<TSchema>[]): Promise<InferDetail<TSchema>[]> {
+        if (!this.entityMetadata?.primaryKey) {
+            throw new Error('Primary key is not defined in the schema metadata')
+        }
+
+        const results: InferDetail<TSchema>[] = []
+        for (const input of inputs) {
+            let item: InferDetail<TSchema> | undefined
+            if (typeof this.args.lookup === 'function') {
+                item = Array.from(this.data.values()).find((data) => this.args.lookup!(data, input))
+            } else {
+                // Default lookup by primary key
+                item = this.data.get(input[this.entityMetadata.primaryKey!])
+            }
+            if (item) {
+                results.push(item)
+            }
+        }
+        return results
+    }
+    async search(
+        input: InferFilters<TSchema>,
+        options?: ISearchOptions<TSchema>,
+    ): Promise<InferSearchResults<TSchema>> {
+        const pagination = options?.pagination || { page: 1, pageSize: 25 }
+        let items = this.applyFilters(input)
+
+        // Apply sorting if provided
+        if (options?.sort && Array.isArray(options.sort)) {
+            items = items.sort((a, b) => {
+                for (const sortField of options.sort! as any[]) {
+                    for (const [field, direction] of Object.entries(sortField)) {
+                        if (!direction || typeof direction !== 'string') continue
+
+                        const aValue = a[field as keyof typeof a]
+                        const bValue = b[field as keyof typeof b]
+
+                        let comparison = 0
+                        if (aValue < bValue) comparison = -1
+                        else if (aValue > bValue) comparison = 1
+
+                        if (comparison !== 0) {
+                            // Handle different sort directions
+                            const isDesc = direction.includes('desc')
+                            return isDesc ? -comparison : comparison
+                        }
+                    }
+                }
+                return 0
+            })
+        }
+
+        return {
+            results: items.slice(
+                ((pagination?.page ?? 1) - 1) * (pagination?.pageSize ?? 25),
+                (pagination?.page ?? 1) * (pagination?.pageSize ?? 25),
+            ),
+            pagination: {
+                total: items.length,
+                totalPages: Math.ceil(items.length / (pagination?.pageSize ?? 25)),
+                ...pagination,
+                page: pagination?.page ?? 1,
+                pageSize: pagination?.pageSize ?? 25,
+            },
+        }
+    }
+    async remove(lookup: InferLookup<TSchema>): Promise<InferSummary<TSchema>> {
+        if (!this.entityMetadata?.primaryKey) {
+            throw new Error('Primary key is not defined in the schema metadata')
+        }
+
+        let item: InferDetail<TSchema> | undefined
+        let itemKey: string
+
+        if (typeof this.args.lookup === 'function') {
+            item = Array.from(this.data.values()).find((data) => this.args.lookup!(data, lookup))
+            if (item) {
+                itemKey = item[this.entityMetadata.primaryKey!]
+            }
+        } else {
+            // Default lookup by primary key
+            itemKey = lookup[this.entityMetadata.primaryKey]
+            item = this.data.get(itemKey)
+        }
+
+        if (!item) {
+            throw new Error('Item not found')
+        }
+        // Move the item to trash
+        this.trash.set(itemKey!, item)
+        // Remove the item from data
+        this.data.delete(itemKey!)
+        return item
+    }
+    async restore(lookup: InferLookup<TSchema>): Promise<InferSummary<TSchema>> {
+        if (!this.entityMetadata?.primaryKey) {
+            throw new Error('Primary key is not defined in the schema metadata')
+        }
+
+        let item: InferDetail<TSchema> | undefined
+        let itemKey: string
+
+        if (typeof this.args.lookup === 'function') {
+            item = Array.from(this.trash.values()).find((data) => this.args.lookup!(data, lookup))
+            if (item) {
+                itemKey = item[this.entityMetadata.primaryKey!]
+            }
+        } else {
+            // Default lookup by primary key
+            itemKey = lookup[this.entityMetadata.primaryKey]
+            item = this.trash.get(itemKey)
+        }
+
+        if (!item) {
+            throw new Error('Item not found in trash')
+        }
+        this.trash.delete(itemKey!)
+        this.data.set(itemKey!, item)
+        return item
+    }
+
+    async create(input: InferInput<TSchema>): Promise<InferDetail<TSchema>> {
+        if (!this.entityMetadata?.primaryKey) {
+            throw new Error('Primary key is not defined in the schema metadata')
+        }
+        const primaryKeyValue = input[this.entityMetadata.primaryKey]
+
+        if (primaryKeyValue && this.data.has(primaryKeyValue)) {
+            throw new Error('Item with the same primary key already exists')
+        }
+
+        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)
+        return payload
+    }
+
+    async update(lookup: InferLookup<TSchema>, input: InferInput<TSchema>): Promise<InferDetail<TSchema>> {
+        if (!this.entityMetadata?.primaryKey) {
+            throw new Error('Primary key is not defined in the schema metadata')
+        }
+
+        let existingItem: InferDetail<TSchema> | undefined
+        let itemKey: string
+
+        if (typeof this.args.lookup === 'function') {
+            existingItem = Array.from(this.data.values()).find((data) => this.args.lookup!(data, lookup))
+            if (existingItem) {
+                itemKey = existingItem[this.entityMetadata.primaryKey!]
+            } else {
+                throw new Error('Item not found')
+            }
+        } else {
+            // Default lookup by primary key
+            itemKey = lookup[this.entityMetadata.primaryKey]
+            if (!itemKey) {
+                throw new Error('Primary key value must be provided')
+            }
+            existingItem = this.data.get(itemKey)
+            if (!existingItem) {
+                throw new Error('Item not found')
+            }
+        }
+
+        const updatedItem = this.assignInput(existingItem, input)
+        this.data.set(itemKey!, updatedItem)
+        return updatedItem
+    }
+
+    async count(search: InferFilters<TSchema>, options?: ISearchOptions<TSchema> | undefined): Promise<number> {
+        const filteredItems = this.applyFilters(search)
+        return filteredItems.length
+    }
+
+    async upsert(input: InferInput<TSchema>, options?: ICreateOptions | IUpdateOptions): Promise<InferDetail<TSchema>> {
+        const primaryKeyValue = input[this.entityMetadata.primaryKey]
+        let existingItem: InferDetail<TSchema> = {} as InferDetail<TSchema>
+
+        if (primaryKeyValue) {
+            existingItem = this.data.get(primaryKeyValue) ?? ({} as InferDetail<TSchema>)
+        }
+
+        const updatedItem = this.assignInput(existingItem, input)
+        if (!updatedItem[this.entityMetadata.primaryKey!]) {
+            updatedItem[this.entityMetadata.primaryKey!] = await this.generatePrimaryKey()
+        }
+
+        this.data.set(updatedItem[this.entityMetadata.primaryKey!], updatedItem)
+
+        return updatedItem
+    }
+
+    async bulkUpsert(
+        inputs: InferInput<TSchema>[],
+        options?: ICreateOptions | IUpdateOptions,
+    ): Promise<InferDetail<TSchema>[]> {
+        return await Promise.all(inputs.map((input) => this.upsert(input, options)))
+    }
+
+    /**
+     * Apply filtering logic to all items based on the provided search criteria
+     * @param input - The search/filter criteria
+     * @returns Filtered array of items
+     */
+    protected applyFilters(input: InferFilters<TSchema>): InferDetail<TSchema>[] {
+        return Array.from(this.data.values()).filter((item) => {
+            // Apply filtering logic based on the input
+            if (typeof this.args.filter === 'function') {
+                return this.args.filter(item, input)
+            } else {
+                return true
+            }
+        })
+    }
+
+    /**
+     * 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()
+        const primaryKeyMeta = lookupMeta.properties?.[this.entityMetadata.primaryKey!] as JSONSchema
+        const type = primaryKeyMeta.type as string
+
+        if (type === 'string') {
+            return uuid()
+        } else if (['number', 'integer'].includes(type)) {
+            return ++this.nextId
+        } else {
+            throw new Error(`Unsupported primary key type: ${type}`)
+        }
+    }
+}

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

@@ -0,0 +1,108 @@
+import { beforeEach, describe, expect, it } from 'bun:test'
+import { MockBookSchema } from '../models/mock-book-models'
+import { MockMemoryRepository } from './mock-memory-repository'
+
+describe('MockMemoryRepository - Upsert Functionality', () => {
+    const mockSchema = MockBookSchema
+
+    let repository: MockMemoryRepository<typeof mockSchema>
+
+    beforeEach(() => {
+        repository = new MockMemoryRepository({ schema: mockSchema })
+    })
+
+    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)
+    })
+})