lib/src/http/kernel/module/ExecuteResolvedRoutePreflightHTTPModule.ts

import {HTTPKernel} from '../HTTPKernel'
import {MountActivatedRouteHTTPModule} from './MountActivatedRouteHTTPModule'
import {Request} from '../../lifecycle/Request'
import {ActivatedRoute} from '../../routing/ActivatedRoute'
import {ResponseObject} from '../../routing/Route'
import {AbstractResolvedRouteHandlerHTTPModule} from './AbstractResolvedRouteHandlerHTTPModule'
import {collect, isLeft, unleft, unright, withErrorContext} from '../../../util'
import {MountWebSocketRouteHTTPModule} from './MountWebSocketRouteHTTPModule'

/**
 * HTTP Kernel module that executes the preflight handlers for the route.
 *
 * Usually, this is the pre middleware.
 */
export class ExecuteResolvedRoutePreflightHTTPModule extends AbstractResolvedRouteHandlerHTTPModule {
    public static register(kernel: HTTPKernel): void {
        const reg = kernel.register(this)
        reg.after(MountWebSocketRouteHTTPModule)
        reg.after(MountActivatedRouteHTTPModule)
    }

    public async apply(request: Request): Promise<Request> {
        if ( request.hasInstance(ActivatedRoute) ) {
            const route = <ActivatedRoute<unknown, unknown[]>> request.make(ActivatedRoute)
            const preflight = route.preflight

            for ( const handler of preflight ) {
                await withErrorContext(async () => {
                    const result: ResponseObject = await handler(request)
                    if ( typeof result !== 'undefined' ) {
                        await this.applyResponseObject(result, request)
                        request.response.blockingWriteback(true)
                    }
                }, { handler })
            }

            const parameters = route.parameters
            const resolveResult = (await collect(parameters)
                .asyncMapRight(handler => handler(request)))

            if ( isLeft(resolveResult) ) {
                await this.applyResponseObject(unleft(resolveResult), request)
                request.response.blockingWriteback(true)
                return request
            }

            route.resolvedParameters = unright(resolveResult).toArray(false)
        }

        return request
    }
}