apple/swift-openapi-generator

This system is the Swift OpenAPI Generator, a tool that produces Swift client and server code from OpenAPI specifications. It supports OpenAPI versions 3.0 and 3.1, generating type-safe code for HTTP requests, responses, and streaming operations. The generator integrates with Swift Package Manager via plugins and offers configurable output strategies, including idiomatic naming, access modifiers, and document filtering.

Users can now filter OpenAPI documents to generate code for only a subset of operations, paths, tags, or schemas. The new \DocumentFilter\ struct and \FilteredDocumentBuilder\ allow specifying inclusion criteria via operation IDs, tags, paths, and additional schemas, automatically resolving and including all necessary component dependencies (such as schemas, parameters, and responses) referenced by the selected endpoints.

_Sources/\OpenAPIGeneratorCore/Hooks · high confidence

A new Swift Package Manager command plugin is added to the project, enabling automatic OpenAPI source code generation. The plugin scans Swift source modules and runs the generator tool, supporting explicit target selection via the \--target\ argument. It intelligently handles dependencies by including recursive target dependencies when specified, and gracefully skips targets that lack the necessary configuration files rather than failing, ensuring a smoother generation experience across multi-target packages.

Plugins/OpenAPIGeneratorCommand · high confidence

The Examples directory now includes several new illustrative projects: an iOS SwiftUI client app (HelloWorldiOSClientAppExample) that demonstrates using the generated client with URLSession and includes unit/UI tests with a mock client; client and server middleware examples (auth-client-middleware-example and auth-server-middleware-example) showing how to inject and verify authentication headers using Vapor; and a bidirectional event streams client example (bidirectional-event-streams-client-example) using AsyncHTTPClient to handle JSON Lines streams. These additions expand the available patterns for integrating Swift OpenAPI Generator in iOS apps, securing requests, and working with streaming APIs.

Examples · high confidence

The PetstoreConsumerTestCore module now includes new helper files to support testing API integrations. Assertions.swift provides custom assertion functions for comparing stringified data and byte sequences, including detailed diff output for debugging mismatches. Common.swift introduces shared test utilities such as a TestError enum, fixed test dates, and pre-defined HTTP response and request helpers, including multipart body fixtures. TestClientTransport.swift adds a mock client transport that allows simulating network responses via a custom handler closure. TestServerTransport.swift provides a mock server transport that lets developers register specific HTTP method and path handlers to simulate server behavior without actual network calls.

Sources/PetstoreConsumerTestCore · high confidence

The generator now supports x-www-form-urlencoded and multipart/form-data content types in addition to JSON and binary. This allows generated clients to correctly encode and decode form data and multipart payloads, with specific coding strategies assigned to each content category.

_Sources/\OpenAPIGeneratorCore/Translator/Content · high confidence

The generator now supports translating OpenAPI schemas that use multipart content types. This adds new internal translator modules (MultipartAdditionalProperties, MultipartContent, MultipartContentInspector, and translateMultipart) that parse multipart schemas, determine serialization strategies (primitive, complex, binary), handle additional properties, and generate the corresponding Swift enum types and part structures for use in API operations.

_Sources/\OpenAPIGeneratorCore/Translator/Multipart · high confidence

The generator now detects and handles recursive type definitions in OpenAPI schemas. When a cycle is detected, the system identifies the first boxable type within the cycle and wraps its internal storage in a reference type to prevent infinite recursion. This allows users to define and generate code for self-referential or mutually recursive structures that were previously unsupported or would cause generation errors.

_Sources/\OpenAPIGeneratorCore/Translator/Recursion · high confidence

The documentation for the Swift OpenAPI Generator has been significantly expanded and restructured. The main landing page now explicitly lists support for OpenAPI Specification versions 3.0, 3.1, and preliminary 3.2, and updates the minimum macOS requirement for the generator plugin to 10.15. New sections provide usage examples for both client and server generation, detail the package ecosystem (including AWS Lambda support), and list supported platforms including visionOS and Android. Additionally, the DocC catalog is configured to default code listings to Swift.

Sources/swift-openapi-generator/Documentation.docc · high confidence

The parser now accepts OpenAPI documents in versions 3.0.4, 3.1.1, 3.1.2, and 3.2.0, in addition to previously supported versions. It also provides clearer error messages when the 'openapi' key is missing or contains an unsupported version, and emits YAML processing errors with line numbers that Xcode can display directly.

_Sources/\OpenAPIGeneratorCore/Parser · high confidence

