protected fun getOptionalValue()

in graphql-dgs-codegen-shared-core/src/main/kotlin/com/netflix/graphql/dgs/client/codegen/InputValueSerializer.kt [91:170]
65 lines of code
18 McCabe index (conditional complexity)

    protected fun getOptionalValue(input: Any): Optional<Value<*>> {
        if (input is Value<*>) {
            return Optional.of(input)
        }

        for (scalar in scalars.keys) {
            if (input::class.java == scalar || scalar.isAssignableFrom(input::class.java)) {
                return Optional.of(scalars[scalar]!!.valueToLiteral(input, graphQLContext, Locale.getDefault()))
            }
        }

        if (input::class in toStringClasses) {
            return Optional.of(StringValue.of(input.toString()))
        }

        if (input is String) {
            return Optional.of(StringValue.of(input))
        }

        if (input is Float) {
            return Optional.of(FloatValue.of(input.toDouble()))
        }

        if (input is Double) {
            return Optional.of(FloatValue.of(input))
        }

        if (input is BigDecimal) {
            return Optional.of(FloatValue.newFloatValue(input).build())
        }

        if (input is BigInteger) {
            return Optional.of(IntValue.newIntValue(input).build())
        }

        if (input is Int) {
            return Optional.of(IntValue.of(input))
        }

        if (input is Number) {
            return Optional.of(IntValue.newIntValue(BigInteger.valueOf(input.toLong())).build())
        }

        if (input is Boolean) {
            return Optional.of(BooleanValue.of(input))
        }

        if (input is Enum<*>) {
            return Optional.of(EnumValue.newEnumValue(input.name).build())
        }

        if (input is Collection<*>) {
            return Optional.of(
                ArrayValue
                    .newArrayValue()
                    .values(input.map { toValue(it) })
                    .build(),
            )
        }

        if (input is Map<*, *>) {
            return Optional.of(
                ObjectValue
                    .newObjectValue()
                    .objectFields(input.map { (key, value) -> ObjectField(key.toString(), toValue(value)) })
                    .build(),
            )
        }

        if (input is InputValue) {
            return Optional.of(
                ObjectValue
                    .newObjectValue()
                    .objectFields(input.inputValues().map { (name, value) -> ObjectField(name, toValue(value)) })
                    .build(),
            )
        }

        return Optional.empty()
    }