0.5.0

.github/workflows/test.yml

@@ -1,35 +1,34 @@
 name: Swift
 
 on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-  workflow_dispatch:
+    push:
+        branches: [main]
+    pull_request:
+        branches: [main]
+    workflow_dispatch:
 
 jobs:
-  test-macos:
-    if: ${{ false }}  # disable until macOS 12 (with concurrency) runners are available.
-    runs-on: macos-12
-    env:
-      DEVELOPER_DIR: /Applications/Xcode_13.2.app/Contents/Developer
-    steps:
-    - uses: actions/checkout@v2
-    - name: Build
-      run: swift build -v
-    - name: Run tests
-      run: swift test -v
-  test-linux:
-    runs-on: ubuntu-20.04
-    strategy:
-      matrix:
-        swift: [5.5]
-    container: swift:${{ matrix.swift }}
-    steps:
-    - uses: actions/checkout@v2
-    - name: Install sqlite
-      run: apt-get -q update && apt-get install -y libsqlite3-dev
-    - name: Build
-      run: swift build -v --enable-test-discovery
-    - name: Run tests
-      run: swift test -v --enable-test-discovery
+    test-macos:
+        runs-on: macos-13
+        env:
+            DEVELOPER_DIR: /Applications/Xcode_14.3.app/Contents/Developer
+        steps:
+            - uses: actions/checkout@v3
+            - name: Build
+              run: swift build -v
+            - name: Run tests
+              run: swift test -v
+    test-linux:
+        runs-on: ubuntu-22.04
+        strategy:
+            matrix:
+                swift: [5.8]
+        container: swift:${{ matrix.swift }}
+        steps:
+            - uses: actions/checkout@v3
+            - name: Install sqlite
+              run: apt-get -q update && apt-get install -y libsqlite3-dev
+            - name: Build
+              run: swift build -v --enable-test-discovery
+            - name: Run tests
+              run: swift test -v --enable-test-discovery

Example/App.swift

@@ -0,0 +1,47 @@
+import Alchemy
+
+@main
+struct App: Application {
+    func boot() {
+        get("/stream", options: .stream) { req in
+            Response {
+                try await $0.write("foo")
+                try await $0.write("bar")
+                try await $0.write("baz")
+            }
+        }
+
+        post("user") {
+            try await DB.table("users").insert($0.content)
+        }
+
+        get("success") { _ in
+
+        }
+
+        get("bad") { _ -> Void in
+            throw HTTPError(.badRequest)
+        }
+
+        get("fail") { _ -> Void in
+            throw HTTPError(.internalServerError)
+        }
+
+        get("shutdown") { _ in
+            Task {
+                try await stop()
+            }
+        }
+    }
+
+    func schedule(on schedule: Scheduler) {
+        schedule.job(GoJob())
+            .everySecond()
+    }
+}
+
+struct GoJob: Job, Codable {
+    func handle(context: JobContext) async throws {
+        Log.warning("Hello from GoJob!")
+    }
+}

Example/Commands/Debug.swift

