PR is reviewed, some stuff has been transferred to model-sdk and is waiting for merge. Waiting for another review.

the PR is ready to be reviewed, had some issues in regards to some examples values which were being generated did not match with the output. For now, the property name for a model is generated as is to be compliant with other tools.

Signatures should be stable. Any further improvements/bugs will be added/fixed in the library as issues - https://github.com/asyncapi/generator-model-sdk/issues

Output shape should be stable. Any further improvements/bugs will be added/fixed in the library as issues - https://github.com/asyncapi/generator-model-sdk/issues

PR is opened to review https://github.com/asyncapi/java-spring-template/pull/121

Documentation is merged - https://github.com/asyncapi/generator-model-sdk/blob/master/docs/customisation.md

Render nested combined schemas.

Render nested enum.

Most have been integrated. I have to render by presets the nested enums, classes inside class etc ... is what we don't support in our library at the moment. PR is opened https://github.com/asyncapi/java-spring-template/pull/121

finished integration more or less https://github.com/asyncapi/ts-nats-template/pull/53. Currently waiting on some bug fixes from the model generation library.

started to look into integrating the tool into https://github.com/asyncapi/ts-nats-template

Starting integration in https://github.com/asyncapi/java-spring-template

@magicmatatjahu PR with schema name inference is merged and the transformation of JSON Schemas are in a steady-state. Any further improvements will be added to the library as issues - https://github.com/asyncapi/generator-model-sdk/issues

PR with docs is ready to review

further improvements will be added to the issue list in the library. The anonymous schema ids are inherited from the JSON Schema input processing so nothing needs to be changed there. Since JSON Schema is supported as input we will see if inputs for message, channel, operation is needed based on demand, for now it will not be included.

Implementation should be stable. Errors that occur during the integration will be reported to the generator-model-sdk repository.

Implementation should be stable. Errors that occur during the integration will be reported to the generator-model-sdk repository.

Open PR with simplification of schema's name

It won't be integrated in model-sdk, maybe in future as feature, but not now.

Integrate presets in basic TS/JS models: class, interface, enum.

Integrate presets in basic Java models: class and enum.

PR with presets is merged. Start writing docs.

AsyncAPI input processing we now also have the information about extend to enable easy inheritance. Next is to support multiple AsyncAPI inputs such as message, channel, operation etc. Further we need to add better anonymous schema ids and the simplifier needs to use those it gets from the parser.

JSON Schema now fully supports circular schemas, we now also has the information about extend to enable easy inheritance. Other then that all there is left for JSON Schema simplification is to give them correct identifiers/names for anonymous schemas.

PR is opened. Ready to review.

Customisation applied. Start writing tests.

Add PR with first draft to show how customization could look in our sdk - https://github.com/asyncapi/generator-model-sdk/pull/39

Start the task

Shape is stable. If we change it in development process, we'll inform about that in this issue. Task will be opened until the end of the cycle.

Generator and renderers for TS and JS types are almost done. I will add mix/extend, required etc. functionality when simplification process will be completed.

Signatures are stable. If we change them in development process, we'll inform about that in this issue. Task will be opened until the end of the cycle.

Add class and enum (for string and integer type) renderer for Java types

reviewed the processes and added simplified methods so we have single point of entry regardless of whether you want to generate something using a pure JSON schema or an entire AsyncAPI file. The input processor for JSON Schema now supports references which are resolved before the simplification stage.

this is considered done. Any extra improvements or changes will be added to the issues of the library itself which can be found here

Processing AsyncAPI as either an object already parsed by the parser library or as a basic JS object is now supported.

Add basic class renderer for Java in this PR https://github.com/asyncapi/generator-model-sdk/pull/27

Add generators for TS and JS types and make renderers for Enum, Interface, Class types.

Finished item simplification and waiting for review https://github.com/asyncapi/generator-model-sdk/pull/18

Properties are done

Looks like our approach is correct, enum and type simplification are merged. Up next is properties and items.

Create first draft for TS/JS generator in this Pr https://github.com/asyncapi/generator-model-sdk/pull/20

Starting implementation of basic model for Javascript/Typescript. I need wait to other task to go with it, so I will base impl. on mocks and then switch to processor flow.

Signatures for generation and transformation (input processing) are merged. We leave some time in next weeks (next tasks) to check if given signatures are friendly to developer, if no, we will slighty change them.

starting to push the limits of what JSON Schema should be used for in terms of it being a constraint language and us using it to determine type definitions. However enum simplification are done, next I gotta look at how we can simplify overall schemas. I suspect that we might need to add allOf keyword into CommonSchema since multiple types for arrays and objects are at the moment not supported.

roughly defined the how types are simplified, next is enumerators.

finished defining basic input models and their setup, need to revise the documentation for the input process.

have started to define how types are supposed to be simplified

Add output model shape and corresponding tests. I will think if the model is correct when implementing languages ​​and then I will change it if necessary.

started to look at the different transformations and simplification steps we need to perform for the common model.

defined basic models and started setting up the process interactions.

Figured most of the things out how to depict the common input model, still got a hanging issue regarding the structure and use of something like CommonModel instead of Schema. We also added the initial repository for the model generation.

I was able to create a context similar to React (in this PR https://github.com/asyncapi/generator-react-sdk/pull/19), but however I don't have any idea how to properly handle parallel case to speed up generation process. I'll postpone this task when we'll start implementation of model generation for Java/Typescript.

started and trying to figure out the optimal shape to use as a common model for rendering. So fare it actually seems like using simplified JSON schema behind the scenes are the best solution.