swaggie 1.8.0 → 1.8.2

package/README.md

@@ -80,7 +80,8 @@ swaggie -s https://petstore3.swagger.io/api/v3/openapi.json -o ./client/petstore
 -t, --template <string>   Template to use for code generation (default: "axios")
  -m, --mode <mode>         Generation mode: "full" or "schemas" (default: "full")
  -d, --schemaStyle <style> Schema object style: "interface" or "type" (default: "interface")
-    --preferAny           Use "any" instead of "unknown" for untyped values (default: false)
+    --enumStyle <style>    Enum style for plain string enums: "union" or "enum" (default: "union")
+     --preferAny           Use "any" instead of "unknown" for untyped values (default: false)
     --skipDeprecated      Exclude deprecated operations from the output (default: false)
     --servicePrefix       Prefix for service names — useful when generating multiple APIs
     --allowDots           Use dot notation to serialize nested object query params
@@ -123,6 +124,7 @@ swaggie -c swaggie.config.json
   "nullableStrategy": "ignore",
   "generationMode": "full",
   "schemaDeclarationStyle": "interface",
+  "enumDeclarationStyle": "union",
   "queryParamsSerialization": {
     "arrayFormat": "repeat",
     "allowDots": true
@@ -279,6 +281,14 @@ Use `schemaDeclarationStyle` (or CLI `--schemaStyle`) to control object schema o
 | `"interface"`| `export interface Tag { ... }` (default)                                |
 | `"type"`     | `export type Tag = { ... };`                                             |
 
+### Enum Declaration Style
+
+Use `enumDeclarationStyle` (or CLI `--enumStyle`) for plain string enums:
+- `"union"` (default): `export type Status = "active" | "disabled";`
+- `"enum"`: `export enum Status { active = "active", disabled = "disabled" }`
+
+Note: this applies only to plain string enums. Non-string enums are still emitted as union types.
+
 ### Parameter Modifiers
 
 Sometimes an API spec marks a parameter as required, but your client handles it in an interceptor and you don't want it cluttering every method signature. Parameter modifiers let you override this globally without touching the spec.
@@ -360,12 +370,12 @@ Swaggie only needs a JSON or YAML OpenAPI spec file — it does not require a ru
 | Supported                                                                      | Not Supported                                        |
 | ------------------------------------------------------------------------------ | ---------------------------------------------------- |
 | OpenAPI 3.0, 3.1, 3.2                                                          | Swagger / OpenAPI 2.0                                |
-| `allOf`, `oneOf`, `anyOf`, `$ref`                                              | `not` keyword                                        |
+| `allOf`, `oneOf`, `anyOf`, `$ref`, external $refs                              | `not` keyword                                        |
 | Spec formats: JSON, YAML                                                       | Very complex query parameter structures              |
 | Extensions: `x-position`, `x-name`, `x-enumNames`, `x-enum-varnames`           | Multiple response types (only the first is used)     |
 | Content types: JSON, plain text, multipart/form-data                           | Multiple request body types (only the first is used) |
-| Content types: `application/x-www-form-urlencoded`, `application/octet-stream` | References to external spec files                    |
-| Various enum definition styles                                                 | OpenAPI callbacks and webhooks                       |
+| Content types: `application/x-www-form-urlencoded`, `application/octet-stream` | OpenAPI callbacks and webhooks                       |
+| Various enum definition styles, support for additionalProperties               |                                                      |
 | Nullable types, path inheritance, JSDoc descriptions                           |                                                      |
 | Remote URLs and local file paths as spec source                                |                                                      |
 | Grouping by tags, graceful handling of duplicate operation IDs                 |                                                      |

package/dist/cli.js

@@ -23,6 +23,10 @@ const schemaStyleOption = new (0, _commander.Option)(
   '-d, --schemaStyle <style>',
   'Schema object declaration style'
 ).choices(['interface', 'type']);
+const enumStyleOption = new (0, _commander.Option)(
+  '--enumStyle <style>',
+  'Enum declaration style for plain string enums'
+).choices(['union', 'enum']);
 
 const program = new (0, _commander.Command)();
 program
@@ -64,7 +68,8 @@ program
   )
   .addOption(arrayFormatOption)
   .addOption(modeOption)
-  .addOption(schemaStyleOption);
+  .addOption(schemaStyleOption)
+  .addOption(enumStyleOption);
 
 program.parse(process.argv);
 

package/dist/gen/genOperations.js

