Generate Vapor project.

.dockerignore

@@ -0,0 +1,2 @@
+.build/
+.swiftpm/

.gitignore

@@ -0,0 +1,12 @@
+Packages
+.build
+xcuserdata
+*.xcodeproj
+DerivedData/
+.DS_Store
+db.sqlite
+.swiftpm
+.env
+.env.*
+! .env.example
+.vscode

Dockerfile

@@ -0,0 +1,88 @@
+# ================================
+# Build image
+# ================================
+FROM swift:6.0-jammy AS build
+
+# Install OS updates
+RUN export DEBIAN_FRONTEND=noninteractive DEBCONF_NONINTERACTIVE_SEEN=true \
+    && apt-get -q update \
+    && apt-get -q dist-upgrade -y \
+    && apt-get install -y libjemalloc-dev
+
+# Set up a build area
+WORKDIR /build
+
+# First just resolve dependencies.
+# This creates a cached layer that can be reused
+# as long as your Package.swift/Package.resolved
+# files do not change.
+COPY ./Package.* ./
+RUN swift package resolve \
+        $([ -f ./Package.resolved ] && echo "--force-resolved-versions" || true)
+
+# Copy entire repo into container
+COPY . .
+
+# Build everything, with optimizations, with static linking, and using jemalloc
+# N.B.: The static version of jemalloc is incompatible with the static Swift runtime.
+RUN swift build -c release \
+                --static-swift-stdlib \
+                -Xlinker -ljemalloc
+
+# Switch to the staging area
+WORKDIR /staging
+
+# Copy main executable to staging area
+RUN cp "$(swift build --package-path /build -c release --show-bin-path)/App" ./
+
+# Copy static swift backtracer binary to staging area
+RUN cp "/usr/libexec/swift/linux/swift-backtrace-static" ./
+
+# Copy resources bundled by SPM to staging area
+RUN find -L "$(swift build --package-path /build -c release --show-bin-path)/" -regex '.*\.resources$' -exec cp -Ra {} ./ \;
+
+# Copy any resources from the public directory and views directory if the directories exist
+# Ensure that by default, neither the directory nor any of its contents are writable.
+RUN [ -d /build/Public ] && { mv /build/Public ./Public && chmod -R a-w ./Public; } || true
+RUN [ -d /build/Resources ] && { mv /build/Resources ./Resources && chmod -R a-w ./Resources; } || true
+
+# ================================
+# Run image
+# ================================
+FROM ubuntu:jammy
+
+# Make sure all system packages are up to date, and install only essential packages.
+RUN export DEBIAN_FRONTEND=noninteractive DEBCONF_NONINTERACTIVE_SEEN=true \
+    && apt-get -q update \
+    && apt-get -q dist-upgrade -y \
+    && apt-get -q install -y \
+      libjemalloc2 \
+      ca-certificates \
+      tzdata \
+# If your app or its dependencies import FoundationNetworking, also install `libcurl4`.
+      # libcurl4 \
+# If your app or its dependencies import FoundationXML, also install `libxml2`.
+      # libxml2 \
+    && rm -r /var/lib/apt/lists/*
+
+# Create a vapor user and group with /app as its home directory
+RUN useradd --user-group --create-home --system --skel /dev/null --home-dir /app vapor
+
+# Switch to the new home directory
+WORKDIR /app
+
+# Copy built executable and any staged resources from builder
+COPY --from=build --chown=vapor:vapor /staging /app
+
+# Provide configuration needed by the built-in crash reporter and some sensible default behaviors.
+ENV SWIFT_BACKTRACE=enable=yes,sanitize=yes,threads=all,images=all,interactive=no,swift-backtrace=./swift-backtrace-static
+
+# Ensure all further commands run as the vapor user
+USER vapor:vapor
+
+# Let Docker bind to port 8080
+EXPOSE 8080
+
+# Start the Vapor service when the image is run, default to listening on 8080 in production environment
+ENTRYPOINT ["./App"]
+CMD ["serve", "--env", "production", "--hostname", "0.0.0.0", "--port", "8080"]

Package.swift

@@ -0,0 +1,46 @@
+// swift-tools-version:6.0
+import PackageDescription
+
+let package = Package(
+    name: "website",
+    platforms: [
+       .macOS(.v13)
+    ],
+    dependencies: [
+        // 💧 A server-side Swift web framework.
+        .package(url: "https://github.com/vapor/vapor.git", from: "4.99.3"),
+        // 🗄 An ORM for SQL and NoSQL databases.
+        .package(url: "https://github.com/vapor/fluent.git", from: "4.9.0"),
+        // 🐬 Fluent driver for MySQL.
+        .package(url: "https://github.com/vapor/fluent-mysql-driver.git", from: "4.4.0"),
+        // 🔵 Non-blocking, event-driven networking for Swift. Used for custom executors
+        .package(url: "https://github.com/apple/swift-nio.git", from: "2.65.0"),
+    ],
+    targets: [
+        .executableTarget(
+            name: "App",
+            dependencies: [
+                .product(name: "Fluent", package: "fluent"),
+                .product(name: "FluentMySQLDriver", package: "fluent-mysql-driver"),
+                .product(name: "Vapor", package: "vapor"),
+                .product(name: "NIOCore", package: "swift-nio"),
+                .product(name: "NIOPosix", package: "swift-nio"),
+            ],
+            swiftSettings: swiftSettings
+        ),
+        .testTarget(
+            name: "AppTests",
+            dependencies: [
+                .target(name: "App"),
+                .product(name: "XCTVapor", package: "vapor"),
+            ],
+            swiftSettings: swiftSettings
+        )
+    ],
+    swiftLanguageModes: [.v5]
+)
+
+var swiftSettings: [SwiftSetting] { [
+    .enableUpcomingFeature("DisableOutwardActorInference"),
+    .enableExperimentalFeature("StrictConcurrency"),
+] }

Sources/App/Controllers/TodoController.swift

@@ -0,0 +1,37 @@
+import Fluent
+import Vapor
+
+struct TodoController: RouteCollection {
+    func boot(routes: RoutesBuilder) throws {
+        let todos = routes.grouped("todos")
+
+        todos.get(use: self.index)
+        todos.post(use: self.create)
+        todos.group(":todoID") { todo in
+            todo.delete(use: self.delete)
+        }
+    }
+
+    @Sendable
+    func index(req: Request) async throws -> [TodoDTO] {
+        try await Todo.query(on: req.db).all().map { $0.toDTO() }
+    }
+
+    @Sendable
+    func create(req: Request) async throws -> TodoDTO {
+        let todo = try req.content.decode(TodoDTO.self).toModel()
+
+        try await todo.save(on: req.db)
+        return todo.toDTO()
+    }
+
+    @Sendable
+    func delete(req: Request) async throws -> HTTPStatus {
+        guard let todo = try await Todo.find(req.parameters.get("todoID"), on: req.db) else {
+            throw Abort(.notFound)
+        }
+
+        try await todo.delete(on: req.db)
+        return .noContent
+    }
+}

Sources/App/DTOs/TodoDTO.swift

@@ -0,0 +1,17 @@
+import Fluent
+import Vapor
+
+struct TodoDTO: Content {
+    var id: UUID?
+    var title: String?
+    
+    func toModel() -> Todo {
+        let model = Todo()
+        
+        model.id = self.id
+        if let title = self.title {
+            model.title = title
+        }
+        return model
+    }
+}

Sources/App/Migrations/CreateTodo.swift

@@ -0,0 +1,14 @@
+import Fluent
+
+struct CreateTodo: AsyncMigration {
+    func prepare(on database: Database) async throws {
+        try await database.schema("todos")
+            .id()
+            .field("title", .string, .required)
+            .create()
+    }
+
+    func revert(on database: Database) async throws {
+        try await database.schema("todos").delete()
+    }
+}

Sources/App/Models/Todo.swift

@@ -0,0 +1,29 @@
+import Fluent
+import struct Foundation.UUID
+
+/// Property wrappers interact poorly with `Sendable` checking, causing a warning for the `@ID` property
+/// It is recommended you write your model with sendability checking on and then suppress the warning
+/// afterwards with `@unchecked Sendable`.
+final class Todo: Model, @unchecked Sendable {
+    static let schema = "todos"
+    
+    @ID(key: .id)
+    var id: UUID?
+
+    @Field(key: "title")
+    var title: String
+
+    init() { }
+
+    init(id: UUID? = nil, title: String) {
+        self.id = id
+        self.title = title
+    }
+    
+    func toDTO() -> TodoDTO {
+        .init(
+            id: self.id,
+            title: self.$title.value
+        )
+    }
+}

Sources/App/configure.swift

@@ -0,0 +1,22 @@
+import NIOSSL
+import Fluent
+import FluentMySQLDriver
+import Vapor
+
+// configures your application
+public func configure(_ app: Application) async throws {
+    // uncomment to serve files from /Public folder
+    // app.middleware.use(FileMiddleware(publicDirectory: app.directory.publicDirectory))
+
+    app.databases.use(DatabaseConfigurationFactory.mysql(
+        hostname: Environment.get("DATABASE_HOST") ?? "localhost",
+        port: Environment.get("DATABASE_PORT").flatMap(Int.init(_:)) ?? MySQLConfiguration.ianaPortNumber,
+        username: Environment.get("DATABASE_USERNAME") ?? "vapor_username",
+        password: Environment.get("DATABASE_PASSWORD") ?? "vapor_password",
+        database: Environment.get("DATABASE_NAME") ?? "vapor_database"
+    ), as: .mysql)
+
+    app.migrations.add(CreateTodo())
+    // register routes
+    try routes(app)
+}

Sources/App/entrypoint.swift

@@ -0,0 +1,31 @@
+import Vapor
+import Logging
+import NIOCore
+import NIOPosix
+
+@main
+enum Entrypoint {
+    static func main() async throws {
+        var env = try Environment.detect()
+        try LoggingSystem.bootstrap(from: &env)
+        
+        let app = try await Application.make(env)
+
+        // This attempts to install NIO as the Swift Concurrency global executor.
+        // You can enable it if you'd like to reduce the amount of context switching between NIO and Swift Concurrency.
+        // Note: this has caused issues with some libraries that use `.wait()` and cleanly shutting down.
+        // If enabled, you should be careful about calling async functions before this point as it can cause assertion failures.
+        // let executorTakeoverSuccess = NIOSingletons.unsafeTryInstallSingletonPosixEventLoopGroupAsConcurrencyGlobalExecutor()
+        // app.logger.debug("Tried to install SwiftNIO's EventLoopGroup as Swift's global concurrency executor", metadata: ["success": .stringConvertible(executorTakeoverSuccess)])
+        
+        do {
+            try await configure(app)
+        } catch {
+            app.logger.report(error: error)
+            try? await app.asyncShutdown()
+            throw error
+        }
+        try await app.execute()
+        try await app.asyncShutdown()
+    }
+}

Sources/App/routes.swift

@@ -0,0 +1,14 @@
+import Fluent
+import Vapor
+
+func routes(_ app: Application) throws {
+    app.get { req async in
+        "It works!"
+    }
+
+    app.get("hello") { req async -> String in
+        "Hello, world!"
+    }
+
+    try app.register(collection: TodoController())
+}

Tests/AppTests/AppTests.swift

@@ -0,0 +1,82 @@
+@testable import App
+import XCTVapor
+import Testing
+import Fluent
+
+@Suite("App Tests with DB", .serialized)
+struct AppTests {
+    private func withApp(_ test: (Application) async throws -> ()) async throws {
+        let app = try await Application.make(.testing)
+        do {
+            try await configure(app)
+            try await app.autoMigrate()   
+            try await test(app)
+            try await app.autoRevert()   
+        }
+        catch {
+            try await app.asyncShutdown()
+            throw error
+        }
+        try await app.asyncShutdown()
+    }
+    
+    @Test("Test Hello World Route")
+    func helloWorld() async throws {
+        try await withApp { app in
+            try await app.test(.GET, "hello", afterResponse: { res async in
+                #expect(res.status == .ok)
+                #expect(res.body.string == "Hello, world!")
+            })
+        }
+    }
+    
+    @Test("Getting all the Todos")
+    func getAllTodos() async throws {
+        try await withApp { app in
+            let sampleTodos = [Todo(title: "sample1"), Todo(title: "sample2")]
+            try await sampleTodos.create(on: app.db)
+            
+            try await app.test(.GET, "todos", afterResponse: { res async throws in
+                #expect(res.status == .ok)
+                #expect(try res.content.decode([TodoDTO].self) == sampleTodos.map { $0.toDTO()} )
+            })
+        }
+    }
+    
+    @Test("Creating a Todo")
+    func createTodo() async throws {
+        let newDTO = TodoDTO(id: nil, title: "test")
+        
+        try await withApp { app in
+            try await app.test(.POST, "todos", beforeRequest: { req in
+                try req.content.encode(newDTO)
+            }, afterResponse: { res async throws in
+                #expect(res.status == .ok)
+                let models = try await Todo.query(on: app.db).all()
+                #expect(models.map({ $0.toDTO().title }) == [newDTO.title])
+                XCTAssertEqual(models.map { $0.toDTO() }, [newDTO])
+            })
+        }
+    }
+    
+    @Test("Deleting a Todo")
+    func deleteTodo() async throws {
+        let testTodos = [Todo(title: "test1"), Todo(title: "test2")]
+        
+        try await withApp { app in
+            try await testTodos.create(on: app.db)
+            
+            try await app.test(.DELETE, "todos/\(testTodos[0].requireID())", afterResponse: { res async throws in
+                #expect(res.status == .noContent)
+                let model = try await Todo.find(testTodos[0].id, on: app.db)
+                #expect(model == nil)
+            })
+        }
+    }
+}
+
+extension TodoDTO: Equatable {
+    public static func == (lhs: Self, rhs: Self) -> Bool {
+        lhs.id == rhs.id && lhs.title == rhs.title
+    }
+}

docker-compose.yml

@@ -0,0 +1,74 @@
+# Docker Compose file for Vapor
+#
+# Install Docker on your system to run and test
+# your Vapor app in a production-like environment.
+#
+# Note: This file is intended for testing and does not
+# implement best practices for a production deployment.
+#
+# Learn more: https://docs.docker.com/compose/reference/
+#
+#   Build images: docker-compose build
+#      Start app: docker-compose up app
+# Start database: docker-compose up db
+# Run migrations: docker-compose run migrate
+#       Stop all: docker-compose down (add -v to wipe db)
+#
+version: '3.7'
+
+volumes:
+  db_data:
+
+x-shared_environment: &shared_environment
+  LOG_LEVEL: ${LOG_LEVEL:-debug}
+  DATABASE_HOST: db
+  DATABASE_NAME: vapor_database
+  DATABASE_USERNAME: vapor_username
+  DATABASE_PASSWORD: vapor_password
+  
+services:
+  app:
+    image: website:latest
+    build:
+      context: .
+    environment:
+      <<: *shared_environment
+    depends_on:
+      - db
+    ports:
+      - '8080:8080'
+    # user: '0' # uncomment to run as root for testing purposes even though Dockerfile defines 'vapor' user.
+    command: ["serve", "--env", "production", "--hostname", "0.0.0.0", "--port", "8080"]
+  migrate:
+    image: website:latest
+    build:
+      context: .
+    environment:
+      <<: *shared_environment
+    depends_on:
+      - db
+    command: ["migrate", "--yes"]
+    deploy:
+      replicas: 0
+  revert:
+    image: website:latest
+    build:
+      context: .
+    environment:
+      <<: *shared_environment
+    depends_on:
+      - db
+    command: ["migrate", "--revert", "--yes"]
+    deploy:
+      replicas: 0
+  db:
+    image: mysql:8
+    volumes:
+      - db_data:/var/lib/mysql
+    environment:
+      MYSQL_USER: vapor_username
+      MYSQL_PASSWORD: vapor_password
+      MYSQL_DATABASE: vapor_database
+      MYSQL_RANDOM_ROOT_PASSWORD: 'yes'
+    ports:
+      - '3306:3306'