Context wrapper for async (request) operations with some useful state flags

request-context.ts

/**
 * Vormt een wrapper om async operaties waarin de staat van de operatie
 * bijgehouden wordt.
 */
export class AsyncContext {

	bezig = false;
	mislukt = false;
	geslaagd = false;

	/**
	 * Start de gegeven operatie en houdt de staat bij. Optioneel kan een
	 * callback gegeven worden die excepties van de operatie verwerkt. Als een
	 * exceptie optreedt en de callback is niet gegeven, of geeft een falsy
	 * waarde terug, dan wordt de operatie als mislukt gemarkeerd.
	 *
	 * @param operatie
	 * @param verwerkFout
	 */
	async start(operatie: () => Promise<any>, verwerkFout?: (fout: any) => any) {
		if (this.bezig) {
			return;
		}

		this.mislukt = false;
		this.geslaagd = false;
		this.bezig = true;
		try {
			await operatie();
			this.geslaagd = true;
		} catch (e) {
			this.mislukt = verwerkFout ? !verwerkFout(e) : true;
		} finally {
			this.bezig = false;
		}
	}

	reset() {
		this.mislukt = false;
		this.geslaagd = false;
	}
}

interface ValidationController {
	validate(): Promise<{valid: boolean}>;
	reset(): void;
}

interface RequestContextInit {
	/**
	 * Een optionele getter voor een validation controller die eerst moet worden
	 * gevalideerd voor de request gestart wordt.
	 */
	validationController?: () => ValidationController;

	/**
	 * Optionele async logica voor validatie die moet slagen voor de request
	 * gestart wordt. Als dit geïmplementeerd is wordt een eventuele gegeven
	 * validation controller niet meer automatisch gevalideerd.
	 */
	valideer?: () => Promise<boolean>;
}

/**
 * Vormt een wrapper om requests waarin de staat van de request bijgehouden
 * wordt. Biedt de mogelijkheid om vooraf validatie te doen en de request alleen
 * uit te voeren als dit slaagt.
 */
export class RequestContext extends AsyncContext {

	validationController?: () => ValidationController;

	geldig = true;

	constructor(init?: RequestContextInit) {
		super();

		if (init) {
			Object.assign(this, init);
		}
	}

	async valideer() {
		if (this.validationController) {
			return (await this.validationController().validate()).valid;
		}
		return true;
	}

	async start(request: () => Promise<any>, verwerkFout?: (fout: any) => any) {
		this.geldig = await this.valideer();
		if (this.bezig || !this.geldig) {
			return;
		}

		await super.start(request, verwerkFout);
	}

	reset() {
		super.reset();
		this.geldig = true;

		if (this.validationController) {
			this.validationController().reset();
		}
	}
}