zibri 2.3.0 → 2.4.1

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

@@ -1,5 +1,4 @@
-import { setTimeout } from 'node:timers/promises';
-import { isDeepStrictEqual } from 'util';
+import { isDeepStrictEqual } from 'node:util';
 
 import { Repository as TORepository } from 'typeorm';
 
@@ -7,7 +6,14 @@ import { AuthServiceInterface } from '../auth/auth-service.interface';
 import { ChangeSetEntity } from './models/change-set-entity.model';
 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';
+import { BeforeReturnHook } from '../data-source/hooks/before-return';
+import { BeforeSaveHook } from '../data-source/hooks/before-save';
 import { BaseRepositoryOptions } from '../data-source/models/options/base-repository-options.model';
 import { CreateAllOptions } from '../data-source/models/options/create-all-options.model';
 import { CreateOptions } from '../data-source/models/options/create-options.model';
@@ -15,19 +21,18 @@ 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 { HttpRequest } from '../http/http-request.model';
+import { removeExcludeProperties } from '../global/model-registry/remove-exclude-properties.function';
+import { restoreExcludeProperties } from '../global/model-registry/restore-exclude-properties.function';
 import { LoggerInterface } from '../logging/logger.interface';
+import { DeepPartial } from '../types/deep-partial.type';
 import { Newable } from '../types/newable.type';
+import { JsonUtilities } from '../utilities/json.utilities';
 import { MetadataUtilities } from '../utilities/metadata.utilities';
+import { nowInNs } from '../utilities/now-in-ns.function';
 import { ObjectUtilities } from '../utilities/object.utilities';
 import { PromiseUtilities } from '../utilities/promise.utilities';
-import { NewChange } from './models/change.model';
-import { DeepPartial } from '../types/deep-partial.type';
 
 /**
  * The result for resetting a change set on an entity.
@@ -55,22 +60,26 @@ export class ChangeSetRepository<
     /**
      * Any keys that should be excluded from the change set.
      */
-    protected readonly keysToExcludeFromChangeSets: (keyof T)[];
+    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>,
+        private readonly authService: AuthServiceInterface,
+        private readonly changeSetRepository: Repository<ChangeSet, CreateChangeSetData>
 
-    constructor(entityClass: Newable<T>, repo: TORepository<T> | Repository<T>, logger: LoggerInterface) {
-        super(entityClass, repo, logger);
+    ) {
+        super(entityClass, repo, logger, dataSource, beforeSave, beforeReturn);
 
-        this.authService = inject(ZIBRI_DI_TOKENS.AUTH_SERVICE);
-        this.changeSetRepository = inject(repositoryTokenFor(ChangeSet));
-
-        this.keysToExcludeFromChangeSets = ['changeSets'];
+        this.keysToExcludeFromChangeSets.add('changeSets');
         const props: Record<string, PropertyMetadata> = MetadataUtilities.getModelProperties(entityClass);
         for (const [key, m] of ObjectUtilities.entries(props)) {
             if (m.excludeFromChangeSets) {
-                this.keysToExcludeFromChangeSets.push(key as keyof T);
+                this.keysToExcludeFromChangeSets.add(key as keyof T);
             }
         }
     }
@@ -88,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;
     }
 
@@ -191,7 +202,7 @@ export class ChangeSetRepository<
      * Rolls back all changes on the given entity that have happened since the given change set.
      * This DOES NOT preserve any changes that happened after the change set.
      * The given change set and any change sets after that will be deleted in the end.
-     * Calls rollbackByDate on the change set date internally.
+     * Calls rollbackToTimestamp on the change set timestamp internally.
      * @param entity - The entity to rollback.
      * @param changeSetId - The id of the changeSet to rollback to.
      * @param createChangeSet - Whether or not a change set should be created.
