import * as plugins from './plugins.js'; import { VirtualStream } from './typedrequest.classes.virtualstream.js'; import { TypedHandler } from './typedrequest.classes.typedhandler.js'; import { TypedRequest } from './typedrequest.classes.typedrequest.js'; /** * A typed router decides on which typed handler to call based on the method * specified in the typed request * This is thought for reusing the same url endpoint for different methods */ export class TypedRouter { public routerMap = new plugins.lik.ObjectMap(); public handlerMap = new plugins.lik.ObjectMap< TypedHandler >(); public registeredVirtualStreams = new plugins.lik.ObjectMap>(); public fireEventInterestMap = new plugins.lik.InterestMap< string, plugins.typedRequestInterfaces.ITypedRequest >((correlationId: string) => correlationId); /** * adds the handler to the routing map * @param typedHandlerArg */ public addTypedHandler( typedHandlerArg: TypedHandler ) { // lets check for deduplication const existingTypedHandler = this.getTypedHandlerForMethod(typedHandlerArg.method); if (existingTypedHandler) { throw new Error( `a TypedHandler for ${typedHandlerArg.method} alredy exists! Can't add another one.` ); } this.handlerMap.add(typedHandlerArg); } /** * adds another sub typedRouter * @param typedRequest */ public addTypedRouter(typedRouterArg: TypedRouter) { const routerExists = this.routerMap.findSync((routerArg) => routerArg === typedRouterArg); if (!routerExists) { this.routerMap.add(typedRouterArg); typedRouterArg.addTypedRouter(this); } } public checkForTypedHandler(methodArg: string): boolean { return !!this.getTypedHandlerForMethod(methodArg); } /** * gets a typed Router from the router chain, upstream and downstream * @param methodArg * @param checkUpstreamRouter */ public getTypedHandlerForMethod( methodArg: string, checkedRouters: TypedRouter[] = [] ): TypedHandler { checkedRouters.push(this); let typedHandler: TypedHandler; typedHandler = this.handlerMap.findSync((handler) => { return handler.method === methodArg; }); if (!typedHandler) { this.routerMap.getArray().forEach((typedRouterArg) => { if (!typedHandler && !checkedRouters.includes(typedRouterArg)) { typedHandler = typedRouterArg.getTypedHandlerForMethod(methodArg, checkedRouters); } }); } return typedHandler; } /** * if typedrequest object has correlation.phase === 'request' -> routes a typed request object to a handler * if typedrequest object has correlation.phase === 'response' -> routes a typed request object to request fire event * @param typedRequestArg */ public async routeAndAddResponse< T extends plugins.typedRequestInterfaces.ITypedRequest = plugins.typedRequestInterfaces.ITypedRequest >(typedRequestArg: T, localRequestArg = false): Promise { // decoding first typedRequestArg = VirtualStream.decodePayloadFromNetwork(typedRequestArg, { typedrouter: this, }); // localdata second typedRequestArg.localData = typedRequestArg.localData || {}; typedRequestArg.localData.firstTypedrouter = this; // lets do stream processing if (typedRequestArg.method === '##VirtualStream##') { const result: any = await this.handleStreamTypedRequest(typedRequestArg as plugins.typedRequestInterfaces.IStreamRequest); result.localData = null; return result as T; } // lets do normal routing if (typedRequestArg?.correlation?.phase === 'request' || localRequestArg) { const typedHandler = this.getTypedHandlerForMethod(typedRequestArg.method); if (!typedHandler) { console.log(`Cannot find handler for methodname ${typedRequestArg.method}`); typedRequestArg.error = { text: 'There is no available method for this call on the server side', data: {}, }; typedRequestArg.correlation.phase = 'response'; // encode again before handing back typedRequestArg = VirtualStream.encodePayloadForNetwork(typedRequestArg, { typedrouter: this, }); return typedRequestArg; } typedRequestArg = await typedHandler.addResponse(typedRequestArg); typedRequestArg.localData = null; // encode again before handing back typedRequestArg = VirtualStream.encodePayloadForNetwork(typedRequestArg, { typedrouter: this, }); return typedRequestArg; } else if (typedRequestArg?.correlation?.phase === 'response') { this.fireEventInterestMap .findInterest(typedRequestArg.correlation.id) ?.fullfillInterest(typedRequestArg); return null; } else { console.log('received weirdly shaped request'); console.log(typedRequestArg); return null; } } /** * handle streaming * @param streamTrArg */ public async handleStreamTypedRequest(streamTrArg: plugins.typedRequestInterfaces.IStreamRequest) { const relevantVirtualStream = await this.registeredVirtualStreams.find(async virtualStreamArg => { return virtualStreamArg.streamId === streamTrArg.request.streamId; }); if (!relevantVirtualStream) { console.log(`no relevant virtual stream found for stream with id ${streamTrArg.request.streamId}`); console.log(this.registeredVirtualStreams.getArray()); return streamTrArg; } else { console.log(`success: found relevant virtual stream with id ${streamTrArg.request.streamId}`); } const result = await relevantVirtualStream.handleStreamTr(streamTrArg); return result; } }