具有类型缩小功能的 Typescript 路由参数验证函数

问：

我想为我的 api 路由参数创建一个通用验证函数，但是，我遇到了一个问题，即该函数在调用后没有缩小类型范围。

这是功能：

export default function (
    param: QueryValue | QueryValue[],
    paramName: string,
    type: 'string' | 'number' | { [key: string]: unknown },
    rules: Array<(param: QueryValue | QueryValue[]) => { valid: boolean, errorMessage: string } | boolean> | null = null
): SuccessfulValidation | FailedValidation {

    // if the type is an enum
    if (typeof type === 'object' && type !== null) {
        if (!isEnumKey(type)(param)) {
            return {
                valid: false,
                error: createError({
                    statusCode: 400,
                    statusMessage: `Invalid "${paramName}" query parameter. The value must be one of the supported values.`,
                })
            }
        }
    } else if (['string'].includes(<string>type)) {
        if (typeof param !== type) {
            return {
                valid: false,
                error: createError({
                    statusCode: 400,
                    statusMessage: `Invalid "${paramName}" query parameter. The value must be a ${type}.`,
                })
            }
        }
    } else if (type === 'number') {
        if (typeof param !== 'string' || isNaN(parseInt(param))) {
            return {
                valid: false,
                error: createError({
                    statusCode: 400,
                    statusMessage: `Invalid "${paramName}" query parameter. The value must be a number.`,
                })
            }
        }
    } else if (typeof param !== typeof type) {
        return {
            valid: false,
            error: createError({
                statusCode: 400,
                statusMessage: `Invalid "${paramName}" query parameter. The value must be a ${typeof type}.`,
            })
        }
    }

    // if the rules are provided, validate the param against them
    if (rules) {
        for (const rule of rules) {
            const result = rule(param)

            if (typeof result === 'boolean') {
                if (!result) {
                    return {
                        valid: false,
                        error: createError({
                            statusCode: 400,
                            statusMessage: `Invalid "${paramName}" query parameter. Rule validation failed.`,
                        })
                    }
                }
            } else {
                if (!result.valid) {
                    return {
                        valid: false,
                        error: createError({
                            statusCode: 400,
                            statusMessage: result.errorMessage,
                        })
                    }
                }
            }

        }
    }

    return {
        valid: true,
        error: null,
    }
}

interface SuccessfulValidation {
    valid: true;
    error: null;
}

interface FailedValidation {
    valid: false;
    error: ReturnType<typeof createError>;
}

这是一个示例用法：

const validation = routeParamValidate(queryOffset, 'offset', 'number')
if (!validation.valid) {
    return validation.error
}

// I would expect `queryOffset` to be typed as `number` here,
// but it stays as ` QueryValue | QueryValue[]`

我有这个函数，它确实缩小了类型范围：

export default function <T extends { [s: string]: unknown }>(e: T) {
    return (token: unknown): token is T[keyof T] => Object.values(e).includes(token as T[keyof T])
}

但是，仅凭这个功能，我无法想出解决问题的方法。 我怎样才能改进第一个以确保它缩小了类型范围？另外，有哪些好的资源可以查看，以进入像这样更高级的打字稿内容？大多数教程通常只关注基础知识。