swaggie 1.5.3-beta.2 → 1.5.3-beta.3

package/README.md

@@ -313,14 +313,14 @@ function error(e) {
 
 | Supported                                                                      | Not supported                                   |
 | ------------------------------------------------------------------------------ | ----------------------------------------------- |
-| OpenAPI 3                                                                      | Swagger, Open API 2.0                           |
+| OpenAPI 3, OpenAPI 3.1, OpenAPI 3.2                                            | Swagger, Open API 2.0                           |
 | `allOf`, `oneOf`, `anyOf`, `$ref` to schemas                                   | `not`                                           |
-| Spec formats: `JSON`, `YAML`                                                   | Very complex query params                       |
+| Spec formats: `JSON`, `YAML`                                                   | VERY complex query params                       |
 | Extensions: `x-position`, `x-name`, `x-enumNames`, `x-enum-varnames`           | Multiple response types (only one will be used) |
 | Content types: `JSON`, `text`, `multipart/form-data`                           | Multiple request types (only one will be used)  |
-| Content types: `application/x-www-form-urlencoded`, `application/octet-stream` | References to other spec files                  |
-| Different types of enum definitions (+ OpenAPI 3.1 support for enums)          | OpenAPI callbacks                               |
-| Paths inheritance, comments (descriptions), nullable                           | OpenAPI webhooks                                |
+| Content types: `application/x-www-form-urlencoded`, `application/octet-stream` | References to external spec files               |
+| Different types of enum definitions                                            | OpenAPI callbacks                               |
+| Paths inheritance, comments (descriptions), nullable, `["<TYPE>", null]`       | OpenAPI webhooks                                |
 | Getting documents from remote locations or as path reference (local file)      |                                                 |
 | Grouping endpoints by tags + handle gracefully duplicate operation ids         |                                                 |
 

package/dist/gen/genTypes.js

@@ -201,12 +201,7 @@ function renderTypeProp(
     lines.push(_jsDocs.renderComment.call(void 0, _nullishCoalesce(definition.description, () => ( definition.title))));
   }
 
-  // When nullableAsOptional strategy is set, nullable properties are treated as optional
-  const isNullableAsOptional =
-    options.nullableStrategy === 'nullableAsOptional' &&
-    !('$ref' in definition) &&
-    (definition ).nullable === true;
-  const isOptional = !required || isNullableAsOptional;
+  const isOptional = !required || isNullableAsOptional(definition, options);
   const optionalMark = isOptional ? '?' : '';
   // If prop name is not a valid identifier, we need to wrap it in quotes.
   // We can't use getSafeIdentifier here because it will affect the data model.
@@ -216,6 +211,26 @@ function renderTypeProp(
   return lines.join('\n');
 }
 
+/**
+ * When nullableAsOptional strategy is set, nullable properties are treated as optional.
+ * Supports both OA3.0 (nullable: true) and OA3.1 (type: ["string", "null"]).
+ * @returns True if the property should be treated as optional, false otherwise.
+ */
+function isNullableAsOptional(
+  definition,
+  options
+) {
+  if ('$ref' in definition) {
+    return false;
+  }
+
+  return (
+    options.nullableStrategy === 'nullableAsOptional' &&
+    (definition.nullable === true ||
+      (Array.isArray(definition.type) && definition.type.includes('null')))
+  );
+}
+
 function getMergedCompositeObjects(schema) {
   const { allOf, oneOf, anyOf, ...safeSchema } = schema;
   const composite = allOf || oneOf || anyOf || [];

package/dist/swagger/typesExtractor.js

@@ -52,6 +52,12 @@ var _utils = require('../utils');
     return 'null';
   }
 
+  // OpenAPI 3.1 nullable: type is an array containing 'null', e.g. ["string", "null"]
+  if (Array.isArray(schema.type)) {
+    return getTypeFromOA31ArrayType(schema , options);
+  }
+
+  // OpenAPI 3.0 nullable: nullable: true
   const isNullable = 'nullable' in schema && schema.nullable === true;
   const strategy = _nullishCoalesce(options.nullableStrategy, () => ( 'ignore'));
   const isNullableSuffix = isNullable && strategy === 'include' ? ' | null' : '';
@@ -63,6 +69,58 @@ var _utils = require('../utils');
   return type + isNullableSuffix;
 } exports.getTypeFromSchema = getTypeFromSchema;
 
+/**
+ * Handles OpenAPI 3.1 schemas where `type` is an array (e.g. `["string", "null"]`).
+ * The presence of `"null"` in the array is the OA3.1 way of marking a field as nullable.
+ * Respects `nullableStrategy` the same way as OA3.0 `nullable: true`.
+ */
+function getTypeFromOA31ArrayType(
+  schema,
+  options
+) {
+  const unknownType = options.preferAny ? 'any' : 'unknown';
+  const types = schema.type ;
+  const isNullable = types.includes('null');
+  const nonNullTypes = types.filter((t) => t !== 'null');
+
+  // Build the base type from the non-null types
+  let baseType;
+  if (nonNullTypes.length === 0) {
+    baseType = 'null';
+  } else if (nonNullTypes.length === 1) {
+    // Synthesize a single-type schema to reuse existing resolution logic
+    const singleTypeSchema = { ...schema, type: nonNullTypes[0] } ;
+    baseType = getTypeFromSchemaInternal(singleTypeSchema, options);
+  } else {
+    // Multiple non-null types — resolve each independently and join as a union
+    baseType = nonNullTypes
+      .map((t) => getTypeFromSchemaInternal({ ...schema, type: t } , options))
+      .join(' | ');
+  }
+
+  if (!isNullable) {
+    return baseType || unknownType;
+  }
+
+  // All types were 'null' — just return 'null' regardless of strategy
+  if (nonNullTypes.length === 0) {
+    return 'null';
+  }
+
+  const strategy = _nullishCoalesce(options.nullableStrategy, () => ( 'ignore'));
+  if (strategy === 'include') {
+    // We don't want multiple nulls in the type string
+    if (baseType.endsWith('| null')) {
+      return baseType;
+    }
+    return `${baseType} | null`;
+  }
+
+  // 'ignore' and 'nullableAsOptional' — null is stripped from the type itself
+  // (for nullableAsOptional, the optionality is applied at the property level in genTypes.ts)
+  return baseType || unknownType;
+}
+
 function getTypeFromSchemaInternal(
   schema,
   options
@@ -105,11 +163,22 @@ function getNestedTypeFromSchema(
   options
 ) {
   const strategy = _nullishCoalesce(options.nullableStrategy, () => ( 'ignore'));
-  const isNullableAndActive =
+
+  // OA3.0 nullable: true
+  const isOA30NullableAndActive =
     'nullable' in schema && schema.nullable === true && strategy === 'include';
-  if (isNullableAndActive || ('enum' in schema && schema.enum)) {
+
+  // OA3.1 nullable: type array containing 'null'
+  const isOA31NullableAndActive =
+    'type' in schema &&
+    Array.isArray(schema.type) &&
+    schema.type.includes('null') &&
+    strategy === 'include';
+
+  if (isOA30NullableAndActive || isOA31NullableAndActive || ('enum' in schema && schema.enum)) {
     return `(${getTypeFromSchema(schema, options)})`;
   }
+
   return getTypeFromSchema(schema, options);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swaggie",
-  "version": "1.5.3-beta.2",
+  "version": "1.5.3-beta.3",
   "description": "Generate TypeScript REST client code from an OpenAPI spec",
   "author": {
     "name": "Piotr Dabrowski",