@@ -208,14 +219,14 @@ export class ChangeSetRepository<
         options?: BaseRepositoryOptions
     ): Promise<T> {
         const changeSet: ChangeSet = await this.changeSetRepository.findById(changeSetId, options);
-        return this.rollbackToDate(entity, changeSet.createdAt, createChangeSet, preserveCreateChangeSet, options);
+        return this.rollbackToTimestamp(entity, changeSet.createdAt, createChangeSet, preserveCreateChangeSet, options);
     }
 
     /**
      * Rolls back all changes on the entity with the given id that have happened since the given change set.
      * This DOES NOT preserve any changes that happened after the change set.
      * The given change set and any change sets after that will be deleted in the end.
-     * Calls rollbackByDate on the change set date internally.
+     * Calls rollbackToTimestampById on the change set timestamp internally.
      * @param id - The id of the entity to rollback.
      * @param changeSetId - The id of the changeSet to rollback to.
      * @param createChangeSet - Whether or not a change set should be created.
@@ -237,32 +248,31 @@ export class ChangeSetRepository<
                 'Could not rollback to the given change set: The changeSet doesn\'t belong to the entity with the given id.'
             );
         }
-        return this.rollbackToDateById(id, changeSet.createdAt, createChangeSet, preserveCreateChangeSet, options);
+        return this.rollbackToTimestampById(id, changeSet.createdAt, createChangeSet, preserveCreateChangeSet, options);
     }
 
     /**
-     * Rolls back all changes on the given entity that have happened since the given date.
-     * This DOES NOT preserve any changes that happened after the date.
-     * Any change sets after the given date will be deleted in the end.
+     * Rolls back all changes on the given entity that have happened since the given timestamp.
+     * This DOES NOT preserve any changes that happened after the timestamp.
+     * Any change sets after the given timestamp will be deleted in the end.
      * @param entity - The entity to rollback.
-     * @param date - The date to which the rollback should happen.
+     * @param timestampInNs - The timestamp to which the rollback should happen with nanosecond precision.
      * @param createChangeSet - Whether or not a change set should be created.
      * @param preserveCreateChangeSet - Whether or not create change sets should be preserved.
      * In that case the entity gets reset to the state after the create change set. Also, the create change set isn't deleted.
      * @param options - Additional options, eg. Transaction.
      * @returns The updated entity.
      */