@@ -96,45 +96,63 @@ function prepareClient(
   }
 
   return ops.map((op) => {
-    const [respObject, responseContentType] = _utils.getBestResponse.call(void 0, op, components);
-    const returnType = _swagger.getParameterType.call(void 0, respObject, options);
+    const operationContext = `${op.method.toUpperCase()} ${op.path} (${op.operationId || 'unknown operationId'})`;
 
-    const body = getRequestBody(op.requestBody, components, options);
-    const queryParams = getParams(op.parameters , options, ['query']);
-    const params = getParams(op.parameters , options);
+    try {
+      const [respObject, responseContentType] = _utils.getBestResponse.call(void 0, op, components);
+      const returnType = _swagger.getParameterType.call(void 0, respObject, options);
 
-    if (body) {
-      params.unshift(body);
-    }
+      const body = getRequestBody(op.requestBody, components, options);
+      const queryParams = getParams(op.parameters , options, ['query']);
+      const params = getParams(op.parameters , options);
+
+      if (body) {
+        params.unshift(body);
+      }
 
     // If all parameters have 'x-position' defined, sort them by it
-    if (params.every((p) => p.original['x-position'])) {
-      params.sort((a, b) => a.original['x-position'] - b.original['x-position']);
-    }
+      if (params.every((p) => p.original['x-position'])) {
+        params.sort((a, b) => a.original['x-position'] - b.original['x-position']);
+      }
 
-    markParametersAsSkippable(params);
+      markParametersAsSkippable(params);
 
-    const headers = getParams(op.parameters , options, ['header']);
-    // Some libraries need to know the content type of the request body in case of urlencoded body
-    if (_optionalChain([body, 'optionalAccess', _2 => _2.contentType]) === 'urlencoded') {
-      headers.push({
-        originalName: 'Content-Type',
-        value: 'application/x-www-form-urlencoded',
-      });
-    }
+      const headers = getParams(
+        op.parameters ,
+        options,
+        ['header']
+      );
+      // Some libraries need explicit Content-Type for request bodies.
+      if (_optionalChain([body, 'optionalAccess', _2 => _2.contentType]) === 'urlencoded') {
+        upsertFixedHeader(headers, 'Content-Type', 'application/x-www-form-urlencoded');
+      } else if (_optionalChain([body, 'optionalAccess', _3 => _3.contentType]) === 'json' && options.template === 'fetch') {
+        upsertFixedHeader(headers, 'Content-Type', 'application/json');
+      }
 
-    return {
-      jsDocs: _jsDocs.prepareJsDocsForOperation.call(void 0, op, params),
-      returnType,
-      responseContentType,
-      method: op.method.toUpperCase(),
-      name: getOperationName(op.operationId, op.group),
-      url: prepareUrl(op.path),
-      parameters: params,
-      query: queryParams,
-      body,
-      headers,
-    };
+      return {
+        jsDocs: _jsDocs.prepareJsDocsForOperation.call(void 0, op, params),
+        returnType,
+        responseContentType,
+        method: op.method.toUpperCase(),
+        name: getOperationName(op.operationId, op.group),
+        url: prepareUrl(op.path),
+        parameters: params,
+        query: queryParams,
+        body,
+        headers,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes('Invalid schema at')) {
+        throw new Error(
+          `Failed to prepare operation ${operationContext}. ` +
+            'Check if schema is valid for this operation. ' +
+            'Most common culprit is `properties.$ref` (use `schema.$ref` at root, or put `$ref` under a named property).'
+        );
+      }
+
+      throw new Error(`Failed to prepare operation ${operationContext}: ${message}`);
+    }
   });
 } exports.prepareOperations = prepareOperations;
 
@@ -237,10 +255,10 @@ function prepareUrl(path) {
       type: _swagger.getParameterType.call(void 0, p, options),
       optional: p.required === undefined || p.required === null ? true : !p.required,
       original: p,
-      jsDoc: _optionalChain([p, 'access', _3 => _3.description, 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]),
+      jsDoc: _optionalChain([p, 'access', _4 => _4.description, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]),
     }));
 