The core generator library has been refactored to support Swift concurrency, introducing Sendable conformance across configuration, diagnostics, and pipeline components, and adding thread-safety to the YAML diagnostics collector. The types generation mode now produces multiple namespace-based files (e.g., Types+Components.swift) instead of a single monolithic file. Configuration is expanded to support naming strategies (defensive/idiomatic), access modifiers, document filtering, type overrides, and feature flags. The pipeline now validates OpenAPI documents and supports the OpenAPIKit library, while diagnostics provide precise file and line location information.

_Sources/\OpenAPIGeneratorCore · high confidence

The generator now produces richer documentation comments for generated types, including JSON path references and subpaths for parameters and content types, and supports deprecation annotations based on the OpenAPI document. Additionally, oneOf discriminator mappings now allow non-unique values in the mapping, enabling multiple keys to point to the same type, and the generator no longer creates undocumented enum cases for oneOfs or enums.

_Sources/\OpenAPIGeneratorCore/Translator/CommonTypes · high confidence

The Swift OpenAPI Generator plugin now provides clearer, specific error messages when configuration or document files are missing or when multiple conflicting files are found in a target. Instead of generic failures, users will see explicit guidance on which files are expected (e.g., 'openapi-generator-config.yaml' or 'openapi.yaml') and which specific files were detected, helping them quickly resolve misconfigurations in their Swift Package targets.

Plugins/PluginsShared · high confidence

The integration test suite has been migrated to support OpenAPI 3.1.0, reflected in the updated \openapi.yaml\ specification and new generator configurations that enforce \idiomatic\ naming strategies and \package\ access modifiers. This change accompanies a behavioral update to the generated client and server code, which now utilizes \HTTPTypes\ for request and response handling instead of the previous custom types, and adopts idiomatic Swift naming conventions for operations and server URLs.

IntegrationTest/Sources · high confidence

The generated client now relies on the OpenAPIKit library instead of OpenAPIKit30, enabling support for OpenAPI 3.1 specifications in addition to 3.0. This update changes how the client constructs HTTP requests by introducing a dedicated path rendering step and modifying the serializer to return a tuple containing both the request and the request body. Furthermore, the deserializer has been updated to access response status codes via a nested 'status.code' property and to pass header fields and body content to the undocumented response case, ensuring compatibility with the new underlying HTTP types.

_Sources/\OpenAPIGeneratorCore/Translator/ClientTranslator · high confidence

The generator now imports OpenAPIKit instead of OpenAPIKit30, enabling support for OpenAPI 3.1 in addition to 3.0. A new TranslatorContext is introduced to pass configuration values (such as the safe name generator) into OperationDescription, replacing direct calls to global helpers. The parameter merging logic has been updated to explicitly retain operation-level parameters over path-level ones when duplicates exist, and HTTP method handling now validates tokens against RFC 9110, throwing an error for invalid methods rather than silently accepting them.

_Sources/\OpenAPIGeneratorCore/Translator/Operations · high confidence

The generator now relies on the unified OpenAPIKit library instead of OpenAPIKit30, enabling support for OpenAPI 3.1 documents in addition to 3.0. Users can now configure the naming strategy (defensive or idiomatic) and provide specific name overrides to control generated Swift identifiers. Additionally, generated import statements now respect the configured access modifier (public or package), ensuring proper visibility under Swift 6's internal imports by default behavior.

_Sources/\OpenAPIGeneratorCore/Translator · high confidence

The CLI now includes a new 'filter' command that allows users to extract specific subsets of an OpenAPI document (operations, tags, paths, schemas) using a YAML configuration file. The 'generate' command has been expanded with new configuration options: users can now specify an access modifier for generated code, choose a naming strategy, add custom file comments, define name and type overrides, and enable pre-release feature flags. Additionally, a 'dry-run' option is available to simulate generation without writing files, and the generator now supports parallel execution of modes and distinguishes between build and command plugin invocations.

Sources/swift-openapi-generator · high confidence

The repository introduces two new scripts, \scripts/run-integration-test.sh\ and \scripts/test-examples.sh\, to automate the validation of the generator. The integration test script clones the repository, overrides the local package dependency in the \IntegrationTest\ package, and runs the command plugin on both standard and AOT targets to verify code generation. The example testing script iterates through the \Examples\ directory, copies each example into a shared harness, overrides the generator dependency, and builds/tests them using shared cache and scratch paths. These additions coincide with the removal of the legacy \scripts/soundness.sh\ suite and its associated checks (broken symlinks, license headers, swift-format, DocC warnings, and unacceptable language), streamlining the developer workflow toward automated integration and example validation.

