Creating a new generator which will become a part of the officially supported generators in OpenAPI Generator is pretty simple. We've created a helper script to bootstrap the operation. Let's look at the files necessary to create a new generator, then an example of bootstrapping a generator using the new.sh script in the root of the repository.

Required Files

The minimum set of files required to create a new generator are:

  • A "Codegen" file
    • exists under modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/
    • defines language options
    • defines framework options
    • determines OpenAPI feature set
    • extends the generation workflow
  • SPI registration
    • Above class must be referenced in modules/openapi-generator/src/main/resources/META-INF/services/org.openapitools.codegen.CodegenConfig
    • Tells the generator that this class exists
    • Allows for classpath extension (addition) of generators
  • A minimal template
    • Should include a README explaining usage
    • Must include an api.mustache
    • Exists under modules/openapi-generator/src/main/resources/ (plus embeddedTemplate dir value, see below)
  • Sample scripts under ./bin and ./bin/windows
    • Gives users a "real life" example of generated output
    • Samples are used by CI to verify generators and test for regressions in some casesNow, let's generate an example generator and then walk through the pieces. At the end, we'll touch on some known sticking points for new generator authors and provide some suggestions.

new.sh

The new.sh script in the root of the project is meant to simplify this process. Run ./new.sh —help.

  1. Stubs out files for new generators
  3. Usage:
  4. ./new.sh [options]
  5.     Options:
  6.     -n  Required. Specify generator name, should be kebab-cased.
  7.     -c  Create a client generator
  8.     -s  Create a server generator
  9.     -d  Create a documentation generator
  10.     -t  When specified, creates test file(s) for the generator.
  11.     -h  Display help.
  13. Examples:
  14.   Create a server generator for ktor:
  15.   ./new.sh -n kotlin -s
  17.     Creates:
  18.     modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/KotlinServerCodegen.java
  19.     modules/openapi-generator/src/main/resources/kotlin-server/README.mustache
  20.     modules/openapi-generator/src/main/resources/kotlin-server/model.mustache
  21.     modules/openapi-generator/src/main/resources/kotlin-server/api.mustache
  22.     bin/windows/kotlin-server-petstore.bat
  23.     bin/kotlin-server-petstore.sh
  25.   Create a generic C# server generator:
  26.   ./new.sh -n csharp -s -t
  27.     Creates:
  28.     modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/CsharpServerCodegen.java
  29.     modules/openapi-generator/src/main/resources/csharp-server/README.mustache
  30.     modules/openapi-generator/src/main/resources/csharp-server/model.mustache
  31.     modules/openapi-generator/src/main/resources/csharp-server/api.mustache
  32.     bin/windows/csharp-server-petstore.bat
  33.     bin/csharp-server-petstore.sh
  34.     modules/openapi-generator/src/test/java/org/openapitools/codegen/csharp/CsharpServerCodegenTest.java
  35.     modules/openapi-generator/src/test/java/org/openapitools/codegen/csharp/CsharpServerCodegenModelTest.java
  36.     modules/openapi-generator/src/test/java/org/openapitools/codegen/csharp/CsharpServerCodegenOptionsTest.java
  37.     modules/openapi-generator/src/test/java/org/openapitools/codegen/options/CsharpServerCodegenOptionsProvider.java

This script allows us to define a client, server, schema, or documentation generator. We'll focus on the simplest generator (documentation). The other generator types may require heavy extension of the "Config" base class, and these docs could very quickly become outdated. When creating a new generator, please review existing generators as a guideline for implementation.

Create a new Markdown generator:

  1. ./new.sh -n markdown -d

You should see output similar to the following:

  1. Creating modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/MarkdownDocumentationCodegen.java
  2. Creating modules/openapi-generator/src/main/resources/markdown-documentation/README.mustache
  3. Creating modules/openapi-generator/src/main/resources/markdown-documentation/model.mustache
  4. Creating modules/openapi-generator/src/main/resources/markdown-documentation/api.mustache
  5. Creating bin/windows/markdown-documentation-petstore.bat
  6. Creating bin/markdown-documentation-petstore.sh
  7. Finished.

Review Generated Config

Beginning with the "Codegen" file (MarkdownDocumentationCodegen.java), the constructor was created:

  1.     public MarkdownDocumentationCodegen() {
  2.         super();
  4.         outputFolder = "generated-code" + File.separator + "markdown";
  5.         modelTemplateFiles.put("model.mustache", ".zz");
  6.         apiTemplateFiles.put("api.mustache", ".zz");
  7.         embeddedTemplateDir = templateDir = "markdown-documentation";
  8.         apiPackage = File.separator + "Apis";
  9.         modelPackage = File.separator + "Models";
  10.         // TODO: Fill this out.
  11.     }

