Data-oriented programming with Ballerina:
A comparative analysis

enum UserType {
    ADMIN,
    CUSTOMER,
    GUEST
}

record User(int id, String name, UserType userType) {
    public User(int id, String name) {
        this(id, name, UserType.GUEST);
    }
}

class Main {
    public static void main(String[] args) {
        User customer = new User(1, "John Doe");
        System.out.printf("User '%s' with id '%s' as '%s' created successfully",
                customer.name(), customer.id(), customer.userType());
    }
}

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
import com.fasterxml.jackson.databind.module.SimpleModule;

import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;

record Person(int id, String name, Integer age, String email, List<String> availableFields) {
    public Optional<String> getEmail() {
        return Optional.ofNullable(email);
    }

    public Optional<Integer> getAge() {
        return Optional.ofNullable(age);
    }
}

class Main {
    public static void main(String[] args) throws JsonProcessingException {
        String jsonInput = """
                {
                    "id": 1,
                    "name": "John Doe",
                    "age": null
                }
                """;
        ObjectMapper objectMapper = new ObjectMapper();
        SimpleModule module = new SimpleModule();
        module.addDeserializer(Person.class, new PersonDeserializer());
        objectMapper.registerModule(module);

        Person person = objectMapper.readValue(jsonInput, Person.class);

        System.out.println(person.age()); // output: null

        // optional type access
        int age = person.getAge().orElse(-1);
        System.out.println(age); // output: -1

        // optional field access
        System.out.println(person.availableFields().contains("email")); // output: false
        String emailValue = person.getEmail().isPresent()
                ? person.email()
                : "Email is not provided";
        System.out.println(emailValue); // output: Email is not provided
    }
}

class PersonDeserializer extends StdDeserializer<Person> {
    public PersonDeserializer() {
        this(null);
    }

    public PersonDeserializer(Class<?> vc) {
        super(vc);
    }

    @Override
    public Person deserialize(JsonParser jsonParser,
            DeserializationContext deserializationContext) throws IOException {
        JsonNode node = jsonParser.getCodec().readTree(jsonParser);

        List<String> availableFields = Arrays.asList("name", "age", "id");
        int id = node.get("id").asInt();
        String name = node.get("name").asText();
        Integer age = node.get("age").asInt();
        String email = null;

        if (node.has("email")) {
            email = node.get("email").asText();
            availableFields.add("email");
        }

        return new Person(id, name, age, email, availableFields);
    }
}

import jakarta.validation.Valid;
import jakarta.validation.constraints.Pattern;
import jakarta.validation.constraints.Size;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.Collections;
import java.util.stream.Collectors;

@SpringBootApplication
@RestController
public class Main {
    @PostMapping("/user")
    public ResponseEntity<String> handleRequest(@Valid @RequestBody User user) {
        return ResponseEntity.ok("User " + user.username() + " signed up successfully");
    }

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Main.class);
        app.setDefaultProperties(Collections.singletonMap("server.port", "9090"));
        app.run(args);
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<String> handleException(MethodArgumentNotValidException ex) {
        String errorMessage = ex.getBindingResult().getFieldErrors().stream()
                .map(this::getViolationMessage)
                .collect(Collectors.joining(", "));
        return ResponseEntity.badRequest().body("Payload validation failed: " + errorMessage);
    }

    private String getViolationMessage(FieldError fieldError) {
        String fieldName = fieldError.getField();
        String constraintName = fieldError.getCode();
        return String.format("Validation failed for '%s:%s'", fieldName, constraintName);
    }

    record User(
            @Size(min = 1, max = 8,
                    message = "Username is not valid") String username,
            @Pattern(regexp = "^[\\S]{4,}$",
                    message = "Password should be greater than 4") String password
    ) {}
}

import org.modelmapper.ModelMapper;
import org.w3c.dom.Document;
import org.w3c.dom.Node;

import java.io.ByteArrayInputStream;
import java.util.Iterator;
import javax.xml.namespace.NamespaceContext;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.xpath.*;

class Main {
    // Define a SOAP payload
    final static String soapPayload =
            """
            <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
                <soapenv:Body>
                    <person>
                        <name>John Doe</name>
                        <age>30</age>
                        <address>
                            <city>New York</city>
                            <country>USA</country>
                        </address>
                    </person>
                </soapenv:Body>
            </soapenv:Envelope>""";

    public record Address(String city, String country) {
        public Address() {
            this(null, null);
        }
    }

    public static void main(String[] args) throws Exception {
        // Parse the SOAP payload
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document document = builder.parse(new ByteArrayInputStream(soapPayload.getBytes()));

        // Create an XPath instance
        XPath xpath = XPathFactory.newInstance().newXPath();
        NamespaceContext nsContext = new NamespaceContext() {
            public String getNamespaceURI(String prefix) {
                if (prefix.equals("soapenv")) {
                    return "http://schemas.xmlsoap.org/soap/envelope/";
                }
                return null;
            }

            public String getPrefix(String namespaceURI) {
                return null;
            }

            public Iterator<String> getPrefixes(String namespaceURI) {
                return null;
            }
        };
        xpath.setNamespaceContext(nsContext);

        // Navigate to SOAP payload and extract the data using XPath
        String soapPayloadExpression = "/*/soapenv:Body";
        Node soapPayloadNode = (Node) xpath
                .evaluate(soapPayloadExpression, document, XPathConstants.NODE);

        String personPath = "./person";
        Node personNode = (Node) xpath.evaluate(personPath, soapPayloadNode,
                XPathConstants.NODE);

        String name = (String) xpath.evaluate("name", personNode,
                XPathConstants.STRING);
        String age = (String) xpath.evaluate("age", personNode,
                XPathConstants.STRING);
        String city = (String) xpath.evaluate("*/city", personNode,
                XPathConstants.STRING);

        // Extract the sub-xml and convert it to a record
        String addressPath = "./address";
        Node addressNode = (Node) xpath.evaluate(addressPath, personNode,
                XPathConstants.NODE);
        Address address = new ModelMapper().map(addressNode, Address.class);
        String country = address.country();

        System.out.println("Name: " + name + ", Age: " + age
                + ", City: " + city + ", Country: " + country);
    }
}