Vapor Web Framework

Vapor is a web framework written in Swift that runs on iOS, macOS, and Ubuntu. It provides a clear, easy-to-use API for building websites and backend services.

The ecosystem is composed of several core modules and specialized packages that can be used independently or integrated into a Vapor application via Providers.

SQL (vapor/sql) is a Swift library designed for building and serializing SQL queries. It uses an extensible, protocol-based design and supports:

• DQL (Data Query Language)
• DML (Data Manipulation Language)
• DDL (Data Definition Language)

Note for Fluent users: If you are using Vapor's Fluent ORM, you will typically not need to build SQL queries manually, as Fluent handles these operations for you.

The SQL library is an extensible, protocol-based tool for building and serializing SQL queries in Swift. It integrates with Codable and uses parameter binding for security and performance.

It supports standard SQL operations including:

• Data manipulation: SELECT, INSERT, UPDATE, DELETE.
• Schema management: CREATE TABLE, ALTER TABLE, DROP TABLE, CREATE INDEX, DROP INDEX.

Vapor is a web framework written in Swift that runs on iOS, macOS, and Ubuntu. It provides a clear and easy-to-use API for building websites and backend services.

Key features of the core Vapor framework include:

• Auth: Authentication and persistence control.
• Sessions: Secure, transient data storage built on the cookie mechanism.
• Cookies: HTTP cookie management.
• Routing: Type-safe path parameter definition.

If you need help, want to discuss Vapor, or want to explore the source code, use the following resources:

• Discord: Chat with the Vapor developer community at vapor.team.
• API Documentation: Access auto-generated documentation from code comments at api.vapor.codes.
• Stack Overflow: Ask or answer questions using the vapor tag on Stack Overflow.
• Swift Forums: Participate in the Vapor section of the Swift.org forums.
• GitHub Repository: View the source code or report bugs and request features via GitHub Issues.

If you need assistance, additional information, or want to contribute, use the following resources:

The Responder is a protocol that defines how an object handles an incoming Request and produces a Response. In Vapor, the Droplet conforms to Responder, which allows it to be connected to a Server. While most users interact with the Droplet directly, understanding the Responder protocol is useful for manual server configuration or implementing custom request-handling logic.

public protocol Responder {
    func respond(to request: Request) throws -> Response
}

A Droplet is the central service container in Vapor. It manages the application lifecycle, including registering routes, appending middleware, and starting the server. While most applications use a single Droplet instance, advanced use cases allow for creating multiple instances.

import Vapor

let drop = try Droplet()
// your magic here
try drop.run()

Service is a dependency injection (inversion of control) framework. It allows you to register, configure, and create application dependencies in a maintainable way.

To use it, you first register a concrete implementation against a protocol or type during the application boot process. Later, you can resolve and create that dependency using a container by requesting the registered type.

/// register a service during boot
services.register(PrintLogger.self, as: Logger.self)

/// you can then create that service later
let logger = try someContainer.make(Logger.self)
print(logger is PrintLogger) // true