@@ -0,0 +1,234 @@
+import Alchemy
+import RediStack
+
+struct UserDTO: Codable {
+    let id: Int
+    let name: String
+    let age: Int
+}
+
+enum Thing: String {
+    case one
+    case two
+}
+
+struct Debug: Command {
+    static let name = "debug"
+
+    func run() async throws {
+        //
+    }
+
+    func testRelationships() {
+//        let user = try await User.query()
+//            .with(\.posts.comments.likes)
+//            .with {
+//                $0.posts.with {
+//                    $0.comments.with {
+//                        $0.likes
+//                    }
+//                }
+//            }
+//            .with(\.tokens)
+//            .where("id" == "user_1")
+//            .first()!
+//
+//        let posts = try await user.posts()
+//        let comments = try await posts[0].comments()
+//        _ = try await comments[0].likes()
+//        _ = try await user.posts.comments.likes()
+//        let _comments: [Comment] = try await user.posts.comments.get()
+//        let _likes: [Like] = try await user.posts.comments.likes.get()
+//        let _likes1: [Like] = try await user.posts.comments.likes1.get()
+//        let _comments: [Comment] = try await user.posts.comments.get()
+//        let _comments1: [Comment] = try await user.posts.comments1.get()
+//        let posts = try await user.posts()
+//        let tokens = try await user.tokens()
+//        let throughTokens = try await posts.first!.tokens()
+//        let comments = try await user.comments()
+//        let friends = try await user.friends()
+//        let likes = try await user.likes()
+//        let owner = try await likes.first!.postOwner()
+    }
+}
+
+extension Alchemy.RedisClient {
+    static var testing: Alchemy.RedisClient {
+        .configuration(RedisConnectionPool.Configuration(
+            initialServerConnectionAddresses: [
+                try! .makeAddressResolvingHost("localhost", port: 6379)
+            ],
+            maximumConnectionCount: .maximumActiveConnections(1),
+            connectionFactoryConfiguration: RedisConnectionPool.ConnectionFactoryConfiguration(connectionDefaultLogger: Log),
+            connectionRetryTimeout: .milliseconds(100)
+        ))
+    }
+
+    func checkAvailable() async -> Bool {
+        do {
+            _ = try await ping().get()
+            return true
+        } catch {
+            return false
+        }
+    }
+}
+
+
+struct User: Model, Codable, KeyPathQueryable {
+    static var storedProperties = [
+        \Self.id: "id",
+        \Self.name: "name",
+        \Self.age: "age",
+        \Self.pet: "pet",
+    ]
+
+    var id: PK<Int> = .new
+    var name: String
+    var age: Int
+    var pet: String?
+
+    var tokens: HasMany<UserToken> {
+        hasMany()
+    }
+
+    var posts: HasMany<Post> {
+        hasMany()
+    }
+
+    var comments: HasManyThrough<Comment> {
+        hasMany().through("posts")
+    }
+
+    var likes: HasManyThrough<Like> {
+        hasMany().through("posts").through("comments")
+    }
+
+    var friends: BelongsToMany<User> {
+        belongsToMany(pivot: "friends", pivotFrom: "user_a", pivotTo: "user_b")
+    }
+}
+
+struct UserToken: Model, Codable {
+    var id: PK<String> = .new
+    let token: String
+    let userId: String
+
+    var user: BelongsTo<User> {
+        belongsTo()
+    }
+}
+
+struct Post: Model, Codable {
+    var id: PK<String> = .new
+    let title: String
+    let userId: String
+
+    var comments: HasMany<Comment> {
+        hasMany()
+    }
+
+    var comments1: HasOne<Comment?> {
+        hasOne()
+    }
+
+    var tokens: HasManyThrough<UserToken> {
+        hasMany(from: "user_id").through("users", from: "id")
+    }
+}
+
+struct Comment: Model, Codable {
+    var id: PK<String> = .new
+    let text: String
+    let userId: String
+
+    var post: BelongsTo<Post> {
+        belongsTo()
+    }
+
+    var likes: HasMany<Like> {
+        hasMany()
+    }
+
+    var likes1: HasOne<Like> {
+        hasOne()
+    }
+
+    var postOwner: BelongsToThrough<User> {
+        belongsTo().through("posts")
+    }
+}
+
+struct Like: Model, Codable {
+    var id: PK<String> = .new
+    let commentId: String
+    let userId: String
+
+    var postOwner: BelongsToThrough<User> {
+        belongsTo().through("comments").through("posts")
+    }
+}
+
+struct AddStuffMigration: Migration {
+    func up(db: Database) async throws {
+        try await db.createTable("users") {
+            $0.increments("id").primary()
+            $0.string("name")
+            $0.int("age")
+        }
+
+        try await db.createTable("posts") {
+            $0.increments("id").primary()
+            $0.bigInt("user_id").references("id", on: "users").notNull()
+            $0.string("title")
+        }
+
+        try await db.createTable("user_tokens") {
+            $0.increments("id").primary()
+            $0.bigInt("user_id").references("id", on: "users").notNull()
+            $0.string("token")
+        }
+    }
+
+    func down(db: Database) async throws {
+        try await db.dropTable("posts")
+        try await db.dropTable("user_tokens")
+        try await db.dropTable("users")
+    }
+}
+
+struct AddStuff2Migration: Migration {
+    func up(db: Database) async throws {
+        try await db.createTable("friends") {
+            $0.increments("id").primary()
+            $0.bigInt("user_a").references("id", on: "users").notNull()
+            $0.bigInt("user_b").references("id", on: "users").notNull()
+        }
+
+        try await db.createTable("comments") {
+            $0.increments("id").primary()
+            $0.bigInt("post_id").references("id", on: "posts").notNull()
+            $0.bigInt("user_id").references("id", on: "users").notNull()
+            $0.string("text")
+        }
+    }
+
+    func down(db: Database) async throws {
+        try await db.dropTable("friends")
+        try await db.dropTable("comments")
+    }
+}
+
+struct AddStuff3Migration: Migration {
+    func up(db: Database) async throws {
+        try await db.createTable("likes") {
+            $0.increments("id").primary()
+            $0.bigInt("comment_id").references("id", on: "comments").notNull()
+            $0.bigInt("user_id").references("id", on: "users").notNull()
+        }
+    }
+
+    func down(db: Database) async throws {
+        try await db.dropTable("likes")
+    }
+}

Example/Configs/App+Caches.swift

@@ -0,0 +1,22 @@
+import Alchemy
+
+extension Application {
+
+    /// Configurations related to your app's caches.
+
+    var caches: Caches {
+        Caches(
+
+            /// Your app's default Cache
+
+            default: "database",
+
+            /// Define your caches here
+
+            caches: [
+                "database": .database,
+                "redis": .redis,
+            ]
+        )
+    }
+}

Example/Configs/App+Config.swift

@@ -0,0 +1,23 @@
+import Alchemy
+
+extension App {
+
+    /// Configurations related to your app.
+
+    var configuration: Configuration {
+        Configuration(
+
+            // Define plugins your app uses here.
+
+            plugins: [
+                //
+            ],
+
+            // Define any custom commands here.
+
+            commands: [
+                Debug.self
+            ]
+        )
+    }
+}