From a94752a7991716b683912024260c0b3a2fcf9101 Mon Sep 17 00:00:00 2001 From: Andrew Glaze Date: Wed, 14 May 2025 18:38:30 -0400 Subject: [PATCH] Generate Vapor project. --- .dockerignore | 2 + .gitignore | 11 +++ .vscode/extensions.json | 3 + Dockerfile | 89 +++++++++++++++++++ Package.swift | 44 +++++++++ Public/.gitkeep | 0 README.md | 27 ++++++ Sources/stella/Controllers/.gitkeep | 0 .../stella/Controllers/TodoController.swift | 37 ++++++++ Sources/stella/DTOs/TodoDTO.swift | 17 ++++ Sources/stella/Migrations/CreateTodo.swift | 14 +++ Sources/stella/Models/Todo.swift | 29 ++++++ Sources/stella/configure.swift | 17 ++++ Sources/stella/entrypoint.swift | 31 +++++++ Sources/stella/routes.swift | 14 +++ Tests/stellaTests/stellaTests.swift | 81 +++++++++++++++++ docker-compose.yml | 47 ++++++++++ 17 files changed, 463 insertions(+) create mode 100644 .dockerignore create mode 100644 .gitignore create mode 100644 .vscode/extensions.json create mode 100644 Dockerfile create mode 100644 Package.swift create mode 100644 Public/.gitkeep create mode 100644 README.md create mode 100644 Sources/stella/Controllers/.gitkeep create mode 100644 Sources/stella/Controllers/TodoController.swift create mode 100644 Sources/stella/DTOs/TodoDTO.swift create mode 100644 Sources/stella/Migrations/CreateTodo.swift create mode 100644 Sources/stella/Models/Todo.swift create mode 100644 Sources/stella/configure.swift create mode 100644 Sources/stella/entrypoint.swift create mode 100644 Sources/stella/routes.swift create mode 100644 Tests/stellaTests/stellaTests.swift create mode 100644 docker-compose.yml diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..2d9f16e --- /dev/null +++ b/.dockerignore @@ -0,0 +1,2 @@ +.build/ +.swiftpm/ diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..90a6d3f --- /dev/null +++ b/.gitignore @@ -0,0 +1,11 @@ +Packages +.build +xcuserdata +*.xcodeproj +DerivedData/ +.DS_Store +db.sqlite +.swiftpm +.env +.env.* +!.env.example \ No newline at end of file diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 0000000..42783d7 --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,3 @@ +{ + "recommendations": ["swiftlang.swift-vscode", "Vapor.vapor-vscode"] +} \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..6818b19 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,89 @@ +# ================================ +# Build image +# ================================ +FROM swift:6.0-noble 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 the application, 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 \ + --product stella \ + --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)/stella" ./ + +# 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:noble + +# 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 ["./stella"] +CMD ["serve", "--env", "production", "--hostname", "0.0.0.0", "--port", "8080"] diff --git a/Package.swift b/Package.swift new file mode 100644 index 0000000..09e2558 --- /dev/null +++ b/Package.swift @@ -0,0 +1,44 @@ +// swift-tools-version:6.0 +import PackageDescription + +let package = Package( + name: "stella", + platforms: [ + .macOS(.v13) + ], + dependencies: [ + // 💧 A server-side Swift web framework. + .package(url: "https://github.com/vapor/vapor.git", from: "4.110.1"), + // 🗄 An ORM for SQL and NoSQL databases. + .package(url: "https://github.com/vapor/fluent.git", from: "4.9.0"), + // ðŸŠķ Fluent driver for SQLite. + .package(url: "https://github.com/vapor/fluent-sqlite-driver.git", from: "4.6.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: "stella", + dependencies: [ + .product(name: "Fluent", package: "fluent"), + .product(name: "FluentSQLiteDriver", package: "fluent-sqlite-driver"), + .product(name: "Vapor", package: "vapor"), + .product(name: "NIOCore", package: "swift-nio"), + .product(name: "NIOPosix", package: "swift-nio"), + ], + swiftSettings: swiftSettings + ), + .testTarget( + name: "stellaTests", + dependencies: [ + .target(name: "stella"), + .product(name: "VaporTesting", package: "vapor"), + ], + swiftSettings: swiftSettings + ) + ] +) + +var swiftSettings: [SwiftSetting] { [ + .enableUpcomingFeature("ExistentialAny"), +] } diff --git a/Public/.gitkeep b/Public/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/README.md b/README.md new file mode 100644 index 0000000..2341e6c --- /dev/null +++ b/README.md @@ -0,0 +1,27 @@ +# stella + +💧 A project built with the Vapor web framework. + +## Getting Started + +To build the project using the Swift Package Manager, run the following command in the terminal from the root of the project: +```bash +swift build +``` + +To run the project and start the server, use the following command: +```bash +swift run +``` + +To execute tests, use the following command: +```bash +swift test +``` + +### See more + +- [Vapor Website](https://vapor.codes) +- [Vapor Documentation](https://docs.vapor.codes) +- [Vapor GitHub](https://github.com/vapor) +- [Vapor Community](https://github.com/vapor-community) diff --git a/Sources/stella/Controllers/.gitkeep b/Sources/stella/Controllers/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/Sources/stella/Controllers/TodoController.swift b/Sources/stella/Controllers/TodoController.swift new file mode 100644 index 0000000..e1e9204 --- /dev/null +++ b/Sources/stella/Controllers/TodoController.swift @@ -0,0 +1,37 @@ +import Fluent +import Vapor + +struct TodoController: RouteCollection { + func boot(routes: any 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 + } +} diff --git a/Sources/stella/DTOs/TodoDTO.swift b/Sources/stella/DTOs/TodoDTO.swift new file mode 100644 index 0000000..c35ba33 --- /dev/null +++ b/Sources/stella/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 + } +} diff --git a/Sources/stella/Migrations/CreateTodo.swift b/Sources/stella/Migrations/CreateTodo.swift new file mode 100644 index 0000000..7466919 --- /dev/null +++ b/Sources/stella/Migrations/CreateTodo.swift @@ -0,0 +1,14 @@ +import Fluent + +struct CreateTodo: AsyncMigration { + func prepare(on database: any Database) async throws { + try await database.schema("todos") + .id() + .field("title", .string, .required) + .create() + } + + func revert(on database: any Database) async throws { + try await database.schema("todos").delete() + } +} diff --git a/Sources/stella/Models/Todo.swift b/Sources/stella/Models/Todo.swift new file mode 100644 index 0000000..de1837d --- /dev/null +++ b/Sources/stella/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 + ) + } +} diff --git a/Sources/stella/configure.swift b/Sources/stella/configure.swift new file mode 100644 index 0000000..80334f2 --- /dev/null +++ b/Sources/stella/configure.swift @@ -0,0 +1,17 @@ +import NIOSSL +import Fluent +import FluentSQLiteDriver +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.sqlite(.file("db.sqlite")), as: .sqlite) + + app.migrations.add(CreateTodo()) + + // register routes + try routes(app) +} diff --git a/Sources/stella/entrypoint.swift b/Sources/stella/entrypoint.swift new file mode 100644 index 0000000..ad283b4 --- /dev/null +++ b/Sources/stella/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) + try await app.execute() + } catch { + app.logger.report(error: error) + try? await app.asyncShutdown() + throw error + } + try await app.asyncShutdown() + } +} diff --git a/Sources/stella/routes.swift b/Sources/stella/routes.swift new file mode 100644 index 0000000..4f0a094 --- /dev/null +++ b/Sources/stella/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()) +} diff --git a/Tests/stellaTests/stellaTests.swift b/Tests/stellaTests/stellaTests.swift new file mode 100644 index 0000000..a087ac3 --- /dev/null +++ b/Tests/stellaTests/stellaTests.swift @@ -0,0 +1,81 @@ +@testable import stella +import VaporTesting +import Testing +import Fluent + +@Suite("App Tests with DB", .serialized) +struct stellaTests { + 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.autoRevert() + 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.testing().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.testing().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.testing().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]) + }) + } + } + + @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.testing().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 + } +} diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..4a7da74 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,47 @@ +# 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 +# Stop all: docker compose down +# + +x-shared_environment: &shared_environment + LOG_LEVEL: ${LOG_LEVEL:-debug} + +services: + app: + image: stella:latest + build: + context: . + environment: + <<: *shared_environment + 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: stella:latest + build: + context: . + environment: + <<: *shared_environment + command: ["migrate", "--yes"] + deploy: + replicas: 0 + revert: + image: stella:latest + build: + context: . + environment: + <<: *shared_environment + command: ["migrate", "--revert", "--yes"] + deploy: + replicas: 0