feat: Add operation and type registry codegen

.github/workflows/continuous-integration.yml

@@ -66,7 +66,6 @@ jobs:
       - name: Build & Run smithy-swift Kotlin Unit Tests
         run: ./gradlew build
       - name: Build & Run smithy-swift Swift Unit Tests
-        timeout-minutes: 15
         run: |
           set -o pipefail && \
           NSUnbufferedIO=YES xcodebuild \

Plugins/SmithyCodeGeneratorPlugin/SmithyCodeGeneratorPlugin.swift

@@ -38,19 +38,22 @@ struct SmithyCodeGeneratorPlugin: BuildToolPlugin {
         in outputDirectoryPath: Path,
         with generatorToolPath: Path
     ) throws -> Command? {
-        // Skip any file that isn't the smithy-model-info.json for this service.
-        guard inputPath.lastComponent == "smithy-model-info.json" else { return nil }
+        // Skip any file that isn't the swift-settings.json for this service.
+        guard inputPath.lastComponent == "swift-settings.json" else { return nil }
 
         let currentWorkingDirectoryFileURL = URL(fileURLWithPath: FileManager.default.currentDirectoryPath)
 
         // Get the smithy-model-info.json file contents.
         let modelInfoData = try Data(contentsOf: URL(fileURLWithPath: inputPath.string))
         let smithyModelInfo = try JSONDecoder().decode(SmithyModelInfo.self, from: modelInfoData)
 
-        // Get the service ID & model path & settings sdkId from smithy-model-info.
+        // Get the fields from smithy-model-info.
         let service = smithyModelInfo.service
-        let modelPathURL = currentWorkingDirectoryFileURL.appendingPathComponent(smithyModelInfo.path)
+        let sdkId = smithyModelInfo.sdkId
+        let modelPathURL = currentWorkingDirectoryFileURL.appendingPathComponent(smithyModelInfo.modelPath)
         let modelPath = Path(modelPathURL.path)
+        let internalClient = smithyModelInfo.internalClient
+        let operations = smithyModelInfo.operations.joined(separator: ",")
 
         // Construct the Schemas.swift path.
         let schemasSwiftPath = outputDirectoryPath.appending("\(name)Schemas.swift")
@@ -61,32 +64,65 @@ struct SmithyCodeGeneratorPlugin: BuildToolPlugin {
         // Construct the Deserialize.swift path.
         let deserializeSwiftPath = outputDirectoryPath.appending("\(name)Deserialize.swift")
 
+        // Construct the Deserialize.swift path.
+        let typeRegistrySwiftPath = outputDirectoryPath.appending("\(name)TypeRegistry.swift")
+
+        // Construct the Operations.swift path.
+        let operationsSwiftPath = outputDirectoryPath.appending("\(name)Operations.swift")
+
+        var arguments: [any CustomStringConvertible] = [
+            service,
+            modelPath,
+            "--internal", "\(internalClient)",
+            "--sdk-id", sdkId,
+            "--schemas-path", schemasSwiftPath,
+            "--serialize-path", serializeSwiftPath,
+            "--deserialize-path", deserializeSwiftPath,
+            "--type-registry-path", typeRegistrySwiftPath,
+            "--operations-path", operationsSwiftPath,
+            "--schemas-path", schemasSwiftPath,
+            "--serialize-path", serializeSwiftPath,
+            "--deserialize-path", deserializeSwiftPath
+        ]
+
+        if !operations.isEmpty {
+            arguments.append(contentsOf: ["--operations", operations])
+        }
+
         // Construct the build command that invokes SmithyCodegenCLI.
         return .buildCommand(
-            displayName: "Generating Swift source files from model file \(smithyModelInfo.path)",
+            displayName: "Generating Swift source files from model file \(smithyModelInfo.modelPath)",
             executable: generatorToolPath,
-            arguments: [
-                service,
-                modelPath,
-                "--schemas-path", schemasSwiftPath,
-                "--serialize-path", serializeSwiftPath,
-                "--deserialize-path", deserializeSwiftPath
-            ],
+            arguments: arguments,
             inputFiles: [inputPath, modelPath],
             outputFiles: [
                 schemasSwiftPath,
                 serializeSwiftPath,
                 deserializeSwiftPath,
+                typeRegistrySwiftPath,
+                operationsSwiftPath,
             ]
         )
     }
 }
 
-/// Codable structure for reading the contents of `smithy-model-info.json`
+/// Decodable structure for reading the contents of `smithy-model-info.json`
 private struct SmithyModelInfo: Decodable {
     /// The shape ID of the service being generated.  Must exist in the model.
     let service: String
 
+    /// The name to be used for the enclosing module.
+    let module: String
+
+    /// The `sdkId` used by the Smithy-based code generator.
+    let sdkId: String
+
+    /// Set to `true` if the client should be rendered for internal use.
+    let internalClient: Bool
+
+    /// A list of operations to be included in the client.  If omitted or empty, all operations are included.
+    let operations: [String]
+
     /// The path to the model, from the root of the target's project.  Required.
-    let path: String
+    let modelPath: String
 }

