@declaro/data 2.0.0-beta.14 → 2.0.0-beta.140

package/src/shared/utils/test/elephant-schema.ts

@@ -0,0 +1,58 @@
+// Elephant Schema inheriting from Animal Schema
+
+import z4 from 'zod/v4'
+import {
+    AnimalDetailSchema,
+    AnimalFiltersSchema,
+    AnimalLookupSchema,
+    AnimalSortSchema,
+    AnimalSummarySchema,
+} from './animal-schema'
+import { ModelSchema } from '@declaro/core'
+import { ZodModel } from '@declaro/zod'
+import { ElephantTraitsDetailSchema, ElephantTraitsSummarySchema } from './elephant-trait-schema'
+
+export const ElephantDetailSchema = z4.object({
+    ...AnimalDetailSchema.shape,
+    trunkLength: z4.number(),
+    get traits() {
+        return z4.array(ElephantTraitsDetailSchema)
+    },
+    get elephantDetails() {
+        return z4.object({
+            favoriteFood: z4.string(),
+            weight: z4.number(),
+        })
+    },
+})
+
+export const ElephantSummarySchema = z4.object({
+    ...AnimalSummarySchema.shape,
+    trunkLength: z4.number(),
+    get traits() {
+        return z4.array(ElephantTraitsSummarySchema)
+    },
+})
+
+export const ElephantLookupSchema = z4.object({
+    ...AnimalLookupSchema.shape,
+})
+
+export const ElephantFiltersSchema = z4.object({
+    ...AnimalFiltersSchema.shape,
+    minTrunkLength: z4.number().optional(),
+    maxTrunkLength: z4.number().optional(),
+})
+
+export const ElephantSchema = ModelSchema.create('ElephantSchema')
+    .read({
+        detail: (h) => new ZodModel('ElephantDetail', ElephantDetailSchema),
+        lookup: (h) => new ZodModel('ElephantLookup', ElephantLookupSchema),
+    })
+    .search({
+        filters: (h) => new ZodModel('ElephantFilters', ElephantFiltersSchema),
+        sort: (h) => new ZodModel('ElephantSort', AnimalSortSchema),
+        summary: (h) => new ZodModel('ElephantSummary', ElephantSummarySchema),
+    })
+
+export type IElephantSchema = typeof ElephantSchema

package/src/shared/utils/test/elephant-trait-schema.ts

@@ -0,0 +1,53 @@
+// Elephant Traits Schema inheriting from Animal Traits Schema
+
+import z4 from 'zod/v4'
+import { ModelSchema } from '@declaro/core'
+import { ZodModel } from '@declaro/zod'
+import {
+    AnimalTraitsDetailSchema,
+    AnimalTraitsFiltersSchema,
+    AnimalTraitsLookupSchema,
+    AnimalTraitsSortSchema,
+    AnimalTraitsSummarySchema,
+} from './animal-trait-schema'
+import { ElephantDetailSchema, ElephantSummarySchema } from './elephant-schema'
+
+export const ElephantTraitsDetailSchema = z4.object({
+    ...AnimalTraitsDetailSchema.shape,
+    isSharp: z4.boolean(),
+    length: z4.number(),
+    get animal() {
+        return ElephantDetailSchema.optional()
+    },
+})
+
+export const ElephantTraitsSummarySchema = z4.object({
+    ...AnimalTraitsSummarySchema.shape,
+    isSharp: z4.boolean(),
+    length: z4.number(),
+    get animal() {
+        return ElephantSummarySchema.optional()
+    },
+})
+
+export const ElephantTraitsLookupSchema = z4.object({
+    ...AnimalTraitsLookupSchema.shape,
+})
+
+export const ElephantTraitsFiltersSchema = z4.object({
+    ...AnimalTraitsFiltersSchema.shape,
+    isSharp: z4.boolean().optional(),
+})
+
+export const ElephantTraitsSchema = ModelSchema.create('ElephantTraitsSchema')
+    .read({
+        detail: (h) => new ZodModel('ElephantTraitsDetail', ElephantTraitsDetailSchema),
+        lookup: (h) => new ZodModel('ElephantTraitsLookup', ElephantTraitsLookupSchema),
+    })
+    .search({
+        filters: (h) => new ZodModel('ElephantTraitsFilters', ElephantTraitsFiltersSchema),
+        sort: (h) => new ZodModel('ElephantTraitsSort', AnimalTraitsSortSchema),
+        summary: (h) => new ZodModel('ElephantTraitsSummary', ElephantTraitsSummarySchema),
+    })
+
+export type IElephantTraitSchema = typeof ElephantTraitsSchema

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)
+    })
+})