private prepareExecutionStack()

in lib/request-context.ts [111:169]
47 lines of code
12 McCabe index (conditional complexity)

    private prepareExecutionStack(entryPointName: string): Interceptor[] {
        // If nothing has been overrided, use cached execution stack directly. 
        if (this._perRequestObjectContext.def.namedObjectDefs.length == 0) {
            if (this._entryPoint == null) {
                throw new Error("Entrypoint '" + entryPointName + "' does not exist.");
            }
            return this._application.getExecutionStack(entryPointName);
        } 

        // Per-request override happens, it could be entrypoint override or interceptor override.
        let entryPointObject = this.getNamedObject(entryPointName);
        let interceptorNames: string[] = entryPointObject.def.value.executionStack;
        if (interceptorNames == null) {
            interceptorNames = this.app.settings.defaultExecutionStack;
        }

        // When entrypoint is not overriden, check if interceptor definition has be overriden.
        if (entryPointObject.scope !== 'request') {
            let oldStack = this.app.getExecutionStack(entryPointName);
            let newStack: Interceptor[] = [];
        
            // Definition and pre-cached execution stack should align.
            assert(oldStack.length == interceptorNames.length);

            for (let i = 0; i < oldStack.length; ++i) {
                let interceptorName = interceptorNames[i];
                let interceptorObject = this.getNamedObject(interceptorName);
                if (interceptorObject == null) {
                    throw("Interceptor '" + interceptorName + "' does not exist.");
                }
                
                if (interceptorObject.scope !== 'request') {
                    newStack.push(oldStack[i]);
                }
                else {
                    // Interceptor is overriden from request. Look up new.
                    if (interceptorObject.value == null
                        || interceptorObject.def.value._type !== 'Interceptor') {
                        throw new Error("Bad override on interceptor '" 
                            + interceptorName 
                            + "', should be of Interceptor type and not null. ")
                    }
                    newStack.push(interceptorObject.value);
                }
            }
            return newStack;
        }

        // Per-request override happens on current entry point.
        let newStack: Interceptor[] = [];
        for (let interceptorName of interceptorNames) {
            let interceptor = this.getInterceptor(interceptorName);
            if (interceptor == null) {
                throw new Error("Interceptor '" + interceptorName + "' is not a valid interceptor.");
            }
            newStack.push(interceptor);
        }
        return newStack;
    }