-  if (_optionalChain([options, 'access', _6 => _6.modifiers, 'optionalAccess', _7 => _7.parameters])) {
+  if (_optionalChain([options, 'access', _7 => _7.modifiers, 'optionalAccess', _8 => _8.parameters])) {
     for (const [name, modifier] of Object.entries(options.modifiers.parameters)) {
       const paramIndex = result.findIndex(
         (p) => p.original.in !== 'path' && (p.originalName === name || p.name === name)
@@ -291,7 +309,7 @@ function getRequestBody(
   let reqBody;
   if ('$ref' in rawReqBody) {
     const refName = rawReqBody.$ref.replace('#/components/requestBodies/', '');
-    const resolved = _optionalChain([components, 'optionalAccess', _8 => _8.requestBodies, 'optionalAccess', _9 => _9[refName]]);
+    const resolved = _optionalChain([components, 'optionalAccess', _9 => _9.requestBodies, 'optionalAccess', _10 => _10[refName]]);
     if (!resolved || '$ref' in resolved) {
       console.error(`RequestBody $ref '${rawReqBody.$ref}' not found in components/requestBodies`);
       return null;
@@ -317,3 +335,19 @@ function getRequestBody(
 
   return null;
 }
+
+function upsertFixedHeader(headers, headerName, value) {
+  const headerIndex = headers.findIndex(
+    (header) => header.originalName.toLowerCase() === headerName.toLowerCase()
+  );
+
+  if (headerIndex >= 0) {
+    headers[headerIndex].value = value;
+    return;
+  }
+
+  headers.push({
+    originalName: headerName,
+    value,
+  });
+}

package/dist/gen/genTypes.js

@@ -61,6 +61,7 @@ function renderSchema(
   }
 
   const result = [];
+  const schemaContext = `components.schemas.${safeName}`;
   if (_nullishCoalesce(schema.description, () => ( schema.title))) {
     result.push(_jsDocs.renderComment.call(void 0, _nullishCoalesce(schema.description, () => ( schema.title))));
   }
@@ -70,7 +71,7 @@ function renderSchema(
     return result.join('\n');
   }
   if ('enum' in schema) {
-    result.push(renderEnumType(safeName, schema));
+    result.push(renderEnumType(safeName, schema, options));
     return result.join('\n');
   }
 
@@ -83,7 +84,15 @@ function renderSchema(
   if ('allOf' in schema) {
     const types = _swagger.getRefCompositeTypes.call(void 0, schema);
     const mergedSchema = getMergedCompositeObjects(schema);
-    const objectContents = generateObjectTypeContents(mergedSchema, options);
+    const objectType = _swagger.getTypeFromSchema.call(void 0, mergedSchema, options, `${schemaContext}.allOf`);
+    const objectContents = generateObjectTypeContents(mergedSchema, options, schemaContext);
+    const hasAdditionalProperties = !!mergedSchema.additionalProperties;
+
+    if (hasAdditionalProperties) {
+      const compositeTypes = [...types, objectType].join(' & ');
+      result.push(`export type ${safeName} = ${compositeTypes};`);
+      return `${result.join('\n')}\n`;
+    }
 
     if (useTypeAliases) {
       const compositeTypes = [...types, `{${objectContents ? `\n${objectContents}\n` : ''}}`].join(' & ');
@@ -95,7 +104,7 @@ function renderSchema(
     result.push(`export interface ${safeName} ${extensions}{`);
     result.push(objectContents);
   } else if ('oneOf' in schema || 'anyOf' in schema) {
-    const typeDefinition = getTypesFromAnyOrOneOf(schema, options);
+    const typeDefinition = _swagger.getTypeFromSchema.call(void 0, schema, options, schemaContext);
     result.push(`export type ${safeName} = ${typeDefinition};`);
 
     return `${result.join('\n')}\n`;
@@ -105,7 +114,15 @@ function renderSchema(
     result.push(`export type ${safeName} = ${generateItemsType(schema.items, options)}[];`);
     return result.join('\n');
   } else {
-    const objectContents = generateObjectTypeContents(schema, options);
+    const objectType = _swagger.getTypeFromSchema.call(void 0, schema, options, schemaContext);
+    const hasAdditionalProperties = !!schema.additionalProperties;
+
+    const objectContents = generateObjectTypeContents(schema, options, schemaContext);
+    if (hasAdditionalProperties) {
+      result.push(`export type ${safeName} = ${objectType};`);
+      return `${result.join('\n')}\n`;
+    }
+
     if (useTypeAliases) {
       result.push(`export type ${safeName} = {`);
       result.push(objectContents);
@@ -119,25 +136,14 @@ function renderSchema(
   return `${result.join('\n')}\n}\n`;
 }
 
-/**
- * Generates the type definition for an `anyOf` or `oneOf` schema.
- * @param schema - The schema object to generate the type definition for.
- * @param options - The options for the generation.
- * @returns The type definition for the `anyOf` or `oneOf` schema.
- */
-function getTypesFromAnyOrOneOf(schema, options) {
-  const composite = schema.allOf || schema.oneOf || schema.anyOf;
-  if (!composite) {
-    return '';
-  }
-
-  return composite.map((s) => _swagger.getTypeFromSchema.call(void 0, s, options)).join(' | ');
-}
-
 /**
  * Generates the inline contents of an object type.
  */
-function generateObjectTypeContents(schema, options) {
+function generateObjectTypeContents(
+  schema,
+  options,
+  schemaContext = 'components.schemas.unknown'
+) {
   const result = [];
   const required = schema.required || [];
   const props = Object.keys(schema.properties || {});
@@ -145,7 +151,7 @@ function generateObjectTypeContents(schema, options) {
   for (const prop of props) {
     const propDefinition = schema.properties[prop];
     const isRequired = !!~required.indexOf(prop);
-    result.push(renderTypeProp(prop, propDefinition, isRequired, options));
+    result.push(renderTypeProp(prop, propDefinition, isRequired, options, schemaContext));
   }
 
   return result.join('\n');
@@ -182,11 +188,36 @@ function renderExtendedEnumType(name, def) {
 /**
  * Render simple enum types (just a union of values)
  */
-function renderEnumType(name, def) {
+function renderEnumType(name, def, options) {
+  if (options.enumDeclarationStyle === 'enum' && shouldRenderStringEnumDeclaration(def)) {
+    return renderStringEnumDeclaration(name, def);
+  }
+
   const values = def.enum.map((v) => (typeof v === 'number' ? v : `"${v}"`)).join(' | ');
   return `export type ${name} = ${values};\n`;
 }
 
+function shouldRenderStringEnumDeclaration(def)
+
+ {
+  return (
+    def.type === 'string' &&
+    Array.isArray(def.enum) &&
+    def.enum.every((value) => typeof value === 'string')
+  );
+}
+
+function renderStringEnumDeclaration(name, def) {
+  let res = `export enum ${name} {\n`;
+  for (let index = 0; index < def.enum.length; index++) {
+    const value = def.enum[index];
+    const memberName = _nullishCoalesce(_utils.escapePropName.call(void 0, value), () => ( `VALUE_${index}`));
+    res += `  ${memberName} = ${JSON.stringify(value)},\n`;
+  }
+
+  return `${res}}\n`;
+}
+
 /**
  * OpenApi 3.1 introduced a new way to define enums that we support here.
  */
@@ -207,10 +238,11 @@ function renderTypeProp(
   propName,
   definition,
   required,
-  options
+  options,
+  schemaContext
 ) {
   const lines = [];
-  const type = _swagger.getTypeFromSchema.call(void 0, definition, options);
+  const type = _swagger.getTypeFromSchema.call(void 0, definition, options, `${schemaContext}.properties.${propName}`);
 
   if ('description' in definition || 'title' in definition) {
     const renderedComment = _jsDocs.renderComment.call(void 0, _nullishCoalesce(definition.description, () => ( definition.title)));
@@ -267,7 +299,7 @@ function getMergedCompositeObjects(schema) {
     subSchemas.push(safeSchema);
   }
 
-  return deepMerge({}, ...subSchemas);
+  return deepMerge({}, ...subSchemas) ;
 }
 
 function isObject(item) {

package/dist/index.js

@@ -83,6 +83,7 @@ function readFile(filePath) {
     arrayFormat,
     mode,
     schemaStyle,
+    enumStyle,
     template,
     queryParamsSerialization = {},
     ...rest
@@ -104,6 +105,8 @@ function readFile(filePath) {
     generationMode: _nullishCoalesce(_nullishCoalesce(mode, () => ( rest.generationMode)), () => ( _swagger.APP_DEFAULTS.generationMode)),
     schemaDeclarationStyle:
       _nullishCoalesce(_nullishCoalesce(schemaStyle, () => ( rest.schemaDeclarationStyle)), () => ( _swagger.APP_DEFAULTS.schemaDeclarationStyle)),
+    enumDeclarationStyle:
+      _nullishCoalesce(_nullishCoalesce(enumStyle, () => ( rest.enumDeclarationStyle)), () => ( _swagger.APP_DEFAULTS.enumDeclarationStyle)),
     queryParamsSerialization: mergedQueryParamsSerialization,
   };
 } exports.prepareAppOptions = prepareAppOptions;

package/dist/swagger/typesExtractor.js

@@ -16,7 +16,8 @@ var _utils = require('../utils');
  */
  function getParameterType(
   param,
-  options
+  options,
+  context = 'schema'
 ) {
   const unknownType = options.preferAny ? 'any' : 'unknown';
 
@@ -24,7 +25,7 @@ var _utils = require('../utils');
     return unknownType;
   }
 
-  return getTypeFromSchemaResolved(param.schema, options);
+  return getTypeFromSchemaResolved(param.schema, options, `${context}.schema`);
 } exports.getParameterType = getParameterType;
 
 /**
@@ -35,9 +36,10 @@ var _utils = require('../utils');
  */
  function getTypeFromSchema(
   schema,
-  options
+  options,
+  context = 'schema'
 ) {
-  return getTypeFromSchemaResolved(schema, options);
+  return getTypeFromSchemaResolved(schema, options, context);
 } exports.getTypeFromSchema = getTypeFromSchema;
 
 /**
@@ -46,7 +48,8 @@ var _utils = require('../utils');
  */
 function getTypeFromSchemaResolved(
   schema,
-  options
+  options,
+  context
 ) {
   const unknownType = options.preferAny ? 'any' : 'unknown';
 
@@ -54,6 +57,17 @@ function getTypeFromSchemaResolved(
     return unknownType;
   }
 
+  if (typeof schema !== 'object' || Array.isArray(schema)) {
+    if (context.endsWith('.properties.$ref') && typeof schema === 'string') {
+      throw new Error(
+        `Invalid schema at ${context}: string value under properties.$ref is not a valid schema. ` +
+          'Did you mean to use schema.$ref at the root, or wrap it in a named property (for example properties.data.$ref)?'
+      );
+    }
+
+    throw new Error(`Invalid schema at ${context}: expected an object schema, got ${typeof schema}.`);
+  }
+
   if ('$ref' in schema) {
     const refName = schema.$ref.split('/').pop();
     return getSafeIdentifier(refName) || unknownType;
@@ -65,13 +79,13 @@ function getTypeFromSchemaResolved(
 
   // OpenAPI 3.1 nullable: type is an array containing 'null', e.g. ["string", "null"]
   if (Array.isArray(schema.type)) {
-    return getTypeFromOA31ArrayType(schema , options);
+    return getTypeFromOA31ArrayType(schema , options, context);
   }
 
   // OpenAPI 3.0 nullable: nullable: true
   const isNullable = 'nullable' in schema && schema.nullable === true;
   const isNullableSuffix = isNullable && options.nullableStrategy === 'include' ? ' | null' : '';
-  const type = getTypeFromSchemaInternal(schema, options);
+  const type = getTypeFromSchemaInternal(schema, options, context);
 
   if (isNullableSuffix && type.endsWith('| null')) {
     return type;
@@ -84,7 +98,11 @@ function getTypeFromSchemaResolved(
  * 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) {
+function getTypeFromOA31ArrayType(
+  schema,
+  options,
+  context
+) {
   const unknownType = options.preferAny ? 'any' : 'unknown';
   const types = schema.type ;
   const isNullable = types.includes('null');
@@ -97,11 +115,17 @@ function getTypeFromOA31ArrayType(schema, options) {
   } 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);
+    baseType = getTypeFromSchemaInternal(singleTypeSchema, options, context);
   } else {
     // Multiple non-null types — resolve each independently and join as a union
     baseType = nonNullTypes
-      .map((t) => getTypeFromSchemaInternal({ ...schema, type: t } , options))
+      .map((t) =>
+        getTypeFromSchemaInternal(
+          { ...schema, type: t } ,
+          options,
+          `${context}.type`
+        )
+      )
       .join(' | ');
   }
 
@@ -129,22 +153,23 @@ function getTypeFromOA31ArrayType(schema, options) {
 
 function getTypeFromSchemaInternal(
   schema,
-  options
+  options,
+  context
 ) {
   const unknownType = options.preferAny ? 'any' : 'unknown';
 
   if ('allOf' in schema || 'oneOf' in schema || 'anyOf' in schema) {
-    return getTypeFromComposites(schema , options);
+    return getTypeFromComposites(schema , options, context);
   }
 
   if (schema.type === 'array') {
     if (schema.items) {
-      return `${getNestedTypeFromSchema(schema.items, options)}[]`;
+      return `${getNestedTypeFromSchema(schema.items, options, `${context}.items`)}[]`;
     }
     return `${unknownType}[]`;
   }
   if (schema.type === 'object') {
-    return getTypeFromObject(schema, options);
+    return getTypeFromObject(schema, options, undefined, context);
   }
   if ('enum' in schema) {
     return `${schema.enum.map((v) => JSON.stringify(v)).join(' | ')}`;
@@ -166,7 +191,8 @@ function getTypeFromSchemaInternal(
 
 function getNestedTypeFromSchema(
   schema,
-  options
+  options,
+  context
 ) {
   // OA3.0 nullable: true
   const isOA30NullableAndActive =
@@ -180,10 +206,10 @@ function getNestedTypeFromSchema(
     options.nullableStrategy === 'include';
 
   if (isOA30NullableAndActive || isOA31NullableAndActive || ('enum' in schema && schema.enum)) {
-    return `(${getTypeFromSchemaResolved(schema, options)})`;
+    return `(${getTypeFromSchemaResolved(schema, options, context)})`;
   }
 
-  return getTypeFromSchemaResolved(schema, options);
+  return getTypeFromSchemaResolved(schema, options, context);
 }
 
 /**
@@ -192,20 +218,17 @@ function getNestedTypeFromSchema(
  */
 function getTypeFromObject(
   schema,
-  options
+  options,
+  requiredOverride,
+  context = 'schema'
 ) {
   const unknownType = options.preferAny ? 'any' : 'unknown';
-
-  if (schema.additionalProperties) {
-    const extraProps = schema.additionalProperties;
-    return `{ [key: string]: ${
-      extraProps === true ? 'any' : getTypeFromSchemaResolved(extraProps, options)
-    } }`;
-  }
+  let objectWithNamedPropsType = '';
+  let objectWithIndexSignatureType = '';
 
   if (schema.properties) {
     const props = Object.keys(schema.properties);
-    const required = schema.required || [];
+    const required = _nullishCoalesce(_nullishCoalesce(requiredOverride, () => ( schema.required)), () => ( []));
     const result = [];
 
     for (const prop of props) {
@@ -213,11 +236,36 @@ function getTypeFromObject(
       const isRequired = required.includes(prop);
       const safePropName = _utils.escapePropName.call(void 0, prop);
       result.push(
-        `${safePropName}${isRequired ? '' : '?'}: ${getTypeFromSchemaResolved(propDefinition, options)};`
+        `${safePropName}${isRequired ? '' : '?'}: ${getTypeFromSchemaResolved(
+          propDefinition,
+          options,
+          `${context}.properties.${prop}`
+        )};`
       );
     }
 
-    return `{ ${result.join('\n')} }`;
+    objectWithNamedPropsType = `{ ${result.join('\n')} }`;
+  }
+
+  if (schema.additionalProperties) {
+    const extraProps = schema.additionalProperties;
+    objectWithIndexSignatureType = `{ [key: string]: ${
+      extraProps === true
+        ? 'any'
+        : getTypeFromSchemaResolved(extraProps, options, `${context}.additionalProperties`)
+    } }`;
+  }
+
+  if (objectWithNamedPropsType && objectWithIndexSignatureType) {
+    return `${objectWithNamedPropsType} & ${objectWithIndexSignatureType}`;
+  }
+
+  if (objectWithNamedPropsType) {
+    return objectWithNamedPropsType;
+  }
+
+  if (objectWithIndexSignatureType) {
+    return objectWithIndexSignatureType;
   }
 
   return unknownType;
@@ -226,14 +274,76 @@ function getTypeFromObject(
 /**
  * Simplified way of extracting correct type from `anyOf`, `oneOf` or `allOf` schema.
  */
-function getTypeFromComposites(schema, options) {
+function getTypeFromComposites(
+  schema,
+  options,
+  context = 'schema'
+) {
   const composite = schema.allOf || schema.oneOf || schema.anyOf;
 
+  if (!composite) {
+    return options.preferAny ? 'any' : 'unknown';
+  }
+
+  const isUnionComposite = !!schema.oneOf || !!schema.anyOf;
+  const hasParentObjectShape = !!schema.properties || !!schema.additionalProperties;
+
+  if (isUnionComposite && hasParentObjectShape) {
+    const fallbackType = options.preferAny ? 'any' : 'unknown';
+    const parentObjectType = getTypeFromObject(schema, options, undefined, context);
+    const parentRequired = schema.required || [];
+    const parentPropSet = new Set(Object.keys(schema.properties || {}));
+
+    return composite
+      .map((subSchema) => {
+        if (!('$ref' in subSchema) && isRequiredOnlyCompositeBranch(subSchema)) {
+          const branchRequired = subSchema.required || [];
+          const validRequired = branchRequired.filter((name) => {
+            const isKnown = parentPropSet.has(name);
+            if (!isKnown) {
+              console.warn(
+                `Composite required key '${name}' is not present in schema properties and will be ignored.`
+              );
+            }
+            return isKnown;
+          });
+
+          return getTypeFromObject(
+            schema,
+            options,
+            Array.from(new Set([...parentRequired, ...validRequired])),
+            context
+          );
+        }
+
+        const subType = getTypeFromSchemaResolved(subSchema, options, `${context}.composite`);
+        if (subType === fallbackType) {
+          return parentObjectType;
+        }
+
+        return `${parentObjectType} & ${subType}`;
+      })
+      .join(' | ');
+  }
+
   return composite
-    .map((s) => getTypeFromSchemaResolved(s, options))
+    .map((s, index) => getTypeFromSchemaResolved(s, options, `${context}.composite[${index}]`))
     .join(schema.allOf ? ' & ' : ' | ');
 }
 
+function isRequiredOnlyCompositeBranch(schema) {
+  return (
+    Array.isArray(schema.required) &&
+    !schema.type &&
+    !schema.properties &&
+    !schema.additionalProperties &&
+    !schema.allOf &&
+    !schema.oneOf &&
+    !schema.anyOf &&
+    !schema.enum
+  );
+}
+
 /**
  * Escapes name so it can be used as a valid identifier in the generated code.
  * Component names can contain certain characters that are not allowed in identifiers.
@@ -264,6 +374,7 @@ function getTypeFromComposites(schema, options) {
   nullableStrategy: 'ignore',
   generationMode: 'full',
   schemaDeclarationStyle: 'interface',
+  enumDeclarationStyle: 'union',
   queryParamsSerialization: {
     allowDots: true,
     arrayFormat: 'repeat',
@@ -283,6 +394,7 @@ function getTypeFromComposites(schema, options) {
     nullableStrategy: _nullishCoalesce(opts.nullableStrategy, () => ( exports.APP_DEFAULTS.nullableStrategy)),
     generationMode: _nullishCoalesce(opts.generationMode, () => ( exports.APP_DEFAULTS.generationMode)),
     schemaDeclarationStyle: _nullishCoalesce(opts.schemaDeclarationStyle, () => ( exports.APP_DEFAULTS.schemaDeclarationStyle)),
+    enumDeclarationStyle: _nullishCoalesce(opts.enumDeclarationStyle, () => ( exports.APP_DEFAULTS.enumDeclarationStyle)),
     queryParamsSerialization: {
       ...exports.APP_DEFAULTS.queryParamsSerialization,
       ...opts.queryParamsSerialization,

package/dist/types.d.ts

@@ -33,6 +33,8 @@ export interface ClientOptions {
     generationMode?: GenerationMode;
     /** Controls whether object schemas are emitted as interfaces or type aliases */
     schemaDeclarationStyle?: SchemaDeclarationStyle;
+    /** Controls whether plain string enums are emitted as unions or TypeScript enums */
+    enumDeclarationStyle?: EnumDeclarationStyle;
     /** Offers ability to adjust the OpenAPI spec before it is processed */
     modifiers?: {
         /** Global-level modifiers for parameter with a given name */
@@ -46,6 +48,7 @@ export interface CliOptions extends FullAppOptions {
     arrayFormat?: ArrayFormat;
     mode?: GenerationMode;
     schemaStyle?: SchemaDeclarationStyle;
+    enumStyle?: EnumDeclarationStyle;
 }
 export interface FullAppOptions extends ClientOptions {
     /** Path to the configuration file that contains actual config to be used */
@@ -58,6 +61,7 @@ export type ArrayFormat = 'indices' | 'repeat' | 'brackets';
 export type NullableStrategy = 'include' | 'nullableAsOptional' | 'ignore';
 export type GenerationMode = 'full' | 'schemas';
 export type SchemaDeclarationStyle = 'interface' | 'type';
+export type EnumDeclarationStyle = 'union' | 'enum';
 /**
  * Internal options type used throughout the app after `prepareAppOptions` has run.
  * All fields that have defaults are required here so the rest of the codebase never
@@ -69,6 +73,7 @@ export interface AppOptions extends ClientOptions {
     nullableStrategy: NullableStrategy;
     generationMode: GenerationMode;
     schemaDeclarationStyle: SchemaDeclarationStyle;
+    enumDeclarationStyle: EnumDeclarationStyle;
     queryParamsSerialization: {
         allowDots: boolean;
         arrayFormat: ArrayFormat;

package/dist/utils/utils.js

@@ -240,12 +240,11 @@ function resolveResponseRef(
 const sortByKey = (key) => (a, b) => (a[key] > b[key] ? 1 : b[key] > a[key] ? -1 : 0);
 
 const orderedContentTypes = [
-  'application/json',
-  'text/json',
   'text/plain',
   'application/x-www-form-urlencoded',
   'multipart/form-data',
 ];
+const preferredJsonContentTypes = ['application/json', 'text/json'];
  function getBestContentType(
   reqBody
 ) {
@@ -254,6 +253,19 @@ const orderedContentTypes = [
     return [null, null];
   }
 
+  const preferredJsonContentType = preferredJsonContentTypes.find((ct) => contentTypes.includes(ct));
+  if (preferredJsonContentType) {
+    const typeObject = reqBody.content[preferredJsonContentType];
+    const type = getContentType(preferredJsonContentType);
+    return [typeObject, type];
+  }
+
+  const jsonLikeContentType = contentTypes.find(isJsonLikeContentType);
+  if (jsonLikeContentType) {
+    const typeObject = reqBody.content[jsonLikeContentType];
+    return [typeObject, 'json'];
+  }
+
   const firstContentType = orderedContentTypes.find((ct) => contentTypes.includes(ct));
   if (firstContentType) {
     const typeObject = reqBody.content[firstContentType];
@@ -266,6 +278,11 @@ const orderedContentTypes = [
   return [typeObject, type];
 } exports.getBestContentType = getBestContentType;
 
+function isJsonLikeContentType(contentType) {
+  const normalized = contentType.split(';')[0].trim().toLowerCase();
+  return normalized === 'application/*+json' || /^application\/.+\+json$/.test(normalized);
+}
+
 function getContentType(type) {
   if (type === 'application/x-www-form-urlencoded') {
     return 'urlencoded';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swaggie",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "description": "Generate a fully typed TypeScript API client from your OpenAPI 3 spec",
   "author": {
     "name": "Piotr Dabrowski",

package/templates/fetch/operation.ejs

@@ -11,6 +11,21 @@ $config?: RequestInit
 '<%= parameter.originalName %>': <%= parameter.name %>,
       <% }); %>})}<% } %>`;
 
+<% if(it.headers && it.headers.length > 0) { %>
+    const { headers: $configHeaders, ...$configRest } = $config ?? {};
+    const headers = new Headers({
+<% it.headers.forEach((parameter) => { %>
+<% if (parameter.value) { %>
+      '<%= parameter.originalName %>': '<%= parameter.value %>',
+<% } else { %>
+      '<%= parameter.originalName %>': <%= parameter.name %> ?? '',
+<% } %>
+<% }); %>
+    });
+    if ($configHeaders) {
+      new Headers($configHeaders).forEach((value, key) => headers.set(key, value));
+    }
+
     return fetch(url, {
       method: '<%= it.method %>',
 <% if(it.body) { %>
@@ -22,19 +37,24 @@ $config?: RequestInit
       body: <%= it.body.name %>,
 <% } %>
 <% } %>
-<% if(it.headers && it.headers.length > 0) { %>
-      headers: {
-  <% it.headers.forEach((parameter) => { %>
-    <% if (parameter.value) { %>
-  '<%= parameter.originalName %>': '<%= parameter.value %>',
-    <% } else { %>
-  '<%= parameter.originalName %>': <%= parameter.name %> ?? '',
-    <% } %>
-  <% }); %>
-},
+      headers,
+      ...$configRest,
+    })
+<% } else { %>
+    return fetch(url, {
+      method: '<%= it.method %>',
+<% if(it.body) { %>
+<% if(it.body.contentType === 'json') { %>
+      body: JSON.stringify(<%= it.body.name %>),
+<% } else if(it.body.contentType === 'urlencoded') { %>
+      body: new URLSearchParams(<%= it.body.name %> as any),
+<% } else { %>
+      body: <%= it.body.name %>,
+<% } %>
 <% } %>
       ...$config,
     })
+<% } %>
 <% if(it.responseContentType === 'binary') { %>
     .then((response) => response.blob() as Promise<<%~ it.returnType %>>);
 <% } else if(it.responseContentType === 'text') { %>