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

package/src/domain/services/read-only-model-service.ts

@@ -0,0 +1,178 @@
+import type { AnyModelSchema, Model } from '@declaro/core'
+import type {
+    InferDetail,
+    InferFilters,
+    InferLookup,
+    InferSearchResults,
+    InferSort,
+} from '../../shared/utils/schema-inference'
+import { ModelQueryEvent } from '../events/event-types'
+import { QueryEvent } from '../events/query-event'
+import { BaseModelService, type IActionOptions } from './base-model-service'
+import type { IPaginationInput } from '../models/pagination'
+
+/**
+ * Options for loading records.
+ */
+export interface ILoadOptions extends IActionOptions {
+    /**
+     * If true, only removed (soft-deleted) records will be returned.
+     */
+    removedOnly?: boolean
+    /**
+     * If true, both removed and non-removed records will be returned.
+     */
+    includeRemoved?: boolean
+}
+export interface ISearchOptions<TSchema extends AnyModelSchema> extends IActionOptions {
+    pagination?: IPaginationInput
+    sort?: InferSort<TSchema>
+    /**
+     * If true, only removed (soft-deleted) records will be returned.
+     */
+    removedOnly?: boolean
+    /**
+     * If true, both removed and non-removed records will be returned.
+     */
+    includeRemoved?: boolean
+}
+
+export class ReadOnlyModelService<TSchema extends AnyModelSchema> extends BaseModelService<TSchema> {
+    /**
+     * Normalize the detail data to match the expected schema.
+     * WARNING: This method is called once per detail in load operations.
+     * Any intensive operations or queries should be avoided here, and done via bulk operations in the respective methods such as `loadMany` instead.
+     * @param detail The detail data to normalize.
+     * @returns The normalized detail data.
+     */
+    async normalizeDetail(detail: InferDetail<TSchema>): Promise<InferDetail<TSchema>> {
+        return detail
+    }
+
+    /**
+     * Normalize the summary data to match the expected schema.
+     * WARNING: This method is called once per summary in search results, often in parallel.
+     * Any intensive operations or queries should be avoided here, and done via bulk operations in the respective methods such as `search` instead.
+     *
+     * @param summary The summary data to normalize.
+     * @returns The normalized summary data.
+     */
+    async normalizeSummary(summary: InferDetail<TSchema>): Promise<InferDetail<TSchema>> {
+        return summary
+    }
+
+    /**
+     * Load a single record by its lookup criteria.
+     * @param lookup The lookup criteria to find the record.
+     * @param options Additional options for the load operation.
+     * @returns The loaded record details.
+     */
+    async load(lookup: InferLookup<TSchema>, options?: ILoadOptions): Promise<InferDetail<TSchema>> {
+        // Emit the before load event
+        const beforeLoadEvent = new QueryEvent<InferDetail<TSchema>, InferLookup<TSchema>>(
+            this.getDescriptor(ModelQueryEvent.BeforeLoad, options?.scope),
+            lookup,
+        )
+        await this.emitter.emitAsync(beforeLoadEvent)
+
+        // Load the details from the repository
+        const details = await this.repository.load(lookup, options)
+
+        // Emit the after load event
+        const afterLoadEvent = new QueryEvent<InferDetail<TSchema>, InferLookup<TSchema>>(
+            this.getDescriptor(ModelQueryEvent.AfterLoad, options?.scope),
+            lookup,
+        ).setResult(details)
+        await this.emitter.emitAsync(afterLoadEvent)
+
+        return await this.normalizeDetail(details)
+    }
+
+    /**
+     * Load multiple records by their lookup criteria.
+     * @param lookups The lookup criteria to find the records.
+     * @param options Additional options for the load operation.
+     * @returns An array of loaded record details.
+     */
+    async loadMany(lookups: InferLookup<TSchema>[], options?: ILoadOptions): Promise<InferDetail<TSchema>[]> {
+        // Emit the before load many event
+        const beforeLoadManyEvent = new QueryEvent<InferDetail<TSchema>[], InferLookup<TSchema>[]>(
+            this.getDescriptor(ModelQueryEvent.BeforeLoadMany, options?.scope),
+            lookups,
+        )
+        await this.emitter.emitAsync(beforeLoadManyEvent)
+
+        // Load the details from the repository
+        const details = await this.repository.loadMany(lookups, options)
+
+        // Emit the after load many event
+        const afterLoadManyEvent = new QueryEvent<InferDetail<TSchema>[], InferLookup<TSchema>[]>(
+            this.getDescriptor(ModelQueryEvent.AfterLoadMany, options?.scope),
+            lookups,
+        ).setResult(details)
+        await this.emitter.emitAsync(afterLoadManyEvent)
+
+        return await Promise.all(details.map((detail) => this.normalizeDetail(detail)))
+    }
+
+    /**
+     * Search for records matching the given filters.
+     * @param filters The filters to apply to the search.
+     * @param options Additional options for the search operation.
+     * @returns The search results.
+     */
+    async search(
+        filters: InferFilters<TSchema>,
+        options?: ISearchOptions<TSchema>,
+    ): Promise<InferSearchResults<TSchema>> {
+        // Emit the before search event
+        const beforeSearchEvent = new QueryEvent<InferSearchResults<TSchema>, InferFilters<TSchema>>(
+            this.getDescriptor(ModelQueryEvent.BeforeSearch, options?.scope),
+            filters,
+        )
+        await this.emitter.emitAsync(beforeSearchEvent)
+
+        // Search the repository with the provided filters
+        const results = await this.repository.search(filters, options)
+
+        // Emit the after search event
+        const afterSearchEvent = new QueryEvent<InferSearchResults<TSchema>, InferFilters<TSchema>>(
+            this.getDescriptor(ModelQueryEvent.AfterSearch, options?.scope),
+            filters,
+        ).setResult(results)
+        await this.emitter.emitAsync(afterSearchEvent)
+
+        // Return the search results
+        return {
+            ...results,
+            results: await Promise.all(results.results.map((detail) => this.normalizeSummary(detail))),
+        }
+    }
+
+    /**
+     * Count the number of records matching the given filters.
+     * @param filters The filters to apply to the count operation.
+     * @returns The count of matching records.
+     */
+    async count(filters: InferFilters<TSchema>, options?: ISearchOptions<TSchema>): Promise<number> {
+        // Emit the before count event
+        const beforeCountEvent = new QueryEvent<number, InferFilters<TSchema>>(
+            this.getDescriptor(ModelQueryEvent.BeforeCount, options?.scope),
+            filters,
+        )
+        await this.emitter.emitAsync(beforeCountEvent)
+
+        // Count the records in the repository
+        const count = await this.repository.count(filters, options)
+
+        // Emit the after count event
+        const afterCountEvent = new QueryEvent<number, InferFilters<TSchema>>(
+            this.getDescriptor(ModelQueryEvent.AfterCount, options?.scope),
+            filters,
+        ).setResult(count)
+        await this.emitter.emitAsync(afterCountEvent)
+
+        // Return the count
+        return count
+    }
+}