These options are some defaults which may require updating. Let's look line-by-line at the config.

  1. outputFolder = "generated-code" + File.separator + "markdown";

This is the default output location. This will be generated-code/markdown on non-Windows machines and generated-code\markdown on Windows. You may change this to any value you'd like, but a user will almost always provide an output directory.

When joining paths, always use File.seperator

  1.  modelTemplateFiles.put("model.mustache", ".zz");

The model.mustache file is registered as the template for model generation. The new.sh script doesn't have a way to know your intended file extension, so we default to a .zz extension. This must be changed (unless your generator's target extension is .zz). For this example, you'd change .zz to .md or .markdown, depending on your preference.

This model template registration will use model.mustache to generate a new file for every model defined in your API's specification document.

The path is considered relative to embeddedTemplateDir, templateDir, or a library subdirectory (refer to the Java client generator implementation for a prime example).

  1. apiTemplateFiles.put("api.mustache", ".zz");

This is the template used for generating API related files. Similar to the above model template, you'll want to change .zz to .md or .markdown.

The path is considered relative to embeddedTemplateDir, templateDir, or a library subdirectory (refer to the Java client generator implementation for a prime example).

  1. embeddedTemplateDir = templateDir = "markdown-documentation";

This line sets the embedded and template directories to markdown-documentation. The embeddedTemplateDir refers to the directory which will exist under modules/openapi-generator/src/main/resources and will be published with every release in which your new generator is present.

The templateDir variable refers to the "current" template directory setting, as defined by the user. That is, the user may invoke with -t or —template-directory (or plugin option variants), and override this directory.

Both of these variables exist because the generator will fallback to files under embeddedTemplateDir if they are not defined in the user's custom template directory.

  1. apiPackage = File.separator + "Apis";

This sets the "package" location for anything considered an API document. You might want to change this setting if, for instance, your language doesn't support uppercase letters in the path. We don't need to worry about that here.

Every templated output from api.mustache (registered via apiTemplateFiles above) will end up in the directory defined by apiPackage here.

  1. modelPackage = File.separator + "Models";

Similarly, this sets the packasge for Models.

Every templated output from model.mustache (registered via modelTemplateFiles above) will end up in the directory defined by modelPackage here.

  1. supportingFiles.add(new SupportingFile("README.mustache", "", "README.md"));

A "supporting file" is an extra file which isn't created once for every operation or model defined in your specification document. It is a single file which may or may not be templated (determined by the extension of the filename).

A supporting file only passes through the Markdown template processor if the filename ends in .mustache.

The path is considered relative to embeddedTemplateDir, templateDir, or a library subdirectory (refer to the Java client generator implementation for a prime example).

If you want your readme to be generic (not templated), just rename the file to README.md and change README.mustache to README.md above.

Create templates

The new.sh created our three required files. Let's start filling out each of these files.

