ci: fix build

Author: raveclassic

src/index.ts

@@ -13,21 +13,30 @@ const log = console.log.bind(console, '[SWAGGER-CODEGEN-TS]:');
 
 export type TGenerateOptions = {
 	/**
-	 * Absolute path to json spec
+	 * Path to json spec
 	 */
 	pathToSpec: string;
 	/**
-	 * Absolute path to output directory (should be empty)
+	 * Path to output directory (should be empty)
 	 */
 	out: string;
 	/**
 	 * Spec serializer
 	 */
 	serialize: TSerializer;
+	/**
+	 * Path to prettier config
+	 */
+	pathToPrettierConfig?: string;
 };
 
+const cwd = process.cwd();
+const resolvePath = (p: string) => (path.isAbsolute(p) ? p : path.resolve(cwd, p));
+
 export async function generate(options: TGenerateOptions): Promise<void> {
-	const { pathToSpec, out, serialize } = options;
+	const { serialize, pathToPrettierConfig } = options;
+	const out = resolvePath(options.out);
+	const pathToSpec = resolvePath(options.pathToSpec);
 	log('Reading spec from', pathToSpec);
 	const buffer = await fs.readFile(pathToSpec);
 	log('Parsing spec');
@@ -42,18 +51,19 @@ export async function generate(options: TGenerateOptions): Promise<void> {
 		return;
 	}
 	log('Serializing spec');
-	const specName = path.dirname(out);
-	const serialized = serialize(specName, decoded.value);
+	const serialized = serialize(path.basename(out), decoded.value);
 	log('Running prettier');
-	const prettierConfig = fromNullable(await prettier.resolveConfig(path.resolve(__dirname, '../.prettierrc')));
+	const prettierConfig = fromNullable(
+		await prettier.resolveConfig(
+			fromNullable(pathToPrettierConfig)
+				.map(resolvePath)
+				.getOrElseL(() => 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);
-	}
+	await write(path.dirname(out), formatted);
 	log('Done.');
 }

src/swagger.ts

@@ -606,29 +606,114 @@ export const ResponsesDefinitionsObject: t.Type<TResponsesDefinitionsObject, mix
 	ResponseObject,
 );
 
-export type TScopeaObject = TDictionary<string>;
-export const ScopesObject: t.Type<TScopeaObject, mixed> = t.dictionary(t.string, t.string);
+export type TScopesObject = TDictionary<string>;
+export const ScopesObject: t.Type<TScopesObject, mixed> = t.dictionary(t.string, t.string);
 
