@kubb/swagger-ts 1.0.3 → 1.1.1

package/README.md

@@ -10,13 +10,13 @@
 <!-- Badges -->
 <p>
   <a href="https://www.npmjs.com/package/@kubb/swagger-ts">
-    <img alt="Npm version" src="https://img.shields.io/npm/v/@kubb/swagger-ts?style=for-the-badge"/>
+    <img alt="npm version" src="https://img.shields.io/npm/v/@kubb/swagger-ts?style=for-the-badge"/>
   </a>
   <a href="https://www.npmjs.com/package/@kubb/swagger-ts">
-    <img alt="Npm downloads" src="https://img.shields.io/bundlephobia/min/@kubb/swagger-ts?style=for-the-badge"/>
+    <img alt="npm downloads" src="https://img.shields.io/bundlephobia/min/@kubb/swagger-ts?style=for-the-badge"/>
   </a>
   <a href="https://www.npmjs.com/package/@kubb/swagger-ts">
-    <img alt="Npm downloads" src="https://img.shields.io/npm/dm/@kubb/swagger-ts?style=for-the-badge"/>
+    <img alt="npm downloads" src="https://img.shields.io/npm/dm/@kubb/swagger-ts?style=for-the-badge"/>
   </a>
 </p>
    

package/dist/index.cjs

@@ -120,7 +120,9 @@ var _TypeGenerator = class extends core.SchemaGenerator {
           comments: [
             schema.description && `@description ${schema.description}`,
             schema.type && `@type ${schema.type}${isRequired ? "" : " | undefined"} ${schema.format || ""}`,
-            schema.example && `@example ${schema.example}`
+            schema.example && `@example ${schema.example}`,
+            schema.default !== void 0 && typeof schema.default === "string" && `@default '${schema.default}'`,
+            schema.default !== void 0 && typeof schema.default !== "string" && `@default ${schema.default}`
           ]
         });
       }
@@ -172,33 +174,39 @@ var _TypeGenerator = class extends core.SchemaGenerator {
     }
     if (schema.oneOf) {
       const schemaWithoutOneOf = { ...schema, oneOf: void 0 };
+      const union = factory2.createParenthesizedType(
+        tsCodegen.createUnionDeclaration({
+          nodes: schema.oneOf.map((item) => {
+            return this.getBaseTypeFromSchema(item);
+          }).filter(Boolean)
+        })
+      );
+      if (schemaWithoutOneOf.properties) {
+        return tsCodegen.createIntersectionDeclaration({
+          nodes: [this.getBaseTypeFromSchema(schemaWithoutOneOf, baseName), union].filter(Boolean)
+        });
+      }
       return tsCodegen.createIntersectionDeclaration({
-        nodes: [
-          this.getBaseTypeFromSchema(schemaWithoutOneOf, baseName),
-          factory2.createParenthesizedType(
-            tsCodegen.createUnionDeclaration({
-              nodes: schema.oneOf.map((item) => {
-                return this.getBaseTypeFromSchema(item);
-              }).filter(Boolean)
-            })
-          )
-        ].filter(Boolean)
+        nodes: [union]
       });
     }
     if (schema.anyOf) ;
     if (schema.allOf) {
       const schemaWithoutAllOf = { ...schema, allOf: void 0 };
+      const and = factory2.createParenthesizedType(
+        factory2.createIntersectionTypeNode(
+          schema.allOf.map((item) => {
+            return this.getBaseTypeFromSchema(item);
+          }).filter(Boolean)
+        )
+      );
+      if (schemaWithoutAllOf.properties) {
+        return tsCodegen.createIntersectionDeclaration({
+          nodes: [this.getBaseTypeFromSchema(schemaWithoutAllOf, baseName), and].filter(Boolean)
+        });
+      }
       return tsCodegen.createIntersectionDeclaration({
-        nodes: [
-          this.getBaseTypeFromSchema(schemaWithoutAllOf, baseName),
-          factory2.createParenthesizedType(
-            factory2.createIntersectionTypeNode(
-              schema.allOf.map((item) => {
-                return this.getBaseTypeFromSchema(item);
-              }).filter(Boolean)
-            )
-          )
-        ].filter(Boolean)
+        nodes: [and]
       });
     }
     if (schema.enum && baseName) {

package/dist/index.js

@@ -110,7 +110,9 @@ var _TypeGenerator = class extends SchemaGenerator {
           comments: [
             schema.description && `@description ${schema.description}`,
             schema.type && `@type ${schema.type}${isRequired ? "" : " | undefined"} ${schema.format || ""}`,
-            schema.example && `@example ${schema.example}`
+            schema.example && `@example ${schema.example}`,
+            schema.default !== void 0 && typeof schema.default === "string" && `@default '${schema.default}'`,
+            schema.default !== void 0 && typeof schema.default !== "string" && `@default ${schema.default}`
           ]
         });
       }