scripts · high confidence

The Swift OpenAPI generator plugin has been updated to align with current Swift Package Plugin standards. The plugin now uses \URL\ instead of \PackagePlugin.Path\ for working directories and tool paths, and delegates input validation logic to a shared \PluginUtils\ module. This change simplifies the plugin's build command creation and ensures consistent handling of configuration and OpenAPI document inputs across both Swift and Xcode build contexts.

Plugins/OpenAPIGenerator · high confidence

The generator now uses OpenAPIKit v6 (imported as OpenAPIKit) instead of OpenAPIKit30, requiring updates to the translator extension targets (FileTranslator to TypesFileTranslator) and dependency injection (TypeAssigner/TypeMatcher to typeAssigner/typeMatcher). String and integer enums are now generated via a unified translateRawEnum function that handles nullable schemas, empty strings, and negative integer values, replacing the previous translateStringEnum. Additionally, allOf/anyOf/oneOf translation now supports discriminator-based mapping, detects key-value pair schemas, and enforces optionality rules (allOf required, anyOf optional), while object struct translation adds support for deprecation annotations and explicitly skips binary string properties and inferred properties.

_Sources/\OpenAPIGeneratorCore/Translator/CommonTranslations · high confidence

The type assignment logic in the generator has been refactored to introduce a \TranslatorContext\ for configuration and a \ReferenceStack\ to track recursive schema references, preventing infinite loops during validation. This change adds explicit support for multipart request bodies by introducing new built-in types (e.g., \MultipartBody\, \MultipartPart\) and dedicated type usage methods. Additionally, schema validation now returns structured results with specific unsupported reasons, allowing for more precise diagnostic reporting when schemas are invalid.

_Sources/\OpenAPIGeneratorCore/Translator/TypeAssignment · high confidence

The generator no longer uses the swift-format library for code styling, removing the associated configuration and formatting logic from the extension modules. Additionally, the codebase has migrated from OpenAPIKit30 to OpenAPIKit v6, updating reference resolution and schema handling to support OpenAPI 3.1 specifications alongside 3.0.

_Sources/\OpenAPIGeneratorCore/Extensions · high confidence

The code generation pipeline in the Renderer module has been updated to pass a \NamedFileDescription\ instead of a \StructuredSwiftRepresentation\ to the render function, and the \TextBasedRenderer\ now uses a new \StringCodeWriter\ to build output line-by-line. This change modifies how generated Swift files are constructed internally, introducing support for access modifiers on imports and more granular control over line continuation and indentation during the rendering phase.

_Sources/\OpenAPIGeneratorCore/Renderer · high confidence

The generator now supports the deepObject serialization style for query parameters, allowing complex object parameters to be encoded as nested key-value pairs (e.g., filter\[name\]=foo) in addition to the previously supported form style. This change also migrates the underlying library from OpenAPIKit30 to OpenAPIKit, updating the import statements and schema handling to reflect the new library's types and APIs.

_Sources/\OpenAPIGeneratorCore/Translator/Parameters · high confidence

The generator now supports request bodies with multiple content types (e.g., multipart and JSON) by representing them as an enum with associated values, rather than assuming a single content type. This change is part of the migration from OpenAPIKit30 to OpenAPIKit v6, which updates the underlying library dependency. Additionally, generated request body enums are now marked as @frozen to improve performance and stability.

_Sources/\OpenAPIGeneratorCore/Translator/RequestBody · high confidence

The TypesTranslator now imports OpenAPIKit instead of OpenAPIKit30, enabling support for OpenAPI 3.1 documents alongside 3.0. To improve build times and module organization, generated types are now split into separate files based on their namespace (schemas, parameters, request bodies, responses, and headers) rather than being emitted into a single file. The generator also introduces new capabilities for handling recursive types by boxing them into internal storage structs, generating enums for server variables, and adding convenience extension methods to the API protocol for flattened operation inputs.

_Sources/\OpenAPIGeneratorCore/Translator/TypesTranslator · high confidence

