Add Embedded Swift and WASM support

.github/workflows/swift-wasm.yml

@@ -28,3 +28,33 @@ jobs:
         swift build
         -c ${{ matrix.config }}
         --swift-sdk swift-6.3.2-RELEASE_wasm
+
+  embedded:
+    name: Embedded WebAssembly
+    runs-on: ubuntu-latest
+    container: swift:6.3.2
+    strategy:
+      fail-fast: false
+      matrix:
+        config: [debug, release]
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+    - name: Swift Version
+      run: swift --version
+    - name: Install dependencies
+      run: apt-get update -y && apt-get install -y curl
+    - name: Install Embedded WASM SDK
+      run: |
+        set -eux
+        # The embedded SDK identifier ships inside the same artifact bundle as the regular WASM SDK.
+        url="https://download.swift.org/swift-6.3.2-release/wasm-sdk/swift-6.3.2-RELEASE/swift-6.3.2-RELEASE_wasm.artifactbundle.tar.gz"
+        curl -fsSL "$url" -o wasm.artifactbundle.tar.gz
+        swift sdk install wasm.artifactbundle.tar.gz
+        swift sdk list
+    - name: Build
+      run: >-
+        SWIFTPM_ENABLE_MACROS=0
+        swift build
+        -c ${{ matrix.config }}
+        --swift-sdk swift-6.3.2-RELEASE_wasm-embedded

README.md

