@declaro/data 2.0.0-beta.125 → 2.0.0-beta.127

package/src/application/model-controller.ts

@@ -1,52 +1,92 @@
 import type { AuthValidator } from '@declaro/auth'
 import { PermissionValidator, type AnyModelSchema } from '@declaro/core'
 import type { ModelService, ICreateOptions, IUpdateOptions } from '../domain/services/model-service'
+import type { ILoadOptions } from '../domain/services/read-only-model-service'
 import type { InferDetail, InferFilters, InferInput, InferLookup, InferSummary } from '../shared/utils/schema-inference'
 import { ReadOnlyModelController } from './read-only-model-controller'
 
 export class ModelController<TSchema extends AnyModelSchema> extends ReadOnlyModelController<TSchema> {
-    constructor(protected readonly service: ModelService<TSchema>, protected readonly authValidator: AuthValidator) {
+    constructor(
+        protected readonly service: ModelService<TSchema>,
+        protected readonly authValidator: AuthValidator,
+    ) {
         super(service, authValidator)
     }
 
-    async create(input: InferInput<TSchema>): Promise<InferDetail<TSchema>> {
-        this.authValidator.validatePermissions((v) =>
-            v.someOf([
-                this.service.getDescriptor('create', '*').toString(),
-                this.service.getDescriptor('write', '*').toString(),
-            ]),
-        )
-        return this.service.create(input)
+    async createPermissions(input: InferInput<TSchema>, options?: ICreateOptions): Promise<PermissionValidator> {
+        return PermissionValidator.create().someOf([
+            this.service.getDescriptor('create', '*').toString(),
+            this.service.getDescriptor('write', '*').toString(),
+        ])
+    }
+
+    async create(input: InferInput<TSchema>, options?: ICreateOptions): Promise<InferDetail<TSchema>> {
+        const permissions = await this.createPermissions(input, options)
+        this.authValidator.validatePermissions((v) => v.extend(permissions))
+        return this.service.create(input, options)
+    }
+
+    async updatePermissions(
+        lookup: InferLookup<TSchema>,
+        input: InferInput<TSchema>,
+        options?: IUpdateOptions,
+    ): Promise<PermissionValidator> {
+        return PermissionValidator.create().someOf([
+            this.service.getDescriptor('update', '*').toString(),
+            this.service.getDescriptor('write', '*').toString(),
+        ])
+    }
+
+    async update(
+        lookup: InferLookup<TSchema>,
+        input: InferInput<TSchema>,
+        options?: IUpdateOptions,
+    ): Promise<InferDetail<TSchema>> {
+        const permissions = await this.updatePermissions(lookup, input, options)
+        this.authValidator.validatePermissions((v) => v.extend(permissions))
+        return this.service.update(lookup, input, options)
+    }
+
+    async removePermissions(lookup: InferLookup<TSchema>, options?: ILoadOptions): Promise<PermissionValidator> {
+        return PermissionValidator.create().someOf([
+            this.service.getDescriptor('remove', '*').toString(),
+            this.service.getDescriptor('write', '*').toString(),
+        ])
+    }
+
+    async remove(lookup: InferLookup<TSchema>, options?: ILoadOptions): Promise<InferSummary<TSchema>> {
+        const permissions = await this.removePermissions(lookup, options)
+        this.authValidator.validatePermissions((v) => v.extend(permissions))
+        return this.service.remove(lookup, options)
     }
 
-    async update(lookup: InferLookup<TSchema>, input: InferInput<TSchema>): Promise<InferDetail<TSchema>> {
-        this.authValidator.validatePermissions((v) =>
-            v.someOf([
-                this.service.getDescriptor('update', '*').toString(),
-                this.service.getDescriptor('write', '*').toString(),
-            ]),
-        )
-        return this.service.update(lookup, input)
+    async restorePermissions(lookup: InferLookup<TSchema>, options?: ILoadOptions): Promise<PermissionValidator> {
+        return PermissionValidator.create().someOf([
+            this.service.getDescriptor('restore', '*').toString(),
+            this.service.getDescriptor('write', '*').toString(),
+        ])
     }
 
-    async remove(lookup: InferLookup<TSchema>): Promise<InferSummary<TSchema>> {
-        this.authValidator.validatePermissions((v) =>
-            v.someOf([
-                this.service.getDescriptor('remove', '*').toString(),
-                this.service.getDescriptor('write', '*').toString(),
-            ]),
-        )
-        return this.service.remove(lookup)
+    async restore(lookup: InferLookup<TSchema>, options?: ILoadOptions): Promise<InferSummary<TSchema>> {
+        const permissions = await this.restorePermissions(lookup, options)
+        this.authValidator.validatePermissions((v) => v.extend(permissions))
+        return this.service.restore(lookup, options)
     }
 
-    async restore(lookup: InferLookup<TSchema>): Promise<InferSummary<TSchema>> {
-        this.authValidator.validatePermissions((v) =>
-            v.someOf([
-                this.service.getDescriptor('restore', '*').toString(),
-                this.service.getDescriptor('write', '*').toString(),
-            ]),
-        )
-        return this.service.restore(lookup)
+    async upsertPermissions(
+        input: InferInput<TSchema>,
+        options?: ICreateOptions | IUpdateOptions,
+    ): Promise<PermissionValidator> {
+        // Create nested validator for (create AND update) permissions
+        const createAndUpdateValidator = PermissionValidator.create().allOf([
+            this.service.getDescriptor('create', '*').toString(),
+            this.service.getDescriptor('update', '*').toString(),
+        ])
+
+        return PermissionValidator.create().someOf([
+            createAndUpdateValidator,
+            this.service.getDescriptor('write', '*').toString(),
+        ])
     }
 
     /**
@@ -56,16 +96,25 @@ export class ModelController<TSchema extends AnyModelSchema> extends ReadOnlyMod
      * @returns The upserted record.
      */
     async upsert(input: InferInput<TSchema>, options?: ICreateOptions | IUpdateOptions): Promise<InferDetail<TSchema>> {
+        const permissions = await this.upsertPermissions(input, options)
+        this.authValidator.validatePermissions((v) => v.extend(permissions))
+        return this.service.upsert(input, options)
+    }
+
+    async bulkUpsertPermissions(
+        inputs: InferInput<TSchema>[],
+        options?: ICreateOptions | IUpdateOptions,
+    ): Promise<PermissionValidator> {
         // Create nested validator for (create AND update) permissions
         const createAndUpdateValidator = PermissionValidator.create().allOf([
             this.service.getDescriptor('create', '*').toString(),
             this.service.getDescriptor('update', '*').toString(),
         ])
 
-        this.authValidator.validatePermissions((v) =>
-            v.someOf([createAndUpdateValidator, this.service.getDescriptor('write', '*').toString()]),
-        )
-        return this.service.upsert(input, options)
+        return PermissionValidator.create().someOf([
+            createAndUpdateValidator,
+            this.service.getDescriptor('write', '*').toString(),
+        ])
     }
 
     /**
@@ -78,18 +127,19 @@ export class ModelController<TSchema extends AnyModelSchema> extends ReadOnlyMod
         inputs: InferInput<TSchema>[],
         options?: ICreateOptions | IUpdateOptions,
     ): Promise<InferDetail<TSchema>[]> {
-        // Create nested validator for (create AND update) permissions
-        const createAndUpdateValidator = PermissionValidator.create().allOf([
-            this.service.getDescriptor('create', '*').toString(),
-            this.service.getDescriptor('update', '*').toString(),
-        ])
-
-        this.authValidator.validatePermissions((v) =>
-            v.someOf([createAndUpdateValidator, this.service.getDescriptor('write', '*').toString()]),
-        )
+        const permissions = await this.bulkUpsertPermissions(inputs, options)
+        this.authValidator.validatePermissions((v) => v.extend(permissions))
         return this.service.bulkUpsert(inputs, options)
     }
 
+    async permanentlyDeleteFromTrashPermissions(lookup: InferLookup<TSchema>): Promise<PermissionValidator> {
+        return PermissionValidator.create().someOf([
+            this.service.getDescriptor('permanently-delete-from-trash', '*').toString(),
+            this.service.getDescriptor('permanently-delete', '*').toString(),
+            this.service.getDescriptor('empty-trash', '*').toString(),
+        ])
+    }
+
     /**
      * Permanently deletes a specific entity from the trash.
      * Requires 'permanently-delete-from-trash', 'permanently-delete', or 'empty-trash' permission.
@@ -97,16 +147,15 @@ export class ModelController<TSchema extends AnyModelSchema> extends ReadOnlyMod
      * @returns The permanently deleted entity summary
      */
     async permanentlyDeleteFromTrash(lookup: InferLookup<TSchema>): Promise<InferSummary<TSchema>> {
-        this.authValidator.validatePermissions((v) =>
-            v.someOf([
-                this.service.getDescriptor('permanently-delete-from-trash', '*').toString(),
-                this.service.getDescriptor('permanently-delete', '*').toString(),
-                this.service.getDescriptor('empty-trash', '*').toString(),
-            ]),
-        )
+        const permissions = await this.permanentlyDeleteFromTrashPermissions(lookup)
+        this.authValidator.validatePermissions((v) => v.extend(permissions))
         return this.service.permanentlyDeleteFromTrash(lookup)
     }
 
+    async permanentlyDeletePermissions(lookup: InferLookup<TSchema>): Promise<PermissionValidator> {
+        return PermissionValidator.create().someOf([this.service.getDescriptor('permanently-delete', '*').toString()])
+    }
+
     /**
      * Permanently deletes an entity without moving it to trash first.
      * Requires 'permanently-delete' permission.
@@ -114,12 +163,15 @@ export class ModelController<TSchema extends AnyModelSchema> extends ReadOnlyMod
      * @returns The permanently deleted entity summary
      */
     async permanentlyDelete(lookup: InferLookup<TSchema>): Promise<InferSummary<TSchema>> {
-        this.authValidator.validatePermissions((v) =>
-            v.someOf([this.service.getDescriptor('permanently-delete', '*').toString()]),
-        )
+        const permissions = await this.permanentlyDeletePermissions(lookup)
+        this.authValidator.validatePermissions((v) => v.extend(permissions))
         return this.service.permanentlyDelete(lookup)
     }
 
+    async emptyTrashPermissions(filters?: InferFilters<TSchema>): Promise<PermissionValidator> {
+        return PermissionValidator.create().someOf([this.service.getDescriptor('empty-trash', '*').toString()])
+    }
+
     /**
      * Empties the trash by permanently deleting entities that have been marked as removed.
      * Requires 'empty-trash' permission.
@@ -127,9 +179,8 @@ export class ModelController<TSchema extends AnyModelSchema> extends ReadOnlyMod
      * @returns The count of entities permanently deleted
      */
     async emptyTrash(filters?: InferFilters<TSchema>): Promise<number> {
-        this.authValidator.validatePermissions((v) =>
-            v.someOf([this.service.getDescriptor('empty-trash', '*').toString()]),
-        )
+        const permissions = await this.emptyTrashPermissions(filters)
+        this.authValidator.validatePermissions((v) => v.extend(permissions))
         return this.service.emptyTrash(filters)
     }
 }

package/src/application/read-only-model-controller.ts

@@ -1,6 +1,6 @@
 import type { AuthValidator } from '@declaro/auth'
 import {} from '@declaro/auth'
-import type { AnyModelSchema } from '@declaro/core'
+import { PermissionValidator, type AnyModelSchema } from '@declaro/core'
 import type { ILoadOptions, ISearchOptions, ReadOnlyModelService } from '../domain/services/read-only-model-service'
 import type { InferDetail, InferFilters, InferLookup, InferSearchResults } from '../shared/utils/schema-inference'
 
@@ -10,39 +10,61 @@ export class ReadOnlyModelController<TSchema extends AnyModelSchema> {
         protected readonly authValidator: AuthValidator,
     ) {}
 
+    async loadPermissions(lookup: InferLookup<TSchema>): Promise<PermissionValidator> {
+        return PermissionValidator.create().someOf([
+            this.service.getDescriptor('load', '*').toString(),
+            this.service.getDescriptor('read', '*').toString(),
+        ])
+    }
+
     async load(lookup: InferLookup<TSchema>, options?: ILoadOptions): Promise<InferDetail<TSchema>> {
-        this.authValidator.validatePermissions((v) =>
-            v.someOf([
-                this.service.getDescriptor('load', '*').toString(),
-                this.service.getDescriptor('read', '*').toString(),
-            ]),
-        )
+        const permissions = await this.loadPermissions(lookup)
+        this.authValidator.validatePermissions((v) => v.extend(permissions))
         return this.service.load(lookup, options)
     }
 
+    async loadManyPermissions(lookups: InferLookup<TSchema>[]): Promise<PermissionValidator> {
+        return PermissionValidator.create().someOf([
+            this.service.getDescriptor('loadMany', '*').toString(),
+            this.service.getDescriptor('read', '*').toString(),
+        ])
+    }
+
     async loadMany(lookups: InferLookup<TSchema>[], options?: ILoadOptions): Promise<InferDetail<TSchema>[]> {
-        this.authValidator.validatePermissions((v) =>
-            v.someOf([
-                this.service.getDescriptor('loadMany', '*').toString(),
-                this.service.getDescriptor('read', '*').toString(),
-            ]),
-        )
+        const permissions = await this.loadManyPermissions(lookups)
+        this.authValidator.validatePermissions((v) => v.extend(permissions))
         return this.service.loadMany(lookups, options)
     }
 
+    async searchPermissions(
+        input: InferFilters<TSchema>,
+        options?: ISearchOptions<TSchema>,
+    ): Promise<PermissionValidator> {
+        return PermissionValidator.create().someOf([
+            this.service.getDescriptor('search', '*').toString(),
+            this.service.getDescriptor('read', '*').toString(),
+        ])
+    }
+
     async search(
         input: InferFilters<TSchema>,
         options?: ISearchOptions<TSchema>,
     ): Promise<InferSearchResults<TSchema>> {
-        this.authValidator.validatePermissions((v) =>
-            v.someOf([
-                this.service.getDescriptor('search', '*').toString(),
-                this.service.getDescriptor('read', '*').toString(),
-            ]),
-        )
+        const permissions = await this.searchPermissions(input, options)
+        this.authValidator.validatePermissions((v) => v.extend(permissions))
         return this.service.search(input, options)
     }
 
+    async countPermissions(
+        input: InferFilters<TSchema>,
+        options?: ISearchOptions<TSchema>,
+    ): Promise<PermissionValidator> {
+        return PermissionValidator.create().someOf([
+            this.service.getDescriptor('count', '*').toString(),
+            this.service.getDescriptor('read', '*').toString(),
+        ])
+    }
+
     /**
      * Count the number of records matching the given filters.
      * @param input The filters to apply to the count operation.
@@ -50,12 +72,8 @@ export class ReadOnlyModelController<TSchema extends AnyModelSchema> {
      * @returns The count of matching records.
      */
     async count(input: InferFilters<TSchema>, options?: ISearchOptions<TSchema>): Promise<number> {
-        this.authValidator.validatePermissions((v) =>
-            v.someOf([
-                this.service.getDescriptor('count', '*').toString(),
-                this.service.getDescriptor('read', '*').toString(),
-            ]),
-        )
+        const permissions = await this.countPermissions(input, options)
+        this.authValidator.validatePermissions((v) => v.extend(permissions))
         return this.service.count(input, options)
     }
 }

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

@@ -934,4 +934,284 @@ describe('ModelService', () => {
             })
         })
     })
