Typescript 2 refs

src/index.ts

@@ -4,7 +4,7 @@ import * as path from 'path';
 import * as $RefParser from 'json-schema-ref-parser';
 import { pipe } from 'fp-ts/lib/pipeable';
 import { array, either, taskEither } from 'fp-ts';
-import { Either } from 'fp-ts/lib/Either';
+import { Either, isLeft } from 'fp-ts/lib/Either';
 import { identity } from 'fp-ts/lib/function';
 import { reportIfFailed } from './utils/io-ts';
 import { TaskEither } from 'fp-ts/lib/TaskEither';
@@ -47,9 +47,14 @@ export const generate = <A>(options: GenerateOptions<A>): TaskEither<unknown, vo
 			array.reduce({}, (acc, [fullPath, spec]) => {
 				const relative = path.relative(cwd, fullPath);
 				log('Decoding', relative);
+				const decoded = reportIfFailed(options.decoder.decode(spec));
+				if (isLeft(decoded)) {
+					log('Unable to decode', relative, 'as OpenAPI spec. Treat it as an arbitrary json');
+					return acc;
+				}
 				return {
 					...acc,
-					[relative]: getUnsafe(reportIfFailed(options.decoder.decode(spec))),
+					[relative]: decoded.right,
 				};
 			}),
 		);

src/language/typescript/2.0-rx/index.ts

@@ -8,18 +8,22 @@ import { serializeSwaggerObject } from './serializers/swagger-object';
 import { format } from 'prettier';
 import { Either } from 'fp-ts/lib/Either';
 import { sequenceEither } from '@devexperts/utils/dist/adt/either.utils';
+import { combineReader } from '@devexperts/utils/dist/adt/reader.utils';
 
-export const serialize = (
-	out: string,
-	documents: Dictionary<SwaggerObject>,
-	options: SerializeOptions = {},
-): Either<Error, FSEntity> =>
-	pipe(
-		documents,
-		record.collect(serializeSwaggerObject),
-		sequenceEither,
-		either.map(serialized => directory(out, serialized)),
-		either.map(serialized =>
-			map(serialized, content => format(content, options.prettierConfig || defaultPrettierConfig)),
+export const serialize = combineReader(
+	serializeSwaggerObject,
+	serializeSwaggerObject => (
+		out: string,
+		documents: Dictionary<SwaggerObject>,
+		options: SerializeOptions = {},
+	): Either<Error, FSEntity> =>
+		pipe(
+			documents,
+			record.collect(serializeSwaggerObject),
+			sequenceEither,
+			either.map(serialized => directory(out, serialized)),
+			either.map(serialized =>
+				map(serialized, content => format(content, options.prettierConfig || defaultPrettierConfig)),
+			),
 		),
-	);
+);

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

@@ -3,25 +3,30 @@ import { directory, Directory, file, File } from '../../../../utils/fs';
 import { serializeSchemaObject } from './schema-object';
 import { serializeDependencies } from '../../common/data/serialized-dependency';
 import { DefinitionsObject } from '../../../../schema/2.0/definitions-object';
-import { DEFINITIONS_DIRECTORY, getIOName, ROOT_DIRECTORY } from '../../common/utils';
+import { DEFINITIONS_DIRECTORY, getIOName } from '../../common/utils';
 import { pipe } from 'fp-ts/lib/pipeable';
 import { either, record } from 'fp-ts';
 import { Either } from 'fp-ts/lib/Either';
 import { sequenceEither } from '@devexperts/utils/dist/adt/either.utils';
+import { addPathParts, Ref } from '../../../../utils/ref';
 
-export const serializeDefinitions = (definitions: DefinitionsObject): Either<Error, Directory> =>
+export const serializeDefinitions = (from: Ref, definitions: DefinitionsObject): Either<Error, Directory> =>
 	pipe(
 		definitions,
 		record.collect((name, definition) =>
-			serializeDefinition(name, definition, `${ROOT_DIRECTORY}/${DEFINITIONS_DIRECTORY}`),
+			pipe(
+				from,
+				addPathParts(name),
+				either.chain(from => serializeDefinition(from, name, definition)),
+			),
 		),
 		sequenceEither,
 		either.map(serialized => directory(DEFINITIONS_DIRECTORY, serialized)),
 	);
 
-const serializeDefinition = (name: string, definition: SchemaObject, cwd: string): Either<Error, File> =>
+const serializeDefinition = (from: Ref, name: string, definition: SchemaObject): Either<Error, File> =>
 	pipe(
-		serializeSchemaObject(definition, name, cwd),
+		serializeSchemaObject(from, definition),
 		either.map(serialized => {
 			const dependencies = serializeDependencies(serialized.dependencies);
 			return file(

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

@@ -0,0 +1,26 @@
+import { ItemsObject } from '../../../../schema/2.0/items-object';
+import {
+	getSerializedArrayType,
+	SERIALIZED_BOOLEAN_TYPE,
+	SERIALIZED_NUMERIC_TYPE,
+	SERIALIZED_STRING_TYPE,
+	SerializedType,
+} from '../../common/data/serialized-type';
+
+export const serializeItemsObject = (itemsObject: ItemsObject): SerializedType => {
+	switch (itemsObject.type) {
+		case 'array': {
+			return getSerializedArrayType()(serializeItemsObject(itemsObject.items));
+		}
+		case 'string': {
+			return SERIALIZED_STRING_TYPE;
+		}
+		case 'number':
+		case 'integer': {
+			return SERIALIZED_NUMERIC_TYPE;
+		}
+		case 'boolean': {
+			return SERIALIZED_BOOLEAN_TYPE;
+		}
+	}
+};