[BUG][SPRING] Incorrect handling of `format: byte` in query strings

[A18022]

Bug Report Checklist

• Have you provided a full/minimal spec to reproduce the issue?
• Have you validated the input using an OpenAPI validator?
• Have you tested with the latest master to confirm the issue still exists?
• Have you searched for related issues/PRs?
• What's the actual output vs expected output?
• [Optional] Sponsorship to speed up the bug fix or feature request (example)

Description

When generating a spring-cloud implementation with a query string parameter with format: byte the parameter is not decoded as base64 (as required by the spec).

openapi-generator version

1.8.0

OpenAPI declaration file content or url

openapi: '3.0.3'
info:
  title: Test API
  version: '1.0'
servers:
  - url: https://api.server.test/v1
paths:
  /test:
    get:
      parameters:
        - name: data
          in: query
          schema:
            type: string
            format: byte
      responses:
        '200':
          description: OK

Generation Details

pom.xml:

<plugin>
<groupId>org.openapitools</groupId>
<artifactId>openapi-generator-maven-plugin</artifactId>
<executions>
	<execution>
		<id>generate-api</id>
		<goals>
			<goal>generate</goal>
		</goals>
		<configuration>
			<inputSpec>
				${project.basedir}/src/main/resources/testapi.yaml
			</inputSpec>
			<generatorName>spring</generatorName>
			<library>spring-boot</library>
			<generateSupportingFiles>false</generateSupportingFiles>
			<skipOperationExample>true</skipOperationExample>
			<configOptions>
				<delegatePattern>false</delegatePattern>
				<useSpringBoot3>true</useSpringBoot3>
				<interfaceOnly>true</interfaceOnly>
			</configOptions>
		</configuration>
	</execution>
</executions>
</plugin>

Steps to reproduce

Generate code from the spec above. Implement the endpoint:

@RestController
public class TestController implements TestApi {

    @Override
    public ResponseEntity<Void> testGet(byte[] data) {
        StringBuilder hexString = new StringBuilder();
        for (byte b : data) {
            hexString.append(String.format("%02x", b));
        }
        System.out.println(hexString.toString());
        return ResponseEntity.ok().build();
    }
}

Note: The paramter is a byte[] as expected.

Send a sample request:

curl http://localhost:8080/test?data=abc

Actual output: 616263 (ascii encoding of "abc")
Expected output: 69b7 (base64 decoding of "abc")

Related issues/PRs

Suggest a fix

I don't know Spring very well, maybe there is some kind of annotation that can be used to make Spring decode the value correctly? Alternatively the generator should emit an error that format: byte is not supported.

[Picazsoo]

One way would be to simply treat the parameter as a String and leave decoding to the implementation. Even in your case the original content can still be retrieved and decoded correctly.

Other way would be to add a converter:

package com.example.config;

import java.util.Base64;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.convert.converter.Converter;

@Configuration
public class ConverterConfig {

    @Bean
    public Converter<String, byte[]> base64StringToByteArrayConverter() {
        return new Converter<String, byte[]>() {
            @Override
            public byte[] convert(String source) {
                if (source == null) {
                    return null;
                }
                return Base64.getDecoder().decode(source);
            }
        };
    }
}

we could automatically generate this as part of the source code files, when we detect that there is a query param with format: byte

[Picazsoo]

Other way could be to generate a default method on the interface that would handle the conversion from string to byte[] and call the original interface method (that would have to be then implemented). But I can imagine that would make the template file really hard to reason about for 99% of the cases. And it might even be practically impossible when you have e.g. mix of byte[] params and normal string params in a method.

[A18022]

One way would be to simply treat the parameter as a String and leave decoding to the implementation.

Yeah, this is my current workarround.

About the converter: How would Spring know when to apply this converter? Can this be controlled using some kind of annotation on the parameter? If yes, this would sound like the best solution to me.

[Picazsoo]

AFAIK Spring would automatically apply it everywhere where there is a conversion from String in json to byte[]. I don't think it is possible/easy to make it apply to some fields only. But there are other options.

Another possibility would be to really treat the parameter as a String and just put an inline comment such as /* base64 encoded binary */ and leave decoding to the implementation. That would make it clear that it needs additional processing.