zibri 2.4.0 → 2.5.0

package/src/caching/cache/read-aside/write-behind-read-aside.cache.ts

@@ -1,5 +1,5 @@
 import { AlsUtilities } from '../../../context/als.utilities';
-import { LogCacheContext } from '../../../logging/log-context.model';
+import { CacheContext } from '../../../context/cache/cache.context';
 import { CacheOperation } from '../cache-operation.enum';
 import { ResultCacheKeyProvider, CacheWrapWriteOptionsWithResult, CacheSetDirectOptions } from '../cache-options.model';
 import { CacheInterface } from '../cache.interface';
@@ -25,7 +25,7 @@ export abstract class WriteBehindReadAsideCache<K, V, N extends string, CacheTag
         options?: CacheWrapWriteOptionsWithResult<V, TArgs, CacheTag>
     ): (...args: TArgs) => Promise<V> {
         return async (...args) => {
-            const cacheCtx: LogCacheContext = { cache: this.name, operation: CacheOperation.WRITE };
+            const cacheCtx: CacheContext = { cache: this.name, operation: CacheOperation.WRITE };
 
             return AlsUtilities.runWithCacheContext(cacheCtx, async () => {
                 const sourceStart: number = performance.now();

package/src/caching/cache/read-aside/write-invalidate-read-aside-args-only.cache.ts

@@ -1,5 +1,5 @@
 import { AlsUtilities } from '../../../context/als.utilities';
-import { LogCacheContext } from '../../../logging/log-context.model';
+import { CacheContext } from '../../../context/cache/cache.context';
 import { CacheOperation } from '../cache-operation.enum';
 import { CacheKeyProvider, CacheWrapWriteOptionsArgsOnly } from '../cache-options.model';
 import { CacheInterface } from '../cache.interface';
@@ -25,7 +25,7 @@ export abstract class WriteInvalidateReadAsideArgsOnlyCache<K, V, N extends stri
         options?: CacheWrapWriteOptionsArgsOnly<TArgs, CacheTag>
     ): (...args: TArgs) => Promise<V> {
         return async (...args) => {
-            const cacheCtx: LogCacheContext = { cache: this.name, operation: CacheOperation.WRITE };
+            const cacheCtx: CacheContext = { cache: this.name, operation: CacheOperation.WRITE };
 
             return AlsUtilities.runWithCacheContext(cacheCtx, async () => {
                 const sourceStart: number = performance.now();

package/src/caching/cache/read-aside/write-invalidate-read-aside-with-result.cache.ts

@@ -1,5 +1,5 @@
 import { AlsUtilities } from '../../../context/als.utilities';
-import { LogCacheContext } from '../../../logging/log-context.model';
+import { CacheContext } from '../../../context/cache/cache.context';
 import { CacheOperation } from '../cache-operation.enum';
 import { ResultCacheKeyProvider, CacheWrapWriteOptionsWithResult } from '../cache-options.model';
 import { CacheInterface } from '../cache.interface';
@@ -25,7 +25,7 @@ export abstract class WriteInvalidateReadAsideWithResultCache<K, V, N extends st
         options?: CacheWrapWriteOptionsWithResult<V, TArgs, CacheTag>
     ): (...args: TArgs) => Promise<V> {
         return async (...args) => {
-            const cacheCtx: LogCacheContext = { cache: this.name, operation: CacheOperation.WRITE };
+            const cacheCtx: CacheContext = { cache: this.name, operation: CacheOperation.WRITE };
 
             return AlsUtilities.runWithCacheContext(cacheCtx, async () => {
                 const sourceStart: number = performance.now();

package/src/caching/cache/read-aside/write-through-read-aside.cache.ts

@@ -1,5 +1,5 @@
 import { AlsUtilities } from '../../../context/als.utilities';
-import { LogCacheContext } from '../../../logging/log-context.model';
+import { CacheContext } from '../../../context/cache/cache.context';
 import { CacheOperation } from '../cache-operation.enum';
 import { ResultCacheKeyProvider, CacheWrapWriteOptionsWithResult, CacheSetDirectOptions } from '../cache-options.model';
 import { CacheInterface } from '../cache.interface';
@@ -25,7 +25,7 @@ export abstract class WriteThroughReadAsideCache<K, V, N extends string, CacheTa
         options?: CacheWrapWriteOptionsWithResult<V, TArgs, CacheTag>
     ): (...args: TArgs) => Promise<V> {
         return async (...args) => {
-            const cacheCtx: LogCacheContext = { cache: this.name, operation: CacheOperation.WRITE };
+            const cacheCtx: CacheContext = { cache: this.name, operation: CacheOperation.WRITE };
 
             return AlsUtilities.runWithCacheContext(cacheCtx, async () => {
                 const sourceStart: number = performance.now();

package/src/caching/cache/read-through/read-through.cache.ts

@@ -1,5 +1,5 @@
 import { AlsUtilities } from '../../../context/als.utilities';
-import { LogCacheContext } from '../../../logging/log-context.model';
+import { CacheContext } from '../../../context/cache/cache.context';
 import { CachedValue } from '../../store/cached-value.model';
 import { BaseCache } from '../base-cache.model';
 import { CacheOperation } from '../cache-operation.enum';
@@ -22,7 +22,7 @@ export abstract class ReadThroughCache<
         options?: CacheWrapOptions<V, TArgs, CacheTag>
     ): (...args: TArgs) => Promise<V> {
         return async (...args) => {
-            const cacheCtx: LogCacheContext = { cache: this.name, operation: CacheOperation.WRAP };
+            const cacheCtx: CacheContext = { cache: this.name, operation: CacheOperation.WRAP };
             const label: Record<string, string> = { cache: this.name };
 
             return AlsUtilities.runWithCacheContext(cacheCtx, async () => {

package/src/caching/cache/read-through/write-around-read-through.cache.ts

@@ -1,5 +1,5 @@
 import { AlsUtilities } from '../../../context/als.utilities';
-import { LogCacheContext } from '../../../logging/log-context.model';
+import { CacheContext } from '../../../context/cache/cache.context';
 import { CacheOperation } from '../cache-operation.enum';
 import { CacheKeyProvider, CacheWrapWriteOptionsArgsOnly } from '../cache-options.model';
 import { CacheInterface } from '../cache.interface';
@@ -23,7 +23,7 @@ export abstract class WriteAroundReadThroughCache<K, V, N extends string, CacheT
         options?: CacheWrapWriteOptionsArgsOnly<TArgs, CacheTag>
     ): (...args: TArgs) => Promise<V> {
         return async (...args) => {
-            const cacheCtx: LogCacheContext = { cache: this.name, operation: CacheOperation.WRITE };
+            const cacheCtx: CacheContext = { cache: this.name, operation: CacheOperation.WRITE };
 
             return AlsUtilities.runWithCacheContext(cacheCtx, async () => {
                 const sourceStart: number = performance.now();

package/src/caching/cache/read-through/write-behind-read-through.cache.ts

@@ -1,5 +1,5 @@
 import { AlsUtilities } from '../../../context/als.utilities';
-import { LogCacheContext } from '../../../logging/log-context.model';
+import { CacheContext } from '../../../context/cache/cache.context';
 import { CacheOperation } from '../cache-operation.enum';
 import { ResultCacheKeyProvider, CacheWrapWriteOptionsWithResult, CacheSetDirectOptions } from '../cache-options.model';
 import { CacheInterface } from '../cache.interface';
@@ -26,7 +26,7 @@ export abstract class WriteBehindReadThroughCache<K, V, N extends string, CacheT
         options?: CacheWrapWriteOptionsWithResult<V, TArgs, CacheTag>
     ): (...args: TArgs) => Promise<V> {
         return async (...args) => {
-            const cacheCtx: LogCacheContext = { cache: this.name, operation: CacheOperation.WRITE };
+            const cacheCtx: CacheContext = { cache: this.name, operation: CacheOperation.WRITE };
 
             return AlsUtilities.runWithCacheContext(cacheCtx, async () => {
                 const sourceStart: number = performance.now();

package/src/caching/cache/read-through/write-invalidate-read-through-args-only.cache.ts

@@ -1,5 +1,5 @@
 import { AlsUtilities } from '../../../context/als.utilities';
-import { LogCacheContext } from '../../../logging/log-context.model';
+import { CacheContext } from '../../../context/cache/cache.context';
 import { CacheOperation } from '../cache-operation.enum';
 import { CacheKeyProvider, CacheWrapWriteOptionsArgsOnly } from '../cache-options.model';
 import { CacheInterface } from '../cache.interface';
@@ -26,7 +26,7 @@ export abstract class WriteInvalidateReadThroughArgsOnlyCache<K, V, N extends st
         options?: CacheWrapWriteOptionsArgsOnly<TArgs, CacheTag>
     ): (...args: TArgs) => Promise<V> {
         return async (...args) => {
-            const cacheCtx: LogCacheContext = { cache: this.name, operation: CacheOperation.WRITE };
+            const cacheCtx: CacheContext = { cache: this.name, operation: CacheOperation.WRITE };
 
             return AlsUtilities.runWithCacheContext(cacheCtx, async () => {
                 const sourceStart: number = performance.now();

package/src/caching/cache/read-through/write-invalidate-read-through-with-result.cache.ts

@@ -1,5 +1,5 @@
 import { AlsUtilities } from '../../../context/als.utilities';
-import { LogCacheContext } from '../../../logging/log-context.model';
+import { CacheContext } from '../../../context/cache/cache.context';
 import { CacheOperation } from '../cache-operation.enum';
 import { ResultCacheKeyProvider, CacheWrapWriteOptionsWithResult } from '../cache-options.model';
 import { CacheInterface } from '../cache.interface';
@@ -25,7 +25,7 @@ export abstract class WriteInvalidateReadThroughWithResultCache<K, V, N extends
         options?: CacheWrapWriteOptionsWithResult<V, TArgs, CacheTag>
     ): (...args: TArgs) => Promise<V> {
         return async (...args) => {
-            const cacheCtx: LogCacheContext = { cache: this.name, operation: CacheOperation.WRITE };
+            const cacheCtx: CacheContext = { cache: this.name, operation: CacheOperation.WRITE };
 
             return AlsUtilities.runWithCacheContext(cacheCtx, async () => {
                 const sourceStart: number = performance.now();

package/src/caching/cache/read-through/write-through-read-through.cache.ts

@@ -1,5 +1,5 @@
 import { AlsUtilities } from '../../../context/als.utilities';
-import { LogCacheContext } from '../../../logging/log-context.model';
+import { CacheContext } from '../../../context/cache/cache.context';
 import { CacheOperation } from '../cache-operation.enum';
 import { ResultCacheKeyProvider, CacheWrapWriteOptionsWithResult, CacheSetDirectOptions } from '../cache-options.model';
 import { CacheInterface } from '../cache.interface';
@@ -22,7 +22,7 @@ export abstract class WriteThroughReadThroughCache<K, V, N extends string, Cache
         options?: CacheWrapWriteOptionsWithResult<V, TArgs, CacheTag>
     ): (...args: TArgs) => Promise<V> {
         return async (...args) => {
-            const cacheCtx: LogCacheContext = { cache: this.name, operation: CacheOperation.WRITE };
+            const cacheCtx: CacheContext = { cache: this.name, operation: CacheOperation.WRITE };
 
             return AlsUtilities.runWithCacheContext(cacheCtx, async () => {
                 const sourceStart: number = performance.now();

package/src/change-sets/change-set-repository.test.ts

@@ -0,0 +1,317 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from '@jest/globals';
+
+import { ChangeSetRepository, ResetChangeSetResult } from './change-set-repository';
+import { ChangeSet, CreateChangeSetData } from './models/change-set.model';
+import { Change } from './models/change.model';
+import { Roles } from '../__testing__/mocks/entities/roles.enum';
+import { createTestDataSource, defaultTestServerEntities } from '../__testing__/test-server/create-test-data-source.function';
+import { startTestServer, StartedTestServer } from '../__testing__/test-server/start-test-server.function';
+import { DefaultTestServerUserRepository } from '../__testing__/test-server/user-repository'; // adjust if needed
+import { AuthServiceInterface } from '../auth/auth-service.interface';
+import { Auth } from '../auth/decorators/auth.decorator';
+import { BaseUserEntity } from '../auth/models/base-user.model';
+import { JwtAuthData } from '../auth/strategies/jwt/jwt-auth-data.model';
+import { JwtCredentials } from '../auth/strategies/jwt/jwt-credentials.model';
+import { JwtAuthStrategy } from '../auth/strategies/jwt/jwt.auth-strategy';
+import { Repository } from '../data-source/repository';
+import { InjectRepository, repositoryTokenFor } from '../di/decorators/inject-repository.decorator';
+import { ZIBRI_DI_TOKENS } from '../di/default/zibri-di-tokens.default';
+import { inject } from '../di/inject.function';
+import { BaseEntity } from '../entity/base-entity.model';
+import { ChangeSetEntity } from './models/change-set-entity.model';
+import { ChangeSetType } from './models/change-set-type.enum';
+import { Entity } from '../entity/decorators/entity.decorator';
+import { Property } from '../entity/decorators/property.decorator';
+import { OmitClass } from '../entity/omit-class.model';
+import { PartialClass } from '../entity/partial-class.model';
+import { Body } from '../routing/decorators/body.decorator';
+import { Controller } from '../routing/decorators/controller.decorator';
+import { Delete } from '../routing/decorators/delete.decorator';
+import { Param } from '../routing/decorators/param.decorator';
+import { Patch } from '../routing/decorators/patch.decorator';
+import { Post } from '../routing/decorators/post.decorator';
+import { JsonUtilities } from '../utilities/json.utilities';
+
+// ---- Test entity that extends ChangeSetEntity ----
+@Entity()
+class Widget extends BaseEntity implements ChangeSetEntity {
+    @Property.string()
+    name!: string;
+
+    @Property.number()
+    value!: number;
+
+    @Property.string({ excludeFromChangeSets: true })
+    internalNote!: string;
+
+    // required by ChangeSetEntity
+    @Property.oneToMany({ target: () => ChangeSet, inverseSide: 'changeSetEntityId' }) // dummy, real implementation may differ
+    changeSets!: ChangeSet[];
+}
+
+class CreateWidgetDto extends OmitClass(Widget, ['changeSets', 'id']) {}
+
+class UpdateWidgetDto extends PartialClass(OmitClass(Widget, ['changeSets', 'id'])) {}
+
+@Entity()
+class TestUser extends BaseUserEntity(Roles) {
+    @Property.string({ hash: true })
+    password!: string;
+}
+
+// ---- Controller that uses the repository ----
+@Controller('/widgets')
+class WidgetController {
+    constructor(
+        @InjectRepository(Widget)
+        private readonly repo: ChangeSetRepository<Widget>
+    ) {}
+
+    @Post('/')
+    @Auth.isLoggedIn([JwtAuthStrategy])
+    async create(@Body(CreateWidgetDto) body: CreateWidgetDto): Promise<Widget> {
+        return await this.repo.create(body);
+    }
+
+    @Patch('/:id')
+    @Auth.isLoggedIn([JwtAuthStrategy])
+    async update(@Param.path('id') id: string, @Body(UpdateWidgetDto) body: UpdateWidgetDto): Promise<Widget> {
+        return this.repo.updateById(id, body);
+    }
+
+    @Delete('/:id')
+    @Auth.isLoggedIn([JwtAuthStrategy])
+    async delete(@Param.path('id') id: string): Promise<Widget> {
+        return this.repo.deleteById(id);
+    }
+
+    @Post('/:id/reset/:changeSetId')
+    @Auth.isLoggedIn([JwtAuthStrategy])
+    async resetSingle(
+        @Param.path('id') id: string,
+        @Param.path('changeSetId') changeSetId: string
+    ): Promise<ResetChangeSetResult<Widget>> {
+        const entity: Widget = await this.repo.findById(id);
+        return this.repo.resetSingleChangeSet(entity, changeSetId);
+    }
+
+    @Post('/:id/rollback/:changeSetId')
+    @Auth.isLoggedIn([JwtAuthStrategy])
+    async rollbackTo(
+        @Param.path('id') id: string,
+        @Param.path('changeSetId') changeSetId: string
+    ): Promise<Widget> {
+        const entity: Widget = await this.repo.findById(id);
+        return this.repo.rollbackToChangeSet(entity, changeSetId);
+    }
+}
+
+let server: StartedTestServer;
+let baseUrl: string;
+let accessToken: string;
+let userId: string;
+
+let changeSetRepo: Repository<ChangeSet, CreateChangeSetData>;
+let changeRepo: Repository<Change>;
+let widgetRepo: ChangeSetRepository<Widget>;
+
+beforeAll(async () => {
+    server = await startTestServer({
+        dataSources: [
+            createTestDataSource({
+                entities: [...defaultTestServerEntities, Widget, TestUser]
+            })
+        ],
+        controllers: [WidgetController]
+    });
+    baseUrl = await server.start();
+
+    // Inject repository instances
+    changeSetRepo = inject(repositoryTokenFor(ChangeSet));
+    changeRepo = inject(repositoryTokenFor(Change));
+    widgetRepo = inject(repositoryTokenFor(Widget)) as ChangeSetRepository<Widget>;
+
+    // Create a user and login to get a token
+    const userRepo: DefaultTestServerUserRepository = inject(DefaultTestServerUserRepository);
+    const credentialsRepo: Repository<JwtCredentials> = inject(repositoryTokenFor(JwtCredentials));
+
+    const testEmail: string = 'widget-test@example.com';
+    const testPassword: string = 'test123';
+    await userRepo.create({ email: testEmail, roles: [Roles.USER] });
+    await credentialsRepo.create({ email: testEmail, password: testPassword, userId: (await userRepo.findOne({ where: { email: testEmail } }, true)).id });
+
+    userId = (await userRepo.findOne({ where: { email: testEmail } }, true)).id;
+
+    const authService: AuthServiceInterface = inject(ZIBRI_DI_TOKENS.AUTH_SERVICE);
+    const authData: JwtAuthData<Roles> = await authService.login(JwtAuthStrategy<Roles>, { email: testEmail, password: testPassword });
+    accessToken = authData.accessToken.value;
+}, 15000);
+
+afterAll(async () => {
+    await server.shutdown();
+});
+
+beforeEach(async () => {
+    await changeSetRepo.deleteAll({});
+    await changeRepo.deleteAll({});
+    await widgetRepo.deleteAll({});
+});
+
+// Helper for authorized requests
+async function authFetch(path: string, options: RequestInit = {}): Promise<Response> {
+    const res: Response = await fetch(`${baseUrl}${path}`, {
+        ...options,
+        headers: {
+            ...options.headers,
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json'
+        }
+    });
+
+    if (!res.ok) {
+        const body: unknown = await res.json();
+        throw new Error(`Request "${options.method ?? 'GET'} ${path}" failed:\n${JsonUtilities.stringify(body, undefined, 4)}`);
+    }
+
+    return res;
+}
+
+describe('ChangeSetRepository behavior', () => {
+    describe('on create', () => {
+        it('creates a CREATE change set with correct changes (excluding internalNote)', async () => {
+            const res: Response = await authFetch('/widgets', {
+                method: 'POST',
+                body: JSON.stringify({ name: 'TestWidget', value: 42, internalNote: 'secret' })
+            });
+            expect(res.status).toBe(200);
+            const widget: Widget = await res.json() as Widget;
+
+            const changeSets: ChangeSet[] = await changeSetRepo.findAll({ where: { changeSetEntityId: widget.id } });
+            expect(changeSets).toHaveLength(1);
+            const cs: ChangeSet = changeSets[0];
+            expect(cs.type).toBe(ChangeSetType.CREATE);
+            expect(cs.createdBy).toBe(userId);
+
+            const changes: Change[] = await changeRepo.findAll({ where: { changeSetId: cs.id } });
+            expect(changes).toHaveLength(3); // id, name and value. not internalNote
+            expect(changes.map(c => c.key).sort()).toEqual(['id', 'name', 'value']);
+            expect(changes.find(c => c.key === 'name')?.previousValue).toBeNull();
+            expect(changes.find(c => c.key === 'name')?.newValue).toBe('TestWidget');
+        });
+    });
+
+    describe('on update', () => {
+        let widgetId: string;
+
+        beforeEach(async () => {
+            const res: Response = await authFetch('/widgets', {
+                method: 'POST',
+                body: JSON.stringify({ name: 'Original', value: 100, internalNote: 'old-secret' })
+            });
+            const widget: Widget = await res.json() as Widget;
+            widgetId = widget.id;
+            // clear change sets from creation to isolate update test
+            await changeSetRepo.deleteAll({});
+        });
+
+        it('creates an UPDATE change set only with changed fields', async () => {
+            await authFetch(`/widgets/${widgetId}`, {
+                method: 'PATCH',
+                body: JSON.stringify({ name: 'Updated', value: 100 }) // value unchanged
+            });
+
+            const changeSets: ChangeSet[] = await changeSetRepo.findAll({ where: { changeSetEntityId: widgetId } });
+            expect(changeSets).toHaveLength(1);
+            expect(changeSets[0].type).toBe(ChangeSetType.UPDATE);
+
+            const changes: Change[] = await changeRepo.findAll({ where: { changeSetId: changeSets[0].id } });
+            expect(changes).toHaveLength(1); // only name changed
+            expect(changes[0].key).toBe('name');
+            expect(changes[0].previousValue).toBe('Original');
+            expect(changes[0].newValue).toBe('Updated');
+        });
+
+        it('does not create a change set when no values actually change', async () => {
+            await authFetch(`/widgets/${widgetId}`, {
+                method: 'PATCH',
+                body: JSON.stringify({ name: 'Original', value: 100 })
+            });
+
+            const changeSets: ChangeSet[] = await changeSetRepo.findAll({ where: { changeSetEntityId: widgetId } });
+            expect(changeSets).toHaveLength(0);
+        });
+    });
+
+    describe('resetSingleChangeSet', () => {
+        let widgetId: string;
+        let nameUpdateChangeSetId: string;
+
+        beforeEach(async () => {
+            // Create widget, this causes
+            const res1: Response = await authFetch('/widgets', {
+                method: 'POST',
+                body: JSON.stringify({ name: 'Initial', value: 10, internalNote: 'test' })
+            });
+            const w: Widget = await res1.json() as Widget;
+            widgetId = w.id;
+
+            // First update: change name
+            await authFetch(`/widgets/${widgetId}`, { method: 'PATCH', body: JSON.stringify({ name: 'FirstEdit' }) });
+
+            // Second update: change value
+            await authFetch(`/widgets/${widgetId}`, { method: 'PATCH', body: JSON.stringify({ value: 20 }) });
+
+            const sets: ChangeSet[] = await changeSetRepo.findAll({
+                where: { changeSetEntityId: widgetId },
+                order: { createdAt: 'ASC' },
+                relations: ['changes']
+            });
+            // sets[0] = CREATE, sets[1] = UPDATE name, sets[2] = UPDATE value
+            nameUpdateChangeSetId = sets[1].id; // target the name update
+        });
+
+        it('reverts only the targeted change, preserving later changes', async () => {
+            await authFetch(`/widgets/${widgetId}/reset/${nameUpdateChangeSetId}`, { method: 'POST' });
+
+            const widget: Widget = await widgetRepo.findById(widgetId);
+            expect(widget.name).toBe('Initial'); // reverted
+            expect(widget.value).toBe(20); // preserved (later change untouched)
+
+            // A new RESET change set was created
+            const allSets: ChangeSet[] = await changeSetRepo.findAll({ where: { changeSetEntityId: widgetId } });
+            expect(allSets.some(s => s.type === ChangeSetType.RESET)).toBe(true);
+        });
+    });
+
+    describe('rollbackToChangeSet', () => {
+        let widgetId: string;
+        let createSetId: string;
+
+        beforeEach(async () => {
+            const res: Response = await authFetch('/widgets', {
+                method: 'POST',
+                body: JSON.stringify({ name: 'Base', value: 1, internalNote: 'base' })
+            });
+            const w: Widget = await res.json() as Widget;
+            widgetId = w.id;
+            createSetId = (await changeSetRepo.findOne({ where: { changeSetEntityId: widgetId, type: ChangeSetType.CREATE } }, true)).id;
+
+            // Two subsequent updates
+            await authFetch(`/widgets/${widgetId}`, { method: 'PATCH', body: JSON.stringify({ name: 'Version2' }) });
+            await authFetch(`/widgets/${widgetId}`, { method: 'PATCH', body: JSON.stringify({ value: 99 }) });
+        });
+
+        it('rolls back all changes after the given change set', async () => {
+            await authFetch(`/widgets/${widgetId}/rollback/${createSetId}`, { method: 'POST' });
+
+            const widget: Widget = await widgetRepo.findById(widgetId);
+            expect(widget.name).toBe('Base');
+            expect(widget.value).toBe(1);
+
+            // Only the CREATE and the new RESET change set remain (intermediate ones deleted)
+            const remaining: ChangeSet[] = await changeSetRepo.findAll({ where: { changeSetEntityId: widgetId } });
+            expect(remaining).toHaveLength(2);
+            expect(remaining.map(s => s.type)).toEqual(expect.arrayContaining([ChangeSetType.CREATE, ChangeSetType.RESET]));
+        });
+    });
+});

package/src/change-sets/change-set-repository.ts

@@ -8,6 +8,7 @@ import { ChangeSetType } from './models/change-set-type.enum';
 import { ChangeSet, CreateChangeSetData } from './models/change-set.model';
 import { NewChange } from './models/change.model';
 import { BaseUser } from '../auth/models/base-user.model';
+import { AlsUtilities } from '../context/als.utilities';
 import { HttpRequestContext } from '../context/request/http-request.context';
 import { WebsocketRequestContext } from '../context/request/websocket-request.context';
 import { DataSourceInterface } from '../data-source/data-sources/data-source.interface';
@@ -20,9 +21,6 @@ import { UpdateAllOptions } from '../data-source/models/options/update-all-optio
 import { UpdateByIdOptions } from '../data-source/models/options/update-by-id-options.model';
 import { Where } from '../data-source/models/where/where-filter.model';
 import { Repository } from '../data-source/repository';
-import { repositoryTokenFor } from '../di/decorators/inject-repository.decorator';
-import { ZIBRI_DI_TOKENS } from '../di/default/zibri-di-tokens.default';
-import { inject } from '../di/inject.function';
 import { PropertyMetadata } from '../entity/decorators/property.decorator';
 import { BadRequestError } from '../error-handling/errors/bad-request.error';
 import { removeExcludeProperties } from '../global/model-registry/remove-exclude-properties.function';
@@ -64,22 +62,19 @@ export class ChangeSetRepository<
      */
     protected readonly keysToExcludeFromChangeSets: Set<keyof T> = new Set();
 
-    private readonly changeSetRepository: Repository<ChangeSet, CreateChangeSetData>;
-    private readonly authService: AuthServiceInterface;
-
     constructor(
         entityClass: Newable<T>,
         repo: TORepository<T> | Repository<T>,
         logger: LoggerInterface,
         dataSource: DataSourceInterface,
         beforeSave: BeforeSaveHook<T, CreateData, UpdateData>,
-        beforeReturn: BeforeReturnHook<T>
+        beforeReturn: BeforeReturnHook<T>,
+        private readonly authService: AuthServiceInterface,
+        private readonly changeSetRepository: Repository<ChangeSet, CreateChangeSetData>
+
     ) {
         super(entityClass, repo, logger, dataSource, beforeSave, beforeReturn);
 
-        this.authService = inject(ZIBRI_DI_TOKENS.AUTH_SERVICE);
-        this.changeSetRepository = inject(repositoryTokenFor(ChangeSet));
-
         this.keysToExcludeFromChangeSets.add('changeSets');
         const props: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(entityClass);
         for (const [key, m] of ObjectUtilities.entries(props)) {
@@ -102,14 +97,16 @@ export class ChangeSetRepository<
     }
 
     override async updateById(id: T['id'], data: UpdateData, options?: UpdateByIdOptions): Promise<T> {
+        const original: T = await this.findById(id, options);
         const res: T = await super.updateById(id, data, options);
-        await this.createChangeSet(res, data, ChangeSetType.UPDATE, options);
+        await this.createChangeSet(original, data, ChangeSetType.UPDATE, options);
         return res;
     }
 
     override async updateAll(where: Where<T>, data: UpdateData, options?: UpdateAllOptions): Promise<T[]> {
+        const original: T[] = await this.findAll({ where, ...options });
         const res: T[] = await super.updateAll(where, data, options);
-        await this.createAllChangeSets(res, res.map(() => data), ChangeSetType.UPDATE, options);
+        await this.createAllChangeSets(original, original.map(() => data), ChangeSetType.UPDATE, options);
         return res;
     }
 
@@ -275,8 +272,7 @@ export class ChangeSetRepository<
     ): Promise<T> {
         const changeSets: ChangeSet[] = await this.changeSetRepository.findAll({
             where: { changeSetEntityId: entity.id, createdAt: { greaterThan: timestampInNs } },
-            relations: ['changes'],
-            order: { createdAt: 'ASC' }
+            relations: ['changes']
         });
         let data: DeepPartial<T> = {} as DeepPartial<T>;
         for (const changeSet of changeSets) {
@@ -455,9 +451,9 @@ export class ChangeSetRepository<
      * @returns The id of the currently logged in user or undefined if that didn't work.
      */
     protected async getCreatedBy(): Promise<string | undefined> {
-        const context: HttpRequestContext | WebsocketRequestContext | undefined = inject(ZIBRI_DI_TOKENS.CURRENT_REQUEST_CONTEXT);
+        const context: HttpRequestContext | WebsocketRequestContext | undefined = AlsUtilities.getCurrentRequestContext();
         if (!context) {
-            throw new Error('No request in context');
+            return undefined;
         }
         const user: BaseUser<string> | undefined = await this.authService.getCurrentUser(
             context,
@@ -477,7 +473,11 @@ export class ChangeSetRepository<
     ): (keyof (CreateData | UpdateData | DeepPartial<T>))[] {
         const keys: (keyof (CreateData | UpdateData | DeepPartial<T>))[] = [];
         for (const key in data) {
-            if (!this.keysToExcludeFromChangeSets.has(key as keyof T)) {
+            if (
+                !this.keysToExcludeFromChangeSets.has(key as keyof T)
+                // we need to use triple equals here, setting a value to null is valid and should be tracked
+                && data[key as keyof (CreateData | UpdateData | DeepPartial<T>)] !== undefined
+            ) {
                 keys.push(key as keyof (CreateData | UpdateData | DeepPartial<T>));
             }
         }

package/src/change-sets/models/change-set-entity.model.ts

@@ -1,5 +1,6 @@
 import { ChangeSet } from './change-set.model';
 import { BaseEntity } from '../../entity/base-entity.model';
+import { Property } from '../../entity/decorators/property.decorator';
 import { Newable } from '../../types/newable.type';
 import { MetadataUtilities } from '../../utilities/metadata.utilities';
 
@@ -7,12 +8,13 @@ import { MetadataUtilities } from '../../utilities/metadata.utilities';
  * An entity that can be handled by the ChangeSetRepository.
  * Has an uuid id and a relation to all its changeSets.
  */
-export type ChangeSetEntity = BaseEntity & {
+export class ChangeSetEntity extends BaseEntity {
     /**
      * The change sets of the entity.
      */
-    changeSets: ChangeSet[]
-};
+    @Property.oneToMany({ target: () => ChangeSet, inverseSide: 'changeSetEntityId' })
+    changeSets!: ChangeSet[];
+}
 
 /**
  * Checks whether the given class is a ChangeSetEntity class.
@@ -20,5 +22,5 @@ export type ChangeSetEntity = BaseEntity & {
  * @returns True if it has a changeSets property of type array.
  */
 export function isChangeSetEntityNewable(cls: Newable<unknown>): cls is Newable<ChangeSetEntity> {
-    return MetadataUtilities.getModelProperties(cls)['changeSets']?.type === 'array';
+    return MetadataUtilities.getModelProperties(cls)['changeSets'] !== undefined;
 }

package/src/change-sets/models/change-set.model.ts

@@ -10,7 +10,7 @@ import { OmitStrict } from '../../types/omit-strict.type';
  * A single change set.
  * Gets automatically created for configured entities whenever they are changed.
  */
-@Entity()
+@Entity({ defaultOrder: { createdAt: 'ASC' }, defaultRelations: { changes: true } })
 export class ChangeSet extends BaseEntity {
     /**
      * Whether this change set was initialized on creating, updating or deleting the entity.
@@ -26,7 +26,7 @@ export class ChangeSet extends BaseEntity {
      * The id of the user that changed something.
      */
     @Property.string({ format: 'uuid', required: false })
-    createdBy?: string;
+    createdBy?: string | null;
     /**
      * The things that have been changed.
      */