@penkov/swagger-code-gen 1.0.0

package/README.md

@@ -0,0 +1,13 @@
+# swagger-code-gen
+The utility to generate a client for a services, described with openapi.
+
+Install:
+```shell
+npm install -D @penkov/swagger-code-gen
+```
+
+
+Usage:
+```shell
+generate-client --url <URI> output_filename.ts
+```

package/config/log4js.json

@@ -0,0 +1,20 @@
+{
+  "appenders": {
+    "out": {
+      "type": "stdout",
+      "layout": {
+        "type": "pattern",
+        "pattern": "%[%d [%p] (%f{1}:%l:%o) %c%] %m"
+      }
+    }
+  },
+  "categories": {
+    "default": {
+      "appenders": [
+        "out"
+      ],
+      "level": "DEBUG",
+      "enableCallStack": true
+    }
+  }
+}

package/dist/cli.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { main } from './index.js';
+main().then(() => {
+});

package/dist/components-parse.js

@@ -0,0 +1,15 @@
+import { Collection } from 'scats';
+import { SchemaFactory } from './schemas.js';
+import { Method } from './method.js';
+export function resolveSchemas(json) {
+    const jsonSchemas = json.components.schemas;
+    return Collection.from(Object.keys(jsonSchemas))
+        .toMap(name => [name, SchemaFactory.build(name, jsonSchemas[name])]);
+}
+export function resolvePaths(json) {
+    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]));
+    });
+}

package/dist/index.js

@@ -0,0 +1,31 @@
+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';
+export async function main() {
+    const { configure, getLogger } = log4js;
+    configure('./config/log4js.json');
+    const logger = getLogger('Main');
+    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);
+        logger.debug(`Downloaded swagger: ${schemas.size} schemas, ${paths.size} paths`);
+        await renderer.renderToFile(schemas.values, paths, outputFile);
+        logger.debug(`Wrote client to ${outputFile}`);
+    });
+}

package/dist/method.js

@@ -0,0 +1,93 @@
+import { Collection, HashMap, identity, option } from 'scats';
+import { Property } from './property.js';
+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) {
+        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))
+            .sort((a, b) => {
+            const r1 = a.required ? 1 : 0;
+            const r2 = b.required ? 1 : 0;
+            const reqS = r2 - r1;
+            if (reqS === 0) {
+                return sortByIn.get(a.in).getOrElseValue(10) - sortByIn.get(b.in).getOrElseValue(10);
+            }
+            else {
+                return reqS;
+            }
+        });
+        const namesCount = parameters.groupBy(p => p.name);
+        this.parameters = parameters.map(p => {
+            if (namesCount.get(p.name).exists(c => c.size > 1)) {
+                return p.copy({
+                    uniqueName: `${p.in}${Method.capitalize(p.name)}`
+                });
+            }
+            else {
+                return p;
+            }
+        });
+        this.body = option(def.requestBody).flatMap(body => option(body.content))
+            .flatMap(body => {
+            const mimeTypes = Collection.from(Object.keys(body));
+            return mimeTypes
+                .find(_ => _ === 'application/json')
+                .orElseValue(mimeTypes.headOption)
+                .map(mt => SchemaFactory.build('body', body[mt].schema));
+        });
+        const statusCodes = Collection.from(Object.keys(def.responses))
+            .map(x => parseInt(x));
+        const successCode = statusCodes
+            .filter(code => code / 100 === 2)
+            .minByOption(identity);
+        const respDef = successCode.map(_ => def.responses[_]).getOrElseValue(def.responses[statusCodes.head]);
+        const mimeTypes = option(respDef.content)
+            .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(r => ({
+            responseType: r.jsType,
+            description: respDef.description
+        }))
+            .getOrElseValue(({
+            responseType: 'any'
+        }));
+    }
+    get endpointName() {
+        return `${this.method}${Method.pathToName(this.path)}`;
+    }
+    get pathWithSubstitutions() {
+        const paramPrefix = `${this.parameters.size > 2 ? 'params.' : ''}`;
+        return this.path.replace(/\{(\w+?)\}/g, (matched, group) => {
+            const remappedName = this.parameters.find(p => p.name === group && p.in === 'path')
+                .map(_ => _.uniqueName)
+                .getOrElseValue(group);
+            return `\${${paramPrefix}${remappedName}}`;
+        });
+    }
+    static pathToName(path) {
+        const tokens = Collection.from(path.split('/'));
+        return tokens.filter(t => t.length > 0).map(t => {
+            let token = t;
+            if (t[0] == '{') {
+                token = `By${this.capitalize(t.substring(1, t.length - 1))}`;
+            }
+            return Collection.from(token.split(/\W/)).map(_ => this.capitalize(_)).mkString();
+        }).mkString();
+    }
+    static capitalize(s) {
+        if (s.length <= 0) {
+            return s;
+        }
+        else {
+            return s[0].toUpperCase() + s.substring(1);
+        }
+    }
+}

package/dist/openapi.js

@@ -0,0 +1 @@
+export {};

package/dist/parameter.js

