Project Structure and Swift Package Manager

bookshelf/
├── Package.swift              # the SwiftPM manifest
├── Package.resolved           # created by the first build, records exact dependency versions
├── Public/                    # static files served by FileMiddleware (CSS, JS, images)
├── Resources/
│   └── Views/                 # Leaf templates (only with Leaf)
├── Sources/
│   └── bookshelf/             # the executable target, named after the project
│       ├── Controllers/       # RouteCollection types: request-handling logic grouped by resource
│       ├── DTOs/              # request and response bodies, kept apart from database models
│       ├── Migrations/        # Fluent Migration / AsyncMigration types (only with Fluent)
│       ├── Models/            # Fluent Model types and plain Content structs
│       ├── configure.swift    # func configure(_ app: Application) async throws
│       ├── entrypoint.swift   # @main enum Entrypoint
│       └── routes.swift       # func routes(_ app: Application) throws
├── Tests/
│   └── bookshelfTests/        # Swift Testing tests using VaporTesting
├── Dockerfile
├── docker-compose.yml
├── .gitignore
└── .dockerignore

// swift-tools-version:6.3
import PackageDescription

let package = Package(
    name: "bookshelf",
    platforms: [
        .macOS(.v13)
    ],
    dependencies: [
        // A server-side Swift web framework.
        .package(url: "https://github.com/vapor/vapor.git", from: "4.122.2"),
        // An ORM for SQL and NoSQL databases.
        .package(url: "https://github.com/vapor/fluent.git", from: "4.13.0"),
        // Fluent driver for PostgreSQL.
        .package(url: "https://github.com/vapor/fluent-postgres-driver.git", from: "2.12.0"),
        // An expressive, performant, and extensible templating language built for Swift.
        .package(url: "https://github.com/vapor/leaf.git", from: "4.5.1"),
        // Non-blocking, event-driven networking for Swift. Used for custom executors
        .package(url: "https://github.com/apple/swift-nio.git", from: "2.101.0"),
    ],
    targets: [
        .executableTarget(
            name: "bookshelf",
            dependencies: [
                .product(name: "Fluent", package: "fluent"),
                .product(name: "FluentPostgresDriver", package: "fluent-postgres-driver"),
                .product(name: "Leaf", package: "leaf"),
                .product(name: "Vapor", package: "vapor"),
                .product(name: "NIOCore", package: "swift-nio"),
                .product(name: "NIOPosix", package: "swift-nio"),
            ],
            swiftSettings: swiftSettings
        ),
        .testTarget(
            name: "bookshelfTests",
            dependencies: [
                .target(name: "bookshelf"),
                .product(name: "VaporTesting", package: "vapor"),
            ],
            swiftSettings: swiftSettings
        )
    ]
)

var swiftSettings: [SwiftSetting] { [
    .enableUpcomingFeature("ExistentialAny"),
    .enableUpcomingFeature("InternalImportsByDefault"),
    .enableUpcomingFeature("MemberImportVisibility"),
    .enableUpcomingFeature("InferIsolatedConformances"),
    .enableUpcomingFeature("ImmutableWeakCaptures"),
] }

BookshelfServer/
├── Package.swift
├── Public/
├── Resources/Views/
├── Sources/
│   ├── BookshelfShared/       # shared DTOs: Codable + Sendable, no Vapor import
│   │   └── BookDTO.swift
│   ├── BookshelfServerKit/    # the server library: everything except @main
│   │   ├── Controllers/BooksController.swift
│   │   ├── DTOs/BookDTO+Content.swift
│   │   ├── Services/BookService.swift
│   │   ├── configure.swift
│   │   └── routes.swift
│   └── App/                   # the thin executable
│       └── Entrypoint.swift
└── Tests/AppTests/BooksTests.swift

// swift-tools-version:6.3
import PackageDescription

let package = Package(
    name: "BookshelfServer",
    platforms: [
        .macOS(.v13)
    ],
    products: [
        // Importable by an iOS or macOS client without pulling in Vapor
        .library(name: "BookshelfShared", targets: ["BookshelfShared"]),
        .executable(name: "App", targets: ["App"]),
    ],
    dependencies: [
        .package(url: "https://github.com/vapor/vapor.git", from: "4.122.2"),
        .package(url: "https://github.com/apple/swift-nio.git", from: "2.101.0"),
    ],
    targets: [
        .target(
            name: "BookshelfShared",
            swiftSettings: swiftSettings
        ),
        .target(
            name: "BookshelfServerKit",
            dependencies: [
                "BookshelfShared",
                .product(name: "Vapor", package: "vapor"),
            ],
            swiftSettings: swiftSettings
        ),
        .executableTarget(
            name: "App",
            dependencies: [
                "BookshelfServerKit",
                .product(name: "Vapor", package: "vapor"),
                .product(name: "NIOCore", package: "swift-nio"),
                .product(name: "NIOPosix", package: "swift-nio"),
            ],
            swiftSettings: swiftSettings
        ),
        .testTarget(
            name: "AppTests",
            dependencies: [
                "BookshelfServerKit",
                .product(name: "VaporTesting", package: "vapor"),
            ],
            swiftSettings: swiftSettings
        ),
    ]
)

var swiftSettings: [SwiftSetting] { [
    .enableUpcomingFeature("ExistentialAny"),
    .enableUpcomingFeature("InternalImportsByDefault"),
    .enableUpcomingFeature("MemberImportVisibility"),
    .enableUpcomingFeature("InferIsolatedConformances"),
    .enableUpcomingFeature("ImmutableWeakCaptures"),
] }

import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif

/// URLSession lives in FoundationNetworking on Linux, in Foundation on Apple platforms.
func statusCode(of url: URL) async throws -> Int {
    let (_, response) = try await URLSession.shared.data(from: url)
    return (response as? HTTPURLResponse)?.statusCode ?? 0
}

#if os(Linux)
let platformName = "Linux"
#elseif os(macOS)
let platformName = "macOS"
#else
let platformName = "other"
#endif

.target(
    name: "BookshelfShared",
    swiftSettings: swiftSettings + [
        .define("BOOKSHELF_LINUX", .when(platforms: [.linux])),
    ]
)

import BookshelfShared

/// The port the service depends on: a repository protocol, not a database.
protocol BookRepository: Sendable {
    func all() async -> [BookDTO]
    func find(isbn: String) async -> BookDTO?
}

/// In-memory adapter; a Fluent-backed one would implement the same protocol.
actor InMemoryBookRepository: BookRepository {
    private var books: [String: BookDTO] = [
        "9780441172719": BookDTO(isbn: "9780441172719", title: "Dune", author: "Frank Herbert"),
    ]

    func all() -> [BookDTO] { books.values.sorted { $0.title < $1.title } }
    func find(isbn: String) -> BookDTO? { books[isbn] }
}

/// Business rules live here, free of HTTP types.
struct BookService: Sendable {
    let repository: any BookRepository

    func list() async -> [BookDTO] { await repository.all() }
    func book(isbn: String) async -> BookDTO? { await repository.find(isbn: isbn) }
}

import BookshelfShared
import Vapor

struct BooksController: RouteCollection {
    let service: BookService

    func boot(routes: any RoutesBuilder) throws {
        let books = routes.grouped("books")
        books.get(use: index)
        books.get(":isbn", use: show)
    }

    @Sendable
    func index(req: Request) async throws -> [BookDTO] {
        await service.list()
    }

    @Sendable
    func show(req: Request) async throws -> BookDTO {
        guard let isbn = req.parameters.get("isbn"),
              let book = await service.book(isbn: isbn) else {
            throw Abort(.notFound)
        }
        return book
    }
}