# service-model-swift-code-generate
**Repository Path**: mirrors_amzn/service-model-swift-code-generate
## Basic Information
- **Project Name**: service-model-swift-code-generate
- **Description**: Modular code generator to generate Swift applications from service models.
- **Primary Language**: Unknown
- **License**: Apache-2.0
- **Default Branch**: main
- **Homepage**: None
- **GVP Project**: No
## Statistics
- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-08-08
- **Last Updated**: 2025-12-20
## Categories & Tags
**Categories**: Uncategorized
**Tags**: None
## README
# ServiceModelSwiftCodeGenerate
ServiceModelSwiftCodeGenerate is a foundational code generation library that can be used
to generate code based on different service models. This library can be integrated into
higher level code generation applications and provides some standard generation functions that can
be called.
# Getting Started
## Step 1: Add the ServiceModelSwiftCodeGenerate dependency
ServiceModelSwiftCodeGenerate uses the Swift Package Manager. To use the framework, add the following dependency
to your Package.swift-
```swift
dependencies: [
.package(url: "https://github.com/amzn/service-model-swift-code-generate.git", from: "3.0.0")
]
```
## Step 2: Use the library to generate code
The easiest way to integrate ServiceModelSwiftCodeGenerate into a higher level code generation application is to use
`ServiceModelGenerate.generateFromModel`. This function takes a file path to a xml, json or yaml encoded service model,
will attempt to parse that file into the required service model type and will then pass that model and a `ServiceModelCodeGenerator`
to the provided function which can call any required generation functions.
```swift
extension ServiceModelCodeGenerator where TargetSupportType: ModelTargetSupport & ClientTargetSupport {
func generateFromModel(serviceModel: ModelType,
...) throws {
let myClientDelegate = ...
let myModelErrorsDelegate = ...
let defaultTraceContextType = DefaultTraceContextType(...)
let operationsReportingType = OperationsReportingType(...)
let invocationReportingType = InvocationReportingType(...)
generateClient(delegate: myClientDelegate, fileType: .clientImplementation,
defaultTraceContextType: defaultTraceContextType)
generateModelOperationsEnum()
generateOperationsReporting(operationsReportingType: operationsReportingType)
generateInvocationsReporting(invocationReportingType: invocationReportingType)
generateModelOperationClientInput()
generateModelOperationClientOutput()
generateModelOperationHTTPInput()
generateModelOperationHTTPOutput()
generateModelStructures()
generateModelTypes()
generateModelErrors(delegate: myModelErrorsDelegate)
generateDefaultInstances(generationType: .internalTypes)
// Call any custom generation functions as required
}
}
public struct MyCodeGeneration {
public static func generateFromModel(
modelFilePath: String,
modelType: ModelType.Type,
customizations: CodeGenerationCustomizations,
applicationDescription: ApplicationDescription,
modelOverride: ModelOverride?,
...) throws
-> ModelType {
return try ServiceModelGenerate.generateFromModel(
modelFilePath: modelFilePath,
customizations: customizations,
applicationDescription: applicationDescription,
modelOverride: modelOverride) { (codeGenerator, serviceModel) in
try codeGenerator.generateFromModel(serviceModel: serviceModel, ...)
}
}
}
```
By default, the code generator will use `\(applicationDescription.baseName)Model` for the name of the model target and
`\(applicationDescription.baseName)Client` for the name of the client target. You can override these defaults by using
the `ModelAndClientTargetSupport` type.
```
public struct MyCodeGeneration {
public static func generateFromModel(
modelFilePath: String,
modelType: ModelType.Type,
modelTargetName: String, clientTargetName: String,
customizations: CodeGenerationCustomizations,
applicationDescription: ApplicationDescription,
modelOverride: ModelOverride?,
...) throws
-> ModelType {
let targetSupport = ModelAndClientTargetSupport(modelTargetName: modelTargetName,
clientTargetName: clientTargetName)
return try ServiceModelGenerate.generateFromModel(
modelFilePath: modelFilePath,
customizations: customizations,
applicationDescription: applicationDescription,
targetSupport: targetSupport,
modelOverride: modelOverride) { (codeGenerator, serviceModel) in
try codeGenerator.generateFromModel(serviceModel: serviceModel, ...)
}
}
}
```
Further, if you are generating additional targets, you can use a custom type that provides the name of
additional targets. This type will have to conform to the `ModelTargetSupport` and `ClientTargetSupport` protocols.
```swift
extension ServiceModelCodeGenerator where TargetSupportType: ModelTargetSupport & ClientTargetSupport & MyCustomTargetSupport {
func generateFromModel(serviceModel: ModelType,
...) throws {
let myClientDelegate = ...
let myModelErrorsDelegate = ...
generateClient(delegate: myClientDelegate)
generateModelOperationsEnum()
generateOperationsReporting()
generateModelOperationClientInput()
generateModelOperationClientOutput()
generateModelOperationHTTPInput()
generateModelOperationHTTPOutput()
generateModelStructures()
generateModelTypes()
generateModelErrors(delegate: myModelErrorsDelegate)
generateDefaultInstances(generationType: .internalTypes)
// Call any custom generation functions as required
// The `targetSupport` attribute will conform to the `MyCustomTargetSupport` protocol.
}
}
public protocol MyCustomTargetSupport {
var myCustomTargetName: String { get }
}
public struct MyTargetSupport: ModelTargetSupport, ClientTargetSupport, MyCustomTargetSupport {
public let modelTargetName: String
public let clientTargetName: String
public let myCustomTargetName: String
public init(modelTargetName: String, clientTargetName: String,
myCustomTargetName: String) {
self.modelTargetName = modelTargetName
self.clientTargetName = clientTargetName
self.myCustomTargetName = myCustomTargetName
}
}
public struct MyCodeGeneration {
public static func generateFromModel(
modelFilePath: String,
modelType: ModelType.Type,
modelTargetName: String, clientTargetName: String,
myCustomTargetName: String,
customizations: CodeGenerationCustomizations,
applicationDescription: ApplicationDescription,
modelOverride: ModelOverride?,
...) throws
-> ModelType {
let targetSupport = MyTargetSupport(modelTargetName: modelTargetName,
clientTargetName: clientTargetName,
myCustomTargetName: myCustomTargetName)
return try ServiceModelGenerate.generateFromModel(
modelFilePath: modelFilePath,
customizations: customizations,
applicationDescription: applicationDescription,
targetSupport: targetSupport,
modelOverride: modelOverride) { (codeGenerator, serviceModel) in
try codeGenerator.generateFromModel(serviceModel: serviceModel, ...)
}
}
}
```
# Further Concepts
## The ServiceModel Protocol
The `ServiceModel` protocol represents the parsed service model and provides access to descriptions of
the operations, fields and errors.
## The ModelClientDelegate protocol
The `ModelClientDelegate` protocol provides customization points for the creation of service clients.
## The ModelErrorsDelegate protocol
The `ModelErrorsDelegate` protocol provides customization points for handling errors returned from an application endpoint conforming to the service model.
## The ModelOverride type
The `ModelOverride` type provides the opportunity to override values from the service model.
## License
This library is licensed under the Apache 2.0 License.