commercetools / rest-modeling-framework Goto Github PK

We should update our gradle version to the latest version.

• fix bootstrap classpath issue
• fix bintrayUpload

It would be nice if we could provide a helper method to parse type expression (e.g. MyType[] or MyType | yourType) and resolve it against the current API.

Usecase is that we want to use type expressions in annitations.

Looks like file loading under windows doesn't work. We should run our tests on Windows and make sure that RMF works there too.

We currently don't support parsing of RAML overlays (https://github.com/raml-org/raml-spec/blob/master/versions/raml-10/raml-10.md/#overlays).

Our current ObjectType models its properties with a separate Property type. This isn't following the RAML spec which uses types for the properties. I had doubts in the beginning if I really liked to reuse Type for them, but with our experience now it seems to be better to remove our Property type and replace it with Type.

This change has a big impact on our codegenerator and updating to this fix will take some time.

Every type in our model should provide the following two methods

<T> T getParent(Class<T> type)
<T> T getParent(Class<T> type, Predicate<T> filter)

For an union type with multiple types, our parser builds a chain of union types. It would be better to just create a list of the types.

When using an enumeration with on off values, for example as follows

ImageSearchConfigStatus:
    type: string
    enum:
        - on
        - off

i get the following error Enum facet contains duplicate values
this seems weird as if the parser consider them the same value.
any ideas what might be the issue here @katmatt @jenschude ?

Merging named example could already work if our example element would extend from NamedElement.

Newer JDK versions don't ship anymore with a javascript script engine and this then breaks the runtime of RMF. We should find a replacement for it and it as a dependency to RMF - instead of relying that the JDK provides it.

Looks like our current validation has the following issues:

• ignores errors in used libraries
• doesn't validate enum values on inline types

Hi @jenschude, thanks for this framework, I think it is great. We are using it now in https://github.com/commercetools/scraml to generate types in sbt.
I stumbled upon In fd6865f when I tried to create a hierarchy of types:

type A
type B
type C extends B, C

B, C and are basically marker interfaces and do not have their own properties or only non-conflicting ones.

In the RAML:

type: [A, B]

While debugging it appeared to me that the resulting type was actually correct for what I was trying to model, giving me an Intersection type with the two types but the TypeConsistencyCheck was throwing an error.

The check seems to be broader than the actual fix, as it is not considering the container type being property and the ignored tests suggest that this was really a quick hack. Any chance this can be revisited again?

Is there an example on how to use this component within Eclipse, as a P2 or similar? It seems the model registers extension points, but what about resource factories.

Example provided by Tigran:

uses:
   traits: traits.raml

Example:

annotationTypes:
  ReferenceType:
    description: |
      This annotation documents the type of an import reference.
    type: string
    enum:
      - category
types:
  MyType:
    (ReferenceType): product

should report an invalid enum value. But doesn't report it.

Currently we don't raise a validation error on:

/{resourceKey}:
   uriParameters:
      key: string

Issue #30 revealed the more generic problem that most of our names in our ANTLR grammar don't support reserved keywords. They're using the SCALAR token instead of the id rule. We should write more tests and fix our grammar appropriately.

Otherwise these facets will end up in the super type of the type.

If a TypedElement has a description facet, we will always create an inline type with this description. It would be better to add a description attribute to TypedElement instead of adding it to the inline type.