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.
142 lines
4.3 KiB
142 lines
4.3 KiB
import {Container, Inject, Injectable, Instantiable} from '../../di'
|
|
import {Awaitable, ErrorWithContext, hasOwnProperty, 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
|
|
}
|
|
}
|
|
|
|
/** A serialized `StateEvent` instance. */
|
|
export type SerializedStateEvent<T extends JSONState = JSONState> = {
|
|
state: T,
|
|
eventUuid: string,
|
|
}
|
|
|
|
export function isSerializedStateEvent(what: unknown): what is SerializedStateEvent {
|
|
return (
|
|
typeof what === 'object' && what !== null
|
|
&& hasOwnProperty(what, 'state')
|
|
&& hasOwnProperty(what, 'eventUuid')
|
|
&& typeof what.eventUuid === 'string'
|
|
)
|
|
}
|
|
|
|
/**
|
|
* 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>, SerializedStateEvent> {
|
|
@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<SerializedStateEvent> {
|
|
return {
|
|
state: actual.getState(),
|
|
eventUuid: actual.eventUuid,
|
|
}
|
|
}
|
|
|
|
protected decodeSerial(serial: SerializedStateEvent): Awaitable<StateEvent<JSONState>> {
|
|
const inst = this.injector.makeNew<StateEvent<JSONState>>(this.eventClass)
|
|
if ( !isSerializedStateEvent(serial) || !inst.validate(serial.state) ) {
|
|
throw new ErrorWithContext('Invalid serial state', {
|
|
serial,
|
|
eventClass: inst.getName(),
|
|
})
|
|
}
|
|
|
|
inst.setState(serial.state)
|
|
inst.eventUuid = serial.eventUuid
|
|
return inst
|
|
}
|
|
|
|
protected getName(): string {
|
|
const inst = this.injector.makeNew<StateEvent<JSONState>>(this.eventClass)
|
|
return `${inst.getName()}Serializer`
|
|
}
|
|
}
|