FluentKit 1.0.0 GM (#152)

tanner0101 · gwynne · web-flow · commit 8828d56fe7d9 · 2020-05-29T17:53:51.000-04:00
* fluentkit gm

* Include the new benchmarker suites for this driver's tests

* new tests

* gm update, tests

* cleanup

* macos formatting

* fix macos tests

* env var rename

* update ci config

* env var fixes

* rm nested

* version update

Co-authored-by: Gwynne Raskind &lt;gwynne@darkrainfall.org&gt;
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
@@ -1,61 +1,70 @@
 name: Test Matrix
-on: ['pull_request']
-defaults:
-  run:
-    shell: bash
+on:
+  - pull_request
 jobs:
-  PR-tests-linux:
+  linux:
     strategy:
       fail-fast: false
       matrix:
-        dbimage: ['postgres:11', 'postgres:12']
-        runner: [
-          'swift:5.2-xenial', 'swift:5.2-bionic',
-          'swiftlang/swift:nightly-5.2-xenial', 'swiftlang/swift:nightly-5.2-bionic',
-          'swiftlang/swift:nightly-5.3-xenial', 'swiftlang/swift:nightly-5.3-bionic',
-          'swiftlang/swift:nightly-master-xenial', 'swiftlang/swift:nightly-master-bionic',
-          'swiftlang/swift:nightly-master-focal',
-          'swiftlang/swift:nightly-master-centos8',
-          'swiftlang/swift:nightly-master-amazonlinux2'
-        ]
-        include:
-          - installcmd: 'apt-get -q update && apt-get -q install -y postgresql-client'
-          - { 'runner': 'swiftlang/swift:nightly-master-centos8', 'installcmd': 'dnf install -y zlib-devel postgresql' }
-          - { 'runner': 'swiftlang/swift:nightly-master-amazonlinux2', 'installcmd': 'yum install -y zlib-devel postgresql' }
+        dbimage: 
+          - postgres:11
+          - postgres:12
+        runner:
+          # 5.2 Stable
+          - swift:5.2-xenial
+          - swift:5.2-bionic
+          # 5.2 Unstable
+          - swiftlang/swift:nightly-5.2-xenial
+          - swiftlang/swift:nightly-5.2-bionic
+          # 5.3 Unstable
+          - swiftlang/swift:nightly-5.3-xenial
+          - swiftlang/swift:nightly-5.3-bionic
+          # Master Unsable
+          - swiftlang/swift:nightly-master-xenial
+          - swiftlang/swift:nightly-master-bionic
+          - swiftlang/swift:nightly-master-focal
+          - swiftlang/swift:nightly-master-centos8
+          - swiftlang/swift:nightly-master-amazonlinux2
     container: ${{ matrix.runner }}
     runs-on: ubuntu-latest
     services:
-      postgres:
+      postgres-a:
         image: ${{ matrix.dbimage }}
-        env: { POSTGRES_USER: vapor_username, POSTGRES_PASSWORD: vapor_password, POSTGRES_DB: vapor_database }
-    env: { 'PGPASSWORD': 'vapor_password' }
+        env:
+          POSTGRES_USER: vapor_username
+          POSTGRES_PASSWORD: vapor_password
+          POSTGRES_DB: vapor_database
+      postgres-b:
+        image: ${{ matrix.dbimage }}
+        env:
+          POSTGRES_USER: vapor_username
+          POSTGRES_PASSWORD: vapor_password
+          POSTGRES_DB: vapor_database
     steps:
-      - name: Install dependencies
-        run: ${{ matrix.installcmd }}
-      - name: Wait for Postgres server to be ready
-        run: until echo | psql -hpostgres -Uvapor_username vapor_database; do sleep 1; done
-        timeout-minutes: 5
-      - name: Set up Postgres databases and privileges
-        run: |
-          for db in vapor_migration_extra; do createdb -hpostgres -Uvapor_username -Ovapor_username $db; done
       - name: Check out code
         uses: actions/checkout@v2
       - name: Run tests with Thread Sanitizer
         run: swift test --enable-test-discovery --sanitize=thread
-        env: { 'POSTGRES_HOSTNAME': 'postgres' }
-  PR-tests-macos:
+        env: 
+          POSTGRES_HOSTNAME_A: postgres-a
+          POSTGRES_HOSTNAME_B: postgres-b
+  macos:
     strategy:
       fail-fast: false
       matrix:
         include: 
-          - {'formula': 'postgresql@11', 'datadir': 'postgresql@11'}
-          - {'formula': 'postgresql@12', 'datadir': 'postgres'}
+          - formula: postgresql@11
+            datadir: postgresql@11
+          - formula: postgresql@12
+            datadir: postgres
     runs-on: macos-latest
-    env: { 'PGPASSWORD': 'vapor_password' }
+    env: 
+      PGPASSWORD: vapor_password
     steps:
       - name: Select latest available Xcode
         uses: maxim-lobanov/setup-xcode@1.0
-        with: { 'xcode-version': 'latest' }
+        with:
+          xcode-version: latest
       - name: Blow away the default Postgres installation
         run: brew uninstall --force postgresql php && rm -rf /usr/local/{etc,var}/{postgres,pg}*
       - name: Install Postgres server from Homebrew
@@ -70,10 +79,13 @@ jobs:
       - name: Set up Postgres databases and privileges
         run: |
           createuser --createdb --login vapor_username
-          for db in vapor_{database,migration_extra}; do
+          for db in vapor_{database_a,database_b}; do
             createdb -Ovapor_username $db && psql $db <<<"ALTER SCHEMA public OWNER TO vapor_username;"
           done
       - name: Check out code
         uses: actions/checkout@v2
       - name: Run tests with Thread Sanitizer
         run: swift test --enable-test-discovery --sanitize=thread
+        env: 
+          POSTGRES_DATABASE_A: vapor_database_a
+          POSTGRES_DATABASE_B: vapor_database_b
diff --git a/Package.swift b/Package.swift
@@ -10,7 +10,7 @@ let package = Package(
         .library(name: "FluentPostgresDriver", targets: ["FluentPostgresDriver"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/vapor/fluent-kit.git", from: "1.0.0-rc.1"),
+        .package(url: "https://github.com/vapor/fluent-kit.git", from: "1.0.0-rc.2"),
         .package(url: "https://github.com/vapor/postgres-kit.git", from: "2.0.0"),
     ],
     targets: [
diff --git a/Sources/FluentPostgresDriver/FluentPostgresDatabase.swift b/Sources/FluentPostgresDriver/FluentPostgresDatabase.swift
@@ -3,9 +3,9 @@ import FluentSQL
 struct _FluentPostgresDatabase {
     let database: PostgresDatabase
     let context: DatabaseContext
-
     let encoder: PostgresDataEncoder
     let decoder: PostgresDataDecoder
+    let inTransaction: Bool
 }
 
 extension _FluentPostgresDatabase: Database {
@@ -72,13 +72,17 @@ extension _FluentPostgresDatabase: Database {
     }
 
     func transaction<T>(_ closure: @escaping (Database) -> EventLoopFuture<T>) -> EventLoopFuture<T> {
-        self.database.withConnection { conn in
+        guard !self.inTransaction else {
+            return closure(self)
+        }
+        return self.database.withConnection { conn in
             conn.simpleQuery("BEGIN").flatMap { _ in
                 let db = _FluentPostgresDatabase(
                     database: conn,
                     context: self.context,
                     encoder: self.encoder,
-                    decoder: self.decoder
+                    decoder: self.decoder,
+                    inTransaction: true
                 )
                 return closure(db).flatMap { result in
                     conn.simpleQuery("COMMIT").map { _ in
@@ -95,7 +99,13 @@ extension _FluentPostgresDatabase: Database {
     
     func withConnection<T>(_ closure: @escaping (Database) -> EventLoopFuture<T>) -> EventLoopFuture<T> {
         self.database.withConnection {
-            closure(_FluentPostgresDatabase(database: $0, context: self.context, encoder: self.encoder, decoder: self.decoder))
+            closure(_FluentPostgresDatabase(
+                database: $0,
+                context: self.context,
+                encoder: self.encoder,
+                decoder: self.decoder,
+                inTransaction: self.inTransaction
+            ))
         }
     }
 }
diff --git a/Sources/FluentPostgresDriver/FluentPostgresDriver.swift b/Sources/FluentPostgresDriver/FluentPostgresDriver.swift
@@ -16,7 +16,8 @@ struct _FluentPostgresDriver: DatabaseDriver {
             database: self.pool.pool(for: context.eventLoop).database(logger: context.logger),
             context: context,
             encoder: self.encoder,
-            decoder: self.decoder
+            decoder: self.decoder,
+            inTransaction: false
         )
     }
     
diff --git a/Sources/FluentPostgresDriver/PostgresConverterDelegate.swift b/Sources/FluentPostgresDriver/PostgresConverterDelegate.swift
@@ -23,4 +23,17 @@ struct PostgresConverterDelegate: SQLConverterDelegate {
             return nil
         }
     }
+
+
+    func nestedFieldExpression(_ column: String, _ path: [String]) -> SQLExpression {
+        switch path.count {
+        case 1:
+            return SQLRaw("\(column)->>'\(path[0])'")
+        case 2...:
+            let inner = path[0..<path.count - 1].map { "'\($0)'" }.joined(separator: "->")
+            return SQLRaw("\(column)->\(inner)->>'\(path.last!)'")
+        default:
+            fatalError()
+        }
+    }
 }
diff --git a/Sources/FluentPostgresDriver/PostgresRow+Database.swift b/Sources/FluentPostgresDriver/PostgresRow+Database.swift
@@ -4,48 +4,86 @@ extension PostgresRow {
     internal func databaseOutput(using decoder: PostgresDataDecoder) -> DatabaseOutput {
         _PostgresDatabaseOutput(
             row: self,
-            decoder: decoder,
-            schema: nil
+            decoder: decoder
         )
     }
 }
 
 private struct _PostgresDatabaseOutput: DatabaseOutput {
     let row: PostgresRow
     let decoder: PostgresDataDecoder
-    let schema: String?
 
     var description: String {
         self.row.description
     }
 
-    func contains(_ path: [FieldKey]) -> Bool {
-        return self.row.column(self.columnName(path)) != nil
+    func decodeNil(_ key: FieldKey) throws -> Bool {
+        if let data = self.row.column(self.columnName(key)) {
+            return data.type == .null
+        } else {
+            return true
+        }
+    }
+
+    func contains(_ key: FieldKey) -> Bool {
+        self.row.column(self.columnName(key)) != nil
     }
 
     func schema(_ schema: String) -> DatabaseOutput {
-        _PostgresDatabaseOutput(
-            row: self.row,
-            decoder: self.decoder,
+        _SchemaDatabaseOutput(
+            output: self,
             schema: schema
         )
     }
 
-    func decode<T>(
-        _ path: [FieldKey],
-        as type: T.Type
-    ) throws -> T where T : Decodable {
+    func decode<T>(_ key: FieldKey, as type: T.Type) throws -> T
+        where T: Decodable
+    {
         try self.row.sql(decoder: self.decoder)
-            .decode(column: self.columnName(path), as: T.self)
+            .decode(column: self.columnName(key), as: T.self)
     }
 
-    private func columnName(_ path: [FieldKey]) -> String {
-        let field = path.map { $0.description }.joined(separator: "_")
-        if let schema = self.schema {
-            return "\(schema)_\(field)"
-        } else {
-            return field
+    func columnName(_ key: FieldKey) -> String {
+        switch key {
+        case .id:
+            return "id"
+        case .aggregate:
+            return key.description
+        case .string(let name):
+            return name
+        case .prefix(let prefix, let key):
+            return self.columnName(prefix) + self.columnName(key)
         }
+    }
+}
+
+private struct _SchemaDatabaseOutput: DatabaseOutput {
+    let output: DatabaseOutput
+    let schema: String
+
+    var description: String {
+        self.output.description
+    }
+
+    func schema(_ schema: String) -> DatabaseOutput {
+        self.output.schema(schema)
+    }
+
+    func contains(_ key: FieldKey) -> Bool {
+        self.output.contains(self.key(key))
+    }
+
+    func decodeNil(_ key: FieldKey) throws -> Bool {
+        try self.output.decodeNil(self.key(key))
+    }
+
+    func decode<T>(_ key: FieldKey, as type: T.Type) throws -> T
+        where T: Decodable
+    {
+        try self.output.decode(self.key(key), as: T.self)
+    }
 
+    private func key(_ key: FieldKey) -> FieldKey {
+        .prefix(.string(self.schema + "_"), key)
     }
 }
diff --git a/Tests/FluentPostgresDriverTests/FluentPostgresDriverTests.swift b/Tests/FluentPostgresDriverTests/FluentPostgresDriverTests.swift
diff --git a/docker-compose.yml b/docker-compose.yml

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,8 @@ struct _FluentPostgresDriver: DatabaseDriver {`
`16`	`16`	`database: self.pool.pool(for: context.eventLoop).database(logger: context.logger),`
`17`	`17`	`context: context,`
`18`	`18`	`encoder: self.encoder,`
`19`		`- decoder: self.decoder`
	`19`	`+ decoder: self.decoder,`
	`20`	`+ inTransaction: false`
`20`	`21`	`)`
`21`	`22`	`}`
`22`	`23`
Original file line number	Diff line number	Diff line change
`@@ -23,4 +23,17 @@ struct PostgresConverterDelegate: SQLConverterDelegate {`
`23`	`23`	`return nil`
`24`	`24`	`}`
`25`	`25`	`}`
	`26`	`+`
	`27`	`+`
	`28`	`+ func nestedFieldExpression(_ column: String, _ path: [String]) -> SQLExpression {`
	`29`	`+ switch path.count {`
	`30`	`+ case 1:`
	`31`	`+ return SQLRaw("\(column)->>'\(path[0])'")`
	`32`	`+ case 2...:`
	`33`	`+ let inner = path[0..<path.count - 1].map { "'\($0)'" }.joined(separator: "->")`
	`34`	`+ return SQLRaw("\(column)->\(inner)->>'\(path.last!)'")`
	`35`	`+ default:`
	`36`	`+ fatalError()`
	`37`	`+ }`
	`38`	`+ }`
`26`	`39`	`}`