package/src/index.ts

@@ -1,4 +1,17 @@
-export * from './databaseConnection'
-export * from './serverConnection'
-export * from './datastoreAbstract'
-export * from './hydrateEntity'
+export * from './application/model-controller'
+export * from './application/read-only-model-controller'
+export * from './domain/events/domain-event'
+export * from './domain/events/event-types'
+export * from './domain/events/mutation-event'
+export * from './domain/events/query-event'
+export * from './domain/events/request-event'
+export * from './domain/interfaces/repository'
+export * from './domain/models/pagination'
+export * from './domain/services/base-model-service'
+export * from './domain/services/model-service'
+export * from './domain/services/model-service-args'
+export * from './domain/services/read-only-model-service'
+export * from './shared/utils/schema-inference'
+export * from './shared/utils/schema-inheritance'
+export * from './test/mock/models/mock-book-models'
+export * from './test/mock/repositories/mock-memory-repository'

package/src/shared/utils/schema-inference.ts

@@ -0,0 +1,26 @@
+import type { AnyModelSchema, InferModelInput, InferModelOutput } from '@declaro/core'
+import type { IPagination } from '../../domain/models/pagination'
+
+export interface ISearchResults<T> {
+    results: T[]
+    pagination: IPagination
+}
+
+export type InferLookup<TSchema extends AnyModelSchema> = InferModelInput<TSchema['definition']['lookup']>
+export type InferDetail<TSchema extends AnyModelSchema> = InferModelOutput<TSchema['definition']['detail']>
+export type InferFilters<TSchema extends AnyModelSchema> = InferModelInput<TSchema['definition']['filters']>
+export type InferSummary<TSchema extends AnyModelSchema> = InferModelOutput<TSchema['definition']['summary']>
+export type InferSort<TSchema extends AnyModelSchema> = InferModelInput<TSchema['definition']['sort']>
+export type InferInput<TSchema extends AnyModelSchema> = InferModelInput<TSchema['definition']['input']>
+export type InferSearchResults<TSchema extends AnyModelSchema> = ISearchResults<InferSummary<TSchema>>
+export type InferEntityMetadata<TSchema extends AnyModelSchema> = ReturnType<TSchema['getEntityMetadata']>
+export type InferPrimaryKeyType<TSchema extends AnyModelSchema> =
+    InferLookup<TSchema>[InferEntityMetadata<TSchema>['primaryKey']]
+
+export type InferSummarySchema<TSchema extends AnyModelSchema> = TSchema['definition']['summary']['schema']
+export type InferDetailSchema<TSchema extends AnyModelSchema> = TSchema['definition']['detail']['schema']
+export type InferLookupSchema<TSchema extends AnyModelSchema> = TSchema['definition']['lookup']['schema']
+export type InferInputSchema<TSchema extends AnyModelSchema> = TSchema['definition']['input']['schema']
+export type InferFiltersSchema<TSchema extends AnyModelSchema> = TSchema['definition']['filters']['schema']
+export type InferSortSchema<TSchema extends AnyModelSchema> = TSchema['definition']['sort']['schema']
+export type InferSearchResultsSchema<TSchema extends AnyModelSchema> = TSchema['definition']['search']['schema']

