@penkov/swagger-code-gen 1.0.7 → 1.1.0

package/README.md

@@ -11,3 +11,8 @@ Usage:
 ```shell
 generate-client --url <URI> output_filename.ts
 ```
+
+Cli parameters:
+* `--url` - the swagger url
+* `--enableScats` - generate additional wrappers in [scats](https://www.npmjs.com/package/scats) 
+  style for all objects and create a service with methods for each endpoint.

package/dist/cli.mjs

@@ -1,4 +1,17 @@
 #!/usr/bin/env node
 import { main } from './index.js';
-main().then(() => {
+import { Command } from "commander";
+const program = new Command();
+program
+    .name('Swagger client code generator')
+    .description('CLI to generate client based on swagger definitions')
+    .version('1.0.0')
+    .option('--url <URI>', 'The url with swagger definitions')
+    .option('--enableScats', 'Generate scats', false)
+    .argument('outputFile', 'File with generated code')
+    .parse();
+const url = program.opts().url;
+const enableScats = program.opts().enableScats;
+const outputFile = program.args[0];
+main(url, enableScats, outputFile).then(() => {
 });

package/dist/components-parse.js

@@ -1,15 +1,21 @@
 import { Collection } from 'scats';
 import { SchemaFactory } from './schemas.js';
 import { Method } from './method.js';
-export function resolveSchemas(json) {
+export function resolveSchemasTypes(json) {
     const jsonSchemas = json.components.schemas;
-    return Collection.from(Object.keys(jsonSchemas))
-        .toMap(name => [name, SchemaFactory.build(name, jsonSchemas[name])]);
+    const schemasNames = Collection.from(Object.keys(jsonSchemas));
+    return schemasNames.toMap(name => [name, SchemaFactory.resolveSchemaType(jsonSchemas[name])]);
 }
-export function resolvePaths(json) {
+export function resolveSchemas(json, schemasTypes) {
+    const jsonSchemas = json.components.schemas;
+    const schemasNames = Collection.from(Object.keys(jsonSchemas));
+    return schemasNames
+        .toMap(name => [name, SchemaFactory.build(name, jsonSchemas[name], schemasTypes)]);
+}
+export function resolvePaths(json, schemasTypes) {
     const jsonSchemas = json.paths;
     return Collection.from(Object.keys(jsonSchemas)).flatMap(path => {
         const methods = jsonSchemas[path];
-        return Collection.from(Object.keys(methods)).map(methodName => new Method(path, methodName, methods[methodName]));
+        return Collection.from(Object.keys(methods)).map(methodName => new Method(path, methodName, methods[methodName], schemasTypes));
     });
 }

package/dist/index.js

@@ -1,35 +1,25 @@
-import { Command } from 'commander';
 import log4js from 'log4js';
 import fetch from 'node-fetch';
 import { Renderer } from './renderer.js';
-import { resolvePaths, resolveSchemas } from './components-parse.js';
+import { resolvePaths, resolveSchemas, resolveSchemasTypes } from './components-parse.js';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-export async function main() {
+export async function main(url, enableScats, outputFile) {
     const { configure, getLogger } = log4js;
     configure(`${__dirname}/../config/log4js.json`);
     const logger = getLogger('Generator');
-    const program = new Command();
-    program
-        .name('Swagger client code generator')
-        .description('CLI to generate client based on swagger definitions')
-        .version('1.0.0')
-        .option('--url <URI>', 'The url with swagger definitions')
-        .argument('outputFile', 'File with generated code')
-        .parse();
-    const url = program.opts().url;
-    const outputFile = program.args[0];
     logger.info(`Generating code from ${url}`);
     const renderer = new Renderer();
     fetch(url)
         .then(res => res.json())
         .then(async (json) => {
-        const schemas = resolveSchemas(json);
-        const paths = resolvePaths(json);
+        const schemasTypes = resolveSchemasTypes(json);
+        const schemas = resolveSchemas(json, schemasTypes);
+        const paths = resolvePaths(json, schemasTypes);
         logger.debug(`Downloaded swagger: ${schemas.size} schemas, ${paths.size} paths`);
-        await renderer.renderToFile(schemas.values, paths, outputFile);
+        await renderer.renderToFile(schemas.values, paths, enableScats, outputFile);
         logger.debug(`Wrote client to ${outputFile}`);
     });
 }

package/dist/method.js

@@ -4,13 +4,13 @@ import { Parameter } from './parameter.js';
 import { SchemaFactory } from './schemas.js';
 const sortByIn = HashMap.of(['path', 0], ['query', 1], ['header', 2], ['body', 3]);
 export class Method {
-    constructor(path, method, def) {
+    constructor(path, method, def, schemasTypes) {
         this.path = path;
         this.method = method;
         this.tags = option(def.tags).getOrElseValue([]);
         this.summary = def.summary;
         const parameters = Collection.from(def.parameters)
-            .map(p => Parameter.fromDefinition(p))
+            .map(p => Parameter.fromDefinition(p, schemasTypes))
             .sort((a, b) => {
             const r1 = a.required ? 1 : 0;
             const r2 = b.required ? 1 : 0;
@@ -39,7 +39,7 @@ export class Method {
             return mimeTypes
                 .find(_ => _ === 'application/json')
                 .orElseValue(mimeTypes.headOption)
-                .map(mt => SchemaFactory.build('body', body[mt].schema));
+                .map(mt => SchemaFactory.build('body', body[mt].schema, schemasTypes));
         });
         const statusCodes = Collection.from(Object.keys(def.responses))
             .map(x => parseInt(x));
@@ -51,12 +51,14 @@ export class Method {
             .map(content => Collection.from(Object.keys(content)).toMap(mimeType => [mimeType, content[mimeType]])).getOrElseValue(HashMap.empty);
         this.response = mimeTypes.get('application/json')
             .orElseValue(mimeTypes.values.headOption)
-            .map(p => new Property('', p.schema))
+            .map(p => Property.fromDefinition('', p.schema, schemasTypes))
             .map(r => ({
+            asProperty: r,
             responseType: r.jsType,
             description: respDef.description
         }))
             .getOrElseValue(({
+            asProperty: Property.fromDefinition('UNKNOWN', { type: 'any' }, schemasTypes),
             responseType: 'any'
         }));
     }

package/dist/parameter.js

@@ -1,6 +1,7 @@
 import { SchemaEnum, SchemaFactory, SchemaObject } from './schemas.js';
 import { Collection, identity, option } from 'scats';
 import { Method } from './method.js';
+import { Property } from './property.js';
 export class Parameter {
     constructor(name, uniqueName, inValue, jsType, required, description) {
         this.name = name;
@@ -10,12 +11,12 @@ export class Parameter {
         this.description = description;
         this.in = inValue;
     }
-    static fromDefinition(def) {
+    static fromDefinition(def, schemas) {
         const name = Parameter.toJSName(def.name);
         const inValue = def.in;
         const desc = option(def.description);
         const required = option(def.required).exists(identity);
-        const schema = SchemaFactory.build(def.name, def.schema);
+        const schema = SchemaFactory.build(def.name, def.schema, schemas);
         let jsType;
         if (schema instanceof SchemaObject) {
             jsType = schema.type;
@@ -23,9 +24,12 @@ export class Parameter {
         else if (schema instanceof SchemaEnum) {
             jsType = schema.name;
         }
-        else {
+        else if (schema instanceof Property) {
             jsType = schema.jsType;
         }
+        else {
+            throw new Error('Unknown schema type');
+        }
         return new Parameter(name, name, inValue, jsType, required, desc);
     }
     static toJSName(path) {

package/dist/property.js

@@ -1,22 +1,42 @@
 import { identity, option } from 'scats';
 const SCHEMA_PREFIX = '#/components/schemas/';
 export class Property {
-    constructor(name, definition) {
+    constructor(name, type, description, defaultValue, nullable, required, items, referencesObject, itemReferencesObject) {
         this.name = name;
-        this.type = option(definition.$ref)
+        this.type = type;
+        this.description = description;
+        this.defaultValue = defaultValue;
+        this.nullable = nullable;
+        this.required = required;
+        this.items = items;
+        this.referencesObject = referencesObject;
+        this.itemReferencesObject = itemReferencesObject;
+        this.schemaType = 'property';
+    }
+    static fromDefinition(name, definition, schemas) {
+        const referencesObject = option(definition.$ref)
+            .exists(ref => schemas.get(ref.substring(SCHEMA_PREFIX.length)).contains('object'));
+        const itemReferencesObject = option(definition.items)
+            .flatMap(i => option(i.$ref))
+            .exists(ref => schemas.get(ref.substring(SCHEMA_PREFIX.length)).contains('object'));
+        const type = option(definition.$ref)
             .map(ref => ref.substring(SCHEMA_PREFIX.length))
             .getOrElseValue(definition.type);
-        this.nullable = option(definition.nullable).exists(identity);
-        this.description = option(definition.description);
-        this.required = option(definition.required).exists(identity);
-        this.items = option(definition.items?.$ref)
+        const nullable = option(definition.nullable).exists(identity);
+        const description = option(definition.description);
+        const required = option(definition.required).exists(identity);
+        const items = option(definition.items?.$ref)
             .map(ref => ref.substring(SCHEMA_PREFIX.length))
             .orElseValue(option(definition.items?.type))
             .getOrElseValue('any');
+        return new Property(name, type, description, null, nullable, required, items, referencesObject, itemReferencesObject);
     }
     get jsType() {
         return Property.toJsType(this.type, this.items);
     }
+    get isArray() {
+        return this.type === 'array';
+    }
     static toJsType(tpe, itemTpe = 'any') {
         switch (tpe) {
             case 'integer': return 'number';
@@ -24,4 +44,28 @@ export class Property {
             default: return tpe;
         }
     }
+    get itemScatsWrapperType() {
+        if (this.isArray) {
+            if (this.itemReferencesObject) {
+                return `${this.items}Dto`;
+            }
+            else {
+                return Property.toJsType(this.items);
+            }
+        }
+        else {
+            return this.scatsWrapperType;
+        }
+    }
+    get scatsWrapperType() {
+        if (this.referencesObject) {
+            return this.nullable ? `Option<${this.type}Dto>` : `${this.type}Dto`;
+        }
+        else if (this.isArray) {
+            return this.itemReferencesObject ? `Collection<${this.items}Dto>` : `Collection<${Property.toJsType(this.items)}>`;
+        }
+        else {
+            return this.nullable ? `Option<${this.jsType}>` : this.jsType;
+        }
+    }
 }

package/dist/renderer.js

@@ -6,10 +6,11 @@ import { dirname } from 'path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export class Renderer {
-    async renderToFile(schemas, methods, file) {
+    async renderToFile(schemas, methods, enableScats, file) {
         const view = await ejs.renderFile(path.resolve(__dirname, 'templates/index.ejs'), {
             schemas: schemas,
             methods: methods,
+            scats: enableScats
         });
         fs.writeFileSync(file, view);
     }

package/dist/schemas.js

@@ -1,45 +1,63 @@
 import { Collection, Nil, option } from 'scats';
 import { Property } from './property.js';
 export class SchemaFactory {
-    static build(name, def) {
+    static resolveSchemaType(def) {
         if (def.type === 'object') {
-            return new SchemaObject(name, def);
+            return 'object';
         }
         else if (def.enum) {
-            return new SchemaEnum(name, def);
+            return 'enum';
+        }
+        else {
+            return 'property';
+        }
+    }
+    static build(name, def, schemasTypes) {
+        if (def.type === 'object') {
+            return SchemaObject.fromDefinition(name, def, schemasTypes);
+        }
+        else if (def.enum) {
+            return SchemaEnum.fromDefinition(name, def);
         }
         else if (def.type === 'string') {
-            return new Property(name, def);
+            return Property.fromDefinition(name, def, schemasTypes);
         }
         else if (def.type === 'boolean') {
-            return new Property(name, def);
+            return Property.fromDefinition(name, def, schemasTypes);
         }
         else if (def.type === 'integer') {
-            return new Property(name, def);
+            return Property.fromDefinition(name, def, schemasTypes);
         }
         else if (def.type === 'array') {
-            return new Property(name, def);
+            return Property.fromDefinition(name, def, schemasTypes);
         }
         else {
-            return new Property(name, def);
+            return Property.fromDefinition(name, def, schemasTypes);
         }
     }
 }
 export class SchemaEnum {
-    constructor(name, def) {
-        this.schemaType = 'enum';
+    constructor(name, title, type, values) {
         this.name = name;
-        this.title = def.title;
-        this.type = def.type;
-        this.values = option(def.enum).map(Collection.from).getOrElseValue(Nil);
+        this.title = title;
+        this.type = type;
+        this.values = values;
+        this.schemaType = 'enum';
+    }
+    static fromDefinition(name, def) {
+        return new SchemaEnum(name, def.title, def.type, option(def.enum).map(Collection.from).getOrElseValue(Nil));
     }
 }
 export class SchemaObject {
-    constructor(name, def) {
-        this.schemaType = 'object';
+    constructor(name, title, type, properties) {
         this.name = name;
-        this.title = def.title;
-        this.type = def.type;
-        this.properties = Collection.from(Object.keys(def.properties)).map(p => new Property(p, def.properties[p]));
+        this.title = title;
+        this.type = type;
+        this.properties = properties;
+        this.schemaType = 'object';
+    }
+    static fromDefinition(name, def, schemasTypes) {
+        const properties = Collection.from(Object.keys(def.properties)).map(p => Property.fromDefinition(p, def.properties[p], schemasTypes));
+        return new SchemaObject(name, def.title, def.type, properties);
     }
 }

package/dist/templates/index.ejs

@@ -11,30 +11,50 @@
  *********************************************************
  *********************************************************/
 import fetch from 'node-fetch';
+<% if (scats) {%>
+import {option, Option, Collection, Try, TryLike, none} from 'scats';
+<% } %>
+
+export interface RequestOptions {
+    headers: Record<string, string>;
+}
+
 
 export interface SwaggerCodeGenParams {
     apiPrefix: string;
+    requestOptions: RequestOptions
 }
 
 export const swaggerCodeGenParams: SwaggerCodeGenParams = {
-    apiPrefix: ''
+    apiPrefix: '',
+    requestOptions: {
+        headers: {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json'
+        }
+    }
 };
 
+const defaultRequestOptions = () => swaggerCodeGenParams.requestOptions;
+
 <% schemas.foreach(schema => { %>
 <%- include('schema.ejs', {schema: schema}); %>
 <% }); %>
 
-export interface RequestOptions {
-    headers: Record<string, string>;
-}
 
-export const defaultRequestOptions = {
-    headers: {
-        'Accept': 'application/json',
-        'Content-Type': 'application/json'
-    }
-}
 
 <% methods.foreach(method => { %>
 <%- include('method.ejs', {method: method}); %>
 <% }); %>
+
+
+<% if (scats) {%>
+<% schemas.foreach(schema => { %>
+<%- include('scats-schema.ejs', {schema: schema}); %>
+<% }); %>
+
+<%- include('scats-method.ejs'); %>
+
+<% } %>
+
+

package/dist/templates/method.ejs

@@ -28,7 +28,7 @@ export async function <%= method.endpointName %>(
     <%_ if (method.body.nonEmpty) { -%>
     body: <%= method.body.get.type %>,
     <%_ } -%>
-    requestOptions: RequestOptions = defaultRequestOptions
+    requestOptions: RequestOptions = defaultRequestOptions()
 ): Promise<<%= method.response.responseType %>> {
     let query = '';
     <%_ if (method.parameters.filter(x => x.in === 'query').nonEmpty) { -%>

package/dist/templates/scats-method.ejs

@@ -0,0 +1,52 @@
+export class ApiClient {
+
+    constructor(private readonly requestOptions: RequestOptions = swaggerCodeGenParams.requestOptions) {
+    }
+
+
+    <% methods.foreach(method => { %>
+    async <%= method.endpointName %>(
+        <%_ if (method.parameters.size <= 2) { -%>
+        <%_ method.parameters.foreach(p => { -%>
+        <%= p.uniqueName %>: <%- p.required && !p.nullable ? p.jsType : `Option<${p.jsType}> = none` %>,
+        <%_ }) -%>
+        <%_ } else { -%>
+        params: {
+            <%_ method.parameters.foreach(p => { -%>
+            <%= p.uniqueName %><%= p.required && !p.nullable ? '' : '?'%>: <%= p.jsType %>,
+            <%_ }) -%>
+        },
+        <%_ } -%>
+        <%_ method.body.foreach(body => { -%>
+        body: <%= body.type %>,
+        <%_ }); -%>
+        requestOptions: RequestOptions = this.requestOptions
+    ): Promise<TryLike<<%- method.response.asProperty.scatsWrapperType %>>> {
+        return (await Try.promise(() =>
+                <%= method.endpointName %>(
+                    <%_ if (method.parameters.size <= 2) { -%>
+                    <%_ method.parameters.foreach(p => { -%>
+                    <%= p.uniqueName %><%- p.required && !p.nullable ? '' : `.orUndefined` %>,
+                    <%_ }) -%>
+                    <%_ } else { -%>
+                    params,
+                    <%_ } -%>
+                    <%_ if (method.body.nonEmpty) { -%>
+                    body,
+                    <%_ } -%>
+                    requestOptions
+                )
+            ))
+            <%_ if (method.response.asProperty.referencesObject) { _%>
+            .map(res => <%- method.response.asProperty.scatsWrapperType %>.fromJson(res))
+            <%_ } else if (method.response.asProperty.isArray) { _%>
+            .map(res => Collection.from(option(res).getOrElseValue([])))
+            <%_ if (method.response.asProperty.itemReferencesObject) { _%>
+            .map(items => items.map(i => <%- method.response.asProperty.itemScatsWrapperType %>.fromJson(i)))
+            <%_ } _%>
+            <%_ } _%>;
+    }
+    <% }); %>
+
+
+}

package/dist/templates/scats-schema.ejs

@@ -0,0 +1,38 @@
+<%_ if (schema.schemaType === 'object') { -%>
+export class <%= schema.name %>Dto {
+
+    constructor(
+        <%_ schema.properties.foreach(p => { -%>
+        readonly <%= p.name %>: <%- p.scatsWrapperType %>,
+        <%_ }); -%>
+    ) {}
+
+
+    static fromJson(json: <%= schema.name %>): <%= schema.name %>Dto {
+        return new <%= schema.name %>Dto(
+            <%_ schema.properties.foreach(p => { _%>
+            <%_ if (p.referencesObject) { _%>
+            <%- p.scatsWrapperType %>.fromJson(json.<%= p.name %>),
+            <%_ } else if (p.isArray) { _%>
+            Collection.from(option(json.<%= p.name %>).getOrElseValue([]))
+                <% if (p.itemReferencesObject) { _%>.map(i => <%- p.itemScatsWrapperType %>.fromJson(i))<%_ }  _%>,
+            <%_ } else if (p.required || !p.nullable) { _%>
+            json.<%= p.name %>,
+            <%_ } else { _%>
+            option(json.<%= p.name %>),
+            <%_ } _%>
+            <%_ }); _%>
+        );
+    }
+
+    copy(fields: Partial<<%= schema.name %>Dto>): <%= schema.name %>Dto {
+        return new <%= schema.name %>Dto(
+        <%_ schema.properties.foreach(p => { -%>
+            option(fields.<%= p.name %>).getOrElseValue(this.<%= p.name %>),
+        <%_ });  -%>
+        );
+    }
+}
+
+<%_ } -%>
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@penkov/swagger-code-gen",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "type": "module",
   "bin": {
     "generate-client": "./dist/cli.mjs"
@@ -25,7 +25,7 @@
     "clean": "rimraf dist",
     "lint": "eslint \"{src,test}/**/*.ts\" --fix",
     "prebuild": "npm run lint && npm run clean",
-    "copy-files": "mkdir -p ./dist/templates && cp ./src/templates/* ./dist/templates/",
+    "copy-files": "mkdir -p ./dist/templates && cp -R ./src/templates/* ./dist/templates/",
     "build": "tsc && chmod +x ./dist/cli.mjs && npm run copy-files"
   },
   "dependencies": {
@@ -34,7 +34,6 @@
     "log4js": "^6.7.1",
     "node-fetch": "^3.3.0",
     "scats": "^1.3.0",
-    "ts-node": "^10.9.1",
     "tslib": "^2.4.1"
   },
   "devDependencies": {
@@ -43,6 +42,7 @@
     "@typescript-eslint/parser": "^5.10.2",
     "eslint": "^7.30.0",
     "rimraf": "^3.0.2",
+    "ts-node": "^10.9.1",
     "typescript": "^4.9.3"
   }
 }