-    async rollbackToDate(
+    async rollbackToTimestamp(
         entity: T,
-        date: Date,
+        timestampInNs: bigint,
         createChangeSet: boolean = true,
         preserveCreateChangeSet: boolean = true,
         options?: BaseRepositoryOptions
     ): Promise<T> {
         const changeSets: ChangeSet[] = await this.changeSetRepository.findAll({
-            where: { changeSetEntityId: entity.id, createdAt: { after: date } },
-            relations: ['changes'],
-            order: { createdAt: 'ASC' }
+            where: { changeSetEntityId: entity.id, createdAt: { greaterThan: timestampInNs } },
+            relations: ['changes']
         });
         let data: DeepPartial<T> = {} as DeepPartial<T>;
         for (const changeSet of changeSets) {
@@ -282,33 +292,33 @@ export class ChangeSetRepository<
     }
 
     /**
-     * Rolls back all changes on the entity with the given id that have happened since the given date.
-     * This DOES NOT preserve any changes that happened after the date.
-     * Any change sets after the given date will be deleted in the end.
+     * Rolls back all changes on the entity with the given id that have happened since the given timestamp.
+     * This DOES NOT preserve any changes that happened after the timestamp.
+     * Any change sets after the given timestamp will be deleted in the end.
      * @param id - The id of the entity to rollback.
-     * @param date - The date to which the rollback should happen.
+     * @param timestampInNs - The timestamp to which the rollback should happen with nanosecond precision.
      * @param createChangeSet - Whether or not a change set should be created.
      * @param preserveCreateChangeSet - Whether or not create change sets should be preserved.
      * In that case the entity gets reset to the state after the create change set. Also, the create change set isn't deleted.
      * @param options - Additional options, eg. Transaction.
      * @returns The updated entity.
      */
-    async rollbackToDateById(
+    async rollbackToTimestampById(
         id: T['id'],
-        date: Date,
+        timestampInNs: bigint,
         createChangeSet: boolean = true,
         preserveCreateChangeSet: boolean = true,
         options?: BaseRepositoryOptions
     ): Promise<T> {
         const entity: T = await this.findById(id, options);
-        return this.rollbackToDate(entity, date, createChangeSet, preserveCreateChangeSet, options);
+        return this.rollbackToTimestamp(entity, timestampInNs, createChangeSet, preserveCreateChangeSet, options);
     }
 
     /**
-     * Rolls back all changes on the entities found with the given where filter to the state of the given date.
-     * This DOES NOT preserve any changes that happened after the date.
-     * Any change sets after the given date will be deleted in the end.
-     * @param date - The date to which the rollback should happen.
+     * Rolls back all changes on the entities found with the given where filter to the state of the given timestamp.
+     * This DOES NOT preserve any changes that happened after the timestamp.
+     * Any change sets after the given timestamp will be deleted in the end.
+     * @param timestampInNs - The timestamp to which the rollback should happen with nanosecond precision.
      * @param where - A filter to only rollback some entities.
      * @param createChangeSet - Whether or not a change set should be created.
      * @param preserveCreateChangeSet - Whether or not create change sets should be preserved.
@@ -316,8 +326,8 @@ export class ChangeSetRepository<
      * @param options - Additional options, eg. Transaction.
      * @returns The updated entity.
      */
-    async rollbackAllToDate(
-        date: Date,
+    async rollbackAllToTimestamp(
+        timestampInNs: bigint,
         where?: Where<T>,
         createChangeSet: boolean = true,
         preserveCreateChangeSet: boolean = true,
@@ -326,7 +336,7 @@ export class ChangeSetRepository<
         const entitiesToRollback: T[] = await this.findAll({ where: where, ...options });
         await PromiseUtilities.allChunked(
             entitiesToRollback,
-            e => this.rollbackToDate(e, date, createChangeSet, preserveCreateChangeSet, options)
+            e => this.rollbackToTimestamp(e, timestampInNs, createChangeSet, preserveCreateChangeSet, options)
         );
         return entitiesToRollback.length;
     }
@@ -347,17 +357,25 @@ export class ChangeSetRepository<
         options?: CreateOptions,
         force: boolean = false
     ): Promise<void> {
-        await setTimeout(1); // TODO: Better way to guarantee a different time stamp on change sets.
+        restoreExcludeProperties(entityPriorChanges, this.entityClass);
+        restoreExcludeProperties(data, this.entityClass);
+        const changes: NewChange[] = this.getChangesFromData(entityPriorChanges, data, type);
+        await Promise.all([
+            removeExcludeProperties(entityPriorChanges, this.entityClass),
+            removeExcludeProperties(data, this.entityClass)
+        ]);
+
+        if (!force && !changes.length) {
+            return;
+        }
+
         const changeSetData: CreateChangeSetData = {
             changeSetEntityId: entityPriorChanges.id,
             type: type,
-            createdAt: new Date(),
+            createdAt: nowInNs(),
             createdBy: await this.getCreatedBy(),
-            changes: this.getChangesFromData(entityPriorChanges, data, type)
+            changes
         };
-        if (!force && !changeSetData.changes.length) {
-            return;
-        }
         await this.changeSetRepository.create(changeSetData, options);
     }
 
@@ -378,13 +396,23 @@ export class ChangeSetRepository<
         force: boolean = false
     ): Promise<void> {
         const userId: string | undefined = await this.getCreatedBy();
-        await setTimeout(1); // TODO: Better way to guarantee a different time stamp on change sets.
-        let changeSetData: CreateChangeSetData[] = entitiesPriorChanges.map((e, i) => ({
-            changeSetEntityId: e.id,
-            type: type,
-            createdAt: new Date(),
-            createdByUserId: userId,
-            changes: this.getChangesFromData(e, data[i], type)
+
+        let changeSetData: CreateChangeSetData[] = await Promise.all(entitiesPriorChanges.map(async (e, i) => {
+            restoreExcludeProperties(e, this.entityClass);
+            restoreExcludeProperties(data[i], this.entityClass);
+            const changes: NewChange[] = this.getChangesFromData(e, data[i], type);
+            await Promise.all([
+                removeExcludeProperties(e, this.entityClass),
+                removeExcludeProperties(data[i], this.entityClass)
+            ]);
+
+            return {
+                changeSetEntityId: e.id,
+                type,
+                createdAt: nowInNs(),
+                createdByUserId: userId,
+                changes
+            };
         }));
         if (!force) {
             changeSetData = changeSetData.filter(d => d.changes.length);
@@ -423,12 +451,12 @@ 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 currentRequest: HttpRequest | undefined = inject(ZIBRI_DI_TOKENS.CURRENT_REQUEST);
-        if (!currentRequest) {
-            throw new Error('No request in context');
+        const context: HttpRequestContext | WebsocketRequestContext | undefined = AlsUtilities.getCurrentRequestContext();
+        if (!context) {
+            return undefined;
         }
         const user: BaseUser<string> | undefined = await this.authService.getCurrentUser(
-            currentRequest,
+            context,
             this.authService.strategies,
             false
         );
@@ -445,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.includes(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>));
             }
         }
@@ -465,7 +497,7 @@ export class ChangeSetRepository<
     ): boolean {
         return !(
             isDeepStrictEqual(previousValue, newValue)
-            || JSON.stringify(previousValue) === JSON.stringify(newValue)
+            || JsonUtilities.stringify(previousValue) === JsonUtilities.stringify(newValue)
         );
     }
 }