[REQ] [typescript] Generalize handling of text/* and json-like content-types

[a-ignatov-parc]

Is your feature request related to a problem? Please describe.

Our API requires the use of various json-like content types, including application/vc+ld+json and application/didcomm-plain+json. Regrettably, the typescript generator has a list of supported content types that is hardcoded, without the option to extend it.

openapi-generator/modules/openapi-generator/src/main/resources/typescript/model/ObjectSerializer.mustache

Lines 25 to 32 in f834519

	const supportedMediaTypes: { [mediaType: string]: number } = {
	"application/json": Infinity,
	"application/json-patch+json": 1,
	"application/merge-patch+json": 1,
	"application/strategic-merge-patch+json": 1,
	"application/octet-stream": 0,
	"application/x-www-form-urlencoded": 0
	}

This creates a challenge in generating clients, as we need to modify templates even though all json-like content types utilize the same parse/stringify implementation.

Describe the solution you'd like

Instead of hardcoding content types, we can implement several predicates that will check if we can serialize/parse the provided content type.

type MimeTypeDescriptor = {
    type: string;
    subtype: string;
    subtypeTokens: string[];
};

const simpleMediaTypeRegex = /([^\/]+)\/([^;]+)/;

const parseMimeType = (mimeType: string): MimeTypeDescriptor | undefined => {
    const result = simpleMediaTypeRegex.exec(mimeType);
    if (!result) return undefined;
    const [, type, subtype] = result;
    return {
        type,
        subtype,
        subtypeTokens: subtype.split('+'),
    };
};

type MimeTypePredicate = (mimeType: string) => boolean;

const isJsonLikeMimeType: MimeTypePredicate = (mimeType) => {
    const result = parseMimeType(mimeType);
    if (!result) return false;
    return result.type === 'application' && result.subtypeTokens.includes('json');
}

const isTextLikeMimeType: MimeTypePredicate = (mimeType) => {
    const result = parseMimeType(mimeType);
    if (!result) return false;
    return result.type === 'text';
}

These helpers could then be used as follows

/**
 * Convert data to a string according the given media type
 */
public static stringify(data: any, mediaType: string): string {
    if (isTextLikeMimeType(mediaType)) {
        return String(data);
    }

    if (isJsonLikeMimeType(mediaType)) {
        return JSON.stringify(data);
    }

    throw new Error("The mediaType " + mediaType + " is not supported by ObjectSerializer.stringify.");
}

/**
 * Parse data from a string according to the given media type
 */
public static parse(rawData: string, mediaType: string | undefined) {
    if (mediaType === undefined) {
        throw new Error("Cannot parse content. No Content-Type defined.");
    }

    if (isTextLikeMimeType(mediaType)) {
        return rawData;
    }

    if (isJsonLikeMimeType(mediaType)) {
        return JSON.parse(rawData);
    }

    throw new Error("The mediaType " + mediaType + " is not supported by ObjectSerializer.parse.");
}

Describe alternatives you've considered

The only viable alternative I found is to augment --additional-properties with a mapping of content types to parsers/serializers. This is a more scalable solution, but in my opinion, it should accompany this proposal.

Additional context

None