feat: add index.ts, generate function and update main section

BREAKING CHANGE: move serializer to languages/typescript, rename default serializer

Author: raveclassic

package.json

@@ -2,7 +2,7 @@
   "name": "@devexperts/swagger-codegen-ts",
   "version": "0.1.0",
   "description": "TS generator for swagger spec",
-  "main": "index.js",
+  "main": "dist/index.js",
   "scripts": {
     "ts-node": "ts-node",
     "tslint": "tslint -c tslint.json --project tsconfig.json './src/**/*.ts' './test/**/*.ts'",

src/index.ts

@@ -0,0 +1,54 @@
+import { SwaggerObject } from './swagger';
+import * as prettier from 'prettier';
+import { map, write } from './fs';
+import { TSerializer } from './utils';
+import * as fs from 'fs-extra';
+import { ThrowReporter } from 'io-ts/lib/ThrowReporter';
+import { fromNullable } from 'fp-ts/lib/Option';
+import * as path from 'path';
+
+const log = console.log.bind(console, '[SWAGGER-CODEGEN-TS]:');
+
+export type TGenerateOptions = {
+	/**
+	 * Absolute path to json spec
+	 */
+	pathToSpec: string;
+	/**
+	 * Absolute path to output directory (should be empty)
+	 */
+	out: string;
+	/**
+	 * Spec serializer
+	 */
+	serialize: TSerializer;
+};
+
+export async function generate(options: TGenerateOptions): Promise<void> {
+	const { pathToSpec, out, serialize } = options;
+	log('Reading spec from', pathToSpec);
+	const buffer = await fs.readFile(pathToSpec);
+	log('Parsing spec');
+	const json = buffer.toJSON();
+	log('Decoding spec');
+	const decoded = SwaggerObject.decode(json);
+	if (decoded.isLeft()) {
+		ThrowReporter.report(decoded);
+		return;
+	}
+	log('Serializing spec');
+	const specName = path.dirname(out);
+	const serialized = serialize(specName, decoded.value);
+	log('Resolving .prettierrc');
+	const prettierConfig = fromNullable(await prettier.resolveConfig(path.resolve(__dirname, '../.prettierrc')));
+	const formatted = prettierConfig
+		.map(config => map(serialized, content => prettier.format(content, config)))
+		.getOrElse(serialized);
+	log('Writing to', out);
+	const destination = path.basename(out);
+	if (!fs.pathExists(destination)) {
+		await fs.mkdirp(destination);
+		await write(destination, formatted);
+	}
+	log('Done.');
+}

src/serializer.ts renamed to src/language/typescript.ts

@@ -11,8 +11,8 @@ import {
 	TResponsesObject,
 	TSchemaObject,
 	TSwaggerObject,
-} from './swagger';
-import { directory, file, TDirectory, TFile } from './fs';
+} from '../swagger';
+import { directory, file, TDirectory, TFile } from '../fs';
 import { array, catOptions, uniq } from 'fp-ts/lib/Array';
 import { getRecordSetoid, Setoid, setoidString } from 'fp-ts/lib/Setoid';
 import { groupBy } from 'fp-ts/lib/NonEmptyArray';
@@ -21,7 +21,8 @@ import {
 	getOperationParametersInPath,
 	getOperationParametersInQuery,
 	groupPathsByTag,
-} from './utils';
+	TSerializer,
+} from '../utils';
 import { none, Option, some } from 'fp-ts/lib/Option';
 import { getArrayMonoid, getRecordMonoid, monoidString, fold, monoidAny } from 'fp-ts/lib/Monoid';
 import { camelize } from '@devexperts/utils/dist/string/string';
@@ -112,7 +113,7 @@ const intercalateSerializedParameter = intercalate(monoidSerializedParameter, ar
 const uniqString = uniq(setoidString);
 const uniqSerializedWithoutDependencies = uniq(setoidSerializedTypeWithoutDependencies);
 
-export const serializeSwaggerObject = (name: string, swaggerObject: TSwaggerObject): TDirectory =>
+export const serialize: TSerializer = (name: string, swaggerObject: TSwaggerObject): TDirectory =>
 	directory(name, [
 		directory('client', [file('client.ts', client)]),
 		...catOptions([swaggerObject.definitions.map(serializeDefinitions)]),

src/utils.ts

@@ -8,10 +8,14 @@ import {
 	TPathParameterObject,
 	TReferenceObject,
 	TBodyParameterObject,
+	TSwaggerObject,
 } from './swagger';
 import { tuple } from 'fp-ts/lib/function';
 import { setoidString } from 'fp-ts/lib/Setoid';
 import { TQueryParameterObject } from './swagger';
+import { TFSEntity } from './fs';
+
+export type TSerializer = (name: string, schema: TSwaggerObject) => TFSEntity;
 
 export const getOperationsFromPath = (path: TPathItemObject): TDictionary<TOperationObject> => {
 	const result: TDictionary<TOperationObject> = {};

test/index.ts

@@ -1,33 +1,14 @@
 #!/usr/bin/env node
 
 import * as path from 'path';
-import * as fs from 'fs-extra';
-import { fromNullable } from 'fp-ts/lib/Option';
-import * as prettier from 'prettier';
-
-import { SwaggerObject } from '../src/swagger';
-import { map, write } from '../src/fs';
-import { serializeSwaggerObject } from '../src/serializer';
+import { generate } from '../src';
+import { serialize } from '../src/language/typescript';
 
 const dirname = path.resolve(__dirname);
 const root = path.resolve(dirname, '..');
-const destination = path.resolve('./out');
-const name = 'spec';
-const json = path.resolve(root, './specs/swagger.json');
-
-const prettierConfig = path.resolve(root, '.prettierrc');
 
-async function run() {
-	const raw = await fs.readFile(json);
-	const spec = JSON.parse(raw.toString());
-	const decoded = SwaggerObject.decode(spec);
-	const serialized = decoded.map(spec => serializeSwaggerObject(name, spec));
-	const config = fromNullable(await prettier.resolveConfig(prettierConfig));
-	await fs.remove(destination);
-	if (serialized.isRight() && config.isSome()) {
-		const formatted = map(serialized.value, serialized => prettier.format(serialized, config.value));
-		await fs.mkdirp(destination);
-		await write(destination, formatted);
-	}
-}
-run();
+generate({
+	pathToSpec: path.resolve(root, './specs/swagger.json'),
+	out: path.resolve('./out/spec'),
+	serialize,
+}).catch(error => console.error(error));

tsconfig.json

@@ -8,6 +8,7 @@
     "noUnusedLocals": true
   },
   "exclude": [
-    "node_modules"
+    "node_modules",
+    "dist"
   ]
 }