@goast/kotlin 0.4.18 → 0.4.20

package/script/src/generators/services/spring-reactive-web-clients/spring-reactive-web-client-generator.js

@@ -0,0 +1,388 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultKotlinSpringReactiveWebClientGenerator = void 0;
+const tslib_1 = require("tslib");
+const node_path_1 = require("node:path");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const core_1 = require("@goast/core");
+const index_js_1 = require("../../../ast/index.js");
+const file_builder_js_1 = require("../../../file-builder.js");
+const utils_js_1 = require("../../../utils.js");
+const file_generator_js_1 = require("../../file-generator.js");
+class DefaultKotlinSpringReactiveWebClientGenerator extends file_generator_js_1.KotlinFileGenerator {
+    generate(ctx) {
+        const typeName = this.getRequestsObjectName(ctx, {});
+        const packageName = this.getPackageName(ctx, {});
+        const filePath = this.getFilePath(ctx, { packageName });
+        fs_extra_1.default.ensureDirSync((0, node_path_1.dirname)(filePath));
+        console.log(`Generating client for service ${ctx.service.name} to ${filePath}...`);
+        const builder = new file_builder_js_1.KotlinFileBuilder(packageName, ctx.config);
+        builder.append(this.getClientFileContent(ctx, {}));
+        fs_extra_1.default.writeFileSync(filePath, builder.toString());
+        return { typeName, packageName };
+    }
+    // deno-lint-ignore no-unused-vars
+    getClientFileContent(ctx, args) {
+        return (0, core_1.appendValueGroup)([this.getRequestsObject(ctx, {})], '\n\n');
+    }
+    // deno-lint-ignore no-unused-vars
+    getRequestsObject(ctx, args) {
+        return index_js_1.kt.object({
+            name: this.getRequestsObjectName(ctx, {}),
+            members: ctx.service.endpoints.flatMap((endpoint) => this.getEndpointMembers(ctx, { endpoint, parameters: this.getAllParameters(ctx, { endpoint }) })),
+        });
+    }
+    getEndpointMembers(ctx, args) {
+        const { endpoint, parameters } = args;
+        const responseSchema = this.getResponseSchema(ctx, { endpoint });
+        return [
+            this.getEndpointFunction(ctx, { endpoint, parameters, responseSchema }),
+            this.getEndpointFunctionWithHandler(ctx, { endpoint, parameters, responseSchema }),
+            this.getEndpointUriFunction(ctx, { endpoint, parameters }),
+            this.getEndpointRequestFunction(ctx, { endpoint, parameters, responseSchema }),
+        ];
+    }
+    getEndpointFunctionName(ctx, args) {
+        const { endpoint } = args;
+        return (0, core_1.toCasing)(endpoint.name, ctx.config.functionNameCasing);
+    }
+    getEndpointFunction(ctx, args) {
+        const { endpoint, parameters, responseSchema } = args;
+        const functionName = this.getEndpointFunctionName(ctx, { endpoint });
+        return index_js_1.kt.function(functionName, {
+            doc: index_js_1.kt.doc(endpoint.description),
+            suspend: true,
+            receiverType: index_js_1.kt.refs.springReactive.webClient(),
+            parameters: parameters.map((parameter) => index_js_1.kt.parameter((0, core_1.toCasing)(parameter.name, ctx.config.parameterNameCasing), this.getParameterType(ctx, { endpoint, parameter }), { default: this.getParameterDefaultValue(ctx, { endpoint, parameter }) })),
+            returnType: this.getTypeUsage(ctx, { schema: responseSchema, fallback: index_js_1.kt.refs.unit() }),
+            body: this.getEndpointFunctionBody(ctx, { endpoint, parameters, responseSchema }),
+        });
+    }
+    getEndpointFunctionBody(ctx, args) {
+        const { endpoint, parameters, responseSchema } = args;
+        const result = (0, core_1.appendValueGroup)([], '\n');
+        const requestFunctionName = this.getEndpointRequestFunctionName(ctx, { endpoint });
+        const parameterNames = parameters.map((p) => (0, core_1.toCasing)(p.name, ctx.config.parameterNameCasing));
+        const call = index_js_1.kt.call([
+            'this',
+            index_js_1.kt.call(requestFunctionName, parameterNames),
+            index_js_1.kt.call('retrieve', []),
+            responseSchema
+                ? index_js_1.kt.call(index_js_1.kt.refs.springReactive.awaitBody([
+                    this.getTypeUsage(ctx, { schema: responseSchema, fallback: index_js_1.kt.refs.unit() }),
+                ]), [])
+                : index_js_1.kt.call(index_js_1.kt.refs.springReactive.awaitBodilessEntity(), []),
+        ]);
+        if (responseSchema) {
+            result.values.push((0, core_1.builderTemplate) `return ${call}`);
+        }
+        else {
+            result.values.push(call);
+        }
+        return result;
+    }
+    getEndpointFunctionWithHandler(ctx, args) {
+        const { endpoint, parameters, responseSchema } = args;
+        const functionName = this.getEndpointFunctionName(ctx, { endpoint });
+        return index_js_1.kt.function(functionName, {
+            doc: index_js_1.kt.doc(endpoint.description),
+            suspend: true,
+            generics: [index_js_1.kt.genericParameter('T')],
+            receiverType: index_js_1.kt.refs.springReactive.webClient(),
+            parameters: [
+                ...parameters.map((parameter) => index_js_1.kt.parameter((0, core_1.toCasing)(parameter.name, ctx.config.parameterNameCasing), this.getParameterType(ctx, { endpoint, parameter }), { default: this.getParameterDefaultValue(ctx, { endpoint, parameter }) })),
+                index_js_1.kt.parameter('responseHandler', index_js_1.kt.lambdaType([index_js_1.kt.refs.springReactive.clientResponse()], 'T', { suspend: true })),
+            ],
+            returnType: 'T',
+            body: this.getEndpointFunctionWithHandlerBody(ctx, { endpoint, parameters, responseSchema }),
+        });
+    }
+    getEndpointFunctionWithHandlerBody(ctx, args) {
+        const { endpoint, parameters } = args;
+        const result = (0, core_1.appendValueGroup)([], '\n');
+        const requestFunctionName = this.getEndpointRequestFunctionName(ctx, { endpoint });
+        const parameterNames = parameters.map((p) => (0, core_1.toCasing)(p.name, ctx.config.parameterNameCasing));
+        result.values.push((0, core_1.builderTemplate) `return ${index_js_1.kt.call([
+            index_js_1.kt.call(['this', requestFunctionName], parameterNames),
+            index_js_1.kt.call(['exchangeToMono'], [
+                index_js_1.kt.lambda([], index_js_1.kt.call(index_js_1.kt.refs.kotlinx.mono.infer(), [index_js_1.kt.lambda([], 'responseHandler(it)', { singleline: true })]), { singleline: true }),
+            ]),
+            index_js_1.kt.call([index_js_1.kt.refs.kotlinx.awaitFirstOrNull.infer()], []),
+        ])} as T`);
+        return result;
+    }
+    getEndpointRequestFunctionName(ctx, args) {
+        const { endpoint } = args;
+        return (0, core_1.toCasing)(`${this.getEndpointFunctionName(ctx, { endpoint })}_request`, ctx.config.functionNameCasing);
+    }
+    getEndpointRequestFunction(ctx, args) {
+        const { endpoint, parameters, responseSchema } = args;
+        const functionName = this.getEndpointRequestFunctionName(ctx, { endpoint });
+        return index_js_1.kt.function(functionName, {
+            doc: index_js_1.kt.doc(endpoint.description),
+            receiverType: index_js_1.kt.refs.springReactive.webClient(),
+            parameters: parameters.map((parameter) => index_js_1.kt.parameter((0, core_1.toCasing)(parameter.name, ctx.config.parameterNameCasing), this.getParameterType(ctx, { endpoint, parameter }), { default: this.getParameterDefaultValue(ctx, { endpoint, parameter }) })),
+            returnType: index_js_1.kt.refs.springReactive.requestHeadersSpec(['*']),
+            body: this.getEndpointRequestFunctionBody(ctx, { endpoint, parameters, responseSchema }),
+        });
+    }
+    getEndpointRequestFunctionBody(ctx, args) {
+        var _a, _b;
+        const { endpoint, parameters, responseSchema } = args;
+        const result = (0, core_1.appendValueGroup)([], '\n');
+        const callChain = [];
+        callChain.push((0, core_1.builderTemplate) `return this.method(${index_js_1.kt.refs.spring.httpMethod()}.${endpoint.method.toUpperCase()})`, index_js_1.kt.call('uri', [index_js_1.kt.call([this.getEndpointUriFunctionName(ctx, { endpoint })], parameters.filter((p) => p.target === 'path' || p.target === 'query').map((p) => (0, core_1.toCasing)(p.name, ctx.config.parameterNameCasing)))]));
+        if (responseSchema) {
+            callChain.push((0, core_1.builderTemplate) `accept(${index_js_1.kt.refs.spring.mediaType()}.APPLICATION_JSON)`);
+        }
+        if (((_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0]) !== undefined) {
+            callChain.push((0, core_1.builderTemplate) `contentType(${index_js_1.kt.refs.spring.mediaType()}.parseMediaType(${index_js_1.kt.string(endpoint.requestBody.content[0].type)}))`);
+        }
+        if ((_b = endpoint.requestBody) === null || _b === void 0 ? void 0 : _b.content[0]) {
+            if (endpoint.requestBody.content[0].type === 'multipart/form-data') {
+                callChain.push(index_js_1.kt.call('body', [
+                    index_js_1.kt.call([index_js_1.kt.refs.springReactive.bodyInserters(), 'fromMultipartData'], [
+                        index_js_1.kt.call([
+                            index_js_1.kt.call(index_js_1.kt.refs.spring.multipartBodyBuilder(), []),
+                            index_js_1.kt.call('apply', [
+                                index_js_1.kt.lambda([], (0, core_1.appendValueGroup)(parameters.filter((x) => x.multipart).map((p) => {
+                                    var _a, _b, _c;
+                                    const parameterName = (0, core_1.toCasing)(p.name, ctx.config.parameterNameCasing);
+                                    if ((_a = p.multipart) === null || _a === void 0 ? void 0 : _a.isFile) {
+                                        return index_js_1.kt.call([
+                                            p.required && !((_b = p.schema) === null || _b === void 0 ? void 0 : _b.nullable) ? parameterName : `${parameterName}?`,
+                                            'addToBuilder',
+                                        ], ['this']);
+                                    }
+                                    else {
+                                        const call = index_js_1.kt.call([
+                                            index_js_1.kt.call('part', [index_js_1.kt.string(p.multipart.name), parameterName]),
+                                            index_js_1.kt.call('contentType', [
+                                                index_js_1.kt.call([
+                                                    index_js_1.kt.refs.spring.mediaType(),
+                                                    'APPLICATION_JSON',
+                                                ]),
+                                            ]),
+                                        ]);
+                                        return p.required && !((_c = p.schema) === null || _c === void 0 ? void 0 : _c.nullable) ? call : index_js_1.kt.call([`${parameterName}?`, 'also'], [
+                                            index_js_1.kt.lambda([parameterName], call, { singleline: true }),
+                                        ]);
+                                    }
+                                }), '\n')),
+                            ]),
+                            'build',
+                        ], []),
+                    ]),
+                ]));
+            }
+            else {
+                const bodySchema = endpoint.requestBody.content[0].schema;
+                const parameterName = this.getRequestBodyParamName(ctx, { endpoint });
+                const call = index_js_1.kt.call('bodyValue', [
+                    (0, core_1.toCasing)(parameterName, ctx.config.parameterNameCasing),
+                ]);
+                callChain.push(endpoint.requestBody.required && !(bodySchema === null || bodySchema === void 0 ? void 0 : bodySchema.nullable) ? call : index_js_1.kt.call('apply', [
+                    index_js_1.kt.lambda([], index_js_1.kt.call([`${parameterName}?`, 'also'], [index_js_1.kt.lambda([parameterName], call, { singleline: true })]), { singleline: true }),
+                ]));
+            }
+        }
+        if (parameters.some((x) => x.target === 'header')) {
+            callChain.push(index_js_1.kt.call('headers', [
+                index_js_1.kt.lambda(['headers'], (0, core_1.appendValueGroup)(parameters.filter((x) => x.target === 'header').map((p) => {
+                    var _a;
+                    const parameterName = (0, core_1.toCasing)(p.name, ctx.config.parameterNameCasing);
+                    const toString = this.getParameterToString(ctx, { endpoint, parameter: p });
+                    return p.required && !((_a = p.schema) === null || _a === void 0 ? void 0 : _a.nullable)
+                        ? index_js_1.kt.call(['headers', 'add'], [index_js_1.kt.string(p.name), parameterName + toString])
+                        : index_js_1.kt.call([`${parameterName}?`, 'also'], [
+                            index_js_1.kt.lambda([], index_js_1.kt.call(['headers', 'add'], [index_js_1.kt.string(p.name), 'it' + toString]), {
+                                singleline: true,
+                            }),
+                        ]);
+                }), '\n')),
+            ]));
+        }
+        result.values.push(index_js_1.kt.call(callChain));
+        return result;
+    }
+    getEndpointUriFunctionName(ctx, args) {
+        const { endpoint } = args;
+        return (0, core_1.toCasing)(`${this.getEndpointFunctionName(ctx, { endpoint })}_uri`, ctx.config.functionNameCasing);
+    }
+    getEndpointUriFunction(ctx, args) {
+        const { endpoint, parameters } = args;
+        const functionName = this.getEndpointUriFunctionName(ctx, { endpoint });
+        return index_js_1.kt.function(functionName, {
+            parameters: parameters.filter((p) => p.target === 'path' || p.target === 'query').map((parameter) => index_js_1.kt.parameter((0, core_1.toCasing)(parameter.name, ctx.config.parameterNameCasing), this.getParameterType(ctx, { endpoint, parameter }), { default: this.getParameterDefaultValue(ctx, { endpoint, parameter }) })),
+            returnType: index_js_1.kt.refs.string(),
+            body: this.getEndpointUriFunctionBody(ctx, { endpoint, parameters }),
+        });
+    }
+    getEndpointUriFunctionBody(ctx, args) {
+        const { endpoint } = args;
+        const result = (0, core_1.appendValueGroup)([], '\n');
+        const callChain = [];
+        callChain.push((0, core_1.builderTemplate) `${index_js_1.kt.refs.spring.uriComponentsBuilder()}.fromPath(${index_js_1.kt.string(this.getEndpointPath(ctx, { endpoint }))})`);
+        if (endpoint.parameters.some((x) => x.target === 'query')) {
+            callChain.push(index_js_1.kt.call('apply', [index_js_1.kt.lambda([], (0, core_1.appendValueGroup)(endpoint.parameters.filter((x) => x.target === 'query').map((p) => {
+                    var _a;
+                    const parameterName = (0, core_1.toCasing)(p.name, ctx.config.parameterNameCasing);
+                    const toString = this.getParameterToString(ctx, { endpoint, parameter: p });
+                    return p.required && !((_a = p.schema) === null || _a === void 0 ? void 0 : _a.nullable)
+                        ? index_js_1.kt.call('queryParam', [index_js_1.kt.string(p.name), parameterName + toString])
+                        : index_js_1.kt.call([`${parameterName}?`, 'also'], [
+                            index_js_1.kt.lambda([], index_js_1.kt.call('queryParam', [index_js_1.kt.string(p.name), 'it' + toString]), { singleline: true }),
+                        ]);
+                }), '\n'))]));
+        }
+        if (endpoint.parameters.some((x) => x.target === 'path')) {
+            callChain.push(index_js_1.kt.call('buildAndExpand', [
+                index_js_1.kt.call([index_js_1.kt.refs.mapOf.infer()], endpoint.parameters.filter((p) => p.target === 'path').map((p) => (0, core_1.builderTemplate) `${index_js_1.kt.string(p.name)} to ${(0, core_1.toCasing)(p.name, ctx.config.parameterNameCasing)}${this.getParameterToString(ctx, { endpoint, parameter: p })}`)),
+            ]));
+        }
+        else {
+            callChain.push(index_js_1.kt.call('build', []));
+        }
+        callChain.push('toUriString');
+        result.values.push((0, core_1.builderTemplate) `return ${index_js_1.kt.call(callChain, [])}`);
+        return result;
+    }
+    getParameterToString(ctx, args) {
+        var _a, _b, _c;
+        const { parameter } = args;
+        if (((_a = parameter.schema) === null || _a === void 0 ? void 0 : _a.kind) === 'array') {
+            return '.joinToString()';
+        }
+        else if (((_b = parameter.schema) === null || _b === void 0 ? void 0 : _b.kind) === 'string' && ((_c = parameter.schema.enum) === null || _c === void 0 ? void 0 : _c.length) &&
+            this.getSchemaType(ctx, { schema: parameter.schema })) {
+            return '.value';
+        }
+        else {
+            return '.toString()';
+        }
+    }
+    getParameterType(ctx, args) {
+        var _a;
+        const { parameter } = args;
+        if ((_a = parameter.multipart) === null || _a === void 0 ? void 0 : _a.isFile) {
+            return ctx.refs.apiRequestFile();
+        }
+        return this.getTypeUsage(ctx, {
+            schema: parameter.schema,
+            nullable: !parameter.required,
+        });
+    }
+    getParameterDefaultValue(ctx, args) {
+        var _a, _b;
+        const { parameter } = args;
+        return !parameter.required
+            ? ((_a = parameter.schema) === null || _a === void 0 ? void 0 : _a.kind) === 'string' && parameter.schema.enum && parameter.schema.default
+                ? (0, core_1.builderTemplate) `${this.getTypeUsage(ctx, { schema: parameter.schema, nullable: false })}.${(0, core_1.toCasing)(String(parameter.schema.default), ctx.config.enumValueNameCasing)}`
+                : index_js_1.kt.toNode((_b = parameter.schema) === null || _b === void 0 ? void 0 : _b.default)
+            : null;
+    }
+    getTypeUsage(ctx, args) {
+        const { schema, nullable, fallback } = args;
+        const type = this.getSchemaType(ctx, { schema });
+        return type
+            ? (0, core_1.createOverwriteProxy)(type, { nullable: nullable !== null && nullable !== void 0 ? nullable : type.nullable })
+            : (fallback !== null && fallback !== void 0 ? fallback : index_js_1.kt.refs.any({ nullable }));
+    }
+    // deno-lint-ignore no-unused-vars
+    getPackageName(ctx, args) {
+        const packageSuffix = typeof ctx.config.packageSuffix === 'string'
+            ? ctx.config.packageSuffix
+            : ctx.config.packageSuffix(ctx.service);
+        return ctx.config.packageName + packageSuffix;
+    }
+    getResponseSchema(_ctx, args) {
+        var _a, _b;
+        const { endpoint } = args;
+        return (_b = (_a = endpoint.responses.find((x) => !x.statusCode || (x.statusCode >= 200 && x.statusCode < 300))) === null || _a === void 0 ? void 0 : _a.contentOptions[0]) === null || _b === void 0 ? void 0 : _b.schema;
+    }
+    getSchemaType(ctx, args) {
+        const { schema } = args;
+        return schema && ctx.input.kotlin.models[schema.id].type;
+    }
+    getAllParameters(ctx, args) {
+        var _a, _b;
+        const { endpoint } = args;
+        const parameters = endpoint.parameters.filter((parameter) => parameter.target === 'query' || parameter.target === 'path' || parameter.target === 'header');
+        if (endpoint.requestBody) {
+            const content = endpoint.requestBody.content[0];
+            let schema = content.schema;
+            if (content.type === 'multipart/form-data') {
+                if (schema && schema.kind === 'object') {
+                    schema = (_a = (0, core_1.resolveAnyOfAndAllOf)(schema, true)) !== null && _a !== void 0 ? _a : schema;
+                    const properties = (_b = schema.properties) !== null && _b !== void 0 ? _b : {};
+                    for (const [name, property] of properties.entries()) {
+                        parameters.push(Object.assign(this.createApiParameter({
+                            id: `multipart-${name}`,
+                            name,
+                            target: 'body',
+                            schema: property.schema,
+                            required: schema.required.has(name),
+                            description: property.schema.description,
+                        }), {
+                            multipart: {
+                                name,
+                                isFile: property.schema.kind === 'string' && property.schema.format === 'binary',
+                            },
+                        }));
+                    }
+                }
+            }
+            else {
+                parameters.push(this.createApiParameter({
+                    id: 'body',
+                    name: this.getRequestBodyParamName(ctx, { endpoint }),
+                    target: 'body',
+                    schema,
+                    required: endpoint.requestBody.required,
+                    description: endpoint.requestBody.description,
+                }));
+            }
+        }
+        return parameters.sort((a, b) => (a.required === b.required ? 0 : a.required ? -1 : 1));
+    }
+    getRequestBodyParamName(ctx, args) {
+        var _a;
+        const { endpoint } = args;
+        const schema = (_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0].schema;
+        const schemaInfo = this.getSchemaType(ctx, { schema });
+        return (0, core_1.toCasing)(schemaInfo && schemaInfo.name !== 'Any' ? core_1.SourceBuilder.build((b) => index_js_1.kt.reference.write(b, schemaInfo)) : 'body', ctx.config.parameterNameCasing);
+    }
+    getBasePath(ctx, _args) {
+        var _a, _b, _c, _d, _e, _f;
+        return (0, utils_js_1.modifyString)((_f = (_e = (_d = (_c = ((_a = ctx.service.$src) !== null && _a !== void 0 ? _a : (_b = ctx.service.endpoints[0]) === null || _b === void 0 ? void 0 : _b.$src)) === null || _c === void 0 ? void 0 : _c.document.servers) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.url) !== null && _f !== void 0 ? _f : '/', ctx.config.basePath, ctx.service);
+    }
+    getEndpointPath(ctx, args) {
+        const { endpoint } = args;
+        return (0, utils_js_1.modifyString)(endpoint.path.replace(/^\/*/, ''), ctx.config.pathModifier, endpoint);
+    }
+    getFilePath(ctx, args) {
+        const { packageName } = args;
+        return `${ctx.config.outputDir}/${packageName.replace(/\./g, '/')}/${this.getRequestsObjectName(ctx, {})}.kt`;
+    }
+    // deno-lint-ignore no-unused-vars
+    getRequestsObjectName(ctx, args) {
+        return (0, core_1.toCasing)(`${ctx.service.name}_Requests`, ctx.config.typeNameCasing);
+    }
+    createApiParameter(data) {
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            $src: undefined,
+            $ref: undefined,
+            schema: undefined,
+            required: false,
+            description: undefined,
+            allowEmptyValue: undefined,
+            allowReserved: undefined,
+            deprecated: false,
+            explode: undefined,
+            style: undefined,
+            ...data,
+        };
+    }
+}
+exports.DefaultKotlinSpringReactiveWebClientGenerator = DefaultKotlinSpringReactiveWebClientGenerator;

package/script/src/generators/services/spring-reactive-web-clients/spring-reactive-web-clients-generator.d.ts

@@ -0,0 +1,23 @@
+import { type ApiService, Factory, type MaybePromise, type OpenApiGeneratorContext, OpenApiServicesGenerationProviderBase } from '@goast/core';
+import type { KotlinServicesGeneratorInput } from '../spring-controllers/index.js';
+import { type KotlinSpringReactiveWebClientGeneratorOutput, type KotlinSpringReactiveWebClientsGeneratorConfig, type KotlinSpringReactiveWebClientsGeneratorContext, type KotlinSpringReactiveWebClientsGeneratorInput, type KotlinSpringReactiveWebClientsGeneratorOutput } from './models.js';
+import { type KotlinSpringReactiveWebClientGenerator } from './spring-reactive-web-client-generator.js';
+type Input = KotlinSpringReactiveWebClientsGeneratorInput;
+type Output = KotlinSpringReactiveWebClientsGeneratorOutput;
+type Config = KotlinSpringReactiveWebClientsGeneratorConfig;
+type ServiceOutput = KotlinSpringReactiveWebClientGeneratorOutput;
+type Context = KotlinSpringReactiveWebClientsGeneratorContext;
+export declare class KotlinSpringReactiveWebClientsGenerator extends OpenApiServicesGenerationProviderBase<Input, Output, Config, ServiceOutput, Context> {
+    private readonly _serviceGeneratorFactory;
+    constructor(serviceGeneratorFactory?: Factory<KotlinSpringReactiveWebClientGenerator, []>);
+    protected generateAdditionalFiles(ctx: Context): Promise<void>;
+    protected initResult(): Output;
+    protected generateService(ctx: Context, service: ApiService): MaybePromise<ServiceOutput>;
+    protected addServiceResult(ctx: Context, service: ApiService, result: ServiceOutput): void;
+    protected buildContext(context: OpenApiGeneratorContext<KotlinServicesGeneratorInput>, config?: Partial<Config> | undefined): Context;
+    protected getInfrastructurePackageName(config: Config): string;
+    protected getPackageName(config: Config): string;
+    private copyInfrastructureFiles;
+}
+export {};
+//# sourceMappingURL=spring-reactive-web-clients-generator.d.ts.map

package/script/src/generators/services/spring-reactive-web-clients/spring-reactive-web-clients-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring-reactive-web-clients-generator.d.ts","sourceRoot":"","sources":["../../../../../src/src/generators/services/spring-reactive-web-clients/spring-reactive-web-clients-generator.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,UAAU,EACf,OAAO,EACP,KAAK,YAAY,EACjB,KAAK,uBAAuB,EAC5B,qCAAqC,EACtC,MAAM,aAAa,CAAC;AAGrB,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AACnF,OAAO,EAEL,KAAK,4CAA4C,EACjD,KAAK,6CAA6C,EAClD,KAAK,8CAA8C,EACnD,KAAK,4CAA4C,EACjD,KAAK,6CAA6C,EACnD,MAAM,aAAa,CAAC;AAErB,OAAO,EAEL,KAAK,sCAAsC,EAC5C,MAAM,2CAA2C,CAAC;AAEnD,KAAK,KAAK,GAAG,4CAA4C,CAAC;AAC1D,KAAK,MAAM,GAAG,6CAA6C,CAAC;AAC5D,KAAK,MAAM,GAAG,6CAA6C,CAAC;AAC5D,KAAK,aAAa,GAAG,4CAA4C,CAAC;AAClE,KAAK,OAAO,GAAG,8CAA8C,CAAC;AAE9D,qBAAa,uCAAwC,SAAQ,qCAAqC,CAChG,KAAK,EACL,MAAM,EACN,MAAM,EACN,aAAa,EACb,OAAO,CACR;IACC,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAsD;gBAEnF,uBAAuB,CAAC,EAAE,OAAO,CAAC,sCAAsC,EAAE,EAAE,CAAC;cAMhE,uBAAuB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAI7E,SAAS,CAAC,UAAU,IAAI,MAAM;IAQ9B,SAAS,CAAC,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,GAAG,YAAY,CAAC,aAAa,CAAC;IAQzF,SAAS,CAAC,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa,GAAG,IAAI;IAI1F,SAAS,CAAC,YAAY,CACpB,OAAO,EAAE,uBAAuB,CAAC,4BAA4B,CAAC,EAC9D,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,SAAS,GACnC,OAAO;IAcV,SAAS,CAAC,4BAA4B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAc9D,SAAS,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;YAKlC,uBAAuB;CAiBtC"}

package/script/src/generators/services/spring-reactive-web-clients/spring-reactive-web-clients-generator.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KotlinSpringReactiveWebClientsGenerator = void 0;
+const tslib_1 = require("tslib");
+const node_path_1 = require("node:path");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const core_1 = require("@goast/core");
+const assets_js_1 = require("../../../assets.js");
+const models_js_1 = require("./models.js");
+const refs_js_1 = require("./refs.js");
+const spring_reactive_web_client_generator_js_1 = require("./spring-reactive-web-client-generator.js");
+class KotlinSpringReactiveWebClientsGenerator extends core_1.OpenApiServicesGenerationProviderBase {
+    constructor(serviceGeneratorFactory) {
+        super();
+        Object.defineProperty(this, "_serviceGeneratorFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._serviceGeneratorFactory = serviceGeneratorFactory !== null && serviceGeneratorFactory !== void 0 ? serviceGeneratorFactory : core_1.Factory.fromValue(new spring_reactive_web_client_generator_js_1.DefaultKotlinSpringReactiveWebClientGenerator());
+    }
+    async generateAdditionalFiles(ctx) {
+        await this.copyInfrastructureFiles(ctx);
+    }
+    initResult() {
+        return {
+            kotlin: {
+                clients: {},
+            },
+        };
+    }
+    generateService(ctx, service) {
+        const serviceGenerator = this._serviceGeneratorFactory.create();
+        return serviceGenerator.generate({
+            ...ctx,
+            service,
+        });
+    }
+    addServiceResult(ctx, service, result) {
+        ctx.output.kotlin.clients[service.id] = result;
+    }
+    buildContext(context, config) {
+        context.data.services = context.data.services.filter((x) => x.name !== 'exclude-from-generation');
+        const providerContext = this.getProviderContext(context, config, models_js_1.defaultKotlinSpringReactiveWebClientsGeneratorConfig);
+        const infrastructurePackageName = this.getInfrastructurePackageName(providerContext.config);
+        return Object.assign(providerContext, {
+            infrastructurePackageName,
+            refs: (0, refs_js_1.getReferenceFactories)(infrastructurePackageName),
+        });
+    }
+    getInfrastructurePackageName(config) {
+        if (typeof config.infrastructurePackageName === 'string') {
+            return config.infrastructurePackageName;
+        }
+        if (config.infrastructurePackageName.mode === 'append-package-name') {
+            return config.packageName + config.infrastructurePackageName.value;
+        }
+        if (config.infrastructurePackageName.mode === 'append-full-package-name') {
+            return this.getPackageName(config) + config.infrastructurePackageName.value;
+        }
+        return config.infrastructurePackageName.value;
+    }
+    getPackageName(config) {
+        const packageSuffix = typeof config.packageSuffix === 'string' ? config.packageSuffix : config.packageSuffix();
+        return config.packageName + packageSuffix;
+    }
+    async copyInfrastructureFiles(ctx) {
+        const targetDir = (0, node_path_1.resolve)(ctx.config.outputDir, ctx.infrastructurePackageName.replace(/\./g, '/'));
+        await fs_extra_1.default.ensureDir(targetDir);
+        const files = [
+            'ApiRequestFile.kt',
+        ];
+        for (const file of files) {
+            const sourcePath = `client/spring-reactive-web-clients/${file}`;
+            const targetPath = (0, node_path_1.resolve)(targetDir, file);
+            console.log(`Copying asset file "${sourcePath}" to "${targetPath}"`);
+            const fileContent = (await (0, assets_js_1.getAssetFileContent)(sourcePath))
+                .replace(/@PACKAGE_NAME@/g, ctx.infrastructurePackageName);
+            fs_extra_1.default.writeFileSync(targetPath, fileContent);
+        }
+    }
+}
+exports.KotlinSpringReactiveWebClientsGenerator = KotlinSpringReactiveWebClientsGenerator;

package/src/src/ast/nodes/call.ts

@@ -46,7 +46,16 @@ export class KtCall<TBuilder extends SourceBuilder, TInjects extends string = ne
       builder.append(' ');
       writeKtNode(builder, this.arguments[0]);
     } else {
-      writeKtNodes(builder, this.path, { separator: '.' });
+      if (this.path.length > 2) {
+        writeKtNode(builder, this.path[0]);
+        builder.ensureCurrentLineEmpty();
+        builder.indent((builder) => {
+          builder.append('.');
+          writeKtNodes(builder, this.path.slice(1), { separator: '\n.' });
+        });
+      } else {
+        writeKtNodes(builder, this.path, { separator: '.' });
+      }
 
       if (this.arguments) {
         ktArgument.write(builder, this.arguments);

package/src/src/ast/nodes/lambda-type.ts

@@ -13,6 +13,7 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     extensionFor?: Nullable<KtType<TBuilder>>;
     parameters?: Nullable<Nullable<KtType<TBuilder>>[]>;
     returnType: KtType<TBuilder>;
+    suspend?: boolean;
   }
 >;
 
@@ -23,15 +24,21 @@ export class KtLambdaType<TBuilder extends SourceBuilder, TInjects extends strin
   public extensionFor: KtType<TBuilder> | null;
   public parameters: KtType<TBuilder>[];
   public returnType: KtType<TBuilder>;
+  public suspend: boolean;
 
   constructor(options: Options<TBuilder, TInjects>) {
     super(options);
     this.extensionFor = options.extensionFor ?? null;
     this.parameters = options.parameters?.filter(notNullish) ?? [];
     this.returnType = options.returnType;
+    this.suspend = options.suspend ?? false;
   }
 
   protected override onWrite(builder: TBuilder): void {
+    if (this.suspend) {
+      builder.append('suspend ');
+    }
+
     if (this.extensionFor) {
       builder.append(this.inject.beforeExtensionFor);
       writeKtNode(builder, this.extensionFor);
@@ -42,8 +49,6 @@ export class KtLambdaType<TBuilder extends SourceBuilder, TInjects extends strin
     builder.append(this.inject.beforeParams);
     if (this.parameters.length === 0) {
       builder.append('()');
-    } else if (this.parameters.length === 1 && !this.extensionFor) {
-      writeKtNode(builder, this.parameters[0]);
     } else {
       ktParameter.write(builder, this.parameters);
     }

package/src/src/ast/nodes/lambda.ts

@@ -41,18 +41,24 @@ export class KtLambda<TBuilder extends SourceBuilder, TInjects extends string =
 
     builder.parenthesize('{}', (b) => {
       if (this.arguments.length > 0) {
-        b.append(this.inject.beforeArguments);
+        b.append(' ', this.inject.beforeArguments);
         writeKtNodes(b, this.arguments, { separator: ', ' });
         b.append(this.inject.afterArguments);
 
-        b.append(' -> ');
+        b.append(' ->');
       }
 
-      if (!singleline) b.appendLine();
+      b.append(singleline ? ' ' : '\n');
 
       b.append(this.inject.beforeBody, this.body, this.inject.afterBody);
 
-      if (!singleline) b.ensureCurrentLineEmpty();
+      if (singleline) {
+        if (!b.isCurrentLineEmpty) {
+          b.append(' ');
+        }
+      } else {
+        b.ensureCurrentLineEmpty();
+      }
     });
   }
 }

package/src/src/ast/references/index.ts

@@ -2,7 +2,9 @@ export * as jackson from './jackson.js';
 export * as jakarta from './jakarta.js';
 export * as java from './java.js';
 export * from './kotlin.js';
+export * as kotlinx from './kotlinx.js';
 export * as okhttp3 from './okhttp3.js';
 export * as reactor from './reactor.js';
+export * as springReactive from './spring-reactive.js';
 export * as spring from './spring.js';
 export * as swagger from './swagger.js';

package/src/src/ast/references/java.ts

@@ -11,6 +11,7 @@ export const unsupportedOperationException: KtReferenceFactory = ktReference.fac
   'UnsupportedOperationException',
   'java.lang',
 );
+export const void_: KtReferenceFactory = ktReference.factory('Void', 'java.lang');
 
 // java.time
 export const offsetDateTime: KtReferenceFactory = ktReference.factory('OffsetDateTime', 'java.time');

package/src/src/ast/references/kotlinx.ts

@@ -0,0 +1,14 @@
+import { type KtGenericReferenceFactory, ktReference } from '../nodes/reference.js';
+
+// kotlinx.coroutines.reactive
+export const awaitFirst: KtGenericReferenceFactory<1> = ktReference.genericFactory(
+  'awaitFirst',
+  'kotlinx.coroutines.reactive',
+);
+export const awaitFirstOrNull: KtGenericReferenceFactory<1> = ktReference.genericFactory(
+  'awaitFirstOrNull',
+  'kotlinx.coroutines.reactive',
+);
+
+// kotlinx.coroutines.reactor
+export const mono: KtGenericReferenceFactory<1> = ktReference.genericFactory('mono', 'kotlinx.coroutines.reactor');

package/src/src/ast/references/spring-reactive.ts

@@ -0,0 +1,33 @@
+import { type KtGenericReferenceFactory, ktReference, type KtReferenceFactory } from '../nodes/reference.js';
+
+// org.springframework.web.reactive.function
+export const bodyInserters: KtReferenceFactory = ktReference.factory(
+  'BodyInserters',
+  'org.springframework.web.reactive.function',
+);
+
+// org.springframework.web.reactive.function.client
+export const webClient: KtReferenceFactory = ktReference.factory(
+  'WebClient',
+  'org.springframework.web.reactive.function.client',
+);
+export const clientResponse: KtReferenceFactory = ktReference.factory(
+  'ClientResponse',
+  'org.springframework.web.reactive.function.client',
+);
+export const requestHeadersSpec: KtGenericReferenceFactory<1> = ktReference.genericFactory(
+  'RequestHeadersSpec',
+  'org.springframework.web.reactive.function.client.WebClient',
+);
+export const toEntity: KtGenericReferenceFactory<1> = ktReference.genericFactory(
+  'toEntity',
+  'org.springframework.web.reactive.function.client',
+);
+export const awaitBody: KtGenericReferenceFactory<1> = ktReference.genericFactory(
+  'awaitBody',
+  'org.springframework.web.reactive.function.client',
+);
+export const awaitBodilessEntity: KtReferenceFactory = ktReference.factory(
+  'awaitBodilessEntity',
+  'org.springframework.web.reactive.function.client',
+);