@@ -0,0 +1,40 @@
+import { SchemaEnum, SchemaFactory, SchemaObject } from './schemas.js';
+import { Collection, identity, option } from 'scats';
+import { Method } from './method.js';
+export class Parameter {
+    constructor(name, uniqueName, inValue, jsType, required, description) {
+        this.name = name;
+        this.uniqueName = uniqueName;
+        this.jsType = jsType;
+        this.required = required;
+        this.description = description;
+        this.in = inValue;
+    }
+    static fromDefinition(def) {
+        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);
+        let jsType;
+        if (schema instanceof SchemaObject) {
+            jsType = schema.type;
+        }
+        else if (schema instanceof SchemaEnum) {
+            jsType = schema.name;
+        }
+        else {
+            jsType = schema.jsType;
+        }
+        return new Parameter(name, name, inValue, jsType, required, desc);
+    }
+    static toJSName(path) {
+        const tokens = Collection.from(path.split(/\W/)).filter(t => t.length > 0);
+        return tokens.headOption.getOrElseValue('') + tokens.drop(1).map(t => {
+            return Method.capitalize(t);
+        }).mkString();
+    }
+    copy(p) {
+        return new Parameter(option(p.name).getOrElseValue(this.name), option(p.uniqueName).getOrElseValue(this.uniqueName), option(p.in).getOrElseValue(this.in), option(p.jsType).getOrElseValue(this.jsType), option(p.required).getOrElseValue(this.required), option(p.description).getOrElseValue(this.description));
+    }
+}

package/dist/property.js

@@ -0,0 +1,27 @@
+import { identity, option } from 'scats';
+const SCHEMA_PREFIX = '#/components/schemas/';
+export class Property {
+    constructor(name, definition) {
+        this.name = name;
+        this.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)
+            .map(ref => ref.substring(SCHEMA_PREFIX.length))
+            .orElseValue(option(definition.items?.type))
+            .getOrElseValue('any');
+    }
+    get jsType() {
+        return Property.toJsType(this.type, this.items);
+    }
+    static toJsType(tpe, itemTpe = 'any') {
+        switch (tpe) {
+            case 'integer': return 'number';
+            case 'array': return `readonly ${Property.toJsType(itemTpe)}[]`;
+            default: return tpe;
+        }
+    }
+}

package/dist/renderer.js

@@ -0,0 +1,21 @@
+import * as ejs from 'ejs';
+import * as fs from 'fs';
+export class Renderer {
+    async renderToFile(schemas, methods, file) {
+        const view = await ejs.renderFile('./src/templates/index.ejs', {
+            schemas: schemas,
+            methods: methods,
+        });
+        fs.writeFileSync(file, view);
+    }
+    async renderSchema(obj) {
+        return await ejs.renderFile('./src/templates/index.ejs', {
+            schemas: obj
+        });
+    }
+    async renderMethod(obj) {
+        return (await obj.mapPromise(m => ejs.renderFile('./src/templates/method.ejs', {
+            method: m
+        }))).mkString('\n');
+    }
+}

package/dist/schemas.js

@@ -0,0 +1,45 @@
+import { Collection, Nil, option } from 'scats';
+import { Property } from './property.js';
+export class SchemaFactory {
+    static build(name, def) {
+        if (def.type === 'object') {
+            return new SchemaObject(name, def);
+        }
+        else if (def.enum) {
+            return new SchemaEnum(name, def);
+        }
+        else if (def.type === 'string') {
+            return new Property(name, def);
+        }
+        else if (def.type === 'boolean') {
+            return new Property(name, def);
+        }
+        else if (def.type === 'integer') {
+            return new Property(name, def);
+        }
+        else if (def.type === 'array') {
+            return new Property(name, def);
+        }
+        else {
+            return new Property(name, def);
+        }
+    }
+}
+export class SchemaEnum {
+    constructor(name, def) {
+        this.schemaType = 'enum';
+        this.name = name;
+        this.title = def.title;
+        this.type = def.type;
+        this.values = option(def.enum).map(Collection.from).getOrElseValue(Nil);
+    }
+}
+export class SchemaObject {
+    constructor(name, def) {
+        this.schemaType = 'object';
+        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]));
+    }
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@penkov/swagger-code-gen",
+  "version": "1.0.0",
+  "type": "module",
+  "bin": {
+    "generate-client": "./dist/cli.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/papirosko/swagger-code-gen"
+  },
+  "keywords": [
+    "swagger",
+    "openapi",
+    "typescript",
+    "code generator"
+  ],
+  "author": "penkov.vladimir@gmail.com",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/papirosko/swagger-code-gen/issues"
+  },
+  "homepage": "https://github.com/papirosko/swagger-code-gen#readme",
+  "scripts": {
+    "clean": "rimraf dist",
+    "lint": "eslint \"{src,test}/**/*.ts\" --fix",
+    "prebuild": "npm run lint && npm run clean",
+    "build": "tsc && chmod +x ./dist/cli.mjs"
+  },
+  "dependencies": {
+    "commander": "^9.4.1",
+    "ejs": "^3.1.8",
+    "log4js": "^6.7.1",
+    "node-fetch": "^3.3.0",
+    "scats": "^1.3.0",
+    "ts-node": "^10.9.1",
+    "tslib": "^2.4.1"
+  },
+  "devDependencies": {
+    "@types/ejs": "^3.1.1",
+    "@typescript-eslint/eslint-plugin": "^5.10.2",
+    "@typescript-eslint/parser": "^5.10.2",
+    "eslint": "^7.30.0",
+    "rimraf": "^3.0.2",
+    "typescript": "^4.9.3"
+  }
+}