@goast/typescript 0.0.1

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

@@ -0,0 +1,356 @@
+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 { 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 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());
+        return {
+            filePath,
+            component: name,
+            responseModels: {},
+            imports: [{ kind: 'file', name, modulePath: filePath }],
+        };
+    }
+    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;
+        }
+        const params = [];
+        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,
+            }));
+        }
+        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,
+            }));
+        }
+        builder.appendTypeDeclaration({
+            name: this.getEndpointParamsTypeName(ctx, endpoint),
+            documentation: `Parameters for operation ${this.getEndpointMethodName(ctx, endpoint)}`,
+            type: (builder) => builder.appendCodeBlock(...params),
+        });
+    }
+    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')}`)],
+                },
+            ],
+            extends: (builder) => builder.appendExternalTypeUsage(this.getBaseServiceType(ctx)),
+            body: (builder) => this.generateClassContent(ctx, builder),
+        };
+    }
+    getConstructorOptions(ctx) {
+        return {
+            parameters: [
+                { name: 'config', type: (builder) => builder.appendExternalTypeUsage(this.getApiConfigurationType(ctx)) },
+                { name: 'http', type: (builder) => builder.appendExternalTypeUsage(this.httpClientType) },
+            ],
+            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),
+        });
+        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);
+    }
+    hasEndpointParams(ctx, endpoint) {
+        return endpoint.parameters.length > 0 || endpoint.requestBody !== undefined;
+    }
+    getEndpointParamsTypeName(ctx, endpoint) {
+        return toCasing(this.getEndpointMethodName(ctx, endpoint), 'pascal') + 'Params';
+    }
+    getEndpointPathPropertyName(ctx, endpoint) {
+        return this.getEndpointMethodName(ctx, endpoint) + 'Path';
+    }
+    getEndpointMethodName(ctx, endpoint) {
+        return this.toMethodName(ctx, endpoint.name);
+    }
+    getEndpointResponseMethodName(ctx, endpoint) {
+        return this.getEndpointMethodName(ctx, endpoint) + '$Response';
+    }
+    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`);
+    }
+    getUtilsDirPath(ctx) {
+        return resolve(ctx.config.outputDir, ctx.config.utilsDirPath);
+    }
+}

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

@@ -0,0 +1,118 @@
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { ensureDirSync, writeFileSync } from 'fs-extra';
+import { Factory, OpenApiServicesGenerationProviderBase, notNullish, } from '@goast/core';
+import { DefaultTypeScriptAngularServiceGenerator, } from './angular-service-generator';
+import { defaultTypeScriptAngularServicesGeneratorConfig, } from './models';
+import { TypeScriptFileBuilder } from '../../../file-builder';
+import { ImportExportCollection } from '../../../import-collection';
+import { modifyString } from '../../../utils';
+export class TypeScriptAngularServicesGenerator extends OpenApiServicesGenerationProviderBase {
+    constructor(clientGeneratorFactory) {
+        super();
+        this._clientGeneratorFactory =
+            clientGeneratorFactory !== null && clientGeneratorFactory !== void 0 ? clientGeneratorFactory : Factory.fromValue(new DefaultTypeScriptAngularServiceGenerator());
+    }
+    initResult() {
+        return {
+            services: {},
+            servicesIndexFilePath: undefined,
+            responseModelsIndexFilePath: undefined,
+        };
+    }
+    buildContext(context, config) {
+        return this.getProviderContext(context, config, defaultTypeScriptAngularServicesGeneratorConfig);
+    }
+    onGenerate(ctx) {
+        const output = super.onGenerate(ctx);
+        this.copyUtilsFiles(ctx);
+        output.servicesIndexFilePath = this.generateServicesIndexFile(ctx);
+        return output;
+    }
+    generateService(ctx, service) {
+        const clientGenerator = this._clientGeneratorFactory.create();
+        return clientGenerator.generate(Object.assign(Object.assign({}, ctx), { service }));
+    }
+    addServiceResult(ctx, service, result) {
+        ctx.output.services[service.id] = result;
+    }
+    generateServicesIndexFile(ctx) {
+        if (!this.shouldGenerateServicesIndexFile(ctx)) {
+            return undefined;
+        }
+        const filePath = this.getServicesIndexFilePath(ctx);
+        console.log(`Generating index file to ${filePath}...`);
+        ensureDirSync(dirname(filePath));
+        const builder = new TypeScriptFileBuilder(filePath, ctx.config);
+        this.generateServicesIndexFileContent(ctx, builder);
+        writeFileSync(filePath, builder.toString());
+        return filePath;
+    }
+    getServicesIndexFilePath(ctx) {
+        var _a;
+        return resolve(ctx.config.outputDir, (_a = ctx.config.indexFilePath) !== null && _a !== void 0 ? _a : 'clients.ts');
+    }
+    shouldGenerateServicesIndexFile(ctx) {
+        return notNullish(ctx.config.indexFilePath);
+    }
+    generateServicesIndexFileContent(ctx, builder) {
+        const exports = new ImportExportCollection();
+        for (const serviceId in ctx.output.services) {
+            const service = ctx.output.services[serviceId];
+            exports.addExport(service.component, service.filePath);
+        }
+        exports.writeTo(builder);
+    }
+    generateResponseModelsIndexFile(ctx) {
+        if (!this.shouldGenerateResponseModelsIndexFile(ctx)) {
+            return undefined;
+        }
+        const filePath = this.getResponseModelsIndexFilePath(ctx);
+        console.log(`Generating response models index file to ${filePath}...`);
+        ensureDirSync(dirname(filePath));
+        const builder = new TypeScriptFileBuilder(filePath, ctx.config);
+        this.generateResponseModelsIndexFileContent(ctx, builder);
+        writeFileSync(filePath, builder.toString());
+        return filePath;
+    }
+    getResponseModelsIndexFilePath(ctx) {
+        var _a;
+        return resolve(ctx.config.outputDir, (_a = ctx.config.responseModelsIndexFilePath) !== null && _a !== void 0 ? _a : 'responses.ts');
+    }
+    shouldGenerateResponseModelsIndexFile(ctx) {
+        return notNullish(ctx.config.responseModelsDirPath) && notNullish(ctx.config.responseModelsIndexFilePath);
+    }
+    generateResponseModelsIndexFileContent(ctx, builder) {
+        const exports = new ImportExportCollection();
+        for (const serviceId in ctx.output.services) {
+            const service = ctx.output.services[serviceId];
+            for (const operationId in service.responseModels) {
+                const responseModel = service.responseModels[operationId];
+                if (responseModel.filePath) {
+                    exports.addExport(responseModel.component, responseModel.filePath);
+                }
+            }
+        }
+        exports.writeTo(builder);
+    }
+    copyUtilsFiles(ctx) {
+        const sourceDir = resolve(dirname(require.resolve('@goast/typescript')), '../assets/service/angular');
+        const targetDir = resolve(ctx.config.outputDir, ctx.config.utilsDirPath);
+        ensureDirSync(targetDir);
+        const files = ['api-configuration.ts', 'base-service.ts', 'request-builder.ts', 'strict-http-response.ts'];
+        if (ctx.config.clientMethodFlavor === 'response-handler') {
+            files.push('response-handler.ts');
+        }
+        const rootUrl = this.getRootUrl(ctx);
+        for (const file of files) {
+            const fileContent = readFileSync(resolve(sourceDir, file))
+                .toString()
+                .replace(/@ROOT_URL@/g, rootUrl);
+            writeFileSync(resolve(targetDir, file), fileContent);
+        }
+    }
+    getRootUrl(ctx) {
+        var _a, _b, _c, _d, _e, _f;
+        return modifyString((_f = (_e = (_d = (_c = ((_a = ctx.data.services[0].$src) !== null && _a !== void 0 ? _a : (_b = ctx.data.services[0].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.rootUrl);
+    }
+}

package/esm/lib/generators/services/angular-services/index.js

@@ -0,0 +1,3 @@
+export * from './angular-service-generator';
+export * from './angular-services-generator';
+export * from './models';

package/esm/lib/generators/services/angular-services/models.js

@@ -0,0 +1,2 @@
+import { defaultTypeScriptGeneratorConfig } from '../../../config';
+export const defaultTypeScriptAngularServicesGeneratorConfig = Object.assign(Object.assign({}, defaultTypeScriptGeneratorConfig), { fileNameCasing: { casing: 'kebab', suffix: '.service' }, responseModelsFileNameCasing: { casing: 'kebab', suffix: '-responses.model' }, exposeResponseMethods: false, exposePathProperties: false, clientMethodFlavor: 'default', servicesDirPath: 'services', responseModelsDirPath: 'models/responses', utilsDirPath: 'utils', indexFilePath: 'services.ts', responseModelsIndexFilePath: 'responses.ts' });