fix: add support for non-object types as component schemas (ie oneOfs)

closes #2

Author: maxholman

__tests__/__snapshots__/nullables.test.ts.snap

@@ -0,0 +1,9 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`nullables 1`] = `
+"import type { Jsonifiable } from 'type-fest';
+import type { JsonifiableObject } from 'type-fest/source/jsonifiable.js';
+
+export type MySchemaLolOrNullable = "lol" | "kek" | null;
+"
+`;

__tests__/nullables.test.ts

@@ -0,0 +1,34 @@
+import { test } from '@jest/globals';
+import { processOpenApiDocument } from '../lib/process-document.js';
+
+test('nullables', async () => {
+  const result = await processOpenApiDocument(
+    '/tmp', // if we dont call .save() it doesnt matter
+    {
+      openapi: '3.0.0',
+      info: {
+        title: 'Test',
+        version: '1.0.0',
+      },
+      paths: {},
+      components: {
+        schemas: {
+          MySchemaLolOrNullable: {
+            oneOf: [
+              {
+                type: 'string',
+                enum: ['lol', 'kek'],
+              },
+              {
+                nullable: true,
+              },
+            ],
+          },
+        },
+      },
+    },
+    [],
+  );
+
+  expect(result.typesFile.getText()).toMatchSnapshot();
+});

lib/process-schema.ts

@@ -13,21 +13,24 @@ import {
   type WriterFunction,
 } from 'ts-morph';
 import {
+  isNotNullOrUndefined,
   isNotReferenceObject,
   isReferenceObject,
   pascalCase,
   wordWrap,
 } from './utils.js';
 
 function withNullUnion(type: string | WriterFunction, nullable = false) {
-  return nullable ? Writers.unionType(type, 'null') : type;
+  return nullable && type !== 'null' ? Writers.unionType(type, 'null') : type;
 }
 
 function maybeWithUndefined(
   type: string | WriterFunction,
   withUndefined: boolean,
 ) {
-  return withUndefined ? Writers.unionType(type, 'undefined') : type;
+  return withUndefined && type !== 'undefined'
+    ? Writers.unionType(type, 'undefined')
+    : type;
 }
 
 export function schemaToType(
@@ -114,6 +117,7 @@ export function schemaToType(
 
   const docs: (OptionalKind<JSDocStructure> | string)[] =
     Object.keys(maybeJsDoc).length > 1 ? [maybeJsDoc] : [];
+
   if (schemaObject.type === 'array') {
     const type = schemaToType(
       typesAndInterfaces,
@@ -347,11 +351,14 @@ export function schemaToType(
     };
   }
 
-  const type = schemaObject.type?.toString() || ('never' as const);
+  const type =
+    schemaObject.type?.toString() ||
+    ('nullable' in schemaObject && 'null') ||
+    'never';
 
   if (type === 'never') {
     console.warn(
-      'unsupported type in %j with parent %j',
+      'WARN: unsupported type in %j with parent %j',
       schemaObject,
       parentSchema,
     );
@@ -420,6 +427,7 @@ export function registerTypesFromSchema(
 
     const objectTypesFromNonRefSchemas = schemaItems
       .filter(isNotReferenceObject)
+      .filter((schema) => schema.type === 'object')
       .map((subSchemaObject) =>
         Writers.objectType({
           properties: Object.entries(subSchemaObject.properties || {}).map(
@@ -432,13 +440,29 @@ export function registerTypesFromSchema(
               ),
           ),
         }),
-      );
+      )
+      .filter(isNotNullOrUndefined);
+
+    const nonObjectTypesFromNonRefSchemas = schemaItems
+      .filter(isNotReferenceObject)
+      .filter((schema) => schema.type !== 'object')
+      .map(
+        (subSchemaObject) =>
+          schemaToType(
+            typesAndInterfaces,
+            {}, // no parent schema
+            schemaName,
+            subSchemaObject,
+          ).type,
+      )
+      .filter(isNotNullOrUndefined);
 
     // concat and dedupe
     const typeArgs = [
       ...new Set([
         ...typeAliases.map((t) => t.getName()),
-        ...objectTypesFromNonRefSchemas.filter(Boolean),
+        ...objectTypesFromNonRefSchemas,
+        ...nonObjectTypesFromNonRefSchemas,
       ]),
     ];
 
@@ -450,10 +474,9 @@ export function registerTypesFromSchema(
     const typeAlias = typesFile.addTypeAlias({
       name: pascalCase(schemaName),
       isExported: true,
-      type:
-        firstType && secondType
-          ? writerType.call(Writers, firstType, secondType, ...restTypes)
-          : firstType,
+      type: secondType
+        ? writerType.call(Writers, firstType, secondType, ...restTypes)
+        : firstType,
     });
 
     if (schemaObject.description) {