-export type TSecuritySchemeObject = {
-	type: 'basic' | 'apiKey' | 'oauth2';
+//#region SecuritySchemeObject
+
+export type TBaseSecuritySchemeObjectProps = {
 	description: Option<string>;
-	name: string;
-	in: 'query' | 'header';
-	flow: 'implicit' | 'password' | 'application' | 'accessCode';
-	authorizationUrl: string;
-	tokenUrl: string;
-	scopes: TScopeaObject;
 };
-export const SecuritySchemeObject: t.Type<TSecuritySchemeObject, mixed> = t.type({
-	type: t.union([t.literal('basic'), t.literal('apiKey'), t.literal('oauth2')]),
+const BaseSecuritySchemeObjectProps = {
 	description: stringOption,
-	name: t.string,
+};
+(): t.Type<TBaseSecuritySchemeObjectProps, mixed> => t.type(BaseSecuritySchemeObjectProps); //tslint:disable-line no-unused-expression (integrity check)
+
+export type TBasicSecuritySchemeObject = TBaseSecuritySchemeObjectProps & {
+	type: 'basic';
+};
+const BasicSecuritySchemeObject: t.Tagged<'type', TBasicSecuritySchemeObject, mixed> = t.type({
+	...BaseSecuritySchemeObjectProps,
+	type: t.literal('basic'),
+});
+
+export type TApiKeySecuritySchemeObject = TBaseSecuritySchemeObjectProps & {
+	type: 'apiKey';
+	in: 'query' | 'header';
+	name: string;
+};
+const ApiKeySecuritySchemeObject: t.Tagged<'type', TApiKeySecuritySchemeObject, mixed> = t.type({
+	...BaseSecuritySchemeObjectProps,
+	type: t.literal('apiKey'),
 	in: t.union([t.literal('query'), t.literal('header')]),
-	flow: t.union([t.literal('implicit'), t.literal('password'), t.literal('application'), t.literal('accessCode')]),
+	name: t.string,
+});
+
+export type TImplicitOAuth2SecuritySchemeObject = TBaseSecuritySchemeObjectProps & {
+	type: 'oauth2';
+	flow: 'implicit';
+	authorizationUrl: string;
+	scopes: TScopesObject;
+};
+const ImplicitOAuth2SecuritySchemeObject: t.Tagged<'flow', TImplicitOAuth2SecuritySchemeObject, mixed> = t.type({
+	...BaseSecuritySchemeObjectProps,
+	type: t.literal('oauth2'),
+	flow: t.literal('implicit'),
 	authorizationUrl: t.string,
+	scopes: ScopesObject,
+});
+export type TPasswordOAuth2SecuritySchemeObject = TBaseSecuritySchemeObjectProps & {
+	type: 'oauth2';
+	flow: 'password';
+	tokenUrl: string;
+	scopes: TScopesObject;
+};
+const PasswordOAuth2SecuritySchemeObject: t.Tagged<'flow', TPasswordOAuth2SecuritySchemeObject, mixed> = t.type({
+	...BaseSecuritySchemeObjectProps,
+	type: t.literal('oauth2'),
+	flow: t.literal('password'),
+	tokenUrl: t.string,
+	scopes: ScopesObject,
+});
+export type TApplicationOAuth2SecuritySchemeObject = TBaseSecuritySchemeObjectProps & {
+	type: 'oauth2';
+	flow: 'application';
+	tokenUrl: string;
+	scopes: TScopesObject;
+};
+const ApplicationOAuth2SecuritySchemeObject: t.Tagged<'flow', TApplicationOAuth2SecuritySchemeObject, mixed> = t.type({
+	...BaseSecuritySchemeObjectProps,
+	type: t.literal('oauth2'),
+	flow: t.literal('application'),
 	tokenUrl: t.string,
 	scopes: ScopesObject,
 });
+export type TAccessCodeOAuth2SecuritySchemeObject = TBaseSecuritySchemeObjectProps & {
+	type: 'oauth2';
+	flow: 'accessCode';
+	tokenUrl: string;
+	scopes: TScopesObject;
+};
+const AccessCodeOAuth2SecuritySchemeObject: t.Tagged<'flow', TAccessCodeOAuth2SecuritySchemeObject, mixed> = t.type({
+	...BaseSecuritySchemeObjectProps,
+	type: t.literal('oauth2'),
+	flow: t.literal('accessCode'),
+	tokenUrl: t.string,
+	scopes: ScopesObject,
+});
+export type TOAuth2SecuritySchemeObject =
+	| TImplicitOAuth2SecuritySchemeObject
+	| TPasswordOAuth2SecuritySchemeObject
+	| TApplicationOAuth2SecuritySchemeObject
+	| TAccessCodeOAuth2SecuritySchemeObject;
+const OAuth2SecuritySchemeObject: t.Tagged<'type', TOAuth2SecuritySchemeObject, mixed> = t.taggedUnion('flow', [
+	ImplicitOAuth2SecuritySchemeObject,
+	PasswordOAuth2SecuritySchemeObject,
+	ApplicationOAuth2SecuritySchemeObject,
+	AccessCodeOAuth2SecuritySchemeObject,
+]) as any;
+
+export type TSecuritySchemeObject =
+	| TBasicSecuritySchemeObject
+	| TApiKeySecuritySchemeObject
+	| TOAuth2SecuritySchemeObject;
+const SecuritySchemeObject: t.Type<TSecuritySchemeObject, mixed> = t.taggedUnion('type', [
+	BasicSecuritySchemeObject,
+	ApiKeySecuritySchemeObject,
+	OAuth2SecuritySchemeObject,
+]);
+
+//#endregion
 
 export type TSecurityDefinitionsObject = TDictionary<TSecuritySchemeObject>;
 export const SecurityDefinitionsObject: t.Type<TSecurityDefinitionsObject, mixed> = t.dictionary(

test/index.ts

@@ -8,8 +8,9 @@ const self = path.resolve(__dirname);
 
 generate({
 	pathToSpec: path.resolve(self, './swagger.json'),
-	out: path.resolve(self, './out/spec'),
+	out: path.resolve(self, './spec'),
 	serialize,
 }).catch(error => {
+	console.error(error);
 	process.exit(1);
 });