zibri 2.2.1 → 2.4.0

package/src/entity/models/string-property-metadata.model.ts

@@ -1,6 +1,80 @@
 import { BasePropertyMetadata, WithDefaultMetadata } from './base-property-metadata.model';
+import { EncryptOptions } from '../../auth/encryption/encryption-service.interface';
+import { BaseDecryptOptions, BaseEncryptOptions, EncryptionStrategyInterface } from '../../auth/encryption/strategies/encryption-strategy.interface';
+import { HashOptions } from '../../auth/hash/hash-service.interface';
+import { HttpRequestContext } from '../../context/request/http-request.context';
+import { WebsocketRequestContext } from '../../context/request/websocket-request.context';
 import { AnyEnum } from '../../types/any-enum.type';
+import { Newable } from '../../types/newable.type';
 import { OmitStrict } from '../../types/omit-strict.type';
+import { AnyObject } from '../any-object.model';
+
+/**
+ * Options for encrypt and decrypt.
+ */
+export type EncryptAndDecryptOptions<
+    Data,
+    TKey,
+    TEncryptOptions extends BaseEncryptOptions<TKey>,
+    TDecryptOptions extends BaseDecryptOptions<TKey>
+> = {
+    /**
+     * The encryption strategy that should be used.
+     */
+    strategy: Newable<EncryptionStrategyInterface<TKey, TEncryptOptions, TDecryptOptions>>,
+    /**
+     * The encrypt options.
+     */
+    encrypt?: EncryptPropertyValue<Data, TKey, TEncryptOptions>,
+    /**
+     * The decrypt options.
+     */
+    decrypt?: DecryptPropertyValue<Data, OmitStrict<TDecryptOptions, 'keyId' | 'key'>>
+};
+
+/**
+ * Value for the encryption setting on a property.
+ */
+export type EncryptionPropertyValue<
+    Data,
+    TKey,
+    TEncryptOptions extends BaseEncryptOptions<TKey>,
+    TDecryptOptions extends BaseDecryptOptions<TKey>
+> = boolean
+    | EncryptAndDecryptOptions<Data, TKey, TEncryptOptions, TDecryptOptions>
+    | (
+        (
+            data: Data,
+            ctx: HttpRequestContext | WebsocketRequestContext | undefined
+        ) => EncryptAndDecryptOptions<Data, TKey, TEncryptOptions, TDecryptOptions>
+            | Promise<EncryptAndDecryptOptions<Data, TKey, TEncryptOptions, TDecryptOptions>>
+    );
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+type EncryptPropertyValue<Data, TKey, TEncryptOptions extends BaseEncryptOptions<TKey>> = boolean
+    | EncryptOptions<TKey, TEncryptOptions>['strategyOptions']
+    | (
+        (
+            data: Data,
+            ctx: HttpRequestContext | WebsocketRequestContext | undefined
+        ) => (EncryptOptions<TKey, TEncryptOptions>['strategyOptions'] | boolean)
+            | Promise<EncryptOptions<TKey, TEncryptOptions>['strategyOptions'] | boolean>
+    );
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+type DecryptPropertyValue<Data, T extends AnyObject> = boolean | T
+    | ((data: Data, ctx: HttpRequestContext | WebsocketRequestContext | undefined) => (boolean | T) | Promise<boolean | T>);
+
+/**
+ * Value for the hash setting on a property.
+ */
+export type HashPropertyValue<Data, THashOptions extends AnyObject> = boolean | HashOptions<THashOptions>
+    | (
+        (
+            data: Data,
+            ctx: HttpRequestContext | WebsocketRequestContext | undefined
+        ) => HashOptions<THashOptions> | Promise<HashOptions<THashOptions>>
+    );
 
 /**
  * The possible formats a string value can have.
@@ -10,7 +84,13 @@ export type StringFormat = 'uuid' | 'email';
 /**
  * Metadata for string properties.
  */
