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

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

@@ -630,4 +630,311 @@ describe('ModelService', () => {
             expect(results).toEqual(inputs)
         })
     })
+
+    describe('Trash Functionality', () => {
+        const beforeEmptyTrashSpy = mock((event) => {})
+        const afterEmptyTrashSpy = mock((event) => {})
+        const beforePermanentlyDeleteFromTrashSpy = mock((event) => {})
+        const afterPermanentlyDeleteFromTrashSpy = mock((event) => {})
+        const beforePermanentlyDeleteSpy = mock((event) => {})
+        const afterPermanentlyDeleteSpy = mock((event) => {})
+
+        beforeEach(() => {
+            emitter.on('books::book.beforeEmptyTrash', beforeEmptyTrashSpy)
+            emitter.on('books::book.afterEmptyTrash', afterEmptyTrashSpy)
+            emitter.on('books::book.beforePermanentlyDeleteFromTrash', beforePermanentlyDeleteFromTrashSpy)
+            emitter.on('books::book.afterPermanentlyDeleteFromTrash', afterPermanentlyDeleteFromTrashSpy)
+            emitter.on('books::book.beforePermanentlyDelete', beforePermanentlyDeleteSpy)
+            emitter.on('books::book.afterPermanentlyDelete', afterPermanentlyDeleteSpy)
+
+            beforeEmptyTrashSpy.mockClear()
+            afterEmptyTrashSpy.mockClear()
+            beforePermanentlyDeleteFromTrashSpy.mockClear()
+            afterPermanentlyDeleteFromTrashSpy.mockClear()
+            beforePermanentlyDeleteSpy.mockClear()
+            afterPermanentlyDeleteSpy.mockClear()
+        })
+
+        describe('emptyTrash', () => {
+            it('should permanently delete all items from trash', async () => {
+                // Create and remove multiple items
+                const book1 = await repository.create({
+                    title: 'Book 1',
+                    author: 'Author 1',
+                    publishedDate: new Date(),
+                })
+                const book2 = await repository.create({
+                    title: 'Book 2',
+                    author: 'Author 2',
+                    publishedDate: new Date(),
+                })
+                const book3 = await repository.create({
+                    title: 'Book 3',
+                    author: 'Author 3',
+                    publishedDate: new Date(),
+                })
+
+                await repository.remove({ id: book1.id })
+                await repository.remove({ id: book2.id })
+                await repository.remove({ id: book3.id })
+
+                // Empty trash
+                const count = await service.emptyTrash()
+
+                expect(count).toBe(3)
+
+                // Verify items are no longer in trash
+                const inTrash1 = await repository.load({ id: book1.id }, { removedOnly: true })
+                const inTrash2 = await repository.load({ id: book2.id }, { removedOnly: true })
+                const inTrash3 = await repository.load({ id: book3.id }, { removedOnly: true })
+
+                expect(inTrash1).toBeNull()
+                expect(inTrash2).toBeNull()
+                expect(inTrash3).toBeNull()
+            })
+
+            it('should permanently delete filtered items from trash', async () => {
+                const repositoryWithFilter = new MockMemoryRepository({
+                    schema: mockSchema,
+                    filter: (data, filters) => {
+                        if (filters.text) {
+                            return data.title.toLowerCase().includes(filters.text.toLowerCase())
+                        }
+                        return true
+                    },
+                })
+
+                const serviceWithFilter = new ModelService({
+                    repository: repositoryWithFilter,
+                    emitter,
+                    schema: mockSchema,
+                    namespace,
+                })
+
+                const book1 = await repositoryWithFilter.create({
+                    title: 'Test Book 1',
+                    author: 'Author 1',
+                    publishedDate: new Date(),
+                })
+                const book2 = await repositoryWithFilter.create({
+                    title: 'Test Book 2',
+                    author: 'Author 2',
+                    publishedDate: new Date(),
+                })
+                const book3 = await repositoryWithFilter.create({
+                    title: 'Other Book',
+                    author: 'Author 3',
+                    publishedDate: new Date(),
+                })
+
+                await repositoryWithFilter.remove({ id: book1.id })
+                await repositoryWithFilter.remove({ id: book2.id })
+                await repositoryWithFilter.remove({ id: book3.id })
+
+                // Empty trash with filter
+                const count = await serviceWithFilter.emptyTrash({ text: 'Test' })
+
+                expect(count).toBe(2)
+
+                // Verify only filtered items were deleted
+                const inTrash1 = await repositoryWithFilter.load({ id: book1.id }, { removedOnly: true })
+                const inTrash2 = await repositoryWithFilter.load({ id: book2.id }, { removedOnly: true })
+                const inTrash3 = await repositoryWithFilter.load({ id: book3.id }, { removedOnly: true })
+
+                expect(inTrash1).toBeNull()
+                expect(inTrash2).toBeNull()
+                expect(inTrash3).not.toBeNull()
+                expect(inTrash3?.title).toBe('Other Book')
+            })
+
+            it('should return 0 when trash is empty', async () => {
+                const count = await service.emptyTrash()
+                expect(count).toBe(0)
+            })
+
+            it('should trigger before and after events for emptyTrash', async () => {
+                const book = await repository.create({
+                    title: 'Book to Remove',
+                    author: 'Author',
+                    publishedDate: new Date(),
+                })
+                await repository.remove({ id: book.id })
+
+                await service.emptyTrash()
+
+                expect(beforeEmptyTrashSpy).toHaveBeenCalledTimes(1)
+                expect(beforeEmptyTrashSpy).toHaveBeenCalledWith(
+                    expect.objectContaining({ type: 'books::book.beforeEmptyTrash' }),
+                )
+                expect(afterEmptyTrashSpy).toHaveBeenCalledTimes(1)
+                expect(afterEmptyTrashSpy).toHaveBeenCalledWith(
+                    expect.objectContaining({ type: 'books::book.afterEmptyTrash' }),
+                )
+            })
+
+            it('should not affect non-removed items', async () => {
+                await repository.create({ title: 'Active Book 1', author: 'Author 1', publishedDate: new Date() })
+                await repository.create({ title: 'Active Book 2', author: 'Author 2', publishedDate: new Date() })
+
+                const book3 = await repository.create({
+                    title: 'Book to Remove',
+                    author: 'Author 3',
+                    publishedDate: new Date(),
+                })
+                await repository.remove({ id: book3.id })
+
+                // Empty trash
+                await service.emptyTrash()
+
+                // Verify active items are still there
+                const results = await repository.search({})
+                expect(results.results).toHaveLength(2)
+            })
+        })
+
+        describe('permanentlyDeleteFromTrash', () => {
+            it('should permanently delete a removed item from trash', async () => {
+                const book = await repository.create({
+                    title: 'Book to Delete',
+                    author: 'Author',
+                    publishedDate: new Date(),
+                })
+
+                // Remove the book
+                await repository.remove({ id: book.id })
+
+                // Verify it's in trash
+                const inTrash = await repository.load({ id: book.id }, { removedOnly: true })
+                expect(inTrash).not.toBeNull()
+
+                // Permanently delete from trash
+                const deleted = await service.permanentlyDeleteFromTrash({ id: book.id })
+
+                expect(deleted.id).toBe(book.id)
+                expect(deleted.title).toBe('Book to Delete')
+
+                // Verify it's no longer in trash
+                const afterDelete = await repository.load({ id: book.id }, { removedOnly: true })
+                expect(afterDelete).toBeNull()
+
+                // Verify it's not in main data either
+                const inMain = await repository.load({ id: book.id })
+                expect(inMain).toBeNull()
+            })
+
+            it('should throw error when trying to delete non-existent item from trash', async () => {
+                await expect(service.permanentlyDeleteFromTrash({ id: 999 })).rejects.toThrow()
+            })
+
+            it('should throw error when trying to delete active item from trash', async () => {
+                const book = await repository.create({
+                    title: 'Active Book',
+                    author: 'Author',
+                    publishedDate: new Date(),
+                })
+
+                // Should fail because item is not in trash
+                await expect(service.permanentlyDeleteFromTrash({ id: book.id })).rejects.toThrow()
+            })
+
+            it('should trigger before and after events for permanentlyDeleteFromTrash', async () => {
+                const book = await repository.create({
+                    title: 'Book to Delete',
+                    author: 'Author',
+                    publishedDate: new Date(),
+                })
+                await repository.remove({ id: book.id })
+
+                await service.permanentlyDeleteFromTrash({ id: book.id })
+
+                expect(beforePermanentlyDeleteFromTrashSpy).toHaveBeenCalledTimes(1)
+                expect(beforePermanentlyDeleteFromTrashSpy).toHaveBeenCalledWith(
+                    expect.objectContaining({ type: 'books::book.beforePermanentlyDeleteFromTrash' }),
+                )
+                expect(afterPermanentlyDeleteFromTrashSpy).toHaveBeenCalledTimes(1)
+                expect(afterPermanentlyDeleteFromTrashSpy).toHaveBeenCalledWith(
+                    expect.objectContaining({ type: 'books::book.afterPermanentlyDeleteFromTrash' }),
+                )
+            })
+        })
+
+        describe('permanentlyDelete', () => {
+            it('should permanently delete a removed item', async () => {
+                const book = await repository.create({
+                    title: 'Book to Delete',
+                    author: 'Author',
+                    publishedDate: new Date(),
+                })
+
+                // Remove the book first
+                await repository.remove({ id: book.id })
+
+                // Verify it's in trash
+                const inTrash = await repository.load({ id: book.id }, { removedOnly: true })
+                expect(inTrash).not.toBeNull()
+
+                // Permanently delete
+                const deleted = await service.permanentlyDelete({ id: book.id })
+
+                expect(deleted.id).toBe(book.id)
+                expect(deleted.title).toBe('Book to Delete')
+
+                // Verify it's no longer anywhere
+                const afterDelete = await repository.load({ id: book.id }, { removedOnly: true })
+                expect(afterDelete).toBeNull()
+
+                const inMain = await repository.load({ id: book.id })
+                expect(inMain).toBeNull()
+            })
+
+            it('should permanently delete an active item', async () => {
+                const book = await repository.create({
+                    title: 'Active Book to Delete',
+                    author: 'Author',
+                    publishedDate: new Date(),
+                })
+
+                // Verify it exists
+                const exists = await repository.load({ id: book.id })
+                expect(exists).not.toBeNull()
+
+                // Permanently delete without removing first
+                const deleted = await service.permanentlyDelete({ id: book.id })
+
+                expect(deleted.id).toBe(book.id)
+                expect(deleted.title).toBe('Active Book to Delete')
+
+                // Verify it's no longer in main data
+                const afterDelete = await repository.load({ id: book.id })
+                expect(afterDelete).toBeNull()
+
+                // Verify it's not in trash either
+                const inTrash = await repository.load({ id: book.id }, { removedOnly: true })
+                expect(inTrash).toBeNull()
+            })
+
+            it('should throw error when trying to delete non-existent item', async () => {
+                await expect(service.permanentlyDelete({ id: 999 })).rejects.toThrow()
+            })
+
+            it('should trigger before and after events for permanentlyDelete', async () => {
+                const book = await repository.create({
+                    title: 'Book to Delete',
+                    author: 'Author',
+                    publishedDate: new Date(),
+                })
+
+                await service.permanentlyDelete({ id: book.id })
+
+                expect(beforePermanentlyDeleteSpy).toHaveBeenCalledTimes(1)
+                expect(beforePermanentlyDeleteSpy).toHaveBeenCalledWith(
+                    expect.objectContaining({ type: 'books::book.beforePermanentlyDelete' }),
+                )
+                expect(afterPermanentlyDeleteSpy).toHaveBeenCalledTimes(1)
+                expect(afterPermanentlyDeleteSpy).toHaveBeenCalledWith(
+                    expect.objectContaining({ type: 'books::book.afterPermanentlyDelete' }),
+                )
+            })
+        })
+    })
 })

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