package/src/shared/utils/schema-inheritance.ts

@@ -0,0 +1,28 @@
+import type { AnyModelSchema, Model, ModelSchema } from '@declaro/core'
+import type { InferEntityMetadata } from './schema-inference'
+
+/**
+ * Represents a child schema that inherits from a parent schema.
+ * This is useful for creating schemas that extend the functionality of an existing schema.
+ * It replaces the schema name and all model names with a string type.
+ *
+ * @warning This type is intended for use in generic types. In most cases, you should use concrete schemas for inheritance for best type inference.
+ *
+ * @template TSchema - The parent schema type.
+ * @example
+ * ```ts
+ * import { ModelSchema, ChildSchema } from '@declaro/core';
+ *
+ * export class ParentService<TSchema extends ChildSchema<typeof ParentSchema>> extends ModelService<TSchema> {
+ *     constructor(args: IModelServiceArgs<TSchema>) {
+ *         super(args);
+ *     }
+ * }
+ */
+export type ChildSchema<TSchema extends AnyModelSchema> = ModelSchema<
+    string,
+    {
+        [K in keyof TSchema['definition']]: Model<string, TSchema['definition'][K]['schema']>
+    },
+    InferEntityMetadata<TSchema>
+>

package/src/test/mock/models/mock-book-models.ts

@@ -0,0 +1,78 @@
+import { ModelSchema } from '@declaro/core'
+import { sortArray, ZodModel } from '@declaro/zod'
+import { z } from 'zod/v4'
+import type {
+    InferFilters,
+    InferLookup,
+    InferDetail,
+    InferSummary,
+    InferSort,
+    InferInput,
+    InferSearchResults,
+    InferEntityMetadata,
+} from '../../../shared/utils/schema-inference'
+
+export const MockBookSchema = ModelSchema.create('Book')
+    .read({
+        detail: (h) =>
+            new ZodModel(
+                h.name,
+                z.object({
+                    id: z.number().int().positive(),
+                    title: z.string().min(2).max(100),
+                    author: z.string().min(2).max(100),
+                    publishedDate: z.coerce.date(),
+                }),
+            ),
+        lookup: (h) =>
+            new ZodModel(
+                h.name,
+                z.object({
+                    id: z.number().int().positive(),
+                }),
+            ),
+    })
+    .search({
+        filters: (h) =>
+            new ZodModel(
+                h.name,
+                z.object({
+                    text: z.string().optional(),
+                }),
+            ),
+        summary: (h) =>
+            new ZodModel(
+                h.name,
+                z.object({
+                    id: z.number().int().positive(),
+                    title: z.string().min(2).max(100),
+                    author: z.string().min(2).max(100),
+                    publishedDate: z.coerce.date(),
+                }),
+            ),
+        sort: (h) => new ZodModel(h.name, sortArray(['title', 'author'])),
+    })
+    .write({
+        input: (h) =>
+            new ZodModel(
+                h.name,
+                z.object({
+                    id: z.number().int().positive().optional(),
+                    title: z.string().min(2).max(100),
+                    author: z.string().min(2).max(100),
+                    publishedDate: z.coerce.date(),
+                }),
+            ),
+    })
+    .entity({
+        primaryKey: 'id',
+    })
+
+export type MockBookFilters = InferFilters<typeof MockBookSchema>
+export type MockBookLookup = InferLookup<typeof MockBookSchema>
+export type MockBookDetail = InferDetail<typeof MockBookSchema>
+export type MockBookSummary = InferSummary<typeof MockBookSchema>
+export type MockBookSort = InferSort<typeof MockBookSchema>
+export type MockBookInput = InferInput<typeof MockBookSchema>
+export type MockBookSearchResults = InferSearchResults<typeof MockBookSchema>
+export type MockBookEntityMetadata = InferEntityMetadata<typeof MockBookSchema>

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

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

@@ -0,0 +1,129 @@
+import { beforeEach, describe, expect, it } 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 - Basic Operations', () => {
+    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)
+    })
+})