@@ -162,33 +164,39 @@ var _TypeGenerator = class extends SchemaGenerator {
     }
     if (schema.oneOf) {
       const schemaWithoutOneOf = { ...schema, oneOf: void 0 };
+      const union = factory2.createParenthesizedType(
+        createUnionDeclaration({
+          nodes: schema.oneOf.map((item) => {
+            return this.getBaseTypeFromSchema(item);
+          }).filter(Boolean)
+        })
+      );
+      if (schemaWithoutOneOf.properties) {
+        return createIntersectionDeclaration({
+          nodes: [this.getBaseTypeFromSchema(schemaWithoutOneOf, baseName), union].filter(Boolean)
+        });
+      }
       return createIntersectionDeclaration({
-        nodes: [
-          this.getBaseTypeFromSchema(schemaWithoutOneOf, baseName),
-          factory2.createParenthesizedType(
-            createUnionDeclaration({
-              nodes: schema.oneOf.map((item) => {
-                return this.getBaseTypeFromSchema(item);
-              }).filter(Boolean)
-            })
-          )
-        ].filter(Boolean)
+        nodes: [union]
       });
     }
     if (schema.anyOf) ;
     if (schema.allOf) {
       const schemaWithoutAllOf = { ...schema, allOf: void 0 };
+      const and = factory2.createParenthesizedType(
+        factory2.createIntersectionTypeNode(
+          schema.allOf.map((item) => {
+            return this.getBaseTypeFromSchema(item);
+          }).filter(Boolean)
+        )
+      );
+      if (schemaWithoutAllOf.properties) {
+        return createIntersectionDeclaration({
+          nodes: [this.getBaseTypeFromSchema(schemaWithoutAllOf, baseName), and].filter(Boolean)
+        });
+      }
       return createIntersectionDeclaration({
-        nodes: [
-          this.getBaseTypeFromSchema(schemaWithoutAllOf, baseName),
-          factory2.createParenthesizedType(
-            factory2.createIntersectionTypeNode(
-              schema.allOf.map((item) => {
-                return this.getBaseTypeFromSchema(item);
-              }).filter(Boolean)
-            )
-          )
-        ].filter(Boolean)
+        nodes: [and]
       });
     }
     if (schema.enum && baseName) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/swagger-ts",
-  "version": "1.0.3",
+  "version": "1.1.1",
   "description": "Generator swagger-ts",
   "repository": {
     "type": "git",
@@ -41,9 +41,9 @@
     "change-case": "^4.1.2",
     "lodash.uniqueid": "^4.0.1",
     "typescript": "^5.1.3",
-    "@kubb/core": "1.0.3",
-    "@kubb/swagger": "1.0.3",
-    "@kubb/ts-codegen": "1.0.3"
+    "@kubb/core": "1.1.1",
+    "@kubb/swagger": "1.1.1",
+    "@kubb/ts-codegen": "1.1.1"
   },
   "devDependencies": {
     "@types/lodash.uniqueid": "^4.0.7",

package/src/generators/TypeGenerator.ts

@@ -138,6 +138,8 @@ export class TypeGenerator extends SchemaGenerator<Options, OpenAPIV3.SchemaObje
             schema.description && `@description ${schema.description}`,
             schema.type && `@type ${schema.type}${isRequired ? '' : ' | undefined'} ${schema.format || ''}`,
             schema.example && `@example ${schema.example}`,
+            schema.default !== undefined && typeof schema.default === 'string' && `@default '${schema.default}'`,
+            schema.default !== undefined && typeof schema.default !== 'string' && `@default ${schema.default}`,
           ],
         })
       }
