schema-generator | FR的schema的可视化生成器 | Generator Utils library

Turns out I need at least 1 @Query decorator in my resolvers, I just added a dummy resolver until I need an actual query. For testing, I switched to supertest, check this example if you are interested in using it too for testing

As you can read in an issue posted in the issue tracker of doctrine/cache, that class has been deprecated in v1 of that package, and removed in v2.

If you still want to use that class, run composer require doctrine/cache "^1.12" to install a version of that package from the v1 branch.

On the long run, you should check where your application requires that class and search for alternatives. If you need help with that, please share more details.

I've found a solution. It doesn't use the TypeScript compiler API, directly, but rather the excellent ts-morph library, a wrapper for the compiler API which simplifies many tasks. Here's some example code, where the test.ts file contains the example code from my question above.

I very strongly recommend that you do NOT re-use your production DTO-s for your tests. Think about it, you are setting yourself up for failure - and run the risk of not realizing when a "refactoring" that someone applied via the IDE etc. breaks your API clients.

You should be testing from the perspective of clients which for many teams is a web-browser. That is why Karate avoids Java and sticks to JSON + HTTP.

Second, testing for schema-fit has very little value in my honest opinion. Based on what you said, it is quite likely that your JSON is being generated from the DTO-s already, which makes it even less valuable in your specific case.

Sorry if that sounds harsh, but I see this mistake made all over the place. Being DRY is over-rated especially in a test-automation context.

That said, if you are lucky, the karate.toJson() method would be able to convert your DTO-s into JSON, but if you are using some fancy annotations it may not work, it is all based on the JavaBean conventions.

Finally I would say just use Java inter-op, call some Java library to do schema validation and call it a day as seen in schema.feature over here.

To summarize, I think you should forget about schema validation and focus on testing the "business flows" of your API-s, where you typically chain API-s. Create product. Create order. Check if inventory is reduced. Etc etc. Once you have those in place, then think about whether it is worth testing for schema-fit or not.

I don't think a reputable source is available on this subject but i do have long experience with frameworks, abstract user interfaces and php and created MetaClass Tutorial Api Platform so i will try to answer your question myself.

The tutorial aims to cover the common ground of most CRUD and Search apps for both an api platform api and a react client generated with the api platform client generator. The tutorial does not cover inheritance and polymorphism because i do not think it occurs in many CRUD and Search apps but it adresses many aspects that do, for an overview see the list of chapters in the readme of the master branch. Api Platform offers a lot of generic functionality for the api of such apps out of the box that only needs to be configured for specific resources and operations. In the react branches this led to recurring patterns and refactoring into common components and eventually to an extended react client generator to accompany the tutorial. The scheme of serialization groups in this answer is a bit more generic because my understanding of the subject has improved over time.

Your classes worked out of the box on Api Platform 2.6 except for the repository classes that where not included. I removed them from the annotation as right now none of their specific methods seem to be called. You can allways add them again when your need them.

Against the common preference for REST in general to use a single endpoint /animals i chose for individual ones for /dogs, /cats, and /mice because:

1. Api Platform identifies instances of resource classes by iri's that refer to these specific endpoints and inludes them as values of @id whenever these instances are serialized. The client generater, and i suppose the admin client too, depend on these endpoints to work for crud operations,
2. With Api Platform specific post operations work out of the box with doctrine orm. An endpoint /animals would require a custom Denormalizer that can decide which concrete class to instantiate.
3. With serialization groups specific end points give more control over serializations. Without that is it hard to get serialization compatible with the way it is done in chapter 4 of the tutorial,
4. In many of the extension points of Api Platform it is easy to make things work for a spefic resource and all examples in the docs make use of that. Making them specific for the actual concrete subclass of the object at hand is undocumented and may not allways be possible.

I only include the /animals get collection operation because that allows the client to retrieve, search and sort a polymophic collection of animals in a single request.

In line with chapter 4 of the tutorial i removed the write annotation groups. Api Platforms deserialization already allows the client to only include those properties with post, put and patch that hold data and are meant be set, so the only purpose of deserialization groups can be to disallow certain properties to be set through (certain operations of) the api or to allow the creation of related objects through nested documents. When i tried to add a new cat by posting it as value of $ateByCat of a mouse i got error "Nested documents for attribute "ateByCat" are not allowed. Use IRIs instead." The same happened with adding one through Dog::$catsChased, so security by operation with certain roles granted does not seem to be compromised without write annotation groups. Seems like a sound default to me.

I added a ::getLabel method to Animal to represent each by a single string (annotated as http://schema.org/name). Basic CRUD and Search clients primarily show a single type of entities to the user and represent related entities this way. Having a specific schema.org/name property is more convenient for the client and making it a derived property is more flexible then then adding different properties depending on the type of entity. The label property is the only property that is added to the "related" group. This group is added to the normalization context of each type so that for the "get" operations of Cat, Doc and Mouse it is the only property serialized for related objects:

I have managed to solve the problem by changing the import of the class 'Project' made in the 'ProjectResolver' class.

Instead of: import {Project} from '../entities/project'

Now looks like this: import {Project} from '../../src/entities/project'

Finally figured out a solution after visiting the NPM page for axe-cypress.

The JavaExec Plugin seems to meet your requirements.

This allows you to run a main() method and thereby any Java Code you want – including whatever JSON Schema generation you like.

This other answer also describes pretty much what you want to do.

Adapted from the linked documentation:

Your ormconfig.json need to look like this: