Swift Package Target Creation with a Builder Pattern

When defining multiple Swift Package targets—especially with various dependencies, paths, and resources—your Package.swift can get cluttered. A builder pattern can streamline this process.

Traditional Approach

Typically, you define targets directly:

    targets: [
        .target(
            name: "MyLibrary",
            dependencies: [],
            path: "Sources/MyLibrary",
            resources: [.process("Assets")]
        ),
        .testTarget(
            name: "MyLibraryTests",
            dependencies: ["MyLibrary"],
            path: "Tests/MyLibraryTests"
        )
    ]

As the project grows, repeated parameters become unwieldy.

Builder Pattern

Create a builder type to encapsulate target configuration. Let’s define an enum for resources:

enum ResourceInfo {
    case none
    case process(String)
}

Then, a TargetCreator struct to compose targets:

import PackageDescription

public struct TargetCreator {
    private var name = ""
    private var dependencies: [PackageDescription.Target.Dependency] = []
    private var path = ""
    private var resourceInfo: ResourceInfo = .none

    var target: PackageDescription.Target {
        switch resourceInfo {
        case .none:
            return .target(name: name, dependencies: dependencies, path: path)
        case .process(let resourcesPath):
            return .target(
                name: name,
                dependencies: dependencies,
                path: path,
                resources: [.process(resourcesPath)]
            )
        }
    }

    func addName(_ newName: String) -> Self {
        var new = self
        new.name = newName
        return new
    }

    func addDependencies(_ newDeps: [PackageDescription.Target.Dependency]) -> Self {
        var new = self
        new.dependencies.append(contentsOf: newDeps)
        return new
    }

    func addPath(_ newPath: String) -> Self {
        var new = self
        new.path = newPath
        return new
    }

    func addResources(_ info: ResourceInfo) -> Self {
        var new = self
        new.resourceInfo = info
        return new
    }
}

Usage

let libraryTarget = TargetCreator()
    .addName("MyLibrary")
    .addPath("Sources/MyLibrary")
    .addResources(.process("Assets"))
    .target

let testTarget = TargetCreator()
    .addName("MyLibraryTests")
    .addDependencies([libraryTarget])
    .addPath("Tests/MyLibraryTests")
    .target

let package = Package(
    name: "MyProject",
    products: [
        .library(name: "MyLibrary", targets: [libraryTarget])
    ],
    targets: [
        libraryTarget,
        testTarget
    ]
)

Advantages

• Readability: Each step is explicit (addName, addPath), reducing parameter clutter.
• Consistency: Centralizes logic, reducing repetition and mistakes.
• Expandability: New parameters (e.g., cSettings) can be added without changing every target.

By encapsulating target creation, you keep Package.swift concise and easier to maintain. If your package grows or you add more advanced configurations, you can extend the builder instead of modifying scattered initializers throughout your file.