CHANGELOG.md

@@ -1,3 +1,36 @@
+# [2.0.0-alpha.4](https://github.com/devexperts/swagger-codegen-ts/compare/v2.0.0-alpha.3...v2.0.0-alpha.4) (2019-11-11)
+
+
+### Code Refactoring
+
+* rename ReferenceObject codec to ReferenceObjectCodec ([bdda8e2](https://github.com/devexperts/swagger-codegen-ts/commit/bdda8e2))
+* update SchemaObject ([0b4cf16](https://github.com/devexperts/swagger-codegen-ts/commit/0b4cf16))
+* update SchemaObject ([58ea69d](https://github.com/devexperts/swagger-codegen-ts/commit/58ea69d))
+
+
+### Features
+
+* add branded numeric types and codecs ([7739952](https://github.com/devexperts/swagger-codegen-ts/commit/7739952))
+* asyncapi shema ([5fc7b84](https://github.com/devexperts/swagger-codegen-ts/commit/5fc7b84))
+* full enum support ([21a6b8c](https://github.com/devexperts/swagger-codegen-ts/commit/21a6b8c))
+* oneOf support for typescript openapi 3 ([f9e2ab5](https://github.com/devexperts/swagger-codegen-ts/commit/f9e2ab5))
+* support Data Type Format in SchemaObject ([d8bc635](https://github.com/devexperts/swagger-codegen-ts/commit/d8bc635))
+* support ws channel bindings ([dab6d10](https://github.com/devexperts/swagger-codegen-ts/commit/dab6d10)), closes [#68](https://github.com/devexperts/swagger-codegen-ts/issues/68)
+
+
+### BREAKING CHANGES
+
+* IntegerSchemaObject now emits `Integer` type and `integer` codec from utils
+* SchemaObject.format was moved to PrimitiveSchemaObject.format
+* SchemaObject codec and interfaces were renamed
+* EnumSchemaObject type was added to SchemaObject
+* ReferenceObject was renamed to ReferenceObjectCodec
+* some codecs were renamed and moved
+* OneOfSchemaObject type was added to SchemaObject
+* Fragment type was added to FSEntity
+
+
+
 # [2.0.0-alpha.3](https://github.com/devexperts/swagger-codegen-ts/compare/v2.0.0-alpha.2...v2.0.0-alpha.3) (2019-11-06)
 
 

README.md

@@ -1,4 +1,9 @@
 [![Build Status](https://travis-ci.org/devexperts/swagger-codegen-ts.svg?branch=master)](https://travis-ci.org/devexperts/swagger-codegen-ts)
+
+### FAQ
+  1. **Why don't spec codecs reuse common parts?**
+
+     That's because different versions of specs refer to different versions of [JSON Schema](http://json-schema.org) and they are generally not the same. We would like to avoid maintaining JSON Schema composition in this project. (for now)  
 
 ### Contributions
 - use https://www.conventionalcommits.org/en/v1.0.0-beta.2/

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devexperts/swagger-codegen-ts",
-  "version": "2.0.0-alpha.3",
+  "version": "2.0.0-alpha.4",
   "description": "TS generator for swagger spec",
   "main": "dist/index.js",
   "scripts": {

src/index.ts

@@ -75,4 +75,7 @@ const specLikeCodec = union([
 	type({
 		openapi: union([literal('3.0.0'), literal('3.0.1'), literal('3.0.2')]),
 	}),
+	type({
+		asyncapi: literal('2.0.0'),
+	}),
 ]);

src/language/typescript/2.0/serializers/__tests__/schema-object.spec.ts

@@ -10,7 +10,7 @@ import {
 } from '../../../common/data/serialized-type';
 import { pipe } from 'fp-ts/lib/pipeable';
 import { serializeSchemaObject } from '../schema-object';
-import { SchemaObjectCodec } from '../../../../../schema/2.0/schema-object/schema-object';
+import { SchemaObjectCodec } from '../../../../../schema/2.0/schema-object';
 import { right } from 'fp-ts/lib/Either';
 import { either } from 'fp-ts';
 import { reportIfFailed } from '../../../../../utils/io-ts';

src/language/typescript/2.0/serializers/definitions-object.ts

@@ -1,4 +1,4 @@
-import { SchemaObject } from '../../../../schema/2.0/schema-object/schema-object';
+import { SchemaObject } from '../../../../schema/2.0/schema-object';
 import { directory, Directory, file, File } from '../../../../utils/fs';
 import { serializeSchemaObject } from './schema-object';
 import { serializeDependencies } from '../../common/data/serialized-dependency';

src/language/typescript/2.0/serializers/items-object.ts

@@ -2,7 +2,7 @@ import { ItemsObject } from '../../../../schema/2.0/items-object';
 import {
 	getSerializedArrayType,
 	SERIALIZED_BOOLEAN_TYPE,
-	SERIALIZED_NUMERIC_TYPE,
+	SERIALIZED_NUMBER_TYPE,
 	SERIALIZED_STRING_TYPE,
 	SerializedType,
 } from '../../common/data/serialized-type';
@@ -17,7 +17,7 @@ export const serializeItemsObject = (itemsObject: ItemsObject): SerializedType =
 		}
 		case 'number':
 		case 'integer': {
-			return SERIALIZED_NUMERIC_TYPE;
+			return SERIALIZED_NUMBER_TYPE;
 		}
 		case 'boolean': {
 			return SERIALIZED_BOOLEAN_TYPE;

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

@@ -29,7 +29,7 @@ import { Either, isLeft, right } from 'fp-ts/lib/Either';
 import { array, either, nonEmptyArray, option } from 'fp-ts';
 import { combineEither, sequenceEither } from '@devexperts/utils/dist/adt/either.utils';
 import { fromString, getRelativePath, Ref } from '../../../../utils/ref';
-import { clientRef } from '../../common/client';
+import { clientRef } from '../../common/bundled/client';
 import {
 	BodyParameterObject,
 	FormDataParameterObject,
@@ -39,7 +39,7 @@ import {
 	PathParameterObject,
 	QueryParameterObject,
 } from '../../../../schema/2.0/parameter-object';
-import { ReferenceObject } from '../../../../schema/2.0/reference-object';
+import { ReferenceObjectCodec } from '../../../../schema/2.0/reference-object';
 import { isRequired, serializeParameterObject } from './parameter-object';
 import {
 	fromSerializedParameter,
@@ -91,7 +91,7 @@ const getParameters = combineReader(
 		);
 
 		for (const parameter of parameters) {
-			if (ReferenceObject.is(parameter)) {
+			if (ReferenceObjectCodec.is(parameter)) {
 				const reference = fromString(parameter.$ref);
 				if (isLeft(reference)) {
 					return reference;

src/language/typescript/2.0/serializers/parameter-object.ts

@@ -3,7 +3,7 @@ import { ParameterObject } from '../../../../schema/2.0/parameter-object';
 import {
 	getSerializedArrayType,
 	SERIALIZED_BOOLEAN_TYPE,
-	SERIALIZED_NUMERIC_TYPE,
+	SERIALIZED_NUMBER_TYPE,
 	SERIALIZED_STRING_TYPE,
 	SERIALIZED_UNKNOWN_TYPE,
 } from '../../common/data/serialized-type';
@@ -31,7 +31,7 @@ export const serializeParameterObject = (
 				}
 				case 'number':
 				case 'integer': {
-					return right(toSerializedParameter(SERIALIZED_NUMERIC_TYPE));
+					return right(toSerializedParameter(SERIALIZED_NUMBER_TYPE));
 				}
 				case 'boolean': {
 					return right(toSerializedParameter(SERIALIZED_BOOLEAN_TYPE));

src/language/typescript/2.0/serializers/path-item-object.ts

@@ -12,7 +12,7 @@ import { Either } from 'fp-ts/lib/Either';
 import { combineEither, sequenceEither } from '@devexperts/utils/dist/adt/either.utils';
 import { either, nonEmptyArray, option, record } from 'fp-ts';
 import { getRelativePath, Ref } from '../../../../utils/ref';
-import { clientRef } from '../../common/client';
+import { clientRef } from '../../common/bundled/client';
 import { OperationObject } from '../../../../schema/2.0/operation-object';
 import { tuple } from 'fp-ts/lib/function';
 import { uniqString } from '../../../../utils/array';

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

@@ -12,7 +12,7 @@ import { PathItemObject } from '../../../../schema/2.0/path-item-object';
 import { camelize, decapitalize } from '@devexperts/utils/dist/string';
 import { combineReader } from '@devexperts/utils/dist/adt/reader.utils';
 import { serializedDependency, serializeDependencies } from '../../common/data/serialized-dependency';
-import { clientRef } from '../../common/client';
+import { clientRef } from '../../common/bundled/client';
 
 export const serializePaths = combineReader(
 	serializePathGroup,

src/language/typescript/2.0/serializers/schema-object.ts

@@ -1,22 +1,28 @@
 import {
 	getSerializedRefType,
-	SERIALIZED_NUMERIC_TYPE,
+	SERIALIZED_NUMBER_TYPE,
 	SERIALIZED_BOOLEAN_TYPE,
 	SERIALIZED_UNKNOWN_TYPE,
 	serializedType,
 	SerializedType,
-	SERIALIZED_DATE_TYPE,
-	SERIALIZED_STRING_TYPE,
 	getSerializedPropertyType,
 	intercalateSerializedTypes,
 	getSerializedObjectType,
 	getSerializedRecursiveType,
 	getSerializedDictionaryType,
 	getSerializedIntersectionType,
+	getSerializedEnumType,
+	SERIALIZED_NULL_TYPE,
+	getSerializedIntegerType,
+	getSerializedStringType,
 } from '../../common/data/serialized-type';
 import { serializedDependency } from '../../common/data/serialized-dependency';
-import { AllOfSchemaObject, SchemaObject } from '../../../../schema/2.0/schema-object/schema-object';
-import { none, some } from 'fp-ts/lib/Option';
+import {
+	AllOfSchemaObject,
+	EnumSchemaObjectCodec,
+	PrimitiveSchemaObject,
+	SchemaObject,
+} from '../../../../schema/2.0/schema-object';
 import { pipe } from 'fp-ts/lib/pipeable';
 import { constFalse } from 'fp-ts/lib/function';
 import { includes } from '../../../../utils/array';
@@ -25,7 +31,9 @@ import { Either, right } from 'fp-ts/lib/Either';
 import { sequenceEither } from '@devexperts/utils/dist/adt/either.utils';
 import { either, option, record } from 'fp-ts';
 import { traverseNEAEither } from '../../../../utils/either';
-import { ReferenceObject } from '../../../../schema/2.0/reference-object';
+import { ReferenceObject, ReferenceObjectCodec } from '../../../../schema/2.0/reference-object';
+import { NonEmptyArray } from 'fp-ts/lib/NonEmptyArray';
+import { utilsRef } from '../../common/bundled/utils';
 
 export const serializeSchemaObject = (from: Ref, schema: SchemaObject): Either<Error, SerializedType> =>
 	serializeSchemaObjectWithRecursion(from, schema, true);
@@ -36,50 +44,29 @@ const serializeSchemaObjectWithRecursion = (
 	shouldTrackRecursion: boolean,
 ): Either<Error, SerializedType> => {
 	// check non-typed schemas first
-	if (ReferenceObject.is(schema)) {
+	if (ReferenceObjectCodec.is(schema)) {
 		return pipe(
 			fromString(schema.$ref),
 			either.map(getSerializedRefType(from)),
 		);
 	}
 
+	if (EnumSchemaObjectCodec.is(schema)) {
+		return right(getSerializedEnumType(schema.enum));
+	}
+
 	if (AllOfSchemaObject.is(schema)) {
-		return pipe(
-			traverseNEAEither(schema.allOf, item => serializeSchemaObjectWithRecursion(from, item, false)),
-			either.map(getSerializedIntersectionType),
-			either.map(getSerializedRecursiveType(from, shouldTrackRecursion)),
-		);
+		return serializeAllOf(from, schema.allOf, shouldTrackRecursion);
 	}
 
 	// schema is typed
 	switch (schema.type) {
-		case 'string': {
-			return pipe(
-				schema.enum,
-				option.map(serializeEnum),
-				option.alt(() =>
-					pipe(
-						schema.format,
-						option.chain(format => {
-							switch (format) {
-								case 'date-time': {
-									return some(SERIALIZED_DATE_TYPE);
-								}
-							}
-							return none;
-						}),
-					),
-				),
-				option.getOrElse(() => SERIALIZED_STRING_TYPE),
-				right,
-			);
-		}
-		case 'boolean': {
-			return right(SERIALIZED_BOOLEAN_TYPE);
-		}
+		case 'null':
+		case 'string':
+		case 'number':
 		case 'integer':
-		case 'number': {
-			return right(SERIALIZED_NUMERIC_TYPE);
+		case 'boolean': {
+			return serializePrimitive(from, schema);
 		}
 		case 'array': {
 			return pipe(
@@ -139,16 +126,36 @@ const serializeSchemaObjectWithRecursion = (
 	}
 };
 
-const serializeEnum = (enumValue: Array<string | number | boolean>): SerializedType => {
-	const type = enumValue.map(value => `'${value}'`).join(' | ');
-	const io =
-		enumValue.length === 1
-			? `literal(${type})`
-			: `union([${enumValue.map(value => `literal('${value}')`).join(',')}])`;
-	return serializedType(
-		type,
-		io,
-		[serializedDependency('union', 'io-ts'), serializedDependency('literal', 'io-ts')],
-		[],
+const serializeAllOf = (
+	from: Ref,
+	allOf: NonEmptyArray<ReferenceObject | SchemaObject>,
+	shouldTrackRecursion: boolean,
+): Either<Error, SerializedType> =>
+	pipe(
+		traverseNEAEither(allOf, item => serializeSchemaObjectWithRecursion(from, item, false)),
+		either.map(getSerializedIntersectionType),
+		either.map(getSerializedRecursiveType(from, shouldTrackRecursion)),
 	);
+
+const serializePrimitive = (from: Ref, schemaObject: PrimitiveSchemaObject): Either<Error, SerializedType> => {
+	switch (schemaObject.type) {
+		case 'null': {
+			return right(SERIALIZED_NULL_TYPE);
+		}
+		case 'string': {
+			return right(getSerializedStringType(schemaObject.format));
+		}
+		case 'number': {
+			return right(SERIALIZED_NUMBER_TYPE);
+		}
+		case 'integer': {
+			return pipe(
+				utilsRef,
+				either.map(utilsRef => getSerializedIntegerType(from, utilsRef)),
+			);
+		}
+		case 'boolean': {
+			return right(SERIALIZED_BOOLEAN_TYPE);
+		}
+	}
 };

src/language/typescript/2.0/serializers/swagger-object.ts

@@ -8,10 +8,11 @@ import { array, either, option } from 'fp-ts';
 import { combineEither, sequenceEither } from '@devexperts/utils/dist/adt/either.utils';
 import { SwaggerObject } from '../../../../schema/2.0/swagger-object';
 import { fromString } from '../../../../utils/ref';
-import { clientFile } from '../../common/client';
+import { clientFile } from '../../common/bundled/client';
 import { serializeParametersDefinitionsObject } from './parameters-definitions-object';
 import { combineReader } from '@devexperts/utils/dist/adt/reader.utils';
 import { serializeResponsesDefinitionsObject } from './responses-definitions-object';
+import { utilsFile } from '../../common/bundled/utils';
 
 const definitionsRef = fromString('#/definitions');
 const parametersRef = fromString('#/parameters');
@@ -56,8 +57,8 @@ export const serializeSwaggerObject = combineReader(
 			pathsRef,
 			either.chain(from => serializePaths(from, swaggerObject.paths)),
 		);
-		return combineEither(additional, paths, clientFile, (additional, paths, clientFile) =>
-			directory(name, [clientFile, ...additional, paths]),
+		return combineEither(additional, paths, clientFile, utilsFile, (additional, paths, clientFile, utilsFile) =>
+			directory(name, [clientFile, utilsFile, ...additional, paths]),
 		);
 	},
 );

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

@@ -2,11 +2,10 @@ import { Either, right } from 'fp-ts/lib/Either';
 import { directory, Directory, File, file, FSEntity } from '../../../../utils/fs';
 import { serializeSchemaObject } from './schema-object';
 import { pipe } from 'fp-ts/lib/pipeable';
-import { sequenceEither, sequenceTEither } from '@devexperts/utils/dist/adt/either.utils';
+import { combineEither, sequenceEither, sequenceTEither } from '@devexperts/utils/dist/adt/either.utils';
 import { array, either, option, record } from 'fp-ts';
 import { serializeDependencies } from '../../common/data/serialized-dependency';
-import { combineEither } from '@devexperts/utils/dist/adt/either.utils';
-import { Context, getIOName, getTypeName } from '../../common/utils';
+import { context, getIOName, getTypeName } from '../../common/utils';
 import { addPathParts, Ref } from '../../../../utils/ref';
 import { SchemaObject, SchemaObjectCodec } from '../../../../schema/3.0/schema-object';
 import { ComponentsObject } from '../../../../schema/3.0/components-object';
@@ -16,14 +15,11 @@ import { ReferenceObject, ReferenceObjectCodec } from '../../../../schema/3.0/re
 import { ResponseObject, ResponseObjectCodec } from '../../../../schema/3.0/response-object';
 import { SERIALIZED_VOID_TYPE } from '../../common/data/serialized-type';
 import { serializeResponseObject } from './response-object';
-import { ask } from 'fp-ts/lib/Reader';
 import { combineReader } from '@devexperts/utils/dist/adt/reader.utils';
 import { reportIfFailed } from '../../../../utils/io-ts';
 import { RequestBodyObject, RequestBodyObjectCodec } from '../../../../schema/3.0/request-body-object';
 import { serializeRequestBodyObject } from './request-body-object';
 
-const context = ask<Context>();
-
 const serializeSchema = (from: Ref, schema: SchemaObject): Either<Error, File> => {
 	const typeName = getTypeName(from.name);
 	const ioName = getIOName(from.name);

src/language/typescript/3.0/serializers/document.ts

@@ -10,7 +10,8 @@ import { array, either, option } from 'fp-ts';
 import { applyTo } from '../../../../utils/function';
 import { OpenapiObject } from '../../../../schema/3.0/openapi-object';
 import { pathsRef } from '../../common/utils';
-import { clientFile } from '../../common/client';
+import { clientFile } from '../../common/bundled/client';
+import { utilsFile } from '../../common/bundled/utils';
 
 export const serializeDocument = combineReader(
 	serializeComponentsObject,
@@ -42,8 +43,8 @@ export const serializeDocument = combineReader(
 			array.compact([components]),
 			sequenceEither,
 		);
-		return combineEither(paths, additional, clientFile, (paths, additional, clientFile) =>
-			directory(name, [paths, ...additional, clientFile]),
+		return combineEither(paths, additional, clientFile, utilsFile, (paths, additional, clientFile, utilsFile) =>
+			directory(name, [paths, ...additional, clientFile, utilsFile]),
 		);
 	},
 );