Corvus alternatives and similar libraries
Based on the "Webserver" category.
Alternatively, view Corvus alternatives based on common mentions on social networks and blogs.
-
Perfect
Server-side Swift. The Perfect core toolset and framework for Swift Developers. (For mobile back-end development, website and API development, and more…) -
Swifton
A Ruby on Rails inspired Web Framework for Swift that runs on Linux and OS X -
Zewo
Lightweight library for web server applications in Swift on macOS and Linux powered by coroutines. -
Express
Swift Express is a simple, yet unopinionated web application server written in Swift -
Embassy
Super lightweight async HTTP server library in pure Swift runs in iOS / MacOS / Linux -
XcodeServerSDK
Access Xcode Server API with native Swift objects. -
Restofire
Restofire is a protocol oriented networking client for Alamofire -
Edge
A Swift Multiplatform Single-threaded Non-blocking Web and Networking Framework -
NetworkObjects
Swift backend / server framework (Pure Swift, Supports Linux) -
RxNetworks
🧚 Responsive plugin network architecture for RxSwift + Moya + HandyJSON + Plugins. -
SwiftyHTTP
A simple GCD based HTTP client and server, written in 'pure' Swift -
Dynamo
High Performance (nearly)100% Swift Web server supporting dynamic content. -
Swift-Server
A very basic proof-of-concept Swift HTTP server that does not require Foundation
Appwrite - The Open Source Firebase alternative introduces iOS support
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of Corvus or a related project?
Popular Comparisons
README
Corvus
Corvus is the first truly declarative server-side framework for Swift. It provides a declarative, composable syntax which makes it easy to get APIs up and running. It is based heavily on the existing work from Vapor.
Example
Below is an example of a full-featured API that manages Bank Accounts and Transactions belonging to certain users. It also showcases the ease of using authentication and setting authorization rules for specific routes.
let xpenseApi = Api("api") {
User<CorvusUser>("users")
Login<CorvusToken>("login")
BearerAuthGroup<CorvusToken> {
AccountsEndpoint()
TransactionsEndpoint()
}
}
Because Corvus is composable, it is easy to use a group of components as its own component:
final class AccountsEndpoint: Endpoint {
let parameter = Parameter<Account>()
var content: Endpoint {
Group("accounts") {
Create<Account>().auth(\.$user)
ReadAll<Account>().auth(\.$user)
Group(parameter.id) {
ReadOne<Account>(parameter.id).auth(\.$user)
Update<Account>(parameter.id).auth(\.$user)
Delete<Account>(parameter.id).auth(\.$user)
}
}
}
}
How to set up
After your Swift Project, in the Package.Swift
file, you will need to add the dependencies
for Corvus
and a Fluent
database driver of your choice. Below is an example with an
SQLite
driver:
// swift-tools-version:5.2
import PackageDescription
let package = Package(
name: "XpenseServer",
platforms: [
.macOS(.v10_15)
],
products: [
.library(name: "XpenseServer", targets: ["XpenseServer"])
],
dependencies: [
.package(url: "https://github.com/Apodini/corvus.git", from: "0.0.14"),
.package(url: "https://github.com/vapor/vapor.git", from: "4.0.0"),
.package(url: "https://github.com/vapor/fluent-sqlite-driver.git", from: "4.0.0-rc")
],
targets: [
.target(name: "Run",
dependencies: [
.target(name: "XpenseServer")
]),
.target(name: "XpenseServer",
dependencies: [
.product(name: "Corvus", package: "corvus"),
.product(name: "FluentSQLiteDriver", package: "fluent-sqlite-driver")
]),
.testTarget(name: "XpenseServerTests",
dependencies: [
.target(name: "XpenseServer"),
.product(name: "XCTVapor", package: "vapor"),
.product(name: "FluentSQLiteDriver", package: "fluent-sqlite-driver")
])
]
)
Additionally, under the application's Source
folder (by default that is Sources/App
), two setup functions need to be present:
configure.swift
, in which you can configure middlewares, databases and migrations used
in the application:
import Corvus
import Vapor
import FluentSQLiteDriver
public func configure(_ app: Application) throws {
app.middleware.use(CorvusUser.authenticator())
app.middleware.use(CorvusToken.authenticator())
app.databases.use(.sqlite(.file("db.sqlite")), as: .sqlite)
app.migrations.add(CreateAccount())
app.migrations.add(CreateTransaction())
app.migrations.add(CreateCorvusUser())
app.migrations.add(CreateCorvusToken())
try app.autoMigrate().wait()
}
And routes.swift
, which registers the routes from the Corvus
API:
import Corvus
import Vapor
public func routes(_ app: Application) throws {
try app.register(collection: xpenseApi)
}
Finally the application's main.swift
file (which is usually under the path Sources/Run
) should look like this:
import App
import Vapor
var environment = try Environment.detect()
try LoggingSystem.bootstrap(from: &environment)
let app = Application(environment)
try configure(app)
try routes(app)
defer {
app.shutdown()
}
try app.run()
How to use
In general, there are two types of building blocks for a Corvus
API: Group components, which
allow users to group more groups or concrete endpoints under a common route path, or
components that provide concrete functionality, like Create
or ReadAll
. Check out the
docs and the example project to learn more!
How to contribute
Review our contribution guidelines for contribution formalities.
Sources
The logo: Made by Freepik
*Note that all licence references and agreements mentioned in the Corvus README section above
are relevant to that project's source code only.