@goast/typescript 0.0.5 → 0.2.0

package/esm/lib/generators/services/angular-services/angular-service-generator.js

@@ -1,356 +1,233 @@
-import { writeFileSync } from 'fs';
-import { dirname, resolve } from 'path';
-import { ensureDirSync } from 'fs-extra';
-import { toCasing } from '@goast/core';
-import { TypeScriptFileBuilder, } from '../../../file-builder';
+import { resolve } from 'path';
+import { appendValueGroup, builderTemplate as s, toCasing, } from '@goast/core';
+import { ts } from '../../../ast';
+import { TypeScriptFileBuilder } from '../../../file-builder';
 import { TypeScriptFileGenerator } from '../../file-generator';
 export class DefaultTypeScriptAngularServiceGenerator extends TypeScriptFileGenerator {
-    constructor() {
-        super(...arguments);
-        this.httpClientType = {
-            name: 'HttpClient',
-            module: '@angular/common/http',
-        };
-        this.httpContextType = {
-            name: 'HttpContext',
-            module: '@angular/common/http',
-        };
-        this.httpResponseType = {
-            name: 'HttpResponse',
-            module: '@angular/common/http',
-        };
-        this.observableType = {
-            name: 'Observable',
-            module: 'rxjs',
-        };
-        this.rxjsFilterType = {
-            name: 'filter',
-            module: 'rxjs',
-        };
-        this.rxjsMapType = {
-            name: 'map',
-            module: 'rxjs',
-        };
-    }
-    getApiConfigurationType(ctx) {
-        return { name: 'ApiConfiguration', module: resolve(this.getUtilsDirPath(ctx), 'api-configuration.ts') };
-    }
-    getBaseServiceType(ctx) {
-        return { name: 'BaseService', module: resolve(this.getUtilsDirPath(ctx), 'base-service.ts') };
-    }
-    getStrictHttpResponseType(ctx) {
-        return { name: 'StrictHttpResponse', module: resolve(this.getUtilsDirPath(ctx), 'strict-http-response.ts') };
-    }
-    getRequestBuilderType(ctx) {
-        return { name: 'RequestBuilder', module: resolve(this.getUtilsDirPath(ctx), 'request-builder.ts') };
-    }
     generate(ctx) {
+        const responseModels = this.generateResponseModels(ctx);
         const filePath = this.getServiceFilePath(ctx);
         const name = this.getServiceClassName(ctx);
-        console.log(`Generating service ${name} in ${filePath}...`);
-        ensureDirSync(dirname(filePath));
-        const serviceBuilder = new TypeScriptFileBuilder(filePath, ctx.config);
-        this.generateServiceFileContent(ctx, serviceBuilder);
-        writeFileSync(filePath, serviceBuilder.toString());
+        TypeScriptFileBuilder.generate({
+            logName: `service ${name}`,
+            filePath,
+            options: ctx.config,
+            generator: (b) => b.append(this.getServiceFileContent(ctx)),
+        });
         return {
             filePath,
             component: name,
-            responseModels: {},
-            imports: [{ kind: 'file', name, modulePath: filePath }],
+            responseModels,
         };
     }
-    generateServiceFileContent(ctx, builder) {
-        builder
-            .append((builder) => builder.forEach(ctx.service.endpoints, (builder, endpoint) => this.generateEndpointParamsType(ctx, builder, endpoint), { separator: '\n' }))
-            .ensurePreviousLineEmpty()
-            .append((builder) => this.generateClass(ctx, builder));
-    }
-    // protected generateResponseModels(ctx: Context): Output['responseModels'] {
-    //   const filePath = this.get;
-    //   const builder = new TypeScriptFileBuilder();
-    // }
-    //protected generateResponseModelsFileContent(ctx: Context, builder: Builder) {}
-    generateEndpointParamsType(ctx, builder, endpoint) {
-        if (!this.hasEndpointParams(ctx, endpoint)) {
-            return;
+    // #region Response Model
+    generateResponseModels(ctx) {
+        const result = {};
+        const filePath = this.getResponseModelFilePath(ctx);
+        const builder = new TypeScriptFileBuilder(filePath, ctx.config);
+        for (const endpoint of ctx.service.endpoints) {
+            const name = this.getResponseModelName(ctx, endpoint);
+            builder.appendLine(this.getResponseModelFileContent(ctx, endpoint));
+            result[endpoint.id] = { component: name, filePath };
+        }
+        builder.writeToFile();
+        return result;
+    }
+    getResponseModelFileContent(ctx, endpoint) {
+        const result = appendValueGroup([]);
+        const statusCodes = this.getEndpointStatusCodes(ctx, endpoint);
+        let statusCodeType;
+        const statusCodesTypeName = toCasing(`${endpoint.name}_StatusCodes`, ctx.config.typeNameCasing);
+        result.values.push(ts.typeAlias(statusCodesTypeName, ts.unionType(Object.keys(statusCodes))));
+        if (ctx.config.strictResponseTypes) {
+            statusCodeType = ts.reference(statusCodesTypeName);
+        }
+        else {
+            statusCodeType = ctx.refs.httpStatusCode();
         }
-        const params = [];
+        result.values.push(ts.typeAlias(this.getResponseModelName(ctx, endpoint), ts.intersectionType([
+            ts.unionType([
+                ...Object.entries(statusCodes).map(([key, value]) => ts.intersectionType([
+                    ts.refs.angular.httpResponse([value]),
+                    ts.objectType({ members: [ts.property('status', { type: key })] }),
+                ])),
+                !ctx.config.strictResponseTypes
+                    ? ts.intersectionType([
+                        ts.refs.angular.httpResponse([this.getAnyType(ctx)]),
+                        ts.objectType({
+                            members: [
+                                ts.property('status', {
+                                    type: ts.refs.exclude([ctx.refs.httpStatusCode(), ts.reference(statusCodesTypeName)]),
+                                }),
+                            ],
+                        }),
+                    ])
+                    : null,
+            ]),
+            ts.objectType({ members: [ts.property('status', { type: 'TStatus' })] }),
+        ]), {
+            export: true,
+            generics: [
+                ts.genericParameter('TStatus', {
+                    constraint: statusCodeType,
+                    default: statusCodeType,
+                }),
+            ],
+        }));
+        return result;
+    }
+    getEndpointStatusCodes(ctx, endpoint) {
+        return Object.fromEntries([
+            ...Object.entries(ctx.config.defaultStatusCodeResponseTypes).map(([key, value]) => [
+                key,
+                typeof value === 'function' ? this.getSchemaType(ctx, value(ctx.data.schemas)) : value,
+            ]),
+            ...endpoint.responses
+                .filter((x) => x.statusCode)
+                .map((x) => { var _a; return [x.statusCode, this.getSchemaType(ctx, (_a = x.contentOptions[0]) === null || _a === void 0 ? void 0 : _a.schema, ts.refs.never())]; }),
+        ]);
+    }
+    // #endregion
+    getServiceFileContent(ctx) {
+        const code = appendValueGroup([], '\n');
+        for (const endpoint of ctx.service.endpoints) {
+            if (endpoint.parameters.length > 0 || endpoint.requestBody !== undefined) {
+                code.values.push(this.getEndpointParamsType(ctx, endpoint));
+            }
+        }
+        code.values.push(this.getClass(ctx));
+        return code;
+    }
+    getEndpointParamsType(ctx, endpoint) {
+        const type = ts.objectType();
         for (const parameter of endpoint.parameters) {
             const schema = parameter.schema;
-            params.push((builder) => builder.appendProperty({
-                name: this.toPropertyName(ctx, parameter.name),
-                documentation: parameter.description,
-                type: schema ? (builder) => builder.appendModelUsage(ctx.input.models[schema.id]) : this.getAnyType(ctx),
-                isOptional: !parameter.required,
+            type.members.push(ts.property(toCasing(parameter.name, ctx.config.propertyNameCasing), {
+                doc: ts.doc({ description: parameter.description }),
+                type: schema ? (b) => b.appendModelUsage(ctx.input.models[schema.id]) : this.getAnyType(ctx),
+                optional: !parameter.required,
             }));
         }
         if (endpoint.requestBody !== undefined) {
             const body = endpoint.requestBody;
             const schema = body.content[0].schema;
-            params.push((builder) => builder.appendProperty({
-                name: 'body',
-                documentation: body.description,
-                type: schema ? (builder) => builder.appendModelUsage(ctx.input.models[schema.id]) : this.getAnyType(ctx),
-                isOptional: !body.required,
+            type.members.push(ts.property('body', {
+                doc: ts.doc({ description: body.description }),
+                type: schema ? (b) => b.appendModelUsage(ctx.input.models[schema.id]) : this.getAnyType(ctx),
+                optional: !body.required,
             }));
         }
-        builder.appendTypeDeclaration({
-            name: this.getEndpointParamsTypeName(ctx, endpoint),
-            documentation: `Parameters for operation ${this.getEndpointMethodName(ctx, endpoint)}`,
-            type: (builder) => builder.appendCodeBlock(...params),
+        return ts.typeAlias(this.getEndpointParamsTypeName(ctx, endpoint), type, {
+            doc: ts.doc({ description: `Parameters for operation ${this.getEndpointMethodName(ctx, endpoint)}` }),
         });
     }
-    generateClass(ctx, builder) {
-        builder.appendClass(this.getClassOptions(ctx));
-    }
-    generateClassContent(ctx, builder) {
-        builder
-            .append((builder) => this.generateConstructor(ctx, builder))
-            .forEach(ctx.service.endpoints, (builder, endpoint) => builder.ensurePreviousLineEmpty().append((builder) => this.generateEndpoint(ctx, builder, endpoint)));
-    }
-    generateConstructor(ctx, builder) {
-        builder.appendConstructor(this.getConstructorOptions(ctx));
-    }
-    generateConstructorContent(ctx, builder) {
-        builder.appendLine('super(config, http);');
-    }
-    generateEndpoint(ctx, builder, endpoint) {
-        builder
-            .append((builder) => this.generateEndpointPathProperty(ctx, builder, endpoint))
-            .ensurePreviousLineEmpty()
-            .append((builder) => this.generateEndpointResponseMethod(ctx, builder, endpoint))
-            .ensurePreviousLineEmpty()
-            .append((builder) => this.generateEndpointMethod(ctx, builder, endpoint));
-    }
-    generateEndpointPathProperty(ctx, builder, endpoint) {
-        builder.appendProperty(this.getEndpointPathPropertyOptions(ctx, endpoint));
-    }
-    generateEndpointResponseMethod(ctx, builder, endpoint) {
-        builder.appendMethod(this.getEndpointResponseMethodOptions(ctx, endpoint));
-    }
-    generateEndpointResponseMethodContent(ctx, builder, endpoint) {
-        var _a, _b;
-        builder
-            .append('const rb = new ')
-            .appendExternalTypeUsage(this.getRequestBuilderType(ctx))
-            .appendParameters('this.rootUrl', `${this.getServiceClassName(ctx)}.${this.getEndpointPathPropertyName(ctx, endpoint)}`, this.toStringLiteral(ctx, endpoint.method))
-            .appendLine(';');
-        if (this.hasEndpointParams(ctx, endpoint)) {
-            builder.append('if (params) ').appendCodeBlock((builder) => builder
-                .forEach(endpoint.parameters.filter((x) => x.target === 'path' || x.target === 'query' || x.target === 'header'), (builder, parameter) => builder
-                .append('rb.', parameter.target)
-                .appendParameters(this.toStringLiteral(ctx, parameter.name), `params.${toCasing(parameter.name, 'camel')}`, (builder) => builder.appendObjectLiteral(parameter.style !== undefined
-                ? `style: ${this.toStringLiteral(ctx, parameter.style)}`
-                : undefined, parameter.explode !== undefined ? `explode: ${parameter.explode ? 'true' : 'false'}` : undefined))
-                .appendLine(';'))
-                .if(endpoint.requestBody !== undefined, (builder) => {
-                var _a, _b, _c;
-                return builder
-                    .append('rb.body')
-                    .appendParameters('params.body', this.toStringLiteral(ctx, (_c = (_b = (_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0]) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : 'application/json'))
-                    .appendLine(';');
-            }));
-        }
-        const response = this.getEndpointSuccessResponse(ctx, endpoint);
-        const accept = (_b = (_a = response === null || response === void 0 ? void 0 : response.contentOptions[0]) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : '*/*';
-        const responseType = accept.includes('json') ? 'json' : 'text';
-        builder
-            .ensurePreviousLineEmpty()
-            .append('this.http.request')
-            .appendParameters((builder) => builder
-            .append('rb.build')
-            .appendParameters((builder) => builder.appendObjectLiteral(`responseType: ${this.toStringLiteral(ctx, responseType)}`, `accept: ${this.toStringLiteral(ctx, accept)}`, 'context: context')))
-            .append('.pipe')
-            .appendParameters((builder) => builder.appendExternalTypeUsage(this.rxjsFilterType).appendParameters((builder) => builder.appendFunction({
-            parameters: ['r: any'],
-            body: (builder) => builder.append('r instanceof ').appendExternalTypeUsage(this.httpResponseType),
-            singleLine: true,
-        })), (builder) => builder.appendExternalTypeUsage(this.rxjsMapType).appendParameters((builder) => {
-            var _a;
-            return builder.appendFunction({
-                parameters: [{ name: 'r', type: this.httpResponseType, genericArguments: ['any'] }],
-                body: ((_a = response === null || response === void 0 ? void 0 : response.contentOptions) === null || _a === void 0 ? void 0 : _a[0])
-                    ? (builder) => builder
-                        .append('r as ')
-                        .appendExternalTypeUsage(this.getStrictHttpResponseType(ctx))
-                        .appendGenericArguments((builder) => this.generateEndpointSuccessResponseSchema(ctx, builder, endpoint))
-                    : (builder) => builder
-                        .parenthesize('()', (builder) => builder
-                        .append('r as ')
-                        .appendExternalTypeUsage(this.httpResponseType)
-                        .appendGenericArguments('any'))
-                        .append('.clone')
-                        .appendParameters((builder) => builder.appendObjectLiteral('body: undefined'))
-                        .append(' as ')
-                        .appendExternalTypeUsage(this.getStrictHttpResponseType(ctx))
-                        .appendGenericArguments('void'),
-                singleLine: true,
-            });
-        }))
-            .appendLine(';');
-    }
-    generateEndpointMethod(ctx, builder, endpoint) {
-        builder.appendMethod(this.getEndpointMethodOptions(ctx, endpoint));
-    }
-    generateEndpointMethodContent(ctx, builder, endpoint) {
-        builder
-            .append('return this.', this.getEndpointResponseMethodName(ctx, endpoint))
-            .appendParameters(this.hasEndpointParams(ctx, endpoint) ? 'params' : undefined, 'context')
-            .append('.pipe')
-            .appendParameters((builder) => builder
-            .appendExternalTypeUsage(this.rxjsMapType)
-            .append('((r: ')
-            .appendExternalTypeUsage(this.getStrictHttpResponseType(ctx))
-            .appendGenericArguments((builder) => this.generateEndpointSuccessResponseSchema(ctx, builder, endpoint))
-            .append(') => r.body as ')
-            .append((builder) => this.generateEndpointSuccessResponseSchema(ctx, builder, endpoint))
-            .append(')'))
-            .appendLine(';');
-    }
-    getClassOptions(ctx) {
-        return {
-            name: this.getServiceClassName(ctx),
-            documentation: ctx.service.description,
-            annotations: [
-                {
-                    name: 'Injectable',
-                    module: '@angular/core',
-                    args: [(builder) => builder.appendObjectLiteral(`providedIn: ${this.toStringLiteral(ctx, 'root')}`)],
-                },
+    getClass(ctx) {
+        return ts.class(this.getServiceClassName(ctx), {
+            doc: ts.doc({ description: ctx.service.description }),
+            decorators: [ts.decorator(ts.refs.angular.injectable(), [ts.toNode({ providedIn: 'root' })])],
+            export: true,
+            extends: ctx.refs.apiBaseService(),
+            members: [
+                ...ctx.service.endpoints.map((e) => ts.property(this.getEndpointPathPropertyName(ctx, e), {
+                    accessModifier: 'private',
+                    static: true,
+                    readonly: true,
+                    value: ts.string(e.path),
+                })),
+                ...ctx.service.endpoints.map((e) => this.getEndpointMethod(ctx, e)),
             ],
-            extends: (builder) => builder.appendExternalTypeUsage(this.getBaseServiceType(ctx)),
-            body: (builder) => this.generateClassContent(ctx, builder),
-        };
+        });
     }
-    getConstructorOptions(ctx) {
-        return {
+    getEndpointMethod(ctx, endpoint) {
+        var _a, _b, _c, _d;
+        const hasParams = this.hasEndpointParams(ctx, endpoint);
+        const paramsOptional = !endpoint.parameters.some((p) => p.required) && !((_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.required);
+        const returnType = ts.refs.promise([
+            ts.reference(this.getResponseModelName(ctx, endpoint), this.getResponseModelFilePath(ctx)),
+        ]);
+        const accept = (_d = (_c = (_b = this.getEndpointSuccessResponse(ctx, endpoint)) === null || _b === void 0 ? void 0 : _b.contentOptions[0]) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : '*/*';
+        const responseType = accept.includes('json') ? 'json' : 'text';
+        return ts.method(this.getEndpointMethodName(ctx, endpoint), {
+            accessModifier: 'public',
             parameters: [
-                { name: 'config', type: (builder) => builder.appendExternalTypeUsage(this.getApiConfigurationType(ctx)) },
-                { name: 'http', type: (builder) => builder.appendExternalTypeUsage(this.httpClientType) },
+                hasParams
+                    ? ts.parameter('params', {
+                        optional: paramsOptional,
+                        type: ts.reference(this.getEndpointParamsTypeName(ctx, endpoint)),
+                    })
+                    : null,
+                ts.parameter('context', { optional: true, type: ts.refs.angular.httpContext() }),
             ],
-            body: (builder) => this.generateConstructorContent(ctx, builder),
-        };
-    }
-    getEndpointPathPropertyOptions(ctx, endpoint) {
-        return {
-            name: this.getEndpointPathPropertyName(ctx, endpoint),
-            documentation: ctx.config.exposePathProperties
-                ? `Path part for operation ${this.getEndpointMethodName(ctx, endpoint)}`
-                : undefined,
-            isStatic: true,
-            accessibility: ctx.config.exposePathProperties ? 'public' : 'protected',
-            isReadonly: true,
-            initializer: this.toStringLiteral(ctx, endpoint.path),
-        };
-    }
-    getEndpointMethodParams(ctx, endpoint) {
-        const params = [];
-        if (this.hasEndpointParams(ctx, endpoint)) {
-            params.push({
-                name: 'params',
-                type: this.getEndpointParamsTypeName(ctx, endpoint),
-            });
-        }
-        params.push({
-            name: 'context',
-            isOptional: true,
-            type: (builder) => builder.appendExternalTypeUsage(this.httpContextType),
+            returnType,
+            body: appendValueGroup([
+                s `const rb = new ${ctx.refs.requestBuilder()}(this.rootUrl, ${this.getServiceClassName(ctx)}.${this.getEndpointPathPropertyName(ctx, endpoint)}, '${endpoint.method}');`,
+                hasParams
+                    ? (b) => {
+                        var _a;
+                        return b.appendIf(paramsOptional, 'if (params) ').parenthesizeIf(paramsOptional, '{}', appendValueGroup([
+                            ...endpoint.parameters
+                                .filter((p) => p.target === 'path' || p.target === 'query' || p.target === 'header')
+                                .map((p) => {
+                                const options = ts.object({
+                                    members: [
+                                        p.style !== undefined ? ts.property('style', { value: ts.string(p.style) }) : null,
+                                        p.explode !== undefined ? ts.property('explode', { value: p.explode }) : null,
+                                    ],
+                                });
+                                return s `rb.${p.target}(${ts.string(p.name)}, params.${toCasing(p.name, ctx.config.propertyNameCasing)}, ${options});`;
+                            }),
+                            endpoint.requestBody
+                                ? s `rb.body(params.body, ${ts.string((_a = endpoint.requestBody.content[0].type) !== null && _a !== void 0 ? _a : 'application/json')});`
+                                : null,
+                        ], '\n'), { multiline: true });
+                    }
+                    : null,
+                '',
+                s `return ${ts.refs.rxjs.firstValueFrom()}(${s.indent `
+              this.http.request(rb.build({${s.indent `
+                responseType: ${ts.string(responseType)},
+                accept: ${ts.string(accept)},
+                context,`}
+              })).pipe(${s.indent `
+                ${ts.refs.rxjs.filter()}((r: unknown) => r instanceof ${ts.refs.angular.httpResponse.infer()}),
+                ${ts.refs.rxjs.take()}(1),`}
+              )`}
+            ) as unknown as ${returnType};`,
+            ], '\n'),
         });
-        return params;
-    }
-    generateEndpointSuccessResponseSchema(ctx, builder, endpoint) {
-        var _a;
-        const successResponse = this.getEndpointSuccessResponse(ctx, endpoint);
-        const schema = (_a = successResponse === null || successResponse === void 0 ? void 0 : successResponse.contentOptions[0]) === null || _a === void 0 ? void 0 : _a.schema;
-        if (schema) {
-            const model = ctx.input.models[schema.id];
-            if (model) {
-                builder.appendModelUsage(model);
-            }
-            else {
-                builder.append(this.getAnyType(ctx));
-            }
-        }
-        else {
-            builder.append('void');
-        }
-    }
-    getEndpointResponseMethodOptions(ctx, endpoint) {
-        return {
-            name: this.getEndpointResponseMethodName(ctx, endpoint),
-            accessibility: ctx.config.exposeResponseMethods ? 'public' : 'protected',
-            documentation: ctx.config.exposeResponseMethods
-                ? [
-                    endpoint.summary,
-                    endpoint.description,
-                    'This method provides access to the full `HttpResponse`, allowing access to response headers.\n' +
-                        `To access only the response body, use \`${this.getEndpointMethodName(ctx, endpoint)}()\` instead.`,
-                ]
-                    .filter((x) => x)
-                    .join('\n\n')
-                : undefined,
-            parameters: this.getEndpointMethodParams(ctx, endpoint),
-            returnType: (builder) => builder
-                .appendExternalTypeUsage(this.observableType)
-                .appendGenericArguments((builder) => builder
-                .appendExternalTypeUsage(this.getStrictHttpResponseType(ctx))
-                .appendGenericArguments((builder) => this.generateEndpointSuccessResponseSchema(ctx, builder, endpoint))),
-            body: (builder) => this.generateEndpointResponseMethodContent(ctx, builder, endpoint),
-        };
-    }
-    getEndpointMethodOptions(ctx, endpoint) {
-        return {
-            name: this.getEndpointMethodName(ctx, endpoint),
-            accessibility: 'public',
-            documentation: [
-                endpoint.summary,
-                endpoint.description,
-                ctx.config.exposeResponseMethods
-                    ? 'This method provides access only to the response body.\n' +
-                        `To access the full response (for headers, for example), \`${this.getEndpointResponseMethodName(ctx, endpoint)}()\` instead.`
-                    : undefined,
-            ]
-                .filter((x) => x)
-                .join('\n\n'),
-            parameters: this.getEndpointMethodParams(ctx, endpoint),
-            returnType: ctx.config.clientMethodFlavor === 'response-handler'
-                ? 'void'
-                : (builder) => builder
-                    .appendExternalTypeUsage(this.observableType)
-                    .appendGenericArguments((builder) => this.generateEndpointSuccessResponseSchema(ctx, builder, endpoint)),
-            body: (builder) => this.generateEndpointMethodContent(ctx, builder, endpoint),
-        };
     }
     getEndpointSuccessResponse(ctx, endpoint) {
         var _a;
         return ((_a = endpoint.responses.find((x) => x.statusCode && x.statusCode >= 200 && x.statusCode < 300)) !== null && _a !== void 0 ? _a : endpoint.responses.find((x) => x.statusCode === undefined));
     }
     getServiceClassName(ctx) {
-        return this.toTypeName(ctx, ctx.service.name);
+        return toCasing(ctx.service.name + '_Service', ctx.config.typeNameCasing);
     }
-    hasEndpointParams(ctx, endpoint) {
-        return endpoint.parameters.length > 0 || endpoint.requestBody !== undefined;
+    getResponseModelName(ctx, endpoint) {
+        return toCasing(`${this.getEndpointMethodName(ctx, endpoint)}ApiResponse`, ctx.config.typeNameCasing);
     }
     getEndpointParamsTypeName(ctx, endpoint) {
-        return toCasing(this.getEndpointMethodName(ctx, endpoint), 'pascal') + 'Params';
+        return toCasing(this.getEndpointMethodName(ctx, endpoint) + '_Params', ctx.config.typeNameCasing);
     }
     getEndpointPathPropertyName(ctx, endpoint) {
-        return this.getEndpointMethodName(ctx, endpoint) + 'Path';
+        return toCasing(this.getEndpointMethodName(ctx, endpoint) + '_Path', ctx.config.constantNameCasing);
     }
     getEndpointMethodName(ctx, endpoint) {
-        return this.toMethodName(ctx, endpoint.name);
-    }
-    getEndpointResponseMethodName(ctx, endpoint) {
-        return this.getEndpointMethodName(ctx, endpoint) + '$Response';
+        return toCasing(endpoint.name, ctx.config.functionNameCasing);
     }
     getServiceFilePath(ctx) {
         return resolve(ctx.config.outputDir, ctx.config.servicesDirPath, `${toCasing(ctx.service.name, ctx.config.fileNameCasing)}.ts`);
     }
-    getResponseModelsFilePath(ctx) {
-        var _a;
-        return resolve(ctx.config.outputDir, (_a = ctx.config.responseModelsDirPath) !== null && _a !== void 0 ? _a : 'models/responses', `${toCasing(ctx.service.name, ctx.config.responseModelsFileNameCasing)}.ts`);
+    getResponseModelFilePath(ctx) {
+        return resolve(ctx.config.outputDir, ctx.config.responseModelsDirPath, `${toCasing(ctx.service.name, ctx.config.responseModelFileNameCasing)}.ts`);
+    }
+    hasEndpointParams(ctx, endpoint) {
+        return endpoint.parameters.length > 0 || endpoint.requestBody !== undefined;
     }
-    getUtilsDirPath(ctx) {
-        return resolve(ctx.config.outputDir, ctx.config.utilsDirPath);
+    getSchemaType(ctx, schema, fallback) {
+        const output = schema && ctx.input.models[schema.id];
+        if (!output)
+            return fallback !== null && fallback !== void 0 ? fallback : this.getAnyType(ctx);
+        return (b) => b.appendModelUsage(output);
     }
 }