@@ -13,3 +13,20 @@ Swift Object Graph
 - CoreData
 - [SQLite](https://github.com/PureSwift/CoreModel-SQLite)
 - [MongoDB](https://github.com/PureSwift/CoreModel-MongoDB)
+
+## Embedded Swift
+
+The `CoreModel` target compiles under [Embedded Swift](https://docs.swift.org/embedded/documentation/embedded), starting with WebAssembly (`wasm32-unknown-none-wasm` / `wasm32-unknown-wasip1` via the embedded Swift SDK). `CoreDataModel` remains a Foundation/CoreData-only target and is unaffected.
+
+```
+SWIFTPM_ENABLE_MACROS=0 swift build --swift-sdk swift-6.3.2-RELEASE_wasm-embedded
+```
+
+Macros must be disabled (`SWIFTPM_ENABLE_MACROS=0`) since `swift-syntax` isn't available under Embedded. This means a few things `@Entity` normally generates aren't available and must be written by hand:
+
+- `Entity.entityName`, `attributes`, and `relationships` have no default implementation — implement them explicitly.
+- `Entity.init(from:)` / `encode()` have no default Codable-derived implementation — implement them using `ModelData.decode(_:forKey:)` / `.encode(_:forKey:)` (see `Person` in `Tests/CoreModelTests/TestModel.swift` for the pattern).
+- `enum CodingKeys: CodingKey { ... }` must declare an explicit `String` raw value — `enum CodingKeys: String, CodingKey { ... }` — since Embedded Swift has no `Codable`/`CodingKey` synthesis; `CoreModel` provides its own `CodingKey` protocol under Embedded that relies on the raw value.
+- `Model(entities: any Entity.Type...)` is unavailable (calls a generic initializer through an existential); use `Model(entities: [EntityDescription(entity: Person.self), ...])` with concrete types instead.
+- `ModelStorage`'s generic `Entity`-based convenience methods (`fetch<T>`, `insert<T>`, `delete<T>`, `count<T>`) and `ViewContext` are unavailable under Embedded (a compiler limitation in `async` default protocol-extension methods). Call the `ModelStorage` protocol requirements directly with `ModelData`/`ObjectID`.
+- `UUID`, `Date`, `Data`, `URL`, and `Decimal` are Foundation-free storage-layer replacements on platforms without Foundation — sufficient for round-tripping through `AttributeValue`, not general-purpose Foundation substitutes.

Sources/CoreModel/Attribute.swift

@@ -5,15 +5,13 @@
 //  Created by Alsey Coleman Miller on 8/16/23.
 //
 
-import Foundation
-
 /// CoreModel `Attribute`
-public struct Attribute: Property, Codable, Equatable, Hashable, Identifiable, Sendable {
-    
+public struct Attribute: Property, Equatable, Hashable, Identifiable, Sendable {
+
     public let id: PropertyKey
-    
+
     public var type: AttributeType
-    
+
     public init(
         id: PropertyKey,
         type: AttributeType
@@ -22,3 +20,9 @@ public struct Attribute: Property, Codable, Equatable, Hashable, Identifiable, S
         self.type = type
     }
 }
+
+// MARK: - Codable
+
+#if !hasFeature(Embedded)
+extension Attribute: Codable {}
+#endif

Sources/CoreModel/AttributeType.swift

@@ -5,10 +5,8 @@
 //  Created by Alsey Coleman Miller on 8/16/23.
 //
 
-import Foundation
-
 /// CoreModel Attribute type
-public enum AttributeType: String, Codable, CaseIterable, Sendable {
+public enum AttributeType: String, CaseIterable, Sendable {
 
     /// Boolean number type.
     case bool
@@ -46,3 +44,9 @@ public enum AttributeType: String, Codable, CaseIterable, Sendable {
     /// Decimal
     case decimal
 }
+
+// MARK: - Codable
+
+#if !hasFeature(Embedded)
+extension AttributeType: Codable {}
+#endif

Sources/CoreModel/Codable.swift

@@ -5,6 +5,4 @@
 //  Created by Alsey Coleman Miller on 8/18/23.
 //
 
-import Foundation
-
 public typealias AttributeCodable = AttributeEncodable & AttributeDecodable

Sources/CoreModel/Decodable.swift

@@ -5,63 +5,67 @@
 //  Created by Alsey Coleman Miller on 8/17/23.
 //
 
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#elseif canImport(Foundation)
 import Foundation
+#endif
 
 // MARK: - ModelData Decoding
 
 public extension ModelData {
-    
+
     func decode<T, K>(_ type: T.Type, forKey key: K) throws -> T where T: AttributeDecodable, K: CodingKey {
-        
+
         let property = PropertyKey(key)
         guard let attribute = self.attributes[property] else {
-            throw DecodingError.keyNotFound(key, DecodingError.Context(codingPath: [], debugDescription: "Key \(key.stringValue) not found"))
+            throw coreModelKeyNotFoundError(key)
         }
         // TODO: Optional values
         /*
         guard attribute != .null else {
             return
         }*/
         guard let decodable = type.init(attributeValue: attribute) else {
-            throw DecodingError.typeMismatch(type, DecodingError.Context(codingPath: [], debugDescription: "Cannot decode \(String(describing: type)) from \(attribute)"))
+            throw coreModelTypeMismatchError(type, forKey: key, from: attribute)
         }
         return decodable
     }
-    
+
     func decodeRelationship<T, K>(_ type: T.Type, forKey key: K) throws -> T where T: ObjectIDConvertible, K: CodingKey {
-        
+
         let property = PropertyKey(key)
         guard let relationship = self.relationships[property] else {
-            throw DecodingError.keyNotFound(key, DecodingError.Context(codingPath: [], debugDescription: "Key \(key.stringValue) not found"))
+            throw coreModelKeyNotFoundError(key)
         }
         switch relationship {
         case .null:
-            throw DecodingError.keyNotFound(key, DecodingError.Context(codingPath: [], debugDescription: "Key \(key.stringValue) not found"))
+            throw coreModelKeyNotFoundError(key)
         case .toMany:
-            throw DecodingError.typeMismatch(type, DecodingError.Context(codingPath: [], debugDescription: "Cannot decode \(String(describing: type)) from \(relationship)"))
+            throw coreModelTypeMismatchError(type, forKey: key, from: relationship)
         case let .toOne(objectID):
             guard let id = type.init(objectID: objectID) else {
-                throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: [], debugDescription: "Cannot decode identifier from \(objectID)"))
+                throw coreModelInvalidIdentifierError(objectID)
             }
             return id
         }
     }
-    
+
     func decodeRelationship<T, K>(_ type: [T].Type, forKey key: K) throws -> [T] where T: ObjectIDConvertible, K: CodingKey {
-        
+
         let property = PropertyKey(key)
         guard let relationship = self.relationships[property] else {
-            throw DecodingError.keyNotFound(key, DecodingError.Context(codingPath: [], debugDescription: "Key \(key.stringValue) not found"))
+            throw coreModelKeyNotFoundError(key)
         }
         switch relationship {
         case .null:
             return []
         case .toOne:
-            throw DecodingError.typeMismatch(type, DecodingError.Context(codingPath: [], debugDescription: "Cannot decode \(String(describing: type)) from \(relationship)"))
+            throw coreModelTypeMismatchError(type, forKey: key, from: relationship)
         case let .toMany(objectIDs):
             return try objectIDs.map {
                 guard let id = T.init(objectID: $0) else {
-                    throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: [], debugDescription: "Cannot decode identifier from \($0)"))
+                    throw coreModelInvalidIdentifierError($0)
                 }
                 return id
             }

Sources/CoreModel/Decoder.swift

@@ -5,6 +5,7 @@
 //  Created by Alsey Coleman Miller on 8/18/23.
 //
 
+#if !hasFeature(Embedded)
 import Foundation
 
 // MARK: - Default Codable Implementation
@@ -687,7 +688,6 @@ internal struct IndexCodingKey: CodingKey, RawRepresentable, Equatable, Hashable
     init?(intValue: Int) {
         self.init(rawValue: intValue)
     }
-
-
-
+
 }
+#endif

Sources/CoreModel/Embedded/EmbeddedCodingKey.swift

@@ -0,0 +1,61 @@
+//
+//  CodingKey.swift
+//  CoreModel
+//
+//  Drop-in replacement for `Swift.CodingKey` under Embedded Swift, where the
+//  stdlib's Codable machinery (including `CodingKey`) is unavailable.
+//
+
+#if hasFeature(Embedded)
+
+/// A type that can be used as a key for encoding and decoding `CoreModel` entities.
+///
+/// - Note: Under Embedded Swift, `enum CodingKeys: CodingKey { ... }` without an
+///   explicit `String` (or `Int`) raw type cannot compile — stdlib `CodingKey`
+///   synthesis is compiler magic tied to `Swift.CodingKey`. Declare
+///   `enum CodingKeys: String, CodingKey` instead.
+public protocol CodingKey: Sendable, CustomStringConvertible, CustomDebugStringConvertible {
+
+    var stringValue: String { get }
+
+    init?(stringValue: String)
+
+    var intValue: Int? { get }
+
+    init?(intValue: Int)
+}
+
+extension CodingKey {
+
+    public var description: String { stringValue }
+
+    public var debugDescription: String { stringValue }
+
+    public var intValue: Int? { nil }
+
+    public init?(intValue: Int) { nil }
+}
+
+extension CodingKey where Self: RawRepresentable, Self.RawValue == String {
+
+    public var stringValue: String { rawValue }
+
+    public init?(stringValue: String) {
+        self.init(rawValue: stringValue)
+    }
+}
+
+extension CodingKey where Self: RawRepresentable, Self.RawValue == Int {
+
+    public var stringValue: String { rawValue.description }
+
+    public var intValue: Int? { rawValue }
+
+    public init?(stringValue: String) { nil }
+
+    public init?(intValue: Int) {
+        self.init(rawValue: intValue)
+    }
+}
+
+#endif

Sources/CoreModel/Encodable.swift

@@ -5,7 +5,11 @@
 //  Created by Alsey Coleman Miller on 8/17/23.
 //
 
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#elseif canImport(Foundation)
 import Foundation
+#endif
 
 // MARK: - ModelData Encoding
 

Sources/CoreModel/Encoder.swift

@@ -5,6 +5,7 @@
 //  Created by Alsey Coleman Miller on 8/18/23.
 //
 
+#if !hasFeature(Embedded)
 import Foundation
 
 extension Entity where Self: Encodable {
@@ -523,3 +524,4 @@ internal final class ModelUnkeyedEncodingContainer: UnkeyedEncodingContainer {
         encoder.data.relationships[key] = value
     }
 }
+#endif

Sources/CoreModel/Entity.swift

@@ -6,41 +6,45 @@
 //  Copyright © 2015 PureSwift. All rights reserved.
 //
 
-import Foundation
-
 /// CoreModel Entity for Codable types
 public protocol Entity: Identifiable, Sendable where CodingKeys: Hashable, Self.ID: ObjectIDConvertible {
-    
+
     static var entityName: EntityName { get }
-    
+
     static var attributes: [CodingKeys: AttributeType] { get }
-    
+
     static var relationships: [CodingKeys: Relationship] { get }
-    
+
     associatedtype CodingKeys: CodingKey
-    
+
     init(from model: ModelData) throws
-    
+
     func encode() throws -> ModelData
 }
 
 public extension Entity {
-
+
+    #if !hasFeature(Embedded)
+    /// - Note: Unavailable under Embedded Swift (relies on runtime type metadata). Implement explicitly.
     static var entityName: EntityName {
         EntityName(rawValue: String(describing: Self.self))
     }
-
+    #endif
+
     static var attributes: [CodingKeys: AttributeType] { [:] }
-    
+
     static var relationships: [CodingKeys: Relationship] { [:] }
 }
 
+#if !hasFeature(Embedded)
 public extension Model {
-
+
+    /// - Note: Unavailable under Embedded Swift (calls a generic initializer through an existential metatype). Construct `Model(entities:)` from concrete `EntityDescription` values instead.
     init(entities: any Entity.Type...) {
         self.init(entities: entities.map { .init(entity: $0) })
     }
 }
+#endif
 
 public extension EntityDescription {
 

Sources/CoreModel/EntityDescription.swift

@@ -5,20 +5,24 @@
 //  Created by Alsey Coleman Miller on 8/17/23.
 //
 
-import Foundation
-
 /// Defines the model for an entity
-public struct EntityDescription: Codable, Identifiable, Hashable, Sendable {
-    
+public struct EntityDescription: Identifiable, Hashable, Sendable {
+
     public let id: EntityName
-    
+
     public var attributes: [Attribute]
-    
+
     public var relationships: [Relationship]
-    
+
     public init(id: EntityName, attributes: [Attribute], relationships: [Relationship]) {
         self.id = id
         self.attributes = attributes
         self.relationships = relationships
     }
 }
+
+// MARK: - Codable
+
+#if !hasFeature(Embedded)
+extension EntityDescription: Codable {}
+#endif