[EPIC] Schema-based serialization

Package.swift

@@ -57,10 +57,12 @@ let package = Package(
         .library(name: "SmithySwiftNIO", targets: ["SmithySwiftNIO"]),
         .library(name: "SmithyTelemetryAPI", targets: ["SmithyTelemetryAPI"]),
         .library(name: "SmithyHTTPClientAPI", targets: ["SmithyHTTPClientAPI"]),
+        .plugin(name: "SmithyCodeGeneratorPlugin", targets: ["SmithyCodeGeneratorPlugin"]),
     ],
     dependencies: {
         var dependencies: [Package.Dependency] = [
             .package(url: "https://github.com/awslabs/aws-crt-swift.git", exact: "0.58.0"),
+            .package(url: "https://github.com/apple/swift-argument-parser.git", exact: "1.6.2"),
             .package(url: "https://github.com/apple/swift-log.git", from: "1.0.0"),
             .package(url: "https://github.com/open-telemetry/opentelemetry-swift", from: "1.13.0"),
             .package(url: "https://github.com/swift-server/async-http-client.git", from: "1.22.0"),
@@ -119,6 +121,7 @@ let package = Package(
                 "SmithyChecksumsAPI",
                 "SmithyChecksums",
                 "SmithyCBOR",
+                "SmithySerialization",
                 .product(name: "AwsCommonRuntimeKit", package: "aws-crt-swift"),
                 // Only include these on macOS, iOS, tvOS, watchOS, and macCatalyst (visionOS and Linux are excluded)
                 .product(
@@ -285,12 +288,36 @@ let package = Package(
             dependencies: [
                 "SmithyReadWrite",
                 "SmithyTimestamps",
+                "Smithy",
+                "SmithySerialization",
                 .product(name: "AwsCommonRuntimeKit", package: "aws-crt-swift")
             ]
         ),
         .target(
             name: "SmithyWaitersAPI"
         ),
+        .plugin(
+            name: "SmithyCodeGeneratorPlugin",
+            capability: .buildTool(),
+            dependencies: [
+                "SmithyCodegenCLI",
+            ]
+        ),
+        .executableTarget(
+            name: "SmithyCodegenCLI",
+            dependencies: [
+                "SmithyCodegenCore",
+                .product(name: "ArgumentParser", package: "swift-argument-parser"),
+            ]
+        ),
+        .target(
+            name: "SmithyCodegenCore",
+            dependencies: [
+                "Smithy",
+                "SmithySerialization",
+            ],
+            resources: [ .process("Resources") ]
+        ),
         .testTarget(
             name: "ClientRuntimeTests",
             dependencies: [
@@ -301,6 +328,10 @@ let package = Package(
             ],
             resources: [ .process("Resources") ]
         ),
+        .testTarget(
+            name: "SmithyTests",
+            dependencies: ["Smithy"]
+        ),
         .testTarget(
             name: "SmithySwiftNIOTests",
             dependencies: [
@@ -374,5 +405,10 @@ let package = Package(
             name: "SmithyStreamsTests",
             dependencies: ["SmithyStreams", "Smithy"]
         ),
+        .testTarget(
+            name: "SmithyCodegenCoreTests",
+            dependencies: ["SmithyCodegenCore"],
+            resources: [ .process("Resources") ]
+        ),
     ].compactMap { $0 }
 )

Plugins/SmithyCodeGeneratorPlugin/SmithyCodeGeneratorPlugin.swift

@@ -0,0 +1,92 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import struct Foundation.Data
+import class Foundation.FileManager
+import class Foundation.JSONDecoder
+import struct Foundation.URL
+import PackagePlugin
+
+@main
+struct SmithyCodeGeneratorPlugin: BuildToolPlugin {
+
+    func createBuildCommands(context: PluginContext, target: Target) throws -> [Command] {
+        // This plugin only runs for package targets that can have source files.
+        guard let sourceFiles = target.sourceModule?.sourceFiles else { return [] }
+
+        // Retrieve the `SmithyCodegenCLI` tool from the plugin's tools.
+        let smithyCodegenCLITool = try context.tool(named: "SmithyCodegenCLI")
+
+        // Construct a build command for each source file with a particular suffix.
+        return try sourceFiles.map(\.path).compactMap {
+            try createBuildCommand(
+                name: target.name,
+                for: $0,
+                in: context.pluginWorkDirectory,
+                with: smithyCodegenCLITool.path
+            )
+        }
+    }
+
+    private func createBuildCommand(
+        name: String,
+        for inputPath: Path,
+        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 }
+
+        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.
+        let service = smithyModelInfo.service
+        let modelPathURL = currentWorkingDirectoryFileURL.appendingPathComponent(smithyModelInfo.path)
+        let modelPath = Path(modelPathURL.path)
+
+        // Construct the Schemas.swift path.
+        let schemasSwiftPath = outputDirectoryPath.appending("\(name)Schemas.swift")
+
+        // Construct the Serialize.swift path.
+        let serializeSwiftPath = outputDirectoryPath.appending("\(name)Serialize.swift")
+
+        // Construct the Deserialize.swift path.
+        let deserializeSwiftPath = outputDirectoryPath.appending("\(name)Deserialize.swift")
+
+        // Construct the build command that invokes SmithyCodegenCLI.
+        return .buildCommand(
+            displayName: "Generating Swift source files from model file \(smithyModelInfo.path)",
+            executable: generatorToolPath,
+            arguments: [
+                service,
+                modelPath,
+                "--schemas-path", schemasSwiftPath,
+                "--serialize-path", serializeSwiftPath,
+                "--deserialize-path", deserializeSwiftPath
+            ],
+            inputFiles: [inputPath, modelPath],
+            outputFiles: [
+                schemasSwiftPath,
+                serializeSwiftPath,
+                deserializeSwiftPath,
+            ]
+        )
+    }
+}
+
+/// Codable 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 path to the model, from the root of the target's project.  Required.
+    let path: String
+}

Sources/Smithy/Document/Implementations/BigIntegerDocument.swift

@@ -8,9 +8,9 @@
 @_spi(SmithyDocumentImpl)
 public struct BigIntegerDocument: SmithyDocument {
     public var type: ShapeType { .bigInteger }
-    let value: Int
+    let value: Int64
 
-    public init(value: Int) {
+    public init(value: Int64) {
         self.value = value
     }
 
@@ -29,7 +29,7 @@ public struct BigIntegerDocument: SmithyDocument {
     }
 
     public func asInteger() throws -> Int {
-        value
+        Int(value)
     }
 
     public func asLong() throws -> Int64 {
@@ -45,7 +45,7 @@ public struct BigIntegerDocument: SmithyDocument {
     }
 
     public func asBigInteger() throws -> Int64 {
-        Int64(value)
+        value
     }
 
     public func asBigDecimal() throws -> Double {

Sources/Smithy/Node.swift

@@ -0,0 +1,109 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/// Contains the value of a Smithy Node.
+///
+/// Smithy node data is basically the same as the data that can be stored in JSON.
+/// The root of a Smithy node may be of any type, i.e. unlike JSON, the root element is not limited to object or list.
+///
+/// See the definition of node value in the Smithy spec: https://smithy.io/2.0/spec/model.html#node-values
+public enum Node: Sendable, Hashable {
+    case object([String: Node])
+    case list([Node])
+    case string(String)
+    case number(Double)
+    case boolean(Bool)
+    case null
+}
+
+public extension Node {
+
+    /// Returns the object dictionary if this Node is `.object`, else returns `nil`.
+    var object: [String: Node]? {
+        guard case .object(let value) = self else { return nil }
+        return value
+    }
+
+    /// Returns the array of `Node` if this node is `.list`, else returns `nil`.
+    var list: [Node]? {
+        guard case .list(let value) = self else { return nil }
+        return value
+    }
+
+    /// Returns the string if this node is `.string`, else returns `nil`.
+    var string: String? {
+        guard case .string(let value) = self else { return nil }
+        return value
+    }
+
+    /// Returns the Double if this node is `.number`, else returns `nil`.
+    var number: Double? {
+        guard case .number(let value) = self else { return nil }
+        return value
+    }
+
+    /// Returns the `Bool` value if this node is `.boolean`, else returns `nil`.
+    var boolean: Bool? {
+        guard case .boolean(let value) = self else { return nil }
+        return value
+    }
+
+    /// Returns `true` if this node is `.null`, else returns `false`.
+    var null: Bool {
+        guard case .null = self else { return false }
+        return true
+    }
+}
+
+extension Node: ExpressibleByDictionaryLiteral {
+
+    public init(dictionaryLiteral elements: (String, Node)...) {
+        self = .object(Dictionary(uniqueKeysWithValues: elements))
+    }
+}
+
+extension Node: ExpressibleByArrayLiteral {
+
+    public init(arrayLiteral elements: Node...) {
+        self = .list(elements)
+    }
+}
+
+extension Node: ExpressibleByStringLiteral {
+
+    public init(stringLiteral value: String) {
+        self = .string(value)
+    }
+}
+
+extension Node: ExpressibleByIntegerLiteral {
+
+    public init(integerLiteral value: IntegerLiteralType) {
+        self = .number(Double(value))
+    }
+}
+
+extension Node: ExpressibleByFloatLiteral {
+
+    public init(floatLiteral value: FloatLiteralType) {
+        self = .number(Double(value))
+    }
+}
+
+extension Node: ExpressibleByBooleanLiteral {
+
+    public init(booleanLiteral value: BooleanLiteralType) {
+        self = .boolean(value)
+    }
+}
+
+extension Node: ExpressibleByNilLiteral {
+
+    public init(nilLiteral: ()) {
+        self = .null
+    }
+}