@declaro/data 2.0.0-beta.126 → 2.0.0-beta.128

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

@@ -1,4 +1,4 @@
-import type { ActionDescriptor, AnyModelSchema, IActionDescriptor } from '@declaro/core'
+import type { ActionDescriptor, AnyModelSchema, IActionDescriptor, IAnyModel } from '@declaro/core'
 import type {
     InferDetail,
     InferFilters,
@@ -12,8 +12,18 @@ import type { IModelServiceArgs } from './model-service-args'
 import { ReadOnlyModelService, type ILoadOptions } from './read-only-model-service'
 import type { IActionOptions } from './base-model-service'
 
-export interface ICreateOptions extends IActionOptions {}
-export interface IUpdateOptions extends IActionOptions {}
+export interface ICreateOptions extends IActionOptions {
+    /**
+     * If true, skips dispatching events for this action.
+     */
+    doNotDispatchEvents?: boolean
+}
+export interface IUpdateOptions extends IActionOptions {
+    /**
+     * If true, skips dispatching events for this action.
+     */
+    doNotDispatchEvents?: boolean
+}
 
 export interface INormalizeInputArgs<TSchema extends AnyModelSchema> {
     existing?: InferDetail<TSchema>
@@ -39,6 +49,72 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         return input
     }
 
+    /**
+     * Converts a detail object to a valid input for this service's schema.
+     * Picks only fields that exist in the input model and validates/coerces
+     * them through the input schema. Useful for duplicating entities or
+     * converting a detail from one entity type into an input for another.
+     * @param detail The detail object to convert (can be from any schema).
+     * @returns A validated input object with coerced values.
+     */
+    async detailsToInput(detail: Record<string, unknown>): Promise<InferInput<TSchema>> {
+        const inputModel: IAnyModel = this.schema.definition.input
+        const inputJsonSchema = inputModel.toJSONSchema()
+        const inputFields = Object.keys(inputJsonSchema.properties ?? {})
+
+        // Pick only fields that exist in the input model
+        const picked: Record<string, unknown> = {}
+        for (const field of inputFields) {
+            if (field in detail) {
+                picked[field] = detail[field]
+            }
+        }
+
+        // Validate through the input model to coerce values
+        const result = await inputModel.validate(picked as any)
+
+        if ('value' in result) {
+            return result.value as InferInput<TSchema>
+        }
+
+        return picked as InferInput<TSchema>
+    }
+
+    /**
+     * Duplicates an existing entity by loading it, converting to input, removing the
+     * primary key, and creating a new record. Accepts an optional partial input to
+     * merge on top of the converted copy before creation.
+     * @param lookup The lookup criteria to find the record to duplicate.
+     * @param overrides Optional partial input to merge on top of the duplicated data.
+     * @param options Optional create options.
+     * @returns The newly created duplicate record.
+     */
+    async duplicate(
+        lookup: InferLookup<TSchema>,
+        overrides?: Partial<InferInput<TSchema>>,
+        options?: ICreateOptions,
+    ): Promise<InferDetail<TSchema>> {
+        // Load the existing entity
+        const existing = await this.load(lookup)
+        if (!existing) {
+            throw new Error('Item not found')
+        }
+
+        // Convert the detail to an input
+        const input = await this.detailsToInput(existing as Record<string, unknown>)
+
+        // Remove the primary key to ensure a new record gets created
+        if (this.entityMetadata?.primaryKey) {
+            delete (input as Record<string, unknown>)[this.entityMetadata.primaryKey]
+        }
+
+        // Merge optional overrides
+        const finalInput = overrides ? Object.assign({}, input, overrides) : input
+
+        // Create the new record
+        return this.create(finalInput as InferInput<TSchema>, options)
+    }
+
     /**
      * Removes a record by its lookup criteria.
      * @param lookup The lookup criteria to find the record.
@@ -101,21 +177,25 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         })
 
         // Emit the before create event
-        const beforeCreateEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
-            this.getDescriptor(ModelMutationAction.BeforeCreate),
-            normalizedInput,
-        )
-        await this.emitter.emitAsync(beforeCreateEvent)
+        if (!options?.doNotDispatchEvents) {
+            const beforeCreateEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                this.getDescriptor(ModelMutationAction.BeforeCreate),
+                normalizedInput,
+            )
+            await this.emitter.emitAsync(beforeCreateEvent)
+        }
 
         // Perform the creation
         const result = await this.repository.create(normalizedInput, options)
 
         // Emit the after create event
-        const afterCreateEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
-            this.getDescriptor(ModelMutationAction.AfterCreate),
-            normalizedInput,
-        ).setResult(result)
-        await this.emitter.emitAsync(afterCreateEvent)
+        if (!options?.doNotDispatchEvents) {
+            const afterCreateEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                this.getDescriptor(ModelMutationAction.AfterCreate),
+                normalizedInput,
+            ).setResult(result)
+            await this.emitter.emitAsync(afterCreateEvent)
+        }
 
         // Return the results of the creation
         return await this.normalizeDetail(result)
@@ -126,7 +206,7 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         input: InferInput<TSchema>,
         options?: IUpdateOptions,
     ): Promise<InferDetail<TSchema>> {
-        const existing = await this.repository.load(lookup, options)
+        const existing = await this.repository.load(lookup, { ...options, doNotDispatchEvents: true })
         // Normalize the input data
         const normalizedInput = await this.normalizeInput(input, {
             existing,
@@ -134,21 +214,25 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         })
 
         // Emit the before update event
-        const beforeUpdateEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
-            this.getDescriptor(ModelMutationAction.BeforeUpdate),
-            normalizedInput,
-        )
-        await this.emitter.emitAsync(beforeUpdateEvent)
+        if (!options?.doNotDispatchEvents) {
+            const beforeUpdateEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                this.getDescriptor(ModelMutationAction.BeforeUpdate),
+                normalizedInput,
+            )
+            await this.emitter.emitAsync(beforeUpdateEvent)
+        }
 
         // Perform the update
         const result = await this.repository.update(lookup, normalizedInput, options)
 
         // Emit the after update event
-        const afterUpdateEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
-            this.getDescriptor(ModelMutationAction.AfterUpdate),
-            normalizedInput,
-        ).setResult(result)
-        await this.emitter.emitAsync(afterUpdateEvent)
+        if (!options?.doNotDispatchEvents) {
+            const afterUpdateEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                this.getDescriptor(ModelMutationAction.AfterUpdate),
+                normalizedInput,
+            ).setResult(result)
+            await this.emitter.emitAsync(afterUpdateEvent)
+        }
 
         // Return the results of the update
         return await this.normalizeDetail(result)
@@ -177,7 +261,10 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
                 {
                     [this.entityMetadata.primaryKey]: primaryKeyValue,
                 } as InferLookup<TSchema>,
-                options,
+                {
+                    ...options,
+                    doNotDispatchEvents: true,
+                },
             )
 
             if (existingItem) {
@@ -198,21 +285,25 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         })
 
         // Emit the before upsert event
-        const beforeUpsertEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
-            this.getDescriptor(beforeOperation),
-            normalizedInput,
-        )
-        await this.emitter.emitAsync(beforeUpsertEvent)
+        if (!options?.doNotDispatchEvents) {
+            const beforeUpsertEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                this.getDescriptor(beforeOperation),
+                normalizedInput,
+            )
+            await this.emitter.emitAsync(beforeUpsertEvent)
+        }
 
         // Perform the upsert operation
         const result = await this.repository.upsert(normalizedInput, options)
 
         // Emit the after upsert event
-        const afterUpsertEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
-            this.getDescriptor(afterOperation),
-            normalizedInput,
-        ).setResult(result)
-        await this.emitter.emitAsync(afterUpsertEvent)
+        if (!options?.doNotDispatchEvents) {
+            const afterUpsertEvent = new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                this.getDescriptor(afterOperation),
+                normalizedInput,
+            ).setResult(result)
+            await this.emitter.emitAsync(afterUpsertEvent)
+        }
 
         // Return the results of the upsert operation
         return await this.normalizeDetail(result)
@@ -268,7 +359,10 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         const existingEntitiesMap = new Map<string | number, InferDetail<TSchema>>()
         if (uniqueLookups.size > 0) {
             const lookups = Array.from(uniqueLookups.values())
-            const existingEntities = await this.loadMany(lookups, options)
+            const existingEntities = await this.loadMany(lookups, {
+                ...options,
+                doNotDispatchEvents: true,
+            })
             existingEntities.forEach((entity) => {
                 if (entity) {
                     const pkValue = this.getPrimaryKeyValue(entity)
@@ -306,44 +400,48 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         const normalizedInputs = await Promise.all(normalizationPromises)
 
         // Create before events
-        const beforeEvents: MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>[] = []
-        for (const inputInfo of inputInfos) {
-            beforeEvents.push(
-                new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
-                    this.getDescriptor(inputInfo.operation!),
-                    inputInfo.input,
-                ),
-            )
-        }
+        if (!options?.doNotDispatchEvents) {
+            const beforeEvents: MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>[] = []
+            for (const inputInfo of inputInfos) {
+                beforeEvents.push(
+                    new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                        this.getDescriptor(inputInfo.operation!),
+                        inputInfo.input,
+                    ),
+                )
+            }
 
-        // Emit all before events
-        await Promise.all(beforeEvents.map((event) => this.emitter.emitAsync(event)))
+            // Emit all before events
+            await Promise.all(beforeEvents.map((event) => this.emitter.emitAsync(event)))
+        }
 
         // Perform the bulk upsert operation with all normalized inputs
         const results = await this.repository.bulkUpsert(normalizedInputs, options)
 
         // Create after events and return results
-        const afterEvents: MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>[] = []
-
-        for (let i = 0; i < inputInfos.length; i++) {
-            const inputInfo = inputInfos[i]
-            const result = results[i]
-
-            const afterOperation =
-                inputInfo.operation === ModelMutationAction.BeforeCreate
-                    ? ModelMutationAction.AfterCreate
-                    : ModelMutationAction.AfterUpdate
-
-            afterEvents.push(
-                new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
-                    this.getDescriptor(afterOperation),
-                    inputInfo.input,
-                ).setResult(result),
-            )
-        }
+        if (!options?.doNotDispatchEvents) {
+            const afterEvents: MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>[] = []
+
+            for (let i = 0; i < inputInfos.length; i++) {
+                const inputInfo = inputInfos[i]
+                const result = results[i]
+
+                const afterOperation =
+                    inputInfo.operation === ModelMutationAction.BeforeCreate
+                        ? ModelMutationAction.AfterCreate
+                        : ModelMutationAction.AfterUpdate
+
+                afterEvents.push(
+                    new MutationEvent<InferDetail<TSchema>, InferInput<TSchema>>(
+                        this.getDescriptor(afterOperation),
+                        inputInfo.input,
+                    ).setResult(result),
+                )
+            }
 
-        // Emit all after events
-        await Promise.all(afterEvents.map((event) => this.emitter.emitAsync(event)))
+            // Emit all after events
+            await Promise.all(afterEvents.map((event) => this.emitter.emitAsync(event)))
+        }
 
         // Return normalized results
         return await Promise.all(results.map((result) => this.normalizeDetail(result)))

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

@@ -825,4 +825,234 @@ describe('ReadOnlyModelService', () => {
             })
         })
     })
+
+    describe('doNotDispatchEvents Option', () => {
+        const beforeLoadSpy = mock(
+            (event: QueryEvent<InferDetail<typeof mockSchema>, InferLookup<typeof mockSchema>>) => {},
+        )
+        const afterLoadSpy = mock(
+            (event: QueryEvent<InferDetail<typeof mockSchema>, InferLookup<typeof mockSchema>>) => {},
+        )
+
+        const beforeLoadManySpy = mock(
+            (event: QueryEvent<InferDetail<typeof mockSchema>[], InferLookup<typeof mockSchema>[]>) => {},
+        )
+        const afterLoadManySpy = mock(
+            (event: QueryEvent<InferDetail<typeof mockSchema>[], InferLookup<typeof mockSchema>[]>) => {},
+        )
+
+        const beforeSearchSpy = mock(
+            (event: QueryEvent<InferSearchResults<typeof mockSchema>[], InferFilters<typeof mockSchema>[]>) => {},
+        )
+        const afterSearchSpy = mock(
+            (event: QueryEvent<InferSearchResults<typeof mockSchema>[], InferFilters<typeof mockSchema>[]>) => {},
+        )
+
+        const beforeCountSpy = mock((event: QueryEvent<number, InferFilters<typeof mockSchema>>) => {})
+        const afterCountSpy = mock((event: QueryEvent<number, InferFilters<typeof mockSchema>>) => {})
+
+        beforeEach(() => {
+            repository = new MockMemoryRepository({ schema: mockSchema })
+            emitter = new EventManager()
+
+            beforeLoadSpy.mockClear()
+            afterLoadSpy.mockClear()
+            beforeLoadManySpy.mockClear()
+            afterLoadManySpy.mockClear()
+            beforeSearchSpy.mockClear()
+            afterSearchSpy.mockClear()
+            beforeCountSpy.mockClear()
+            afterCountSpy.mockClear()
+
+            emitter.on<QueryEvent<InferDetail<typeof mockSchema>, InferLookup<typeof mockSchema>>>(
+                'books::book.beforeLoad',
+                beforeLoadSpy,
+            )
+            emitter.on<QueryEvent<InferDetail<typeof mockSchema>, InferLookup<typeof mockSchema>>>(
+                'books::book.afterLoad',
+                afterLoadSpy,
+            )
+
+            emitter.on<QueryEvent<InferDetail<typeof mockSchema>[], InferLookup<typeof mockSchema>[]>>(
+                'books::book.beforeLoadMany',
+                beforeLoadManySpy,
+            )
+            emitter.on<QueryEvent<InferDetail<typeof mockSchema>[], InferLookup<typeof mockSchema>[]>>(
+                'books::book.afterLoadMany',
+                afterLoadManySpy,
+            )
+
+            emitter.on<QueryEvent<InferSearchResults<typeof mockSchema>[], InferFilters<typeof mockSchema>[]>>(
+                'books::book.beforeSearch',
+                beforeSearchSpy,
+            )
+            emitter.on<QueryEvent<InferSearchResults<typeof mockSchema>[], InferFilters<typeof mockSchema>[]>>(
+                'books::book.afterSearch',
+                afterSearchSpy,
+            )
+
+            emitter.on<QueryEvent<number, InferFilters<typeof mockSchema>>>('books::book.beforeCount', beforeCountSpy)
+            emitter.on<QueryEvent<number, InferFilters<typeof mockSchema>>>('books::book.afterCount', afterCountSpy)
+
+            service = new ReadOnlyModelService({ repository, emitter, schema: mockSchema, namespace })
+        })
+
+        describe('load', () => {
+            it('should not dispatch events when doNotDispatchEvents is true', async () => {
+                const input = { id: 1, title: 'Test Book', author: 'Author', publishedDate: new Date() }
+                await repository.create(input)
+
+                const result = await service.load({ id: 1 }, { doNotDispatchEvents: true })
+
+                expect(result).toEqual(input)
+                expect(beforeLoadSpy).not.toHaveBeenCalled()
+                expect(afterLoadSpy).not.toHaveBeenCalled()
+            })
+
+            it('should dispatch events when doNotDispatchEvents is false', async () => {
+                const input = { id: 2, title: 'Test Book 2', author: 'Author', publishedDate: new Date() }
+                await repository.create(input)
+
+                const result = await service.load({ id: 2 }, { doNotDispatchEvents: false })
+
+                expect(result).toEqual(input)
+                expect(beforeLoadSpy).toHaveBeenCalledTimes(1)
+                expect(afterLoadSpy).toHaveBeenCalledTimes(1)
+            })
+
+            it('should dispatch events when doNotDispatchEvents is not specified', async () => {
+                const input = { id: 3, title: 'Test Book 3', author: 'Author', publishedDate: new Date() }
+                await repository.create(input)
+
+                const result = await service.load({ id: 3 })
+
+                expect(result).toEqual(input)
+                expect(beforeLoadSpy).toHaveBeenCalledTimes(1)
+                expect(afterLoadSpy).toHaveBeenCalledTimes(1)
+            })
+        })
+
+        describe('loadMany', () => {
+            it('should not dispatch events when doNotDispatchEvents is true', async () => {
+                const input1 = { id: 1, title: 'Test Book 1', author: 'Author 1', publishedDate: new Date() }
+                const input2 = { id: 2, title: 'Test Book 2', author: 'Author 2', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.loadMany([{ id: 1 }, { id: 2 }], { doNotDispatchEvents: true })
+
+                expect(result).toEqual([input1, input2])
+                expect(beforeLoadManySpy).not.toHaveBeenCalled()
+                expect(afterLoadManySpy).not.toHaveBeenCalled()
+            })
+
+            it('should dispatch events when doNotDispatchEvents is false', async () => {
+                const input1 = { id: 3, title: 'Test Book 3', author: 'Author 3', publishedDate: new Date() }
+                const input2 = { id: 4, title: 'Test Book 4', author: 'Author 4', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.loadMany([{ id: 3 }, { id: 4 }], { doNotDispatchEvents: false })
+
+                expect(result).toEqual([input1, input2])
+                expect(beforeLoadManySpy).toHaveBeenCalledTimes(1)
+                expect(afterLoadManySpy).toHaveBeenCalledTimes(1)
+            })
+
+            it('should dispatch events when doNotDispatchEvents is not specified', async () => {
+                const input1 = { id: 5, title: 'Test Book 5', author: 'Author 5', publishedDate: new Date() }
+                const input2 = { id: 6, title: 'Test Book 6', author: 'Author 6', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.loadMany([{ id: 5 }, { id: 6 }])
+
+                expect(result).toEqual([input1, input2])
+                expect(beforeLoadManySpy).toHaveBeenCalledTimes(1)
+                expect(afterLoadManySpy).toHaveBeenCalledTimes(1)
+            })
+        })
+
+        describe('search', () => {
+            it('should not dispatch events when doNotDispatchEvents is true', async () => {
+                const input1 = { id: 1, title: 'Test Book 1', author: 'Author 1', publishedDate: new Date() }
+                const input2 = { id: 2, title: 'Test Book 2', author: 'Author 2', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.search({}, { doNotDispatchEvents: true })
+
+                expect(result.results).toEqual([input1, input2])
+                expect(beforeSearchSpy).not.toHaveBeenCalled()
+                expect(afterSearchSpy).not.toHaveBeenCalled()
+            })
+
+            it('should dispatch events when doNotDispatchEvents is false', async () => {
+                const input1 = { id: 3, title: 'Test Book 3', author: 'Author 3', publishedDate: new Date() }
+                const input2 = { id: 4, title: 'Test Book 4', author: 'Author 4', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.search({}, { doNotDispatchEvents: false })
+
+                expect(result.results).toEqual([input1, input2])
+                expect(beforeSearchSpy).toHaveBeenCalledTimes(1)
+                expect(afterSearchSpy).toHaveBeenCalledTimes(1)
+            })
+
+            it('should dispatch events when doNotDispatchEvents is not specified', async () => {
+                const input1 = { id: 5, title: 'Test Book 5', author: 'Author 5', publishedDate: new Date() }
+                const input2 = { id: 6, title: 'Test Book 6', author: 'Author 6', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.search({})
+
+                expect(result.results).toEqual([input1, input2])
+                expect(beforeSearchSpy).toHaveBeenCalledTimes(1)
+                expect(afterSearchSpy).toHaveBeenCalledTimes(1)
+            })
+        })
+
+        describe('count', () => {
+            it('should not dispatch events when doNotDispatchEvents is true', async () => {
+                const input1 = { id: 1, title: 'Test Book 1', author: 'Author 1', publishedDate: new Date() }
+                const input2 = { id: 2, title: 'Test Book 2', author: 'Author 2', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.count({}, { doNotDispatchEvents: true })
+
+                expect(result).toBe(2)
+                expect(beforeCountSpy).not.toHaveBeenCalled()
+                expect(afterCountSpy).not.toHaveBeenCalled()
+            })
+
+            it('should dispatch events when doNotDispatchEvents is false', async () => {
+                const input1 = { id: 3, title: 'Test Book 3', author: 'Author 3', publishedDate: new Date() }
+                const input2 = { id: 4, title: 'Test Book 4', author: 'Author 4', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.count({}, { doNotDispatchEvents: false })
+
+                expect(result).toBe(2)
+                expect(beforeCountSpy).toHaveBeenCalledTimes(1)
+                expect(afterCountSpy).toHaveBeenCalledTimes(1)
+            })
+
+            it('should dispatch events when doNotDispatchEvents is not specified', async () => {
+                const input1 = { id: 5, title: 'Test Book 5', author: 'Author 5', publishedDate: new Date() }
+                const input2 = { id: 6, title: 'Test Book 6', author: 'Author 6', publishedDate: new Date() }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const result = await service.count({})
+
+                expect(result).toBe(2)
+                expect(beforeCountSpy).toHaveBeenCalledTimes(1)
+                expect(afterCountSpy).toHaveBeenCalledTimes(1)
+            })
+        })
+    })
 })