[IO-363] add mediaType generic controller

Author: Geksanit

src/language/typescript/3.0/serializers/operation-object.ts

@@ -1,15 +1,4 @@
-import {
-	DEFAULT_MEDIA_TYPE,
-	getJSDoc,
-	getKindValue,
-	getResponseTypeFromMediaType,
-	getSafePropertyName,
-	getTypeName,
-	getURL,
-	HTTPMethod,
-	SUCCESSFUL_CODES,
-	XHRResponseType,
-} from '../../common/utils';
+import { getJSDoc, getKindValue, getSafePropertyName, getTypeName, getURL, HTTPMethod } from '../../common/utils';
 import {
 	getSerializedPropertyType,
 	getSerializedObjectType,
@@ -45,8 +34,8 @@ import { ResolveRefContext, fromString, getRelativePath, Ref } from '../../../..
 import { OperationObject } from '../../../../schema/3.0/operation-object';
 import { ParameterObject, ParameterObjectCodec } from '../../../../schema/3.0/parameter-object';
 import { RequestBodyObjectCodec } from '../../../../schema/3.0/request-body-object';
-import { chain, isSome, none, Option, some, map, fromEither, getOrElse, fold } from 'fp-ts/lib/Option';
-import { constFalse } from 'fp-ts/lib/function';
+import { chain, isSome, none, Option, some, map, fromEither, fold } from 'fp-ts/lib/Option';
+import { constFalse, flow } from 'fp-ts/lib/function';
 import { clientRef } from '../../common/bundled/client';
 import { Kind } from '../../../../utils/types';
 import { ReferenceObjectCodec } from '../../../../schema/3.0/reference-object';
@@ -60,16 +49,13 @@ import {
 	SerializedFragment,
 } from '../../common/data/serialized-fragment';
 import { SchemaObjectCodec } from '../../../../schema/3.0/schema-object';
-import { lookup } from 'fp-ts/lib/Record';
-import { ResponseObjectCodec } from '../../../../schema/3.0/response-object';
 import {
 	fromSerializedHeaderParameter,
 	getSerializedHeaderParameterType,
 	SerializedHeaderParameter,
 } from '../../common/data/serialized-header-parameters';
-import { getResponseMedia } from './response-object';
 
-const getOperationName = (pattern: string, operation: OperationObject, method: HTTPMethod): string =>
+export const getOperationName = (pattern: string, operation: OperationObject, method: HTTPMethod): string =>
 	pipe(
 		operation.operationId,
 		option.getOrElse(() => `${method}_${getSafePropertyName(pattern)}`),
@@ -289,20 +275,6 @@ export const serializeOperationObject = combineReader(
 		);
 
 		const serializedResponses = serializeResponsesObject(from)(operation.responses);
-		const mediaType: string = pipe(
-			SUCCESSFUL_CODES,
-			array.findFirstMap(code => lookup(code, operation.responses)),
-			chain(response =>
-				ReferenceObjectCodec.is(response)
-					? fromEither(e.resolveRef(response.$ref, ResponseObjectCodec))
-					: some(response),
-			),
-			chain(response => response.content),
-			chain(getResponseMedia),
-			map(({ key }) => key),
-			getOrElse(() => DEFAULT_MEDIA_TYPE),
-		);
-		const responseType: XHRResponseType = getResponseTypeFromMediaType(mediaType);
 		const serializedContentType = pipe(
 			operation.requestBody,
 			chain(requestBody =>
@@ -318,10 +290,6 @@ export const serializeOperationObject = combineReader(
 				contentType => `'Content-type': '${contentType}',`,
 			),
 		);
-		const requestHeaders = `{
-			Accept: '${mediaType}',
-			${serializedContentType}
-		}`;
 
 		return combineEither(
 			parameters,
@@ -332,6 +300,7 @@ export const serializeOperationObject = combineReader(
 				const hasBodyParameter = isSome(parameters.serializedBodyParameter);
 				const hasHeaderParameters = isSome(parameters.serializedHeadersParameter);
 				const hasParameters = hasQueryParameters || hasBodyParameter || hasHeaderParameters;
+				const hasResponseMap = either.isRight(serializedResponses);
 
 				const bodyType = pipe(
 					parameters.serializedBodyParameter,
@@ -346,7 +315,7 @@ export const serializeOperationObject = combineReader(
 
 				const queryType = pipe(
 					parameters.serializedQueryParameter,
-					option.map(query => `query: ${query.type},`),
+					option.map(query => `query: ${query.type};`),
 					option.getOrElse(() => ''),
 				);
 				const queryIO = pipe(
@@ -357,7 +326,7 @@ export const serializeOperationObject = combineReader(
 
 				const headersType = pipe(
 					parameters.serializedHeadersParameter,
-					option.map(headers => `headers: ${headers.type}`),
+					option.map(headers => `headers: ${headers.type};`),
 					option.getOrElse(() => ''),
 				);
 
@@ -366,43 +335,102 @@ export const serializeOperationObject = combineReader(
 					option.map(headers => `const headers = ${headers.io}.encode(parameters.headers)`),
 					option.getOrElse(() => ''),
 				);
+				const accepArg = hasResponseMap ? 'accept?: A;' : '';
 
 				const argsType = concatIf(
-					hasParameters,
+					hasParameters || hasResponseMap,
 					parameters.serializedPathParameters.map(p => p.type),
-					[`parameters: { ${queryType}${bodyType}${headersType} }`],
+					[`parameters${hasParameters ? '' : '?'}: { ${queryType}${bodyType}${headersType}${accepArg} }`],
 				).join(',');
 
-				const type = `
+				const type = pipe(
+					serializedResponses,
+					either.fold(
+						sr => `
 					${getJSDoc(array.compact([deprecated, operation.summary]))}
-					readonly ${operationName}: (${argsType}) => ${getKindValue(kind, serializedResponses.type)};
-				`;
+					readonly ${operationName}: (${argsType}) => ${getKindValue(kind, sr.schema.type)};
+				`,
+						sr => `
+					${getJSDoc(array.compact([deprecated, operation.summary]))}
+					readonly ${operationName}: <A extends keyof MapToResponse${operationName} = '${
+							sr[0].mediaType
+						}'>(${argsType}) => ${getKindValue(kind, `MapToResponse${operationName}[A]`)};
+				`,
+					),
+				);
 
 				const argsIO = concatIf(
-					hasParameters,
+					hasParameters || hasResponseMap,
 					parameters.pathParameters.map(p => p.name),
 					['parameters'],
 				).join(',');
 
+				const decode = pipe(
+					serializedResponses,
+					either.fold(
+						sr => `${sr.schema.io}.decode(value)`,
+						() => `decode(accept, value)`,
+					),
+				);
+				const acceptIO = pipe(
+					serializedResponses,
+					either.fold(
+						sr => `const accept = '${sr.mediaType}';`,
+						sr =>
+							`const rawAccept = (parameters && parameters.accept)!;
+							const accept = (rawAccept || '${sr[0].mediaType}') as typeof rawAccept;`,
+					),
+				);
+
+				const mapToIO = pipe(
+					serializedResponses,
+					either.fold(
+						() => '',
+						sr => {
+							const rows = sr.map(s => `'${s.mediaType}': ${s.schema.io}`);
+							return `const mapToIO = { ${rows.join()} };`;
+						},
+					),
+				);
+
+				const decodeIO = pipe(
+					serializedResponses,
+					either.fold(
+						() => '',
+						() =>
+							`const decode = <A extends keyof MapToResponse${operationName}>(a: A, b: unknown) =>
+						(mapToIO[a].decode(b) as unknown) as Either<Errors, MapToResponse${operationName}[A]>;`,
+					),
+				);
+
+				const requestHeaders = `{
+					Accept: accept,
+					${serializedContentType}
+				}`;
+
 				const io = `
 					${operationName}: (${argsIO}) => {
 						${bodyIO}
 						${queryIO}
 						${headersIO}
+						${acceptIO}
+						${mapToIO}
+						${decodeIO}
+						const responseType = getResponseTypeFromMediaType(accept);
 						const requestHeaders = ${requestHeaders}
 
 						return e.httpClient.chain(
 							e.httpClient.request({
 								url: ${getURL(pattern, parameters.serializedPathParameters)},
 								method: '${method}',
-								responseType: '${responseType}',
+								responseType,
 								${when(hasQueryParameters, 'query,')}
 								${when(hasBodyParameter, 'body,')}
 								headers: {${hasHeaderParameters ? '...headers,' : ''} ...requestHeaders}
 							}),
 							value =>
 								pipe(
-									${serializedResponses.io}.decode(value),
+									${decode},
 									either.mapLeft(ResponseValidationError.create),
 									either.fold(error => e.httpClient.throwError(error), decoded => e.httpClient.of(decoded)),
 								),
@@ -411,11 +439,26 @@ export const serializeOperationObject = combineReader(
 				`;
 
 				const dependencies = [
+					serializedDependency('getResponseTypeFromMediaType', '../utils/utils'),
 					serializedDependency('ResponseValidationError', getRelativePath(from, clientRef)),
 					serializedDependency('pipe', 'fp-ts/lib/pipeable'),
 					serializedDependency('either', 'fp-ts'),
 					getSerializedKindDependency(kind),
-					...serializedResponses.dependencies,
+					...pipe(
+						serializedResponses,
+						either.fold(
+							s => s.schema.dependencies,
+							flow(
+								array.map(s => s.schema.dependencies),
+								array.flatten,
+								arr => [
+									...arr,
+									serializedDependency('Errors', 'io-ts'),
+									serializedDependency('Either', 'fp-ts/lib/Either'),
+								],
+							),
+						),
+					),
 					...array.flatten([
 						...parameters.serializedPathParameters.map(p => p.dependencies),
 						...array.compact([

src/language/typescript/3.0/serializers/paths-object.ts

@@ -16,6 +16,7 @@ import { applyTo } from '../../../../utils/function';
 import { PathsObject } from '../../../../schema/3.0/paths-object';
 import { clientRef } from '../../common/bundled/client';
 import { getControllerName } from '../../common/utils';
+import { serializeResponseMaps } from './response-maps';
 
 const serializeGrouppedPaths = combineReader(
 	serializePathItemObject,
@@ -35,13 +36,19 @@ const serializeGrouppedPaths = combineReader(
 			sequenceEither,
 			either.map(foldSerializedTypes),
 		);
+		const serializedResponseMaps = pipe(
+			serializeDictionary(groupped, (pattern, item) => serializeResponseMaps(pattern, item, from)),
+			sequenceEither,
+			either.map(foldSerializedTypes),
+		);
 
 		return combineEither(
 			serializedHKT,
 			serializedKind,
 			serializedKind2,
 			clientRef,
-			(serializedHKT, serializedKind, serializedKind2, clientRef) => {
+			serializedResponseMaps,
+			(serializedHKT, serializedKind, serializedKind2, clientRef, serializedMaps) => {
 				const dependencies = serializeDependencies([
 					...serializedHKT.dependencies,
 					...serializedKind.dependencies,
@@ -56,6 +63,8 @@ const serializeGrouppedPaths = combineReader(
 					`${from.name}.ts`,
 					`
 						${dependencies}
+
+						${serializedMaps.type}
 						
 						export interface ${from.name}<F> {
 							${serializedHKT.type}

src/language/typescript/3.0/serializers/response-maps.ts

@@ -0,0 +1,67 @@
+import { array, either, option } from 'fp-ts';
+import { pipe } from 'fp-ts/lib/pipeable';
+import { flow } from 'fp-ts/lib/function';
+import { Either } from 'fp-ts/lib/Either';
+import { Option } from 'fp-ts/lib/Option';
+import { sequenceEither } from '@devexperts/utils/dist/adt/either.utils';
+import { getOperationName } from './operation-object';
+import { serializeResponsesObject } from './responses-object';
+import { HTTPMethod } from '../../common/utils';
+import { foldSerializedTypes, serializedType, SerializedType } from '../../common/data/serialized-type';
+import { Ref } from '../../../../utils/ref';
+import { PathItemObject } from '../../../../schema/3.0/path-item-object';
+import { OperationObject } from '../../../../schema/3.0/operation-object';
+
+const serializeResponseMap = (
+	pattern: string,
+	method: HTTPMethod,
+	from: Ref,
+	operation: OperationObject,
+): Either<Error, SerializedType> => {
+	const operationName = getOperationName(pattern, operation, method);
+	const serializedResponses = serializeResponsesObject(from)(operation.responses);
+	return pipe(
+		serializedResponses,
+		either.map(
+			flow(
+				either.fold(
+					() => serializedType('', '', [], []),
+					sr => {
+						const rows = sr.map(s => `'${s.mediaType}': ${s.schema.type};`);
+						const type = `type MapToResponse${operationName} = {${rows.join('')}};`;
+						return serializedType(type, '', [], []); // dependecies in serializeOperationObject serializedResponses
+					},
+				),
+			),
+		),
+	);
+};
+
+export const serializeResponseMaps = (
+	pattern: string,
+	item: PathItemObject,
+	from: Ref,
+): Either<Error, SerializedType> => {
+	const methods: [HTTPMethod, Option<OperationObject>][] = [
+		['GET', item.get],
+		['POST', item.post],
+		['PUT', item.put],
+		['DELETE', item.delete],
+		['PATCH', item.patch],
+		['HEAD', item.head],
+		['OPTIONS', item.options],
+	];
+
+	return pipe(
+		methods,
+		array.map(([method, opObject]) =>
+			pipe(
+				opObject,
+				option.map(operation => serializeResponseMap(pattern, method, from, operation)),
+			),
+		),
+		array.compact,
+		sequenceEither,
+		either.map(foldSerializedTypes),
+	);
+};