@sebspark/openapi-typegen 1.2.1 → 1.4.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,7 @@ 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) + (type.oneOf || []).map(generateType).concat("").join(OR);
 var generatePrimitive = (parsed) => `${preamble(parsed)}${parsed.type}`;
 var generateCustom = (parsed) => `${preamble(parsed)}${typeName(parsed.type)}`;
 var generateObject = (parsed) => {
@@ -204,6 +204,18 @@ var generateObject = (parsed) => {
   lines.push(`${preamble(parsed)}${extensions(parsed)}{`);
   lines.push(...parsed.properties.map(generateProperty));
   lines.push("}");
+  if (parsed.discriminator && parsed.name) {
+    lines.push(generateDiscriminator(parsed.discriminator, parsed.name));
+  }
+  return lines.join("\n");
+};
+var generateDiscriminator = (discriminator, name) => {
+  const lines = [""];
+  lines.push(`export type ${name}Discriminator = {`);
+  for (const [key, type] of Object.entries(discriminator.mapping)) {
+    lines.push(`${key}: ${type.type}`);
+  }
+  lines.push("}");
   return lines.join("\n");
 };
 var generateArray = (parsed) => {
@@ -416,7 +428,6 @@ var generateComponents = (components) => {
     tokens.push(
       generateType({
         type: "object",
-        extends: [],
         name: param2.name,
         properties: [
           {
@@ -489,11 +500,11 @@ var parseSchema = (name, schemaOrRef) => {
   }
 };
 var parseObjectSchema = (name, schema) => {
+  var _a;
   const type = {
     name,
     type: "object",
     properties: [],
-    extends: [],
     ...parseDocumentation(schema)
   };
   if (schema.properties) {
@@ -502,7 +513,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;
 };
@@ -617,7 +644,6 @@ var parseArgs = (path, components) => {
 };
 var createArgs = (initializer = {}) => ({
   type: "object",
-  extends: [],
   properties: [],
   optional: true,
   ...initializer
@@ -633,7 +659,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;
         }
@@ -667,6 +695,7 @@ var parseParameters2 = (parameters = [], components = {}) => {
   return args;
 };
 var parseRequestBody = (requestBody, components = {}) => {
+  var _a, _b;
   const args = {};
   if (!requestBody)
     return args;
@@ -675,7 +704,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;
@@ -692,13 +721,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.1",
+  "version": "1.4.0",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",