open-api | A Monorepo of various packages to power OpenAPI in node | REST library

The answer to both your questions is that this is not possible at the moment.

The GCP API Gateway does not support the handling of CORS at the moment, although it is in the roadmap to be implemented, but you can use a workaround to do that as you can see in this community answer.

On regards to custom authentication, as I decribed in my answer here:

Unfortunately the GCP API Gateway does not provide such option for custom authentication, in order to authenticate using the API Gateway you have to use one of the alternate authentication methods provided in the documentation.

For future reference if others come here for this problem:

I finally found the issue: I was using FROM node:alpine in my Dockerfile, which indicates the latest version of node. However, my application was running on node 10.18.1

Once I changed to FROM:node:10.18.1-alpine the issue was resolved.

Apparently, the express-openapi-validate plugin has some issues in the latest node module, or so it seems.

As Yiyi You suggested, I called UseAllOfToExtendReferenceSchemas in SwaggerGenOptions like this:

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:

base64EncodeWebSafe(data) accepts a string data to encode. While computeHmacSha256Signature(value, key) returns a byte array representing the output signature.

You need to convert Byte array to hex string.

I've got it running by changing 2 points:

• First: I've changed the content type of the response of your /things endpoint, to:

Springdoc has been added to the Spring MVC project using the instructions from the sprindoc website. This meant adding the @EnableWebMvc annotation and changing the configuration class that extended WebMvcConfigurationSupport to implement WebMvcConfigurer. So

time() * 1000

They need 13 character timestamp.

After days and days of trial and error, I was able to pull this off using an interesting trick in Javascript.

First I created the open-api spec as a plain object (as asked in the question). Then passed that to a new decorator, where the magic happens.

In the decorator, I create a DTO class with a predefined name, and map the properties from the plain object to the DTO class. The tricky part is to give it a name dynamically. That can be achieved by the following technique.