You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
123 lines
3.6 KiB
123 lines
3.6 KiB
import {Container, Inject, Injectable, Instantiable} from '../../di'
|
|
import {Awaitable, ErrorWithContext, JSONState, uuid4} from '../../util'
|
|
import {BaseSerializer} from './serial/BaseSerializer'
|
|
import {Event} from './types'
|
|
|
|
/**
|
|
* An event base class that provides its own validator and serializer implementation.
|
|
* This is meant to streamline event creation for app-space by forcing the payload of
|
|
* the event to be a JSONState.
|
|
*/
|
|
@Injectable()
|
|
export abstract class StateEvent<T extends JSONState> implements Event {
|
|
@Inject()
|
|
protected readonly injector!: Container
|
|
|
|
/** The payload of the event. */
|
|
private state?: T
|
|
|
|
eventUuid = uuid4()
|
|
|
|
public get eventName(): string {
|
|
return this.getName()
|
|
}
|
|
|
|
/** Validate the incoming data. */
|
|
public abstract validate(state: JSONState): state is T
|
|
|
|
/** Get the event's name for the bus. */
|
|
public getName(): string {
|
|
const ctor = this.constructor as typeof StateEvent
|
|
return `state:${ctor.name}`
|
|
}
|
|
|
|
/** Get the Serializer implementation for this event. */
|
|
public getSerializer(): StateEventSerializer {
|
|
const ctor = this.constructor as typeof StateEvent
|
|
return this.injector.makeNew<StateEventSerializer>(StateEventSerializer, ctor)
|
|
}
|
|
|
|
/** Validate & set the internal state of this event instance. */
|
|
public setState(state: JSONState): this {
|
|
if ( !this.validate(state) ) {
|
|
throw new ErrorWithContext('Invalid state', {
|
|
state,
|
|
})
|
|
}
|
|
|
|
this.state = state
|
|
return this
|
|
}
|
|
|
|
/** Get the internal state of this event, validated. */
|
|
public getState(): T {
|
|
if ( typeof this.state === 'undefined' ) {
|
|
throw new ErrorWithContext('State has not been set on event')
|
|
}
|
|
|
|
return this.state
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generic serializer implementation for StateEvents.
|
|
* Note that this is NOT registered with @ObjectSerializer() because we need to
|
|
* create an instance of this class for EACH implementation of StateEvent.
|
|
* Still working that one out. For now, you'll need to manually register the
|
|
* serializer. You can do this with the `getSerializer` method.
|
|
*
|
|
* @example
|
|
* ```ts
|
|
* type MyState = {
|
|
* id: number
|
|
* }
|
|
*
|
|
* class MyStateEvent extends StateEvent<MyState> {
|
|
* public validate(state: JSONState): state is MyState {
|
|
* return is<MyState>(state)
|
|
* }
|
|
* }
|
|
* ```
|
|
*/
|
|
@Injectable()
|
|
export class StateEventSerializer extends BaseSerializer<StateEvent<JSONState>, JSONState> {
|
|
@Inject()
|
|
protected readonly injector!: Container
|
|
|
|
/** The StateEvent implementation. */
|
|
public readonly eventClass: Instantiable<StateEvent<JSONState>>;
|
|
|
|
constructor(
|
|
eventClass: Instantiable<StateEvent<JSONState>>,
|
|
) {
|
|
super()
|
|
this.eventClass = eventClass
|
|
}
|
|
|
|
matchActual(some: StateEvent<JSONState>): boolean {
|
|
return some instanceof this.eventClass
|
|
}
|
|
|
|
protected encodeActual(actual: StateEvent<JSONState>): Awaitable<JSONState> {
|
|
return actual.getState()
|
|
}
|
|
|
|
protected decodeSerial(serial: JSONState): Awaitable<StateEvent<JSONState>> {
|
|
const inst = this.injector.makeNew<StateEvent<JSONState>>(this.eventClass)
|
|
if ( !inst.validate(serial) ) {
|
|
throw new ErrorWithContext('Invalid serial state', {
|
|
serial,
|
|
eventClass: inst.getName(),
|
|
})
|
|
}
|
|
|
|
inst.setState(serial)
|
|
return inst
|
|
}
|
|
|
|
protected getName(): string {
|
|
const inst = this.injector.makeNew<StateEvent<JSONState>>(this.eventClass)
|
|
return `${inst.getName()}Serializer`
|
|
}
|
|
}
|