-export type StringPropertyMetadata = BasePropertyMetadata & WithDefaultMetadata<string> & {
+export type StringPropertyMetadata<
+    Data,
+    TKey,
+    TEncryptOptions extends BaseEncryptOptions<TKey>,
+    TDecryptOptions extends BaseDecryptOptions<TKey>,
+    THashOptions extends AnyObject
+> = BasePropertyMetadata & WithDefaultMetadata<string> & {
     /**
      * The type of the property.
      */
@@ -43,10 +123,24 @@ export type StringPropertyMetadata = BasePropertyMetadata & WithDefaultMetadata<
     /**
      * An enum that this property is one of.
      */
-    enum: AnyEnum<string> | undefined
+    enum: AnyEnum<string> | undefined,
+    /**
+     * Settings for encrypting/decrypting this property.
+     */
+    encryption: EncryptionPropertyValue<Data, TKey, TEncryptOptions, TDecryptOptions>,
+    /**
+     * Settings for hashing this property.
+     */
+    hash: HashPropertyValue<Data, THashOptions>
 };
 
 /**
  * Input Metadata for string properties.
  */
-export type StringPropertyMetadataInput = Partial<OmitStrict<StringPropertyMetadata, 'type'>>;
+export type StringPropertyMetadataInput<
+    Data,
+    TKey,
+    TEncryptOptions extends BaseEncryptOptions<TKey>,
+    TDecryptOptions extends BaseDecryptOptions<TKey>,
+    THashOptions extends AnyObject
+> = Partial<OmitStrict<StringPropertyMetadata<Data, TKey, TEncryptOptions, TDecryptOptions, THashOptions>, 'type'>>;

package/src/error-handling/error-handler.ts

@@ -61,7 +61,7 @@ export const errorHandler: GlobalErrorHandler = async (error: unknown, req: Http
     }
 
     try {
-        const html: string = await PreactUtilities.render(template, { error: httpError });
+        const html: string = await PreactUtilities.renderPage(template, { error: httpError });
         res.setHeader(KnownHeader.CONTENT_TYPE, MimeType.HTML);
         res.status(httpError.status).send(html);
     }

package/src/error-handling/errors/http.error.ts

@@ -27,11 +27,7 @@ export abstract class HttpError extends Error {
     }
 }
 
-/**
- * Check whether or not the given value is a http error.
- * @param value - The value to check.
- * @returns True when value is an instance of HttpError, false otherwise.
- */
+// eslint-disable-next-line jsdoc/require-jsdoc
 export function isHttpError(value: unknown): value is HttpError {
     return value instanceof HttpError;
 }

package/src/error-handling/errors/missing-tokens.error.ts

@@ -0,0 +1,19 @@
+import { DiToken } from '../../di/models/di-token.model';
+import { InjectionToken } from '../../di/models/injection-token.model';
+
+/**
+ * An error to throw when there are tokens that are not injectable.
+ */
+export class MissingTokensError extends Error {
+    constructor(context: string, tokens: DiToken<unknown>[]) {
+        const messages: string[] = [
+            `Error initializing ${context}`,
+            'Could not inject the following tokens:'
+        ];
+        for (const token of tokens) {
+            messages.push(`  - ${token instanceof InjectionToken ? token.key : token.name}`);
+        }
+        super(messages.join('\n'));
+        this.name = 'MissingTokensError';
+    }
+}

package/src/error-handling/errors/validation.error.ts

