Generate Definitions from swagger

[eburi]

Hi,

I'd like to use swagger-js-codegen to generate Typescript Code from a swagger-file to get errors in case the REST interface changed. But I'm getting a lot of errors due to the missing Definitions.

I found the ts-barnch that has the code required to generate the Definitions, but it looks outdated compared to the master-branch.

What is the plan with ts-branch? Is there any work going on regarding generating the Definitions?

I created a fork to fix a problem where an array does not have an items definition. Should I implement the Definition-generation and create a pull-request?

[wcandillon]

@eburi The ts-barnch can be ignored. Yes a pull request would be nice. What kind of errors are you getting? Do you had the missing definition when generating the source code? Like so:

var source = CodeGen.getTypescriptCode({ moduleName: api.moduleName, className: api.className, swagger: swagger, lint: false, imports: ['../../typings/tsd.d.ts'] });

I'm using swagger-js-codegen for a typescript project and I didn't come across the use case of having to generate the definition file. In which scenario would that be useful?

[eburi]

@wcandillon I can't share that swagger file. But here is a part of it that shows the problem:

    "/auskuenfte/fachnummer-uuid-mappings" : {
      "get" : {
        "tags" : [ "auskuenfte" ],
        "operationId" : "getUuidsForFachnummer",
        "produces" : [ "application/json" ],
        "parameters" : [ {
          "name" : "fn",
          "in" : "query",
          "required" : false,
          "type" : "array"
        } ],
        "responses" : {
          "200" : {
            "description" : "OK",
            "schema" : {
              "$ref" : "#/definitions/FachnummerUuidMappingDTO"
            }
          },
          "403" : {
            "description" : "Forbidden"
          }
        }
      }
    },

It's a swagger 2.0 file and it's been generated in a Java-Backend. The query-parameter "fn" is not required and it's only specified that it should be an array. Of course, it would be nice if that swagger-file would be complete. But I guess this is stuff that can happen.
The fix I made would just default to 'any' in this case.

Here's the code I'm using:

var rp = require('request-promise');
var fs = require('fs');
var CodeGen = require('swagger-js-codegen').CodeGen;

// This is pretty unsafe, but solves the problem with self-signed certificates in mobi
// see: http://stackoverflow.com/questions/20433287/node-js-request-cert-has-expired#answer-29397100
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";

var url = 'https://jsplb01c.umobi.mobicorp.test/mcs/swagger.json';
rp(url)
    .catch(function (error) {
        console.error('failed to load swagger.json from "' + url + '":');
        console.error(error);
    })
    .then(function (response) {
        var swaggerJson = JSON.parse(response);
        var tsMcsBackendAPICode = CodeGen.getTypescriptCode({
                                                                moduleName: 'mcs',
                                                                className: 'McsBackendAPI',
                                                                swagger: swaggerJson,
                                                                imports: ['../typings/browser.d.ts']
                                                            });

        var defFile = fs.createWriteStream('./src/mcs.ts');
        defFile.write(tsMcsBackendAPICode);
    });

The option moduleName does no seam to do anything...

The code will generate one class - McsBackendAPI - that can be used as client for the API. But it won't validate as a lot of the parameters refer to classes that were not generated.
But I'm doing all this, to have the types from the Backend in the Frontend and profit from type-checking, auto-completion in the IDE etc. In fact I'm more interested in the Definitions/Types generated than the API-Client.

Actually, the code on the ts-branch from the PR #79 is about what I'm looking for, except that it's outdated.

The question is, how that would fit with the current API. Maybe something like:

var defintionsCodeMap = CodeGen.getTypescriptDefinitionCodeMap(...)

I figure that would return a map that has the Type-Name as key and the generated code as value and the CodeGen-user can save that wherever he likes.

[eburi]

I changed the code in my fork here: https://github.com/eburi/swagger-js-codegen

Now, when I'm using this as my template for 'class', I get what I'm looking for (except for the requests, with superagent where the returned Promises are untyped, but I'm trying to find a solution for this).

typescript-class-with-definitions.mustache:

{{#imports}}
/// <reference path="{{&.}}" />
{{/imports}}

import * as request from "superagent";

{{#definitions}}
interface {{name}} {{>type}}
{{/definitions}}

/**
 * {{&description}}
 * @class {{&className}}
 * @param {(string)} [domainOrOptions] - The project domain.
 */
export default class {{&className}} {

    private domain: string;

    constructor(domain: string) {
        this.domain = domain;
    }

{{#methods}}
    {{> method}}

{{/methods}}
}

test.js:

var fs = require('fs');
var CodeGen = require('./lib/codegen.js').CodeGen;


var uberAPISwagger = JSON.parse(fs.readFileSync('./tests/apis/uber.json'));

var opts = { swagger:uberAPISwagger, template: {} };

var templateDirecotry = './templates/';

opts.template.class = fs.readFileSync('./typescript-class-with-definitions.mustache', 'utf-8');
opts.template.method = fs.readFileSync(templateDirecotry + 'typescript-method.mustache', 'utf-8');
opts.template.request = fs.readFileSync(templateDirecotry + 'typescript-request.mustache', 'utf-8');

var result = CodeGen.getTypescriptCode(opts);
console.log(result);

[no-more]

Hi,

At first I didn't realize, but that's exactly what I was trying to ask in #139 .
Please is this fixed? is there a way to generate those definitions? I'm also very interested in this feature.

Thanks a lot.

[wcandillon]

@eburi can you check in v1.7.0 if the types are generated as you would like? Feel free to re-open.