@penkov/swagger-code-gen 1.15.0 → 1.16.1

package/README.md

@@ -11,6 +11,7 @@ Usage:
 ```shell
 generate-client --url <URI> output_filename.ts
 generate-client --url <URI> --includeTags tag1 tag2 -- output_filename.ts
+generate-client --url <URI> --includeTags tag1 tag2 --onlyUsedSchemas -- output_filename.ts
 ```
 
 Cli parameters:
@@ -21,6 +22,8 @@ Cli parameters:
 * `--excludeTags <tags...>` - Space-separated list of tags of paths to be excluded. 
   Path is excluded if exclusion list is non-empty and path contains any of the tags from exclusion list.
   If the tag is both in inclusion and exclusion lists, it gets excluded.
+* `--onlyUsedSchemas` - generate only schemas that are reachable from filtered methods
+  (useful with `--includeTags`/`--excludeTags`). By default all schemas are generated.
 * `--referencedObjectsNullableByDefault` - then specified, the generated code will assume that
   any object's field, that references another object, can be null, unless it is explicitly specified to be not nullable
   (which is default in .net world: asp generates wrong spec)
@@ -28,6 +31,18 @@ Cli parameters:
   style for all objects and create a service with methods for each endpoint.
 * `--targetNode` - adds imports for `node-fetch` package in generated code.
 
+## Tag filtering and schema pruning
+
+By default, tag filters affect only methods and all schemas are still generated:
+```shell
+generate-client --url <URI> --includeTags public -- output_filename.ts
+```
+
+To generate only schemas that are reachable from filtered methods, add `--onlyUsedSchemas`:
+```shell
+generate-client --url <URI> --includeTags public --onlyUsedSchemas -- output_filename.ts
+```
+
 
 
 # Example of generated code:

package/dist/cli.mjs

@@ -11,6 +11,8 @@ program
     .option('--referencedObjectsNullableByDefault', 'Assume that referenced objects can be null (say hello to .net assholes)', false)
     .option('--includeTags <tags...>', 'Space-separated list of tags of paths to be included. Path is included if it contains any of specified tag')
     .option('--excludeTags <tags...>', 'Space-separated list of tags of paths to be excluded. Path is excluded if it contains any of specified tag')
+    .option('--onlyUsedSchemas', 'Generate only schemas reachable from filtered methods', false)
+    .option('--includeSchemasByMask <masks...>', 'Space-separated list of schema name masks to force-include with dependencies (supports * and ? wildcards)')
     .option('--enableScats', 'Generate scats', false)
     .option('--targetNode', 'Add imports for node-fetch into generated code', false)
     .option('--user <username>', 'If swagger requires authorisation')
@@ -28,12 +30,16 @@ const targetNode = program.opts().targetNode;
 const outputFile = program.args[0];
 const includeTags = HashSet.from(program.opts().includeTags || []);
 const excludeTags = HashSet.from(program.opts().excludeTags || []);
+const onlyUsedSchemas = program.opts().onlyUsedSchemas;
+const includeSchemasByMask = HashSet.from(program.opts().includeSchemasByMask || []);
 main(url, enableScats, targetNode, outputFile, ignoreSSLErrors, option(user).flatMap(u => option(password).map(p => ({
     user: u,
     password: p
 }))), {
     referencedObjectsNullableByDefault: referencedObjectsNullableByDefault,
     includeTags: includeTags,
-    excludeTags: excludeTags
+    excludeTags: excludeTags,
+    onlyUsedSchemas: onlyUsedSchemas,
+    includeSchemasByMask: includeSchemasByMask
 }).then(() => {
 });

package/dist/components-parse.js

@@ -1,6 +1,6 @@
-import { Collection, mutable, Nil, option } from 'scats';
+import { Collection, HashSet, mutable, Nil, option } from 'scats';
 import { SchemaFactory, SchemaObject } from './schemas.js';