Sources/Smithy/Schema/Prelude.swift

@@ -11,7 +11,7 @@
 public enum Prelude {
 
     public static var unitSchema: Schema {
-        Schema(id: .init("smithy.api", "Unit"), type: .structure)
+        Schema(id: .init("smithy.api", "Unit"), type: .structure, traits: [UnitTypeTrait()])
     }
 
     public static var booleanSchema: Schema {
@@ -54,6 +54,14 @@ public enum Prelude {
         Schema(id: .init("smithy.api", "Double"), type: .double)
     }
 
+    public static var bigIntegerSchema: Schema {
+        Schema(id: .init("smithy.api", "BigInteger"), type: .bigInteger)
+    }
+
+    public static var bigDecimalSchema: Schema {
+        Schema(id: .init("smithy.api", "BigDecimal"), type: .bigDecimal)
+    }
+
     public static var documentSchema: Schema {
         Schema(id: .init("smithy.api", "Document"), type: .document)
     }
@@ -85,4 +93,20 @@ public enum Prelude {
     public static var primitiveDoubleSchema: Schema {
         Schema(id: .init("smithy.api", "PrimitiveDouble"), type: .double, traits: [DefaultTrait(0.0)])
     }
+
+    // The following schemas aren't strictly part of Smithy's prelude, but are used when deserializing a
+    // list or map contained in a Smithy document.
+
+    public static var listDocumentSchema: Schema {
+        Schema(id: .init("swift.synthetic", "ListDocument"), type: .list, members: [
+            .init(id: .init("swift.synthetic", "ListDocument", "member"), type: .document),
+        ])
+    }
+
+    public static var mapDocumentSchema: Schema {
+        Schema(id: .init("swift.synthetic", "MapDocument"), type: .list, members: [
+            .init(id: .init("swift.synthetic", "MapDocument", "key"), type: .string),
+            .init(id: .init("swift.synthetic", "MapDocument", "value"), type: .document),
+        ])
+    }
 }

Sources/Smithy/TraitLibrary/AllSupportedTraits.swift

@@ -21,8 +21,11 @@ public let allSupportedTraits = Set([
     ErrorTrait.id,
     InputTrait.id,
     OutputTrait.id,
+    RequiredTrait.id,
     SensitiveTrait.id,
     SparseTrait.id,
+    TimestampFormatTrait.id,
+    UnitTypeTrait.id, // UnitTypeTrait will only ever appear in Prelude.unitSchema
 
     // Synthetic traits
     TargetsUnitTrait.id,

Sources/Smithy/TraitLibrary/RequiredTrait.swift

@@ -0,0 +1,16 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+public struct RequiredTrait: Trait {
+    public static var id: ShapeID { .init("smithy.api", "required") }
+
+    public var node: Node { [:] }
+
+    public init(node: Node) throws {}
+
+    public init() {}
+}

Sources/Smithy/TraitLibrary/TimestampFormatTrait.swift

@@ -0,0 +1,31 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+public struct TimestampFormatTrait: Trait {
+
+    public enum Format: String {
+        case dateTime = "date-time"
+        case httpDate = "http-date"
+        case epochSeconds = "epoch-seconds"
+    }
+
+    public static var id: ShapeID { .init("smithy.api", "timestampFormat") }
+
+    public let format: Format
+
+    public init(node: Node) throws {
+        guard let formatString = node.string else {
+            throw TraitError("TimestampFormatTrait does not have string value")
+        }
+        guard let format = Format(rawValue: formatString) else {
+            throw TraitError("TimestampFormatTrait string value is not valid")
+        }
+        self.format = format
+    }
+
+    public var node: Node { .string(format.rawValue) }
+}

Sources/Smithy/TraitLibrary/UnitTypeTrait.swift

@@ -0,0 +1,16 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+public struct UnitTypeTrait: Trait {
+    public static var id: ShapeID { .init("smithy.api", "Unit") }
+
+    public var node: Node { [:] }
+
+    public init(node: Node) throws {}
+
+    public init() {}
+}

Sources/SmithyCodegenCLI/SmithyCodegenCLI.swift

@@ -8,6 +8,7 @@
 import ArgumentParser
 import Foundation
 import struct SmithyCodegenCore.CodeGenerator
+import struct SmithyCodegenCore.SwiftSettings
 
 @main
 struct SmithyCodegenCLI: AsyncParsableCommand {
@@ -18,6 +19,15 @@ struct SmithyCodegenCLI: AsyncParsableCommand {
     @Argument(help: "The full or relative path to read the JSON AST model input file.")
     var modelPath: String
 
+    @Option(help: "The sdkId used by the Smithy-based code generator")
+    var sdkId: String?
+
+    @Option(help: "Set this to true if the client to be generated should be internal-scoped.")
+    var `internal` = false
+
+    @Option(help: "The comma-separated list of operation IDs to be included in the client.")
+    var operations: String?
+
     @Option(help: "The full or relative path to write the Schemas output file.")
     var schemasPath: String?
 
@@ -27,12 +37,26 @@ struct SmithyCodegenCLI: AsyncParsableCommand {
     @Option(help: "The full or relative path to write the Deserialize output file.")
     var deserializePath: String?
 
+    @Option(help: "The full or relative path to write the TypeRegistry output file.")
+    var typeRegistryPath: String?
+
+    @Option(help: "The full or relative path to write the Operations output file.")
+    var operationsPath: String?
+
     func run() async throws {
 
         let start = Date()
 
         let currentWorkingDirectoryFileURL = currentWorkingDirectoryFileURL()
 
+        let operations = (operations ?? "").split(separator: ",").map(String.init)
+        let settings = try SwiftSettings(
+            service: service,
+            sdkId: sdkId,
+            internal: `internal`,
+            operations: operations
+        )
+
         // Create the model file URL
         let modelFileURL = URL(fileURLWithPath: modelPath, relativeTo: currentWorkingDirectoryFileURL)
         guard FileManager.default.fileExists(atPath: modelFileURL.path) else {
@@ -48,13 +72,21 @@ struct SmithyCodegenCLI: AsyncParsableCommand {
         // If --deserialize-path was supplied, create the Deserialize file URL
         let deserializeFileURL = resolve(path: deserializePath)
 
+        // If --type-registry-path was supplied, create the TypeRegistry file URL
+        let typeRegistryFileURL = resolve(path: typeRegistryPath)
+
+        // If --operations-path was supplied, create the Operations file URL
+        let operationsFileURL = resolve(path: operationsPath)
+
         // Use resolved file URLs to run code generator
         try CodeGenerator(
-            service: service,
+            settings: settings,
             modelFileURL: modelFileURL,
             schemasFileURL: schemasFileURL,
             serializeFileURL: serializeFileURL,
-            deserializeFileURL: deserializeFileURL
+            deserializeFileURL: deserializeFileURL,
+            typeRegistryFileURL: typeRegistryFileURL,
+            operationsFileURL: operationsFileURL
         ).run()
 
         let duration = Date().timeIntervalSince(start)

Sources/SmithyCodegenCore/CodeGenerator.swift

@@ -12,29 +12,35 @@ import struct Smithy.ShapeID
 
 /// The wrapper for Swift-native code generation.
 public struct CodeGenerator {
-    let service: String
+    let settings: SwiftSettings
     let modelFileURL: URL
     let schemasFileURL: URL?
     let serializeFileURL: URL?
     let deserializeFileURL: URL?
+    let typeRegistryFileURL: URL?
+    let operationsFileURL: URL?
 
     /// Creates a code generator.
     /// - Parameters:
     ///   - service: The absolute shape ID of the service to be generated.  A service with this ID must exist in the model.
     ///   - modelFileURL: The file URL where the JSON AST model file can be accessed.
     ///   - schemasFileURL: The file URL to which the `Schemas.swift` source file should be written.
     public init(
-        service: String,
+        settings: SwiftSettings,
         modelFileURL: URL,
         schemasFileURL: URL?,
         serializeFileURL: URL?,
-        deserializeFileURL: URL?
+        deserializeFileURL: URL?,
+        typeRegistryFileURL: URL?,
+        operationsFileURL: URL?
     ) throws {
-        self.service = service
+        self.settings = settings
         self.modelFileURL = modelFileURL
         self.schemasFileURL = schemasFileURL
         self.serializeFileURL = serializeFileURL
         self.deserializeFileURL = deserializeFileURL
+        self.typeRegistryFileURL = typeRegistryFileURL
+        self.operationsFileURL = operationsFileURL
     }
 
     /// Executes the code generator.
@@ -45,14 +51,11 @@ public struct CodeGenerator {
         let modelData = try Data(contentsOf: modelFileURL)
         let astModel = try JSONDecoder().decode(ASTModel.self, from: modelData)
 
-        // Create the service's ShapeID
-        let serviceID = try ShapeID(service)
-
         // Create the model from the AST
         let model = try Model(astModel: astModel)
 
         // Create a generation context from the model
-        let ctx = try GenerationContext(serviceID: serviceID, model: model)
+        let ctx = try GenerationContext(settings: settings, model: model)
 
         // If a schemas file URL was provided, generate it
         if let schemasFileURL {
@@ -71,5 +74,17 @@ public struct CodeGenerator {
             let deserializeContents = try DeserializeCodegen().generate(ctx: ctx)
             try Data(deserializeContents.utf8).write(to: deserializeFileURL)
         }
+
+        // If a TypeRegistry file URL was provided, generate it
+        if let typeRegistryFileURL {
+            let typeRegistryContents = try TypeRegistryCodegen().generate(ctx: ctx)
+            try Data(typeRegistryContents.utf8).write(to: typeRegistryFileURL)
+        }
+
+        // If an Operations file URL was provided, generate it
+        if let operationsFileURL {
+            let operationsContents = try OperationsCodegen().generate(ctx: ctx)
+            try Data(operationsContents.utf8).write(to: operationsFileURL)
+        }
     }
 }