@penkov/swagger-code-gen 1.1.2 → 1.2.0

package/README.md

@@ -13,6 +13,9 @@ generate-client --url <URI> output_filename.ts
 ```
 
 Cli parameters:
-* `--url` - the swagger url
+* `--url <URI>` - the swagger url
+* `--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)
 * `--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

@@ -7,11 +7,15 @@ program
     .description('CLI to generate client based on swagger definitions')
     .version('1.0.0')
     .option('--url <URI>', 'The url with swagger definitions')
+    .option('--referencedObjectsNullableByDefault', 'Assume that referenced objects can be null (say hello to .net assholes)', false)
     .option('--enableScats', 'Generate scats', false)
     .argument('outputFile', 'File with generated code')
     .parse();
 const url = program.opts().url;
+const referencedObjectsNullableByDefault = program.opts().referencedObjectsNullableByDefault;
 const enableScats = program.opts().enableScats;
 const outputFile = program.args[0];
-main(url, enableScats, outputFile).then(() => {
+main(url, enableScats, outputFile, {
+    referencedObjectsNullableByDefault: referencedObjectsNullableByDefault
+}).then(() => {
 });

package/dist/components-parse.js

@@ -6,16 +6,16 @@ export function resolveSchemasTypes(json) {
     const schemasNames = Collection.from(Object.keys(jsonSchemas));
     return schemasNames.toMap(name => [name, SchemaFactory.resolveSchemaType(jsonSchemas[name])]);
 }
-export function resolveSchemas(json, schemasTypes) {
+export function resolveSchemas(json, schemasTypes, options) {
     const jsonSchemas = json.components.schemas;
     const schemasNames = Collection.from(Object.keys(jsonSchemas));
     return schemasNames
-        .toMap(name => [name, SchemaFactory.build(name, jsonSchemas[name], schemasTypes)]);
+        .toMap(name => [name, SchemaFactory.build(name, jsonSchemas[name], schemasTypes, options)]);
 }
-export function resolvePaths(json, schemasTypes) {
+export function resolvePaths(json, schemasTypes, options) {
     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], schemasTypes));
+        return Collection.from(Object.keys(methods)).map(methodName => new Method(path, methodName, methods[methodName], schemasTypes, options));
     });
 }

package/dist/index.js

@@ -6,7 +6,7 @@ import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-export async function main(url, enableScats, outputFile) {
+export async function main(url, enableScats, outputFile, options) {
     const { configure, getLogger } = log4js;
     configure(`${__dirname}/../config/log4js.json`);
     const logger = getLogger('Generator');
@@ -16,8 +16,8 @@ export async function main(url, enableScats, outputFile) {
         .then(res => res.json())
         .then(async (json) => {
         const schemasTypes = resolveSchemasTypes(json);
-        const schemas = resolveSchemas(json, schemasTypes);
-        const paths = resolvePaths(json, schemasTypes);
+        const schemas = resolveSchemas(json, schemasTypes, options);
+        const paths = resolvePaths(json, schemasTypes, options);
         logger.debug(`Downloaded swagger: ${schemas.size} schemas, ${paths.size} paths`);
         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, schemasTypes) {
+    constructor(path, method, def, schemasTypes, options) {
         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, schemasTypes))
+            .map(p => Parameter.fromDefinition(p, schemasTypes, options))
             .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, schemasTypes));
+                .map(mt => SchemaFactory.build('body', body[mt].schema, schemasTypes, options));
         });
         const statusCodes = Collection.from(Object.keys(def.responses))
             .map(x => parseInt(x));
@@ -51,14 +51,16 @@ 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 => Property.fromDefinition('', p.schema, schemasTypes))
+            .map(p => Property.fromDefinition('', p.schema, schemasTypes, options).copy({
+            nullable: false
+        }))
             .map(r => ({
             asProperty: r,
             responseType: r.jsType,
             description: respDef.description
         }))
             .getOrElseValue(({
-            asProperty: Property.fromDefinition('UNKNOWN', { type: 'any' }, schemasTypes),
+            asProperty: Property.fromDefinition('UNKNOWN', { type: 'any' }, schemasTypes, options),
             responseType: 'any'
         }));
     }

package/dist/parameter.js

@@ -11,12 +11,12 @@ export class Parameter {
         this.description = description;
         this.in = inValue;
     }
-    static fromDefinition(def, schemas) {
+    static fromDefinition(def, schemas, options) {
         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, schemas);
+        const schema = SchemaFactory.build(def.name, def.schema, schemas, options);
         let jsType;
         if (schema instanceof SchemaObject) {
             jsType = schema.type;

package/dist/property.js

@@ -13,7 +13,10 @@ export class Property {
         this.itemReferencesObject = itemReferencesObject;
         this.schemaType = 'property';
     }
-    static fromDefinition(name, definition, schemas) {
+    copy(p) {
+        return new Property(option(p.name).getOrElseValue(this.name), option(p.type).getOrElseValue(this.type), option(p.description).getOrElseValue(this.description), option(p.defaultValue).getOrElseValue(this.defaultValue), option(p.nullable).getOrElseValue(this.nullable), option(p.required).getOrElseValue(this.required), option(p.items).getOrElseValue(this.items), option(p.referencesObject).getOrElseValue(this.referencesObject), option(p.itemReferencesObject).getOrElseValue(this.itemReferencesObject));
+    }
+    static fromDefinition(name, definition, schemas, options) {
         const referencesObject = option(definition.$ref)
             .exists(ref => schemas.get(ref.substring(SCHEMA_PREFIX.length)).contains('object'));
         const itemReferencesObject = option(definition.items)
@@ -22,7 +25,8 @@ export class Property {
         const type = option(definition.$ref)
             .map(ref => ref.substring(SCHEMA_PREFIX.length))
             .getOrElseValue(definition.type);
-        const nullable = option(definition.nullable).contains(true);
+        const nullable = option(definition.nullable).contains(true) ||
+            (referencesObject && options.referencedObjectsNullableByDefault && !option(definition.nullable).contains(false));
         const description = option(definition.description);
         const required = option(definition.required).contains(true);
         const items = option(definition.items?.$ref)

package/dist/schemas.js

@@ -12,27 +12,27 @@ export class SchemaFactory {
             return 'property';
         }
     }
-    static build(name, def, schemasTypes) {
+    static build(name, def, schemasTypes, options) {
         if (def.type === 'object') {
-            return SchemaObject.fromDefinition(name, def, schemasTypes);
+            return SchemaObject.fromDefinition(name, def, schemasTypes, options);
         }
         else if (def.enum) {
             return SchemaEnum.fromDefinition(name, def);
         }
         else if (def.type === 'string') {
-            return Property.fromDefinition(name, def, schemasTypes);
+            return Property.fromDefinition(name, def, schemasTypes, options);
         }
         else if (def.type === 'boolean') {
-            return Property.fromDefinition(name, def, schemasTypes);
+            return Property.fromDefinition(name, def, schemasTypes, options);
         }
         else if (def.type === 'integer') {
-            return Property.fromDefinition(name, def, schemasTypes);
+            return Property.fromDefinition(name, def, schemasTypes, options);
         }
         else if (def.type === 'array') {
-            return Property.fromDefinition(name, def, schemasTypes);
+            return Property.fromDefinition(name, def, schemasTypes, options);
         }
         else {
-            return Property.fromDefinition(name, def, schemasTypes);
+            return Property.fromDefinition(name, def, schemasTypes, options);
         }
     }
 }
@@ -56,8 +56,8 @@ export class SchemaObject {
         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));
+    static fromDefinition(name, def, schemasTypes, options) {
+        const properties = Collection.from(Object.keys(def.properties)).map(p => Property.fromDefinition(p, def.properties[p], schemasTypes, options));
         return new SchemaObject(name, def.title, def.type, properties);
     }
 }

package/dist/templates/scats-schema.ejs

@@ -15,7 +15,7 @@ export class <%= schema.name %>Dto {
             <%_ if (p.required || !p.nullable) { _%>
             <%- p.scatsWrapperType %>.fromJson(json.<%= p.name %>),
             <%_ } else { _%>
-            option(json.<%= p.name %>).map(_ => <%- p.scatsWrapperType %>.fromJson(_)),
+            option(json.<%= p.name %>).map(_ => <%- p.type %>Dto.fromJson(_)),
             <%_ } _%>
             <%_ } else if (p.isArray) { _%>
             Collection.from(option(json.<%= p.name %>).getOrElseValue([]))

package/package.json

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