-import { SCHEMA_PREFIX } from './property.js';
+import { Property, SCHEMA_PREFIX } from './property.js';
 import { Method, supportedBodyMimeTypes } from './method.js';
 export function resolveSchemasTypes(json) {
     const jsonSchemas = json.components.schemas;
@@ -88,6 +88,59 @@ export function resolvePaths(json, schemasTypes, options, pool) {
         return included && !excluded;
     });
 }
+function collectSchemaRefsFromType(type, schemas, add) {
+    Collection.from(type.split(/[|&]/))
+        .map(t => t.trim())
+        .filter(t => t.length > 0)
+        .filter(t => schemas.containsKey(t))
+        .foreach(t => add(t));
+}
+function wildcardMaskToRegExp(mask) {
+    const escaped = mask.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    const regex = escaped.replace(/\*/g, '.*').replace(/\?/g, '.');
+    return new RegExp(`^${regex}$`);
+}
+export function filterUsedSchemas(paths, schemas, includeSchemasByMask = HashSet.empty) {
+    const used = new Set();
+    const pending = [];
+    const maskRegexes = includeSchemasByMask.map(mask => wildcardMaskToRegExp(mask));
+    const add = (name) => {
+        if (!used.has(name) && schemas.containsKey(name)) {
+            used.add(name);
+            pending.push(name);
+        }
+    };
+    const collectFromProperty = (p) => {
+        collectSchemaRefsFromType(p.type, schemas, add);
+        collectSchemaRefsFromType(p.items, schemas, add);
+    };
+    paths.foreach(m => {
+        m.parameters.foreach(p => p.referencedSchemas.foreach(t => add(t)));
+        collectFromProperty(m.response.asProperty);
+        m.body.foreach(b => {
+            if (b.body instanceof Property) {
+                collectFromProperty(b.body);
+            }
+        });
+    });
+    schemas.keySet
+        .filter(name => maskRegexes.exists(regex => regex.test(name)))
+        .foreach(name => add(name));
+    while (pending.length > 0) {
+        const schemaName = pending.shift();
+        const schema = schemas.get(schemaName).getOrElseThrow(() => new Error(`No schema for ${schemaName}`));
+        if (schema instanceof SchemaObject) {
+            schema.parents.keySet.foreach(parentName => add(parentName));
+            schema.properties.foreach(p => collectFromProperty(p));
+        }
+        else if (schema instanceof Property) {
+            collectFromProperty(schema);
+        }
+    }
+    return schemas.keySet
+        .filter(name => used.has(name))
+        .toMap(name => [name, schemas.get(name).getOrElseThrow(() => new Error(`No schema for ${name}`))]);
+}
 export function generateInPlace(paths, schemasTypes, options, pool) {
     const collectInplaceFromProperty = (p) => {
         if (p.inPlace.isDefined) {

package/dist/index.js

@@ -1,7 +1,7 @@
 import log4js from 'log4js';
 import fetch from 'node-fetch';
 import { Renderer } from './renderer.js';
-import { generateInPlace, resolvePaths, resolveSchemas, resolveSchemasTypes } from './components-parse.js';
+import { filterUsedSchemas, generateInPlace, resolvePaths, resolveSchemas, resolveSchemasTypes } from './components-parse.js';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import https from 'https';
@@ -26,8 +26,11 @@ export async function main(url, enableScats, targetNode, outputFile, ignoreSSLEr
         .then(res => res.json())
         .then(async (json) => {
         const schemasTypes = resolveSchemasTypes(json);
-        const schemas = resolveSchemas(json, schemasTypes, options);
-        const paths = resolvePaths(json, schemasTypes, options, schemas);
+        const allSchemas = resolveSchemas(json, schemasTypes, options);
+        const paths = resolvePaths(json, schemasTypes, options, allSchemas);
+        const schemas = options.onlyUsedSchemas
+            ? filterUsedSchemas(paths, allSchemas, options.includeSchemasByMask)
+            : allSchemas;
         const inplace = generateInPlace(paths, schemasTypes, options, schemas);
         logger.debug(`Downloaded swagger: ${schemas.size} schemas, ${paths.size} paths`);
         await renderer.renderToFile(schemas.appendedAll(inplace.toMap(s => [s.name, s])).values, paths, enableScats, targetNode, outputFile);

package/dist/parameter.js

@@ -3,12 +3,13 @@ import { Collection, identity, none, option } from 'scats';
 import { Method } from './method.js';
 import { Property } from './property.js';
 export class Parameter {
-    constructor(name, rawName, uniqueName, inValue, jsType, required, isArray, defaultValue, description) {
+    constructor(name, rawName, uniqueName, inValue, jsType, referencedSchemas, required, isArray, defaultValue, description) {
         this.name = name;
         this.rawName = rawName;
         this.uniqueName = uniqueName;
         this.inValue = inValue;
         this.jsType = jsType;
+        this.referencedSchemas = referencedSchemas;
         this.required = required;
         this.isArray = isArray;
         this.defaultValue = defaultValue;
@@ -21,6 +22,7 @@ export class Parameter {
         const inValue = def.in;
         const desc = option(def.description);
         let defaultValue = none;
+        const references = new Set();
         const schema = def.schema ?
             SchemaFactory.build(def.name, def.schema, schemas, options) :
             Property.fromDefinition('', name, {
@@ -35,10 +37,14 @@ export class Parameter {
             if (schema.type === 'integer') {
                 jsType = 'number';
             }
+            if (schemas.containsKey(schema.name)) {
+                references.add(schema.name);
+            }
         }
         else if (schema instanceof SchemaEnum) {
             if (schemas.containsKey(schema.name)) {
                 jsType = schema.name;
+                references.add(schema.name);
             }
             else if (schema.type === 'string') {
                 jsType = `${schema.values.map(x => `'${x}'`).mkString(' | ')}`;
@@ -60,13 +66,19 @@ export class Parameter {
         }
         else if (schema instanceof Property) {
             jsType = schema.jsType;
+            if (schemas.containsKey(schema.type)) {
+                references.add(schema.type);
+            }
+            if (schema.isArray && schemas.containsKey(schema.items)) {
+                references.add(schema.items);
+            }
         }
         else {
             throw new Error('Unknown schema type');
         }
         const required = option(def.required).exists(identity) || defaultValue.nonEmpty;
         const isArray = def?.schema?.type === 'array';
-        return new Parameter(name, rawName, name, inValue, jsType, required, isArray, defaultValue, desc);
+        return new Parameter(name, rawName, name, inValue, jsType, Collection.from(Array.from(references)), required, isArray, defaultValue, desc);
     }
     static toJSName(path) {
         const tokens = Collection.from(path.split(/\W/)).filter(t => t.length > 0);
@@ -75,6 +87,6 @@ export class Parameter {
         }).mkString();
     }
     copy(p) {
-        return new Parameter(option(p.name).getOrElseValue(this.name), option(p.rawName).getOrElseValue(this.rawName), 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.isArray).getOrElseValue(this.isArray), option(p.defaultValue).getOrElseValue(this.defaultValue), option(p.description).getOrElseValue(this.description));
+        return new Parameter(option(p.name).getOrElseValue(this.name), option(p.rawName).getOrElseValue(this.rawName), option(p.uniqueName).getOrElseValue(this.uniqueName), option(p.in).getOrElseValue(this.in), option(p.jsType).getOrElseValue(this.jsType), option(p.referencedSchemas).getOrElseValue(this.referencedSchemas), option(p.required).getOrElseValue(this.required), option(p.isArray).getOrElseValue(this.isArray), option(p.defaultValue).getOrElseValue(this.defaultValue), option(p.description).getOrElseValue(this.description));
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@penkov/swagger-code-gen",
-  "version": "1.15.0",
+  "version": "1.16.1",
   "type": "module",
   "bin": {
     "generate-client": "dist/cli.mjs"