openapi-typescript - npm Package Compare versions

Comparing version 6.3.8 to 6.3.9

dist/transform/schema-object.js

@@ -48,15 +48,16 @@ import { escObjKey, escStr, getEntries, getSchemaObjectComment, indent, parseRef, tsArrayOf, tsIntersectionOf, tsOmit, tsOneOf, tsOptionalProperty, tsReadonly, tsTupleOf, tsUnionOf, tsWithRequired } from "../utils.js";
     }
-    const oneOf = ((typeof schemaObject === "object" && schemaObject.oneOf) || schemaObject.enum || undefined);
+    const oneOf = ((typeof schemaObject === "object" && !schemaObject.discriminator && schemaObject.oneOf) || schemaObject.enum || undefined);
     if (oneOf && !oneOf.some((t) => "$ref" in t && ctx.discriminators[t.$ref])) {
         const oneOfNormalized = oneOf.map((item) => transformSchemaObject(item, { path, ctx }));
+        if (schemaObject.nullable)
+            oneOfNormalized.push("null");
+        if ("type" in schemaObject && Array.isArray(schemaObject.type)) {
+            const coreTypes = schemaObject.type.map((t) => transformSchemaObject({ ...schemaObject, oneOf: undefined, type: t }, { path, ctx }));
+            return tsUnionOf(...oneOfNormalized, ...coreTypes);
+        }
         const oneOfTypes = oneOfNormalized.some((t) => typeof t === "string" && t.includes("{")) ? tsOneOf(...oneOfNormalized) : tsUnionOf(...oneOfNormalized);
         if ("type" in schemaObject && schemaObject.type === "object") {
-            const coreSchema = { ...schemaObject };
-            delete coreSchema.oneOf;
-            delete coreSchema.enum;
-            return tsIntersectionOf(transformSchemaObject(coreSchema, { path, ctx }), oneOfTypes);
+            return tsIntersectionOf(transformSchemaObject({ ...schemaObject, oneOf: undefined, enum: undefined }, { path, ctx }), oneOfTypes);
         }
-        else {
-            return oneOfTypes;
-        }
+        return oneOfTypes;
     }
@@ -149,3 +150,3 @@ if ("type" in schemaObject) {
     for (const k of ["oneOf", "allOf", "anyOf"]) {
-        if (!(k in schemaObject))
+        if (!schemaObject[k])
             continue;
@@ -179,3 +180,3 @@ const discriminatorRef = schemaObject[k].find((t) => "$ref" in t && ctx.discriminators[t.$ref]);
     if ("oneOf" in schemaObject && Array.isArray(schemaObject.oneOf)) {
-        const oneOfType = tsOneOf(...collectCompositions(schemaObject.oneOf));
+        const oneOfType = tsUnionOf(...collectCompositions(schemaObject.oneOf));
         finalType = finalType ? tsIntersectionOf(finalType, oneOfType) : oneOfType;
@@ -182,0 +183,0 @@ }

package.json

 {
   "name": "openapi-typescript",
   "description": "Generate TypeScript types from Swagger OpenAPI specs",
-  "version": "6.3.8",
+  "version": "6.3.9",
   "author": {
@@ -65,3 +65,3 @@ "name": "Drew Powers",
     "lint": "run-p -s lint:*",
-    "lint:js": "eslint \"src/**/*.{js,ts}\"",
+    "lint:js": "eslint \"{src,test}/**/*.{js,ts}\"",
     "lint:prettier": "prettier --check \"src/**/*\"",
@@ -68,0 +68,0 @@ "test": "run-p -s test:*",

src/transform/schema-object.ts

@@ -70,16 +70,23 @@ import type { GlobalContext, ReferenceObject, SchemaObject } from "../types.js";
   // oneOf (no discriminator)
-  const oneOf = ((typeof schemaObject === "object" && (schemaObject as any).oneOf) || (schemaObject as any).enum || undefined) as (SchemaObject | ReferenceObject)[] | undefined; // note: for objects, treat enum as oneOf
+  const oneOf = ((typeof schemaObject === "object" && !(schemaObject as any).discriminator && (schemaObject as any).oneOf) || (schemaObject as any).enum || undefined) as (SchemaObject | ReferenceObject)[] | undefined; // note: for objects, treat enum as oneOf
   if (oneOf && !oneOf.some((t) => "$ref" in t && ctx.discriminators[t.$ref])) {
     const oneOfNormalized = oneOf.map((item) => transformSchemaObject(item, { path, ctx }));
+    if (schemaObject.nullable) oneOfNormalized.push("null");
+
+    // handle oneOf + polymorphic array type
+    if ("type" in schemaObject && Array.isArray(schemaObject.type)) {
+      const coreTypes = schemaObject.type.map((t) => transformSchemaObject({ ...schemaObject, oneOf: undefined, type: t }, { path, ctx }));
+      return tsUnionOf(...oneOfNormalized, ...coreTypes);
+    }
+
     // OneOf<> helper needed if any objects present ("{")
     const oneOfTypes = oneOfNormalized.some((t) => typeof t === "string" && t.includes("{")) ? tsOneOf(...oneOfNormalized) : tsUnionOf(...oneOfNormalized);
 
+    // handle oneOf + object type
     if ("type" in schemaObject && schemaObject.type === "object") {
-      const coreSchema = { ...schemaObject };
-      delete (coreSchema as any).oneOf;
-      delete coreSchema.enum;
-      return tsIntersectionOf(transformSchemaObject(coreSchema, { path, ctx }), oneOfTypes);
-    } else {
-      return oneOfTypes;
+      return tsIntersectionOf(transformSchemaObject({ ...schemaObject, oneOf: undefined, enum: undefined } as any, { path, ctx }), oneOfTypes);
     }
+
+    // default
+    return oneOfTypes;
   }
@@ -187,3 +194,3 @@
   for (const k of ["oneOf", "allOf", "anyOf"] as ("oneOf" | "allOf" | "anyOf")[]) {
-    if (!(k in schemaObject)) continue;
+    if (!(schemaObject as any)[k]) continue;
     const discriminatorRef: ReferenceObject | undefined = (schemaObject as any)[k].find((t: SchemaObject | ReferenceObject) => "$ref" in t && ctx.discriminators[t.$ref]);
@@ -221,3 +228,3 @@ if (discriminatorRef) {
   if ("oneOf" in schemaObject && Array.isArray(schemaObject.oneOf)) {
-    const oneOfType = tsOneOf(...collectCompositions(schemaObject.oneOf));
+    const oneOfType = tsUnionOf(...collectCompositions(schemaObject.oneOf));
     finalType = finalType ? tsIntersectionOf(finalType, oneOfType) : oneOfType;
@@ -224,0 +231,0 @@ } else {

No alert changes

Improved metrics

Total package byte prevSize

300232

increased by0.35%

Lines of code

4970

increased by0.1%

No dependency changes