poolster-plugin-java 0.5.0-alpha.1

Native Java SDK generator for Poolster
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use std::collections::BTreeMap;

use poolster_core::{
    AdditionalProperties, Api, Field, GeneratedTree, HttpMethod, Operation, OperationMediaType,
    OperationParameter, OperationRequestBody, OperationResponse, Schema, SchemaKind, SchemaValue,
};

use super::{
    api_exception, render_client_base, render_model, render_operation, render_sdk,
    render_sdk_with_policy, render_test_sdk,
};
use poolster_core::SdkClientStyle;

fn string() -> SchemaValue {
    SchemaValue::new(SchemaKind::String)
}

fn integer() -> SchemaValue {
    SchemaValue::new(SchemaKind::Integer)
}

fn contact_api() -> Api {
    Api {
        name: "Poolster Email API".into(),
        version: "2026-09-19".into(),
        schemas: vec![Schema::new(
            "Contact",
            SchemaValue::new(SchemaKind::Object {
                fields: vec![
                    Field {
                        name: "email".into(),
                        value: string(),
                        required: true,
                        annotations: BTreeMap::new(),
                    },
                    Field {
                        name: "display_name".into(),
                        value: string(),
                        required: false,
                        annotations: BTreeMap::new(),
                    },
                ],
                additional_properties: AdditionalProperties::Forbidden,
            }),
        )],
        operations: vec![Operation {
            id: "getContact".into(),
            method: HttpMethod::Get,
            path: "/v1/contacts/{contact_id}".into(),
            parameters: vec![
                OperationParameter {
                    name: "contact_id".into(),
                    location: "path".into(),
                    required: true,
                    schema: Some(string()),
                    description: None,
                    annotations: BTreeMap::new(),
                },
                OperationParameter {
                    name: "expand".into(),
                    location: "query".into(),
                    required: false,
                    schema: Some(string()),
                    description: None,
                    annotations: BTreeMap::new(),
                },
                OperationParameter {
                    name: "X-Request-ID".into(),
                    location: "header".into(),
                    required: false,
                    schema: Some(string()),
                    description: None,
                    annotations: BTreeMap::new(),
                },
            ],
            request_body: Some(OperationRequestBody {
                required: false,
                description: None,
                media_types: vec![OperationMediaType {
                    content_type: "application/json".into(),
                    schema: Some(SchemaValue::reference("#/components/schemas/Contact")),
                }],
            }),
            responses: vec![OperationResponse {
                status: "200".into(),
                description: None,
                media_types: vec![OperationMediaType {
                    content_type: "application/json".into(),
                    schema: Some(SchemaValue::reference("#/components/schemas/Contact")),
                }],
            }],
            security: Vec::new(),
            annotations: BTreeMap::new(),
        }],
        annotations: BTreeMap::new(),
    }
}

/// The public client inherits generated operations from bounded internal
/// classes; surface assertions intentionally inspect all Java sources.
fn rendered_java(tree: &GeneratedTree) -> String {
    tree.iter()
        .filter(|(path, _)| {
            path.extension()
                .is_some_and(|extension| extension == "java")
        })
        .map(|(_, contents)| contents)
        .collect::<Vec<_>>()
        .join("\n")
}

mod facades;
mod models;
mod pagination;
mod runtime;