feat!: Schema-based serialization

Sources/Smithy/Document/Implementations/BigDecimalDocument.swift

@@ -35,8 +35,8 @@ public struct BigDecimalDocument: SmithyDocument {
         return int
     }
 
-    public func asLong() throws -> Int64 {
-        guard let long = Int64(exactly: value) else {
+    public func asLong() throws -> Int {
+        guard let long = Int(exactly: value) else {
             throw DocumentError.numberOverflow("BigDecimal \(value) overflows long")
         }
         return long

Sources/Smithy/Document/Node+Document.swift

@@ -0,0 +1,27 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+@_spi(SmithyNodeImpl)
+extension Node {
+
+    public func toDocument() -> (any SmithyDocument)? {
+        switch self {
+        case .object(let value):
+            return StringMapDocument(value: value.compactMapValues { $0.toDocument() })
+        case .list(let value):
+            return ListDocument(value: value.compactMap { $0.toDocument() })
+        case .string(let value):
+            return StringDocument(value: value)
+        case .number(let value):
+            return DoubleDocument(value: value)
+        case .boolean(let value):
+            return BooleanDocument(value: value)
+        case .null:
+            return nil
+        }
+    }
+}

Sources/Smithy/Document/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 case, 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 {
+    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
+    }
+}

Sources/Smithy/Document/ShapeType.swift

@@ -8,6 +8,14 @@
 /// Reproduces the cases in Smithy `ShapeType`.
 /// https://github.com/smithy-lang/smithy/blob/main/smithy-model/src/main/java/software/amazon/smithy/model/shapes/ShapeType.java
 public enum ShapeType {
+
+    public enum Category {
+        case simple
+        case aggregate
+        case service
+        case member
+    }
+
     case blob
     case boolean
     case string
@@ -32,4 +40,18 @@ public enum ShapeType {
     case service
     case resource
     case operation
+
+    public var category: Category {
+        switch self {
+        case .blob, .boolean, .string, .timestamp, .byte, .short, .integer, .long,
+             .float, .document, .double, .bigDecimal, .bigInteger, .enum, .intEnum:
+            return .simple
+        case .list, .set, .map, .structure, .union:
+            return .aggregate
+        case .service, .resource, .operation:
+            return .service
+        case .member:
+            return .member
+        }
+    }
 }