The tutorial resources in the documentation have been updated to reflect modern Swift and OpenAPI standards. The examples now target Swift 6.0 and support macOS 10.15 and iOS 13+, replacing older platform constraints. The generated code samples demonstrate idiomatic naming conventions (e.g., \GetGreeting\ instead of \getGreeting\) and updated client/server initialization patterns, such as using \Servers.Server2.url()\ and \Vapor.Application.make()\. The underlying OpenAPI specification files have been upgraded from version 3.0.3 to 3.1.0. Additionally, the Package.swift manifests now reference the v1.0 series of the Swift OpenAPI libraries (generator 1.6.0, runtime 1.7.0, urlsession 1.0.0, and vapor 1.0.0) and Vapor 4.89.0, ensuring the tutorials align with the current stable release.

_Sources/swift-openapi-generator/Documentation.docc/Tutorials/\Resources · high confidence

The project has replaced its local \CODE\_OF\_CONDUCT.md\ and \SECURITY.md\ files with links to the Swift Server Work Group (SSWG) policies. Contributor guidelines in \CONTRING.md\ now explicitly prohibit using AI tools for issue and pull request content, and update local CI instructions to use \act\ instead of a removed \soundness.sh\ script. Additionally, \.editorconfig\ and \.swift-format\ configurations have been added or updated to enforce consistent coding styles, including enabling documentation validation and adjusting line break rules.

(repo-wide) · high confidence

The Swift OpenAPI Generator documentation tutorials have been updated to require Swift 6.0 (previously Swift 5.8) and now demonstrate the shorthand API for unwrapping client responses. A new tutorial has been added to guide users in hosting OpenAPI and Swagger UI endpoints on a Vapor server, and existing client/server tutorials now reference specific example packages for reference.

Sources/swift-openapi-generator/Documentation.docc/Tutorials · high confidence

The server translator now imports OpenAPIKit instead of OpenAPIKit30, enabling support for OpenAPI 3.1 specifications in addition to 3.0. The generated server code structure has been refactored to use a \registerHandlers\ method within a protocol extension, improving how operations are registered. Request deserialization logic has been updated to handle accept headers for content-type validation and to pass request bodies as a separate argument, while response serialization now returns a tuple for undocumented cases to better handle status codes.

_Sources/\OpenAPIGeneratorCore/Translator/ServerTranslator · high confidence