README.mustache

  1. # Documentation for {{appName}}
  3. {{#generateApiDocs}}
  4. <a name="documentation-for-api-endpoints"></a>
  5. ## Documentation for API Endpoints
  7. All URIs are relative to *{{{basePath}}}*
  9. Class | Method | HTTP request | Description
  10. ------------ | ------------- | ------------- | -------------
  11. {{#apiInfo}}{{#apis}}{{#operations}}{{#operation}}*{{classname}}* | [**{{operationId}}**](Apis/{{apiDocPath}}{{classname}}.md#{{operationIdLowerCase}}) | **{{httpMethod}}** {{path}} | {{#summary}}{{{summary}}}{{/summary}}
  12. {{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
  13. {{/generateApiDocs}}
  15. {{#generateModelDocs}}
  16. <a name="documentation-for-models"></a>
  17. ## Documentation for Models
  19. {{#modelPackage}}
  20. {{#models}}{{#model}} - [{{{modelPackage}}}.{{{classname}}}](Models/{{modelDocPath}}{{{classname}}}.md)
  21. {{/model}}{{/models}}
  22. {{/modelPackage}}
  23. {{^modelPackage}}
  24. No model defined in this package
  25. {{/modelPackage}}
  26. {{/generateModelDocs}}
  28. <a name="documentation-for-authorization"></a>{{! TODO: optional documentation for authorization? }}
  29. ## Documentation for Authorization
  31. {{^authMethods}}
  32. All endpoints do not require authorization.
  33. {{/authMethods}}
  34. {{#authMethods}}
  35. {{#last}}
  36. Authentication schemes defined for the API:
  37. {{/last}}
  38. {{/authMethods}}
  39. {{#authMethods}}
  40. <a name="{{name}}"></a>
  41. ### {{name}}
  43. {{#isApiKey}}- **Type**: API key
  44. - **API key parameter name**: {{keyParamName}}
  45. - **Location**: {{#isKeyInQuery}}URL query string{{/isKeyInQuery}}{{#isKeyInHeader}}HTTP header{{/isKeyInHeader}}
  46. {{/isApiKey}}
  47. {{#isBasic}}- **Type**: HTTP basic authentication
  48. {{/isBasic}}
  49. {{#isOAuth}}- **Type**: OAuth
  50. - **Flow**: {{flow}}
  51. - **Authorization URL**: {{authorizationUrl}}
  52. - **Scopes**: {{^scopes}}N/A{{/scopes}}
  53. {{#scopes}}  - {{scope}}: {{description}}
  54. {{/scopes}}
  55. {{/isOAuth}}
  57. {{/authMethods}}

Let's not focus too much on the contents of this file. You may refer to templating for more details on the variables bound to these files and to debugging how to debug the structures. Of note here is that we're generating structures in markdown as defined by the objects constructed by our new "Config" class.

api.mustache

The API documentation might look like this:

  1. # {{classname}}{{#description}}
  2. {{description}}{{/description}}
  4. All URIs are relative to *{{basePath}}*
  6. Method | HTTP request | Description
  7. ------------- | ------------- | -------------
  8. {{#operations}}{{#operation}}[**{{operationId}}**]({{classname}}.md#{{operationId}}) | **{{httpMethod}}** {{path}} | {{#summary}}{{summary}}{{/summary}}
  9. {{/operation}}{{/operations}}
  11. {{#operations}}
  12. {{#operation}}
  13. <a name="{{operationId}}"></a>
  14. # **{{operationId}}**
  15. > {{#returnType}}{{returnType}} {{/returnType}}{{operationId}}({{#allParams}}{{{paramName}}}{{#hasMore}}, {{/hasMore}}{{/allParams}})
  17. {{summary}}{{#notes}}
  19. {{notes}}{{/notes}}
  21. ### Parameters
  22. {{^allParams}}This endpoint does not need any parameter.{{/allParams}}{{#allParams}}{{#-last}}
  23. Name | Type | Description  | Notes
  24. ------------- | ------------- | ------------- | -------------{{/-last}}{{/allParams}}
  25. {{#allParams}} **{{paramName}}** | {{#isPrimitiveType}}**{{dataType}}**{{/isPrimitiveType}}{{^isPrimitiveType}}{{#isFile}}**{{dataType}}**{{/isFile}}{{^isFile}}{{#generateModelDocs}}[**{{dataType}}**]({{baseType}}.md){{/generateModelDocs}}{{^generateModelDocs}}**{{dataType}}**{{/generateModelDocs}}{{/isFile}}{{/isPrimitiveType}}| {{description}} |{{^required}} [optional]{{/required}}{{#defaultValue}} [default to {{defaultValue}}]{{/defaultValue}}{{#allowableValues}} [enum: {{#values}}{{{.}}}{{^-last}}, {{/-last}}{{/values}}]{{/allowableValues}}
  26. {{/allParams}}
  28. ### Return type
  30. {{#returnType}}{{#returnTypeIsPrimitive}}**{{returnType}}**{{/returnTypeIsPrimitive}}{{^returnTypeIsPrimitive}}{{#generateModelDocs}}[**{{returnType}}**]({{returnBaseType}}.md){{/generateModelDocs}}{{^generateModelDocs}}**{{returnType}}**{{/generateModelDocs}}{{/returnTypeIsPrimitive}}{{/returnType}}{{^returnType}}null (empty response body){{/returnType}}
  32. ### Authorization
  34. {{^authMethods}}No authorization required{{/authMethods}}{{#authMethods}}[{{name}}](../README.md#{{name}}){{^-last}}, {{/-last}}{{/authMethods}}
  36. ### HTTP request headers
  38.  - **Content-Type**: {{#consumes}}{{{mediaType}}}{{#hasMore}}, {{/hasMore}}{{/consumes}}{{^consumes}}Not defined{{/consumes}}
  39.  - **Accept**: {{#produces}}{{{mediaType}}}{{#hasMore}}, {{/hasMore}}{{/produces}}{{^produces}}Not defined{{/produces}}
  41. {{/operation}}
  42. {{/operations}}

model.mustache

The models file could resemble the following.

  1. {{#models}}
  2. {{#model}}
  3. # {{{packageName}}}.{{modelPackage}}.{{{classname}}}
  4. ## Properties
  6. Name | Type | Description | Notes
  7. ------------ | ------------- | ------------- | -------------
  8. {{#parent}}
  9. {{#parentVars}}
  10. **{{name}}** | {{#isPrimitiveType}}**{{dataType}}**{{/isPrimitiveType}}{{^isPrimitiveType}}[**{{dataType}}**]({{complexType}}.md){{/isPrimitiveType}} | {{description}} | {{^required}}[optional] {{/required}}{{#readOnly}}[readonly] {{/readOnly}}{{#defaultValue}}[default to {{{.}}}]{{/defaultValue}}
  11. {{/parentVars}}
  12. {{/parent}}
  13. {{#vars}}**{{name}}** | {{#isPrimitiveType}}**{{dataType}}**{{/isPrimitiveType}}{{^isPrimitiveType}}[**{{dataType}}**]({{complexType}}.md){{/isPrimitiveType}} | {{description}} | {{^required}}[optional] {{/required}}{{#readOnly}}[readonly] {{/readOnly}}{{#defaultValue}}[default to {{{.}}}]{{/defaultValue}}
  14. {{/vars}}
  16. [[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
  18. {{/model}}
  19. {{/models}}

Build it

To compile quickly to test this out, you can run mvn clean package -DskipTests.

When implementing a more robust generator, you'll want to run all tests as well: mvn clean package

Compile Sample

The new.sh script created bin/markdown-documentation-petstore.sh:

  1. #!/bin/sh
  3. SCRIPT="$0"
  5. while [ -h "$SCRIPT" ] ; do
  6.   ls=$(ls -ld "$SCRIPT")
  7.   link=$(expr "$ls" : '.*-> \(.*\)$')
  8.   if expr "$link" : '/.*' > /dev/null; then
  9.     SCRIPT="$link"
  10.   else
  11.     SCRIPT=$(dirname "$SCRIPT")/"$link"
  12.   fi
  13. done
  15. if [ ! -d "${APP_DIR}" ]; then
  16.   APP_DIR=$(dirname "$SCRIPT")/..
  17.   APP_DIR=$(cd "${APP_DIR}"; pwd)
  18. fi
  20. executable="./modules/openapi-generator-cli/target/openapi-generator-cli.jar"
  22. if [ ! -f "$executable" ]
  23. then
  24.   mvn clean package
  25. fi
  27. # if you've executed sbt assembly previously it will use that instead.
  28. export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
  29. ags="$@ generate -i modules/openapi-generator/src/test/resources/2_0/petstore.yaml -g markdown -o samples/documentation/petstore/markdown"
  31. java ${JAVA_OPTS} -jar ${executable} ${ags}

This script is often used to apply default options for generation. A common option in most of these script is to define the template directory as the generator's directory under resources. This allows template maintainers to modify and test out template changes which don't require recompilation of the entire project. You'd still need to recompile the project in full if you add or modify behaviors to the generator (such as adding a CliOption).

Add -t modules/openapi-generator/src/main/resources/markdown-documentation to ags line to simplify the evaluation of template-only modifications:

  1. diff --git a/bin/markdown-documentation-petstore.sh b/bin/markdown-documentation-petstore.sh
  2. index d816771478..94b4ce6d12 100644
  3. --- a/bin/markdown-documentation-petstore.sh
  4. +++ b/bin/markdown-documentation-petstore.sh
  5. @@ -26,6 +26,6 @@ fi
  7.  # if you've executed sbt assembly previously it will use that instead.
  8.  export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
  9. -ags="$@ generate -i modules/openapi-generator/src/test/resources/2_0/petstore.yaml -g markdown -o samples/documentation/petstore/markdown"
  10. +ags="$@ generate -t modules/openapi-generator/src/main/resources/markdown-documentation -i modules/openapi-generator/src/test/resources/2_0/petstore.yaml -g markdown -o samples/documentation/petstore/markdown"
  12.  java ${JAVA_OPTS} -jar ${executable} ${ags}

Verify output

Creating a new generator will be an iterative task. Once you've generated the sample, you'll want to try it out. For compiled client/server outputs, this would mean running the code or creating a small sample project to consume your artifact just to make sure it works.

For markdown, you can open in Visual Studio Code or any other editor with a markdown preview. Not all editors support relative links to other markdown documents. To test the output in this guide, install markserv:

  1. npm install --global markserv

Now, you can serve the output directory directly and test your links:

  1. markserv samples/documentation/petstore/markdown

That's it! You've created your first generator!