+
+    describe('doNotDispatchEvents option', () => {
+        const beforeLoadSpy = mock(() => {})
+        const afterLoadSpy = mock(() => {})
+        const beforeLoadManySpy = mock(() => {})
+        const afterLoadManySpy = mock(() => {})
+
+        beforeEach(() => {
+            repository = new MockMemoryRepository({ schema: mockSchema })
+            emitter = new EventManager()
+
+            beforeLoadSpy.mockClear()
+            afterLoadSpy.mockClear()
+            beforeLoadManySpy.mockClear()
+            afterLoadManySpy.mockClear()
+            beforeCreateSpy.mockClear()
+            afterCreateSpy.mockClear()
+            beforeUpdateSpy.mockClear()
+            afterUpdateSpy.mockClear()
+
+            emitter.on('books::book.beforeLoad', beforeLoadSpy)
+            emitter.on('books::book.afterLoad', afterLoadSpy)
+            emitter.on('books::book.beforeLoadMany', beforeLoadManySpy)
+            emitter.on('books::book.afterLoadMany', afterLoadManySpy)
+            emitter.on('books::book.beforeCreate', beforeCreateSpy)
+            emitter.on('books::book.afterCreate', afterCreateSpy)
+            emitter.on('books::book.beforeUpdate', beforeUpdateSpy)
+            emitter.on('books::book.afterUpdate', afterUpdateSpy)
+
+            service = new ModelService({ repository, emitter, schema: mockSchema, namespace })
+        })
+
+        describe('upsert', () => {
+            it('should not dispatch any events when doNotDispatchEvents is true', async () => {
+                const input = {
+                    id: 1,
+                    title: 'Existing Book',
+                    author: 'Author',
+                    publishedDate: new Date(),
+                }
+                await repository.create(input)
+
+                const updatedInput = {
+                    id: 1,
+                    title: 'Updated Book',
+                    author: 'Updated Author',
+                    publishedDate: new Date(),
+                }
+
+                await service.upsert(updatedInput, { doNotDispatchEvents: true })
+
+                // Load events should not be dispatched due to propagation
+                expect(beforeLoadSpy).not.toHaveBeenCalled()
+                expect(afterLoadSpy).not.toHaveBeenCalled()
+
+                // Update events should not be dispatched either
+                expect(beforeUpdateSpy).not.toHaveBeenCalled()
+                expect(afterUpdateSpy).not.toHaveBeenCalled()
+            })
+
+            it('should not dispatch load events even when doNotDispatchEvents is false', async () => {
+                const input = {
+                    id: 2,
+                    title: 'Existing Book',
+                    author: 'Author',
+                    publishedDate: new Date(),
+                }
+                await repository.create(input)
+
+                const updatedInput = {
+                    id: 2,
+                    title: 'Updated Book',
+                    author: 'Updated Author',
+                    publishedDate: new Date(),
+                }
+
+                await service.upsert(updatedInput, { doNotDispatchEvents: false })
+
+                // Load events should NOT be dispatched (forced internally)
+                expect(beforeLoadSpy).not.toHaveBeenCalled()
+                expect(afterLoadSpy).not.toHaveBeenCalled()
+
+                // Update events should be dispatched
+                expect(beforeUpdateSpy).toHaveBeenCalledTimes(1)
+                expect(afterUpdateSpy).toHaveBeenCalledTimes(1)
+            })
+
+            it('should not dispatch load events even when doNotDispatchEvents is not specified', async () => {
+                const input = {
+                    id: 3,
+                    title: 'Existing Book',
+                    author: 'Author',
+                    publishedDate: new Date(),
+                }
+                await repository.create(input)
+
+                const updatedInput = {
+                    id: 3,
+                    title: 'Updated Book',
+                    author: 'Updated Author',
+                    publishedDate: new Date(),
+                }
+
+                await service.upsert(updatedInput)
+
+                // Load events should NOT be dispatched (forced internally)
+                expect(beforeLoadSpy).not.toHaveBeenCalled()
+                expect(afterLoadSpy).not.toHaveBeenCalled()
+
+                // Update events should be dispatched
+                expect(beforeUpdateSpy).toHaveBeenCalledTimes(1)
+                expect(afterUpdateSpy).toHaveBeenCalledTimes(1)
+            })
+        })
+
+        describe('bulkUpsert', () => {
+            it('should not dispatch any events when doNotDispatchEvents is true', async () => {
+                const input1 = {
+                    id: 1,
+                    title: 'Existing Book 1',
+                    author: 'Author 1',
+                    publishedDate: new Date(),
+                }
+                const input2 = {
+                    id: 2,
+                    title: 'Existing Book 2',
+                    author: 'Author 2',
+                    publishedDate: new Date(),
+                }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const updatedInputs = [
+                    {
+                        id: 1,
+                        title: 'Updated Book 1',
+                        author: 'Updated Author 1',
+                        publishedDate: new Date(),
+                    },
+                    {
+                        id: 2,
+                        title: 'Updated Book 2',
+                        author: 'Updated Author 2',
+                        publishedDate: new Date(),
+                    },
+                ]
+
+                await service.bulkUpsert(updatedInputs, { doNotDispatchEvents: true })
+
+                // LoadMany events should not be dispatched due to propagation
+                expect(beforeLoadManySpy).not.toHaveBeenCalled()
+                expect(afterLoadManySpy).not.toHaveBeenCalled()
+
+                // Update events should not be dispatched either
+                expect(beforeUpdateSpy).not.toHaveBeenCalled()
+                expect(afterUpdateSpy).not.toHaveBeenCalled()
+            })
+
+            it('should not dispatch loadMany events even when doNotDispatchEvents is false', async () => {
+                const input1 = {
+                    id: 3,
+                    title: 'Existing Book 3',
+                    author: 'Author 3',
+                    publishedDate: new Date(),
+                }
+                const input2 = {
+                    id: 4,
+                    title: 'Existing Book 4',
+                    author: 'Author 4',
+                    publishedDate: new Date(),
+                }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const updatedInputs = [
+                    {
+                        id: 3,
+                        title: 'Updated Book 3',
+                        author: 'Updated Author 3',
+                        publishedDate: new Date(),
+                    },
+                    {
+                        id: 4,
+                        title: 'Updated Book 4',
+                        author: 'Updated Author 4',
+                        publishedDate: new Date(),
+                    },
+                ]
+
+                await service.bulkUpsert(updatedInputs, { doNotDispatchEvents: false })
+
+                // LoadMany events should NOT be dispatched (forced internally)
+                expect(beforeLoadManySpy).not.toHaveBeenCalled()
+                expect(afterLoadManySpy).not.toHaveBeenCalled()
+
+                // Update events should be dispatched (2 updates)
+                expect(beforeUpdateSpy).toHaveBeenCalledTimes(2)
+                expect(afterUpdateSpy).toHaveBeenCalledTimes(2)
+            })
+
+            it('should not dispatch loadMany events even when doNotDispatchEvents is not specified', async () => {
+                const input1 = {
+                    id: 5,
+                    title: 'Existing Book 5',
+                    author: 'Author 5',
+                    publishedDate: new Date(),
+                }
+                const input2 = {
+                    id: 6,
+                    title: 'Existing Book 6',
+                    author: 'Author 6',
+                    publishedDate: new Date(),
+                }
+                await repository.create(input1)
+                await repository.create(input2)
+
+                const updatedInputs = [
+                    {
+                        id: 5,
+                        title: 'Updated Book 5',
+                        author: 'Updated Author 5',
+                        publishedDate: new Date(),
+                    },
+                    {
+                        id: 6,
+                        title: 'Updated Book 6',
+                        author: 'Updated Author 6',
+                        publishedDate: new Date(),
+                    },
+                ]
+
+                await service.bulkUpsert(updatedInputs)
+
+                // LoadMany events should NOT be dispatched (forced internally)
+                expect(beforeLoadManySpy).not.toHaveBeenCalled()
+                expect(afterLoadManySpy).not.toHaveBeenCalled()
+
+                // Update events should be dispatched (2 updates)
+                expect(beforeUpdateSpy).toHaveBeenCalledTimes(2)
+                expect(afterUpdateSpy).toHaveBeenCalledTimes(2)
+            })
+
+            it('should not dispatch any events with doNotDispatchEvents for mixed create and update operations', async () => {
+                const existingInput = {
+                    id: 7,
+                    title: 'Existing Book',
+                    author: 'Author',
+                    publishedDate: new Date(),
+                }
+                await repository.create(existingInput)
+
+                const inputs = [
+                    {
+                        id: 7,
+                        title: 'Updated Book',
+                        author: 'Updated Author',
+                        publishedDate: new Date(),
+                    },
+                    {
+                        id: 8,
+                        title: 'New Book',
+                        author: 'New Author',
+                        publishedDate: new Date(),
+                    },
+                ]
+
+                await service.bulkUpsert(inputs, { doNotDispatchEvents: true })
+
+                // LoadMany events should not be dispatched
+                expect(beforeLoadManySpy).not.toHaveBeenCalled()
+                expect(afterLoadManySpy).not.toHaveBeenCalled()
+
+                // Neither create nor update events should be dispatched
+                expect(beforeCreateSpy).not.toHaveBeenCalled()
+                expect(afterCreateSpy).not.toHaveBeenCalled()
+                expect(beforeUpdateSpy).not.toHaveBeenCalled()
+                expect(afterUpdateSpy).not.toHaveBeenCalled()
+            })
+        })
+    })
 })