@@ -1,5 +1,11 @@
 import type { ActionDescriptor, AnyModelSchema, IActionDescriptor } from '@declaro/core'
-import type { InferDetail, InferInput, InferLookup, InferSummary } from '../../shared/utils/schema-inference'
+import type {
+    InferDetail,
+    InferFilters,
+    InferInput,
+    InferLookup,
+    InferSummary,
+} from '../../shared/utils/schema-inference'
 import { ModelMutationAction, ModelQueryEvent } from '../events/event-types'
 import { MutationEvent } from '../events/mutation-event'
 import type { IModelServiceArgs } from './model-service-args'
@@ -342,4 +348,85 @@ export class ModelService<TSchema extends AnyModelSchema> extends ReadOnlyModelS
         // Return normalized results
         return await Promise.all(results.map((result) => this.normalizeDetail(result)))
     }
+
+    /**
+     * Permanently deletes all items from trash, optionally filtered by the provided criteria.
+     * @param filters Optional filters to apply when selecting items to delete from trash.
+     * @returns The count of permanently deleted items.
+     */
+    async emptyTrash(filters?: InferFilters<TSchema>): Promise<number> {
+        // Emit the before empty trash event
+        const beforeEmptyTrashEvent = new MutationEvent<number, InferFilters<TSchema> | undefined>(
+            this.getDescriptor(ModelMutationAction.BeforeEmptyTrash),
+            filters,
+        )
+        await this.emitter.emitAsync(beforeEmptyTrashEvent)
+
+        // Perform the empty trash operation
+        const count = await this.repository.emptyTrash(filters)
+
+        // Emit the after empty trash event
+        const afterEmptyTrashEvent = new MutationEvent<number, InferFilters<TSchema> | undefined>(
+            this.getDescriptor(ModelMutationAction.AfterEmptyTrash),
+            filters,
+        ).setResult(count)
+        await this.emitter.emitAsync(afterEmptyTrashEvent)
+
+        // Return the count of deleted items
+        return count
+    }
+
+    /**
+     * Permanently deletes a specific item from trash based on the provided lookup.
+     * @param lookup The lookup criteria for the item to permanently delete from trash.
+     * @returns The permanently deleted item summary.
+     */
+    async permanentlyDeleteFromTrash(lookup: InferLookup<TSchema>): Promise<InferSummary<TSchema>> {
+        // Emit the before permanently delete from trash event
+        const beforePermanentlyDeleteFromTrashEvent = new MutationEvent<InferSummary<TSchema>, InferLookup<TSchema>>(
+            this.getDescriptor(ModelMutationAction.BeforePermanentlyDeleteFromTrash),
+            lookup,
+        )
+        await this.emitter.emitAsync(beforePermanentlyDeleteFromTrashEvent)
+
+        // Perform the permanent deletion from trash
+        const result = await this.repository.permanentlyDeleteFromTrash(lookup)
+
+        // Emit the after permanently delete from trash event
+        const afterPermanentlyDeleteFromTrashEvent = new MutationEvent<InferSummary<TSchema>, InferLookup<TSchema>>(
+            this.getDescriptor(ModelMutationAction.AfterPermanentlyDeleteFromTrash),
+            lookup,
+        ).setResult(result)
+        await this.emitter.emitAsync(afterPermanentlyDeleteFromTrashEvent)
+
+        // Return the results of the permanent deletion
+        return await this.normalizeSummary(result)
+    }
+
+    /**
+     * Permanently deletes an item based on the provided lookup, regardless of whether it is active or in trash.
+     * @param lookup The lookup criteria for the item to permanently delete.
+     * @returns The permanently deleted item summary.
+     */
+    async permanentlyDelete(lookup: InferLookup<TSchema>): Promise<InferSummary<TSchema>> {
+        // Emit the before permanently delete event
+        const beforePermanentlyDeleteEvent = new MutationEvent<InferSummary<TSchema>, InferLookup<TSchema>>(
+            this.getDescriptor(ModelMutationAction.BeforePermanentlyDelete),
+            lookup,
+        )
+        await this.emitter.emitAsync(beforePermanentlyDeleteEvent)
+
+        // Perform the permanent deletion
+        const result = await this.repository.permanentlyDelete(lookup)
+
+        // Emit the after permanently delete event
+        const afterPermanentlyDeleteEvent = new MutationEvent<InferSummary<TSchema>, InferLookup<TSchema>>(
+            this.getDescriptor(ModelMutationAction.AfterPermanentlyDelete),
+            lookup,
+        ).setResult(result)
+        await this.emitter.emitAsync(afterPermanentlyDeleteEvent)
+
+        // Return the results of the permanent deletion
+        return await this.normalizeSummary(result)
+    }
 }