@@ -16,8 +16,9 @@ const startMessage: Record<ValidationErrorType, string> = {
  * An error with validation.
  */
 export class ValidationError extends BadRequestError {
-    constructor(type: ValidationErrorType, problems: ValidationProblem[], options?: ErrorOptions) {
-        const paragraphs: string[] = [startMessage[type]];
+    constructor(readonly type: ValidationErrorType, paramName: string | undefined, problems: ValidationProblem[], options?: ErrorOptions) {
+        const paramNameSuffix: string = paramName ? ` "${paramName}"` : '';
+        const paragraphs: string[] = [`${startMessage[type]}${paramNameSuffix}`];
         for (const problem of problems) {
             paragraphs.push(`- ${problem.key}: ${problem.message}`);
         }

package/src/error-handling/unknown-to-error-string.function.ts

@@ -1,4 +1,5 @@
 import { isError } from './is-error.function';
+import { JsonUtilities } from '../utilities/json.utilities';
 
 // eslint-disable-next-line jsdoc/require-jsdoc
 export function unknownToErrorString(error: unknown): string {
@@ -6,5 +7,5 @@ export function unknownToErrorString(error: unknown): string {
         return error.message;
     }
 
-    return JSON.stringify(error);
+    return JsonUtilities.stringify(error);
 }

package/src/event/event-cleanup.cron-job.ts

@@ -0,0 +1,43 @@
+
+import { Event, EventStatus } from './event.model';
+import { CronExpression } from '../cron/cron-expression.utilities';
+import { CronJob, InitialCronConfig } from '../cron/cron-job.model';
+import { Repository } from '../data-source/repository';
+import { InjectRepository } from '../di/decorators/inject-repository.decorator';
+
+/**
+ * CronJob that cleans up past events.
+ */
+export class EventCleanupCronJob extends CronJob {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    initialConfig: InitialCronConfig = {
+        name: 'Event Cleanup',
+        cron: CronExpression.daily().build(),
+        runOnInit: false
+    };
+
+    constructor(
+        @InjectRepository(Event)
+        private readonly repository: Repository<Event<unknown>>
+    ) {
+        super();
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    async onTick(): Promise<void> {
+        await this.logger.info('cleans up past events');
+
+        try {
+            // const yesterday: Date = new Date(Date.now() - Ms.DAY);
+            const events: Event<unknown>[] = (await this.repository.findAll({
+                where: { status: EventStatus.FINISHED },
+                relations: ['eventSubscriberRuns']
+            })).filter(e => Date.now() > new Date(e.cleanupAt).getTime());
+            const res: Event<unknown>[] = await this.repository.deleteAll({ id: { oneOf: events.map(e => e.id) } });
+            await this.logger.info(`removed ${res.length} events`);
+        }
+        catch {
+            // Do nothing
+        }
+    }
+}

package/src/event/event-processing.error.ts

@@ -0,0 +1,16 @@
+import { Event } from './event.model';
+import { JsonUtilities } from '../utilities/json.utilities';
+
+/**
+ * An error that gets logged when the processing of an event failed.
+ */
+export class EventProcessingError<T> extends Error {
+    constructor(event: Event<T>, subscriberId: string, cause: Error) {
+        const message: string = [
+            `Error processing event "${event.type}" for subscriber "${subscriberId}" with data:`,
+            JsonUtilities.stringify(event.data, undefined, 2)
+        ].join('\n');
+        super(message, { cause });
+        this.name = 'EventProcessingError';
+    }
+}

package/src/event/event-service.interface.ts

@@ -0,0 +1,62 @@
+import { Event } from './event.model';
+
+/**
+ * Options for subscribing to events.
+ */
+export type EventSubscribeOptions = {
+    /**
+     * The id of the subscriber that wants to subscribe.
+     *
+     * Needs to be unique and should stay consistent to survive power cycles.
+     */
+    subscriberId: string,
+    /**
+     * The amount of attempts. Defaults to 1.
+     */
+    attempts?: number,
+    /**
+     * The timeout in which the hook should finish. Defaults to 30 seconds.
+     */
+    timeout?: number
+};
+
+/**
+ * The result of subscribing to an event.
+ */
+export type EventSubscriptionInterface = {
+    /**
+     * Unsubscribes from the event.
+     */
+    unsubscribe: () => void
+};
+
+/**
+ * Interface for an event service.
+ */
+export interface EventServiceInterface<TEvents extends Record<string, unknown>> {
+    /**
+     * Emits an event of the given type and data.
+     */
+    emit: <K extends keyof TEvents>(type: K, data: TEvents[K], cleanupAfterMs?: number) => void | Promise<void>,
+    /**
+     * Subscribes to events of the given type with the given hook.
+     *
+     * Additional options can be provided, like eg. Retries or the id of the subscriber.
+     * This needs to be unique.
+     */
+    subscribe: <K extends keyof TEvents>(
+        type: K,
+        hook: (value: Event<TEvents[K]>) => void | Promise<void>,
+        options: EventSubscribeOptions
+    ) => EventSubscriptionInterface | Promise<EventSubscriptionInterface>,
+    /**
+     * Subscribes to ALL events with the given hook.
+     *
+     * Additional options can be provided, like eg. Retries or the id of the subscriber.
+     * This needs to be unique.
+     */
+    subscribeAll: (
+        hook: (value: Event<TEvents[keyof TEvents]>) => void | Promise<void>,
+        options: EventSubscribeOptions
+    ) => EventSubscriptionInterface | Promise<EventSubscriptionInterface>
+}

package/src/event/event-subscriber-run.model.ts

@@ -0,0 +1,43 @@
+import { Event } from './event.model';
+import { BaseEntity } from '../entity/base-entity.model';
+import { Entity } from '../entity/decorators/entity.decorator';
+import { Property } from '../entity/decorators/property.decorator';
+import { OmitClass } from '../entity/omit-class.model';
+
+/**
+ * Data of a event subscriber run.
+ */
+@Entity({ allowOrphan: true })
+export class EventSubscriberRun<T> extends BaseEntity {
+    /**
+     * The timestamp at which the event run has been created.
+     */
+    @Property.date({ default: () => new Date() })
+    createdAt!: Date;
+    /**
+     * The event that triggered this run.
+     */
+    @Property.manyToOne({ target: () => Event, inverseSide: 'eventSubscriberRuns' })
+    event!: Event<T>;
+    /**
+     * The id of the subscriber.
+     */
+    @Property.string()
+    subscriberId!: string;
+    /**
+     * The error property if the run failed.
+     */
+    @Property.unknown({ required: false })
+    error?: Error;
+}
+
+/**
+ * The data needed to create a new event subscriber run.
+ */
+export class EventSubscriberRunCreateData<T> extends OmitClass(EventSubscriberRun<unknown>, ['id', 'event', 'createdAt']) {
+    /**
+     * The event that triggered this run.
+     */
+    @Property.manyToOne({ target: () => Event, inverseSide: 'eventSubscriberRuns' })
+    event!: Event<T>;
+}

package/src/event/event.model.ts

@@ -0,0 +1,66 @@
+import { EventSubscriberRun } from './event-subscriber-run.model';
+import { BaseEntity } from '../entity/base-entity.model';
+import { Entity } from '../entity/decorators/entity.decorator';
+import { Property } from '../entity/decorators/property.decorator';
+import { OmitClass } from '../entity/omit-class.model';
+
+/**
+ * The status a event can have.
+ */
+export enum EventStatus {
+    CREATED = 'CREATED',
+    FINISHED = 'FINISHED'
+}
+
+/**
+ * Definition for an event.
+ */
+@Entity({ allowOrphan: true })
+export class Event<T> extends BaseEntity {
+    /**
+     * The timestamp at which the event has been created.
+     */
+    @Property.date({ default: () => new Date() })
+    createdAt!: Date;
+    /**
+     * The timestamp after which the event can be cleaned up.
+     */
+    @Property.date()
+    cleanupAt!: Date;
+    /**
+     * The type of the event.
+     */
+    @Property.string()
+    type!: string;
+    /**
+     * The data of the event.
+     */
+    @Property.unknown()
+    data!: T;
+    /**
+     * The status of the event.
+     */
+    @Property.string({ enum: EventStatus, default: EventStatus.CREATED })
+    status!: EventStatus;
+    /**
+     * All ids of eg. Classes that are subscribed to this event.
+     */
+    @Property.array({ items: { type: 'string' } })
+    subscriberIds!: string[];
+    /**
+     * All runs of subscribers that have already happened.
+     */
+    @Property.oneToMany({ target: () => EventSubscriberRun, inverseSide: 'event' })
+    eventSubscriberRuns!: EventSubscriberRun<T>[];
+}
+
+/**
+ * The data needed to create a new event.
+ */
+export class EventCreateData<T> extends OmitClass(Event<unknown>, ['id', 'data', 'createdAt', 'eventSubscriberRuns', 'status']) {
+    /**
+     * The data of the event.
+     */
+    @Property.unknown()
+    data!: T;
+}

package/src/event/event.service.ts

@@ -0,0 +1,252 @@
+import { filter, Subject, Subscription } from 'rxjs';
+
+import { EventServiceInterface, EventSubscribeOptions, EventSubscriptionInterface } from './event-service.interface';
+import { EventSubscriberRun, EventSubscriberRunCreateData } from './event-subscriber-run.model';
+import { Event, EventCreateData, EventStatus } from './event.model';
+import { ZibriApplication } from '../application';
+import { EventCleanupCronJob } from './event-cleanup.cron-job';
+import { EventProcessingError } from './event-processing.error';
+import { Repository } from '../data-source/repository';
+import { InjectRepository } from '../di/decorators/inject-repository.decorator';
+import { Inject } from '../di/decorators/inject.decorator';
+import { Injectable } from '../di/decorators/injectable.decorator';
+import { ZIBRI_DI_TOKENS } from '../di/default/zibri-di-tokens.default';
+import { AfterAppShutdown } from '../global/after-app-shutdown.interface';
+import { OnAppInit } from '../global/on-app-init.interface';
+import { OnAppStart } from '../global/on-app-start.interface';
+import { type LoggerInterface } from '../logging/logger.interface';
+import { JsonUtilities } from '../utilities/json.utilities';
+import { Ms } from '../utilities/ms';
+import { ObjectUtilities } from '../utilities/object.utilities';
+import { PromiseUtilities } from '../utilities/promise.utilities';
+import { validateEntitiesRegistered } from '../utilities/validate-entities-registered.function';
+
+/**
+ * The result for subscribing to an event.
+ */
+export class EventSubscription implements EventSubscriptionInterface {
+    constructor(
+        readonly id: string,
+        readonly rxSub: Subscription,
+        readonly unsubscribe: () => void
+    ) {}
+}
+
+/**
+ * Default implementation of the event service.
+ */
+@Injectable({ register: 'onUse' })
+export class EventService<TEvents extends Record<string, unknown>>
+implements EventServiceInterface<TEvents>, OnAppInit, OnAppStart, AfterAppShutdown {
+    /**
+     * The rxjs subject of the event.
+     */
+    protected readonly eventSubject: Subject<Event<TEvents[keyof TEvents]>> = new Subject();
+    /**
+     * The subscribers for each event type.
+     */
+    protected readonly subscriptionForEvent: Record<
+        keyof TEvents,
+        Set<EventSubscription> | undefined
+    > = {} as Record<keyof TEvents, Set<EventSubscription> | undefined>;
+    /**
+     * The subscribers that listen to all events.
+     */
+    protected readonly subscriptionsForAll: Set<EventSubscription> = new Set();
+
+    constructor(
+        @InjectRepository(Event)
+        protected readonly eventRepository: Repository<Event<TEvents[keyof TEvents]>, EventCreateData<TEvents[keyof TEvents]>>,
+        @InjectRepository(EventSubscriberRun)
+        protected readonly eventSubscriberRunRepository: Repository<
+            EventSubscriberRun<TEvents[keyof TEvents]>,
+            EventSubscriberRunCreateData<TEvents[keyof TEvents]>
+        >,
+        @Inject(ZIBRI_DI_TOKENS.LOGGER)
+        protected readonly logger: LoggerInterface
+    ) { }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    onAppInit(app: ZibriApplication): void {
+        validateEntitiesRegistered('EventService', app, Event, EventSubscriberRun);
+        if (!app.options.cronJobs.includes(EventCleanupCronJob)) {
+            app.options.cronJobs.push(EventCleanupCronJob);
+        }
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    async onAppStart(): Promise<void> {
+        const events: Event<TEvents[keyof TEvents]>[] = await this.eventRepository.findAll({
+            where: { status: { not: EventStatus.FINISHED } },
+            relations: ['eventSubscriberRuns'],
+            order: { createdAt: 'ASC' }
+        });
+
+        for (const event of events) {
+            if (await this.eventHasUnfinishedSubscriptions(event)) {
+                this.eventSubject.next(event);
+                continue;
+            }
+
+            await this.eventRepository.updateById(event.id, { status: EventStatus.FINISHED });
+        }
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    afterAppShutdown(): void {
+        // We unsubscribe on the internal rxjs subscription here
+        // => emit calls happening now will create the correct events
+        for (const subscriber of this.subscriptionsForAll) {
+            subscriber.rxSub.unsubscribe();
+        }
+        for (const subscriber of ObjectUtilities.values(this.subscriptionForEvent).flatMap(s => [...s ?? []])) {
+            subscriber.rxSub.unsubscribe();
+        }
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    async emit<K extends keyof TEvents>(type: K, data: TEvents[K], cleanupAfterMs: number = Ms.DAY): Promise<void> {
+        const event: Event<TEvents[keyof TEvents]> = await this.eventRepository.create({
+            type: String(type),
+            subscriberIds: [...this.subscriptionForEvent[type] ?? [], ...this.subscriptionsForAll].map(d => d.id),
+            cleanupAt: new Date(Date.now() + cleanupAfterMs),
+            data
+        });
+        this.eventSubject.next({ ...event, eventSubscriberRuns: [] });
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    async subscribe<K extends keyof TEvents>(
+        type: K,
+        hook: (value: Event<TEvents[K]>, signal: AbortSignal) => void | Promise<void>,
+        options: EventSubscribeOptions
+    ): Promise<EventSubscription> {
+        const existingAllEventSubscription: EventSubscription | undefined = this.findSubscriptionById(options.subscriberId);
+        if (existingAllEventSubscription) {
+            throw new Error(`Can't subscribe to event: The subscriberId ${options.subscriberId} is already subscribed to all events`);
+        }
+        const existingEventSubscription: EventSubscription | undefined = this.findSubscriptionForEventById(type, options.subscriberId);
+        if (existingEventSubscription) {
+            await this.logger.warn(
+                `The subscriberId ${options.subscriberId} is already subscribed to this event, returning the existing subscription`
+            );
+            return existingEventSubscription;
+        }
+
+        const rxSub: Subscription = this.eventSubject
+            .pipe(
+                filter(e => e.type === type && !e.eventSubscriberRuns.some(r => r.subscriberId === options.subscriberId))
+            )
+            .subscribe(e => void this.runHook(hook, e as Event<TEvents[K]>, options));
+        const subscriber: EventSubscription = new EventSubscription(
+            options.subscriberId,
+            rxSub,
+            () => {
+                this.subscriptionForEvent[type]?.delete(subscriber);
+                rxSub.unsubscribe();
+            }
+        );
+
+        this.subscriptionForEvent[type] ??= new Set();
+        this.subscriptionForEvent[type].add(subscriber);
+        return subscriber;
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    async subscribeAll(
+        hook: (value: Event<TEvents[keyof TEvents]>, signal: AbortSignal) => void | Promise<void>,
+        options: EventSubscribeOptions
+    ): Promise<EventSubscription> {
+        const existingEventSubscriptionTypes: string[] = [];
+        for (const type of ObjectUtilities.keys(this.subscriptionForEvent)) {
+            if (this.findSubscriptionForEventById(type, options.subscriberId)) {
+                existingEventSubscriptionTypes.push(type);
+            }
+        }
+        if (existingEventSubscriptionTypes.length) {
+            throw new Error(
+                [
+                    `Can't subscribe to all events: The subscriberId ${options.subscriberId} is already subscribed to the events:`,
+                    ...existingEventSubscriptionTypes.map(t => `    - ${t}`)
+                ].join('\n')
+            );
+        }
+
+        const existingAllEventSubscription: EventSubscription | undefined = this.findSubscriptionById(options.subscriberId);
+        if (existingAllEventSubscription) {
+            await this.logger.warn(
+                `The subscriberId ${options.subscriberId} is already subscribed to all events, returning the existing subscription`
+            );
+            return existingAllEventSubscription;
+        }
+
+        const rxSub: Subscription = this.eventSubject
+            .pipe(filter(e => !e.eventSubscriberRuns.some(r => r.subscriberId === options.subscriberId)))
+            .subscribe(e => void this.runHook(hook, e, options));
+        const subscription: EventSubscription = new EventSubscription(
+            options.subscriberId,
+            rxSub,
+            () => {
+                this.subscriptionsForAll.delete(subscription);
+                rxSub.unsubscribe();
+            }
+        );
+        this.subscriptionsForAll.add(subscription);
+        return subscription;
+    }
+
+    /**
+     * Runs the given hook with the given event and options.
+     * @param hook - The hook to run.
+     * @param event - The event to run the hook on.
+     * @param options - Additional options like the subscriberId, attempts etc.
+     */
+    protected async runHook<K extends keyof TEvents>(
+        hook: (value: Event<TEvents[K]>, signal: AbortSignal) => void | Promise<void>,
+        event: Event<TEvents[K]>,
+        options: EventSubscribeOptions
+    ): Promise<void> {
+        let error: Error | undefined = undefined;
+        for (let i: number = 0; i < (options.attempts ?? 1); i++) {
+            try {
+                await PromiseUtilities.withTimeout((signal) => hook(event, signal), options.timeout ?? Ms.SECOND * 30);
+                error = undefined;
+                break;
+            }
+            catch (_error) {
+                error = _error instanceof Error ? _error : new Error(JsonUtilities.stringify(_error));
+            }
+        }
+
+        if (error) {
+            await this.logger.error(new EventProcessingError(event, options.subscriberId, error));
+        }
+
+        await this.eventSubscriberRunRepository.create({ event, subscriberId: options.subscriberId, error });
+        if (await this.eventHasUnfinishedSubscriptions(event)) {
+            return;
+        }
+        await this.eventRepository.updateById(event.id, { status: EventStatus.FINISHED });
+    }
+
+    private async eventHasUnfinishedSubscriptions<K extends keyof TEvents>(event: Event<TEvents[K]>): Promise<boolean> {
+        const runs: EventSubscriberRun<unknown>[] = await this.eventSubscriberRunRepository.findAll({
+            where: {
+                event: { where: { id: event.id } }
+            }
+        });
+        const ranSubscriberIds: string[] = runs.map(r => r.subscriberId);
+        const allSubscriberIds: string[] = [...this.subscriptionForEvent[event.type] ?? [], ...this.subscriptionsForAll].map(d => d.id);
+        return event.subscriberIds.some(id => allSubscriberIds.includes(id) && !ranSubscriberIds.includes(id));
+    }
+
+    private findSubscriptionForEventById(event: keyof TEvents, subscriberId: string): EventSubscription | undefined {
+        const subscribers: EventSubscription[] = [...this.subscriptionForEvent[event] ?? []];
+        return subscribers.find(s => s.id === subscriberId);
+    }
+
+    private findSubscriptionById(subscriberId: string): EventSubscription | undefined {
+        const subscribers: EventSubscription[] = [...this.subscriptionsForAll];
+        return subscribers.find(s => s.id === subscriberId);
+    }
+}