@@ -205,19 +207,24 @@ export class TypeGenerator extends SchemaGenerator<Options, OpenAPIV3.SchemaObje
       // union
       const schemaWithoutOneOf = { ...schema, oneOf: undefined }
 
-      return createIntersectionDeclaration({
-        nodes: [
-          this.getBaseTypeFromSchema(schemaWithoutOneOf, baseName),
-          factory.createParenthesizedType(
-            createUnionDeclaration({
-              nodes: schema.oneOf
-                .map((item) => {
-                  return this.getBaseTypeFromSchema(item)
-                })
-                .filter(Boolean) as ts.TypeNode[],
+      const union = factory.createParenthesizedType(
+        createUnionDeclaration({
+          nodes: schema.oneOf
+            .map((item) => {
+              return this.getBaseTypeFromSchema(item)
             })
-          ),
-        ].filter(Boolean) as ts.TypeNode[],
+            .filter(Boolean) as ts.TypeNode[],
+        })
+      )
+
+      if (schemaWithoutOneOf.properties) {
+        return createIntersectionDeclaration({
+          nodes: [this.getBaseTypeFromSchema(schemaWithoutOneOf, baseName), union].filter(Boolean) as ts.TypeNode[],
+        })
+      }
+
+      return createIntersectionDeclaration({
+        nodes: [union],
       })
     }
 
@@ -228,19 +235,24 @@ export class TypeGenerator extends SchemaGenerator<Options, OpenAPIV3.SchemaObje
       // intersection/add
       const schemaWithoutAllOf = { ...schema, allOf: undefined }
 
+      const and = factory.createParenthesizedType(
+        factory.createIntersectionTypeNode(
+          schema.allOf
+            .map((item) => {
+              return this.getBaseTypeFromSchema(item)
+            })
+            .filter(Boolean) as ts.TypeNode[]
+        )
+      )
+
+      if (schemaWithoutAllOf.properties) {
+        return createIntersectionDeclaration({
+          nodes: [this.getBaseTypeFromSchema(schemaWithoutAllOf, baseName), and].filter(Boolean) as ts.TypeNode[],
+        })
+      }
+
       return createIntersectionDeclaration({
-        nodes: [
-          this.getBaseTypeFromSchema(schemaWithoutAllOf, baseName),
-          factory.createParenthesizedType(
-            factory.createIntersectionTypeNode(
-              schema.allOf
-                .map((item) => {
-                  return this.getBaseTypeFromSchema(item)
-                })
-                .filter(Boolean) as ts.TypeNode[]
-            )
-          ),
-        ].filter(Boolean) as ts.TypeNode[],
+        nodes: [and],
       })
     }
 

package/src/plugin.ts

@@ -8,7 +8,7 @@ import { pascalCase, pascalCaseTransformMerge } from 'change-case'
 
 import { getRelativePath, createPlugin, getPathMode, validatePlugins, writeIndexes, renderTemplate } from '@kubb/core'
 import { pluginName as swaggerPluginName } from '@kubb/swagger'
-import type { Api as SwaggerApi, OpenAPIV3 } from '@kubb/swagger'
+import type { API as SwaggerApi, OpenAPIV3 } from '@kubb/swagger'
 
 import { TypeBuilder } from './builders/index.ts'
 import { OperationGenerator } from './generators/index.ts'