@sebspark/openapi-typegen 1.2.0 → 1.3.0

package/dist/index.js

@@ -100,7 +100,7 @@ var requestArgs = (args, name, title) => {
   if (!args)
     return [];
   const tokens = [];
-  const type = args.extends.map((e) => e.type).join(AND) || "Object";
+  const type = (args.allOf || []).map((e) => e.type).join(AND) || "Object";
   tokens.push(
     param(
       buildPath("args", name),
@@ -178,7 +178,7 @@ var generateType = (parsed) => {
       type = generateCustom(parsed);
     }
   }
-  return type.replace(/ & \{\s*\}/g, "");
+  return type.replace(/ [&|] \{\s*\}/g, "");
 };
 var generateProperty = (property) => {
   const types = property.type.map(generateType);
@@ -196,7 +196,37 @@ var propertyName = (name) => {
     return name;
   return `'${name}'`;
 };
-var extensions = (type) => type.extends.map(generateType).concat("").join(AND);
+var extensions = (type) => (type.allOf || []).map(generateType).concat("").join(AND) + parseOptional(type.oneOf, type.discriminator);
+var parseOptional = (optional, discriminator) => {
+  const tokens = [];
+  const map = reverseDiscriminator(discriminator);
+  for (const type of optional || []) {
+    if (type.type === "object")
+      tokens.push(generateType(type));
+    else {
+      const custom = type;
+      if (!map[custom.type])
+        tokens.push(generateType(custom));
+      else {
+        tokens.push(
+          `(${generateType(custom)} & { ${discriminator == null ? void 0 : discriminator.propertyName}: '${map[custom.type]}' })`
+        );
+      }
+    }
+  }
+  if (tokens.length)
+    tokens.push("");
+  return tokens.join(OR);
+};
+var reverseDiscriminator = (discriminator) => {
+  const reverse = {};
+  if (!discriminator)
+    return reverse;
+  for (const [val, { type }] of Object.entries(discriminator.mapping)) {
+    reverse[type] = val;
+  }
+  return reverse;
+};
 var generatePrimitive = (parsed) => `${preamble(parsed)}${parsed.type}`;
 var generateCustom = (parsed) => `${preamble(parsed)}${typeName(parsed.type)}`;
 var generateObject = (parsed) => {
@@ -208,7 +238,8 @@ var generateObject = (parsed) => {
 };
 var generateArray = (parsed) => {
   const lines = [];
-  lines.push(`${preamble(parsed)}${parsed.items.type}[]`);
+  const items = generateType(parsed.items);
+  lines.push(`${preamble(parsed)}${items}[]`);
   return lines.join("\n");
 };
 var generateEnum = (parsed) => {
@@ -415,7 +446,6 @@ var generateComponents = (components) => {
     tokens.push(
       generateType({
         type: "object",
-        extends: [],
         name: param2.name,
         properties: [
           {
@@ -488,11 +518,11 @@ var parseSchema = (name, schemaOrRef) => {
   }
 };
 var parseObjectSchema = (name, schema) => {
+  var _a;
   const type = {
     name,
     type: "object",
     properties: [],
-    extends: [],
     ...parseDocumentation(schema)
   };
   if (schema.properties) {
@@ -501,7 +531,23 @@ var parseObjectSchema = (name, schema) => {
     );
   }
   if (schema.allOf) {
-    type.extends = schema.allOf.flatMap(parsePropertyType);
+    type.allOf = schema.allOf.flatMap(parsePropertyType);
+  }
+  if (schema.oneOf) {
+    type.oneOf = schema.oneOf.flatMap(parsePropertyType);
+  }
+  if (schema.anyOf) {
+    type.oneOf = schema.anyOf.flatMap(parsePropertyType);
+  }
+  if ((_a = schema.discriminator) == null ? void 0 : _a.mapping) {
+    const mapping = {};
+    for (const [prop, ref] of Object.entries(schema.discriminator.mapping)) {
+      mapping[prop] = { type: parseRef(ref) };
+    }
+    type.discriminator = {
+      propertyName: schema.discriminator.propertyName,
+      mapping
+    };
   }
   return type;
 };
@@ -616,7 +662,6 @@ var parseArgs = (path, components) => {
 };
 var createArgs = (initializer = {}) => ({
   type: "object",
-  extends: [],
   properties: [],
   optional: true,
   ...initializer
@@ -632,7 +677,9 @@ var parseParameters2 = (parameters = [], components = {}) => {
           const param2 = findRef(components, ref);
           const arg = args[param2.in] || createArgs({ ...parseDocumentation(param2) });
           arg.optional = arg.optional && !param2.required;
-          arg.extends.push({ type: parseRef(ref) });
+          if (!arg.allOf)
+            arg.allOf = [];
+          arg.allOf.push({ type: parseRef(ref) });
           args[param2.in] = arg;
           break;
         }
@@ -666,6 +713,7 @@ var parseParameters2 = (parameters = [], components = {}) => {
   return args;
 };
 var parseRequestBody = (requestBody, components = {}) => {
+  var _a, _b;
   const args = {};
   if (!requestBody)
     return args;
@@ -674,7 +722,7 @@ var parseRequestBody = (requestBody, components = {}) => {
     const refBody = findRef(components, ref);
     args.body = createArgs({
       optional: !refBody.required,
-      extends: [{ type: parseRef(ref) }]
+      allOf: [{ type: parseRef(ref) }]
     });
   } else {
     const body = requestBody;
@@ -691,13 +739,13 @@ var parseRequestBody = (requestBody, components = {}) => {
         } else if (parsed.type) {
           args.body = createArgs({
             optional: !body.required,
-            extends: [parsed],
+            allOf: [parsed],
             ...parseDocumentation(body)
           });
         }
       }
     }
-    if (bodyArgs.extends.length || bodyArgs.properties.length) {
+    if (((_a = bodyArgs.allOf) == null ? void 0 : _a.length) || ((_b = bodyArgs.oneOf) == null ? void 0 : _b.length) || bodyArgs.properties.length) {
       args.body = bodyArgs;
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sebspark/openapi-typegen",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",