The generator now depends on OpenAPIKit v6 (replacing OpenAPIKit30), enabling support for OpenAPI 3.1 specifications in addition to 3.0. This update refreshes the HTTP status code name mappings in the response translator to align with current standards, adding support for codes like 103 (Early Hints) and 425 (Too Early), while removing obsolete codes such as 418 (I'm a teapot) and 424 (Failed Dependency). Additionally, the generated Swift types for response bodies and headers now use frozen enums and include throwing getters for safer access to response payloads.

_Sources/\OpenAPIGeneratorCore/Translator/Responses · high confidence

The generator now imports OpenAPIKit instead of the legacy OpenAPIKit30, enabling support for OpenAPI 3.1 documents in addition to 3.0. Internally, the rendering layer has been refactored to emit multiple output files (changing RenderedSwiftRepresentation from a single file to an array) and structures have been updated for Swift concurrency safety (adding Sendable conformance). The structured representation layer has been expanded to support more granular code generation, including scoped imports with access modifiers (public/package), trailing closures in function calls, detailed variable accessors (getter/setter/modify), indirect enums, and precise type descriptions (optionals, any protocols).

_Sources/\OpenAPIGeneratorCore/Layers · high confidence

Added and updated tests for OpenAPI generator core translations; Added compatibility and snippet-based reference tests for the OpenAPI generator; Added tests for ContentType parsing and header value generation; Added tests for OpenAPI Generator core components and utilities; Added tests for OpenAPI document validation and YAML parsing; Added tests for OpenAPI generator error handling and configuration; Added tests for OperationDescription parameter and response handling; Added tests for TextBasedRenderer comment and import generation; Added tests for document filtering and types file splitting; Added tests for multipart content inspection and additional properties strategy; Added tests for schema translation diagnostics and naming; Added tests for type assignment and recursion detection logic; Updated generated reference test sources to reflect new generator output; Updated test suite for streaming, multipart, and idiomatic naming conventions; Updated tests for discriminator mapping logic.

The example projects and integration test package now require Swift 6.1 and reference the 1.x versions of the OpenAPI libraries (generator 1.6.0, runtime 1.7.0). This raises the minimum macOS requirement for most examples to 10.15 and adds support for iOS 13, tvOS 13, watchOS 6, and visionOS 1. The old IntegrationTests/Simple package has been removed in favor of the new IntegrationTest package, and several examples have been renamed or restructured to reflect their current purpose.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 62 → 55 (-7.1)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 92 → 92 (+0.1)
• Architecture 96 → 97 (+0.9)
• Maturity 64 → 62 (-1.7)
• Readiness 58 → 44 (-14.5)
• Security 54 → 54 (+0.0)

• Hotspot: Sources/_OpenAPIGeneratorCore/Renderer/TextBasedRenderer.swift (Sources/_OpenAPIGeneratorCore/Renderer/TextBasedRenderer.swift)
• Hotspot: Sources/_OpenAPIGeneratorCore/Translator/TypesTranslator/TypesFileTranslator.swift (Sources/_OpenAPIGeneratorCore/Translator/TypesTranslator/TypesFileTranslator.swift)
• Low cohesion: Array (LCOM4 4) (Plugins/PluginsShared/PluginError.swift)
• Off-boarding risk: anonymized user #1
• SwiftOpenAPIGeneratorPlugin.performCommand (cognitive 22) (Plugins/OpenAPIGenerator/plugin.swift)

• Dependency hygiene PARTLY measured — SwiftPM pinning read, dependency currency NOT established
• Duplicated block (11 lines × 2) (Examples/logging-middleware-oslog-example/Sources/LoggingMiddleware/LoggingMiddleware.swift)
• Duplicated block (7–11 lines × 7) (Sources/PetstoreConsumerTestCore/Common.swift)
• FileTooLong: Layers/StructuredSwiftRepresentation.swift (Sources/_OpenAPIGeneratorCore/Layers/StructuredSwiftRepresentation.swift)
• Low coverage: Examples/curated-client-library-example/Sources/CuratedLibraryClient/CuratedLibraryClient.swift (Examples/curated-client-library-example/Sources/CuratedLibraryClient/CuratedLibraryClient.swift)
• Low coverage: Examples/hello-world-hummingbird-server-example/Sources/HelloWorldHummingbirdServer/HelloWorldHummingbirdServer.swift (Examples/hello-world-hummingbird-server-example/Sources/HelloWorldHummingbirdServer/HelloWorldHummingbirdServer.swift)
• Low coverage: Examples/hello-world-vapor-server-example/Sources/HelloWorldVaporServer/HelloWorldVaporServer.swift (Examples/hello-world-vapor-server-example/Sources/HelloWorldVaporServer/HelloWorldVaporServer.swift)
• Low coverage: Examples/logging-middleware-swift-log-example/Sources/LoggingMiddleware/LoggingMiddleware.swift (Examples/logging-middleware-swift-log-example/Sources/LoggingMiddleware/LoggingMiddleware.swift)
• Low coverage: Sources/PetstoreConsumerTestCore/Assertions.swift (Sources/PetstoreConsumerTestCore/Assertions.swift)
• Low coverage: Sources/_OpenAPIGeneratorCore/Extensions/SwiftStandardLibrary.swift (Sources/_OpenAPIGeneratorCore/Extensions/SwiftStandardLibrary.swift)
• Low coverage: Sources/_OpenAPIGeneratorCore/YamlFileDiagnosticsCollector.swift (Sources/_OpenAPIGeneratorCore/YamlFileDiagnosticsCollector.swift)
• Low coverage: Sources/swift-openapi-generator/Extensions.swift (Sources/swift-openapi-generator/Extensions.swift)
• Low coverage: Sources/swift-openapi-generator/FilterCommand.swift (Sources/swift-openapi-generator/FilterCommand.swift)
• Low coverage: Sources/swift-openapi-generator/GenerateCommand.swift (Sources/swift-openapi-generator/GenerateCommand.swift)
• No Package.resolved committed (Examples/auth-client-middleware-example/Package.swift)
• No Package.resolved committed (Examples/auth-server-middleware-example/Package.swift)
• No Package.resolved committed (Examples/bidirectional-event-streams-client-example/Package.swift)
• No Package.resolved committed (Examples/bidirectional-event-streams-server-example/Package.swift)
• No Package.resolved committed (Examples/command-line-client-example/Package.swift)
• No Package.resolved committed (Examples/event-streams-client-example/Package.swift)
• …and 26 more

• 3 commits — 3 feature/other, 0 fixes

• Sources/_OpenAPIGeneratorCore — 2 commits
• (root) — 1 commit

• change: Handle additional HTTP methods, e.g. QUERY (#957)
• change: Housekeeping: replace repo-level CODE_OF_CONDUCT (#955)
• change: Preserve the casing of content type parameter values (#958)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

apple/swift-openapi-generator was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.