add case style for whole Codable object

Author: haifengkao

Package.swift

@@ -36,16 +36,24 @@ let package = Package(
         ),
     ],
     targets: [
+        .target(
+            name: "MacroCodableKitShared"
+        ),
+
         // Macro declaration
         .target(
             name: "MacroCodableKit",
-            dependencies: ["Macro"]
+            dependencies: [
+                "MacroCodableKitShared",
+                "Macro",
+            ]
         ),
 
         // Macros
         .macro(
             name: "Macro",
             dependencies: [
+                "MacroCodableKitShared",
                 .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
                 .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
                 .product(name: "MacroToolkit", package: "swift-macro-toolkit"),

README.md

@@ -69,6 +69,21 @@ struct User {
 }
 ```
 
+You can also derive default coding keys from property names:
+
+```swift
+@Codable(caseStyle: .snakeCase)
+struct ExamplePayload {
+    let primaryValue: String
+    let secondaryLabel: String?
+
+    @CodingKey("ManualName")
+    let customField: String?
+}
+```
+
+This generates coding keys like `"primary_value"` and `"secondary_label"`, while `customField` still uses `"ManualName"`.
+
 Let's convert `birthday` to `Date`, change coding key of `isVerified` and make it default to `false`
 
 > **Note**
@@ -284,6 +299,8 @@ struct User {
 }
 ```
 
+When `@Codable(caseStyle: ...)`, `@Decodable(caseStyle: ...)`, or `@Encodable(caseStyle: ...)` is used, `@CodingKey(...)` still takes precedence for that property.
+
 #### @OmitCoding
 
 Skip coding for a specific property with `@OmitCoding()` annotation

Sources/Macro/Macro/Codable/CodableMacroBase.swift

@@ -13,7 +13,7 @@ import SwiftSyntaxMacros
 
 struct CodableMacroBase {
     static func expansion(
-        of _: AttributeSyntax,
+        of node: AttributeSyntax,
         attachedTo declaration: some DeclGroupSyntax,
         providingExtensionsOf type: some TypeSyntaxProtocol,
         conformancesToGenerate: Set<Conformance>,
@@ -36,10 +36,16 @@ struct CodableMacroBase {
         )
 
         let expander = InstanceExpander(codableFactory: DefaultCodableBuilderFactoryImpl())
+        let config = CodableMacroConfig(node: node)
 
         let buildingData: CodableBuildingData
         do {
-            buildingData = try expander.verify(declaration: declaration, strategy: .codingKeys, conformances: conformancesToGenerate)
+            buildingData = try expander.verify(
+                declaration: declaration,
+                strategy: .codingKeys,
+                conformances: conformancesToGenerate,
+                config: config
+            )
         } catch {
             return []
         }

Sources/Macro/Macro/Codable/CodableMacroConfig.swift

@@ -0,0 +1,41 @@
+//
+//  CodableMacroConfig.swift
+//
+//
+//  Created by OpenAI Codex on 20.04.26.
+//
+
+import Foundation
+import MacroCodableKitShared
+import SwiftSyntax
+
+struct CodableMacroConfig {
+    struct CaseStyleTransformer {
+        let memberName: String
+
+        func transform(_ propertyName: String) -> String {
+            guard let style = CaseStyle(rawValue: memberName) else { return propertyName }
+            return CaseConverter.format(propertyName, to: style)
+        }
+    }
+
+    let caseStyle: CaseStyleTransformer
+
+    init(caseStyle: CaseStyleTransformer = CaseStyleTransformer(memberName: "verbatim")) {
+        self.caseStyle = caseStyle
+    }
+
+    init(node: AttributeSyntax) {
+        guard case let .argumentList(args) = node.arguments else {
+            self.init()
+            return
+        }
+
+        if let styleArg = args.first(where: { $0.label?.text == "caseStyle" }),
+           let member = styleArg.expression.as(MemberAccessExprSyntax.self) {
+            self.init(caseStyle: CaseStyleTransformer(memberName: member.declName.baseName.text))
+        } else {
+            self.init()
+        }
+    }
+}

Sources/Macro/Macro/TaggedEnum/TaggedEnumMacroBase.swift

@@ -1,5 +1,6 @@
 import MacroToolkit
 import Foundation
+import MacroCodableKitShared
 import SwiftDiagnostics
 import SwiftSyntax
 import SwiftSyntaxMacros
@@ -20,63 +21,11 @@ enum TaggedEnumMacroBase {
         let memberName: String
 
         func transform(_ caseName: String) -> String {
-            switch memberName {
-            case "verbatim":            return caseName
-            case "camelCase":           return CaseConverter.format(caseName, to: .camelCase)
-            case "pascalCase":          return CaseConverter.format(caseName, to: .pascalCase)
-            case "snakeCase":           return CaseConverter.format(caseName, to: .snakeCase)
-            case "screamingSnakeCase":  return CaseConverter.format(caseName, to: .screamingSnakeCase)
-            case "kebabCase":           return CaseConverter.format(caseName, to: .kebabCase)
-            default:                    return caseName
-            }
-        }
-    }
-
-    struct CaseConverter {
-        static func tokenize(_ input: String) -> [String] {
-            let splitCamel = input.replacingOccurrences(
-                of: "([a-z])([A-Z])",
-                with: "$1 $2",
-                options: .regularExpression
-            )
-
-            let separators = CharacterSet.alphanumerics.inverted
-            let components = splitCamel.components(separatedBy: separators)
-
-            return components
-                .filter { !$0.isEmpty }
-                .map { $0.lowercased() }
-        }
-
-        static func format(_ string: String, to style: Style) -> String {
-            let tokens = tokenize(string)
-            guard !tokens.isEmpty else { return string }
-
-            switch style {
-            case .camelCase:
-                let first = tokens[0]
-                let rest = tokens.dropFirst().map(\.capitalized)
-                return first + rest.joined()
-            case .pascalCase:
-                return tokens.map(\.capitalized).joined()
-            case .snakeCase:
-                return tokens.joined(separator: "_")
-            case .screamingSnakeCase:
-                return tokens.joined(separator: "_").uppercased()
-            case .kebabCase:
-                return tokens.joined(separator: "-")
-            }
+            guard let style = CaseStyle(rawValue: memberName) else { return caseName }
+            return CaseConverter.format(caseName, to: style)
         }
     }
 
-    enum Style {
-        case camelCase
-        case pascalCase
-        case snakeCase
-        case screamingSnakeCase
-        case kebabCase
-    }
-
     // MARK: - Entry Point
 
     static func expansion(

Sources/Macro/Misc/CodableBuilders/CodingKeysBuilder+Instance.swift

@@ -10,7 +10,8 @@ import MacroToolkit
 extension CodingKeysBuilder {
     static func verify(
         accessModifier: AccessModifier?,
-        instance: Instance
+        instance: Instance,
+        caseStyle: CodableMacroConfig.CaseStyleTransformer
     ) throws -> CodingKeysBuilder.BuildingData {
         CodingKeysBuilder.BuildingData(
             accessModifier: accessModifier,
@@ -45,9 +46,26 @@ extension CodingKeysBuilder {
 
                     return CodingKeysBuilder.BuildingData.Item(
                         identifier: identifier,
-                        customCodingKey: (knownAttributes[.codingKey]?.first as? CodingKey)?.key
+                        customCodingKey: makeCodingKey(
+                            identifier: identifier,
+                            knownAttributes: knownAttributes,
+                            caseStyle: caseStyle
+                        )
                     )
                 }
         )
     }
+
+    private static func makeCodingKey(
+        identifier: String,
+        knownAttributes: Variable.AllKnownAttributes,
+        caseStyle: CodableMacroConfig.CaseStyleTransformer
+    ) -> String? {
+        if let explicitKey = (knownAttributes[.codingKey]?.first as? CodingKey)?.key {
+            return explicitKey
+        }
+
+        let transformedKey = caseStyle.transform(identifier)
+        return transformedKey == identifier ? nil : transformedKey
+    }
 }

Sources/Macro/Misc/InstanceExpander.swift

@@ -17,7 +17,8 @@ final class InstanceExpander {
     func verify(
         declaration: some DeclGroupSyntax,
         strategy: CodableStrategy,
-        conformances: Set<Conformance>
+        conformances: Set<Conformance>,
+        config: CodableMacroConfig = .init()
     ) throws -> CodableBuildingData {
         guard let instance = InstanceImpl(declaration: declaration), instance.isStruct else {
             MacroConfiguration.current.context.diagnose(
@@ -34,7 +35,8 @@ final class InstanceExpander {
         if strategy == .codingKeys {
             codingKeysBuildingData = try CodingKeysBuilder.verify(
                 accessModifier: accessModifier,
-                instance: instance
+                instance: instance,
+                caseStyle: config.caseStyle
             )
         } else {
             codingKeysBuildingData = nil

Sources/MacroCodableKit/Macros/CaseStyle.swift

@@ -1,52 +1,7 @@
-import Foundation
+@_exported import MacroCodableKitShared
 
-public enum CaseStyle {
-    case verbatim
-    case camelCase
-    case pascalCase
-    case snakeCase
-    case screamingSnakeCase
-    case kebabCase
-}
-
-public struct CaseConverter {
-    public static func tokenize(_ input: String) -> [String] {
-        let splitCamel = input.replacingOccurrences(
-            of: "([a-z])([A-Z])",
-            with: "$1 $2",
-            options: .regularExpression
-        )
-
-        let separators = CharacterSet.alphanumerics.inverted
-        let components = splitCamel.components(separatedBy: separators)
-
-        return components
-            .filter { !$0.isEmpty }
-            .map { $0.lowercased() }
-    }
-
-    public static func format(_ string: String, to style: CaseStyle) -> String {
-        let tokens = tokenize(string)
-        guard !tokens.isEmpty else { return string }
-
-        switch style {
-        case .verbatim:
-            return string
-        case .camelCase:
-            let first = tokens[0]
-            let rest = tokens.dropFirst().map(\.capitalized)
-            return first + rest.joined()
-        case .pascalCase:
-            return tokens.map(\.capitalized).joined()
-        case .snakeCase:
-            return tokens.joined(separator: "_")
-        case .screamingSnakeCase:
-            return tokens.joined(separator: "_").uppercased()
-        case .kebabCase:
-            return tokens.joined(separator: "-")
-        }
-    }
-}
+public typealias CaseStyle = MacroCodableKitShared.CaseStyle
+public typealias CaseConverter = MacroCodableKitShared.CaseConverter
 
 @available(*, deprecated, renamed: "CaseStyle")
 public typealias TaggedCodableCaseStyle = CaseStyle

Sources/MacroCodableKit/Macros/Codable.swift

@@ -17,6 +17,15 @@
 /// }
 /// ```
 ///
+/// Use `caseStyle:` to derive default coding keys from stored property names:
+/// ```swift
+/// @Codable(caseStyle: .snakeCase)
+/// struct ExamplePayload {
+///     let primaryValue: String
+///     let secondaryLabel: String?
+/// }
+/// ```
+///
 /// If you need only `Decodable` or `Encodable` use ``Decodable()`` or ``Encodable()`` respectively
 ///
 /// **Adjust coding behaviour**:
@@ -92,7 +101,7 @@
 /// - Handle decoding errors with ``CustomCodingDecoding/errorHandler`` in ``CustomCodingDecoding``
 /// - Handle encoding errors with ``CustomCodingEncoding/errorHandler`` in ``CustomCodingEncoding``
 @attached(extension, conformances: Decodable, Encodable, names: named(CodingKeys), named(init(from:)), named(encode(to:)))
-public macro Codable() = #externalMacro(module: "Macro", type: "CodableMacro")
+public macro Codable(caseStyle: CaseStyle = .verbatim) = #externalMacro(module: "Macro", type: "CodableMacro")
 
 /// Generates `Decodable` conformance respecting property annotations.
 ///
@@ -105,8 +114,10 @@ public macro Codable() = #externalMacro(module: "Macro", type: "CodableMacro")
 ///     let property: String
 /// }
 /// ```
+///
+/// `caseStyle:` applies to generated default keys here as well, while `@CodingKey(...)` still wins for explicitly annotated properties.
 @attached(extension, conformances: Decodable, names: named(CodingKeys), named(init(from:)))
-public macro Decodable() = #externalMacro(module: "Macro", type: "DecodableMacro")
+public macro Decodable(caseStyle: CaseStyle = .verbatim) = #externalMacro(module: "Macro", type: "DecodableMacro")
 
 /// Generates `Encodable` conformance respecting property annotations.
 ///
@@ -119,5 +130,7 @@ public macro Decodable() = #externalMacro(module: "Macro", type: "DecodableMacro
 ///     let property: String
 /// }
 /// ```
+///
+/// `caseStyle:` applies to generated default keys here as well, while `@CodingKey(...)` still wins for explicitly annotated properties.
 @attached(extension, conformances: Encodable, names: named(CodingKeys), named(encode(to:)))
-public macro Encodable() = #externalMacro(module: "Macro", type: "EncodableMacro")
+public macro Encodable(caseStyle: CaseStyle = .verbatim) = #externalMacro(module: "Macro", type: "EncodableMacro")