Fixing concurrency crash with translation of index based pagination

Sources/GraphZahl/Resolution/OutputResolvable/Implementations/Connection/IndexConnectionWrapper.swift

@@ -2,8 +2,28 @@
 import Foundation
 import NIO
 
+private let lock = Lock()
 private var translators: [ConnectionIdentifier : IndexCursorTranslator] = [:]
 
+private func withTranslator<T>(for connectionIdentifier: ConnectionIdentifier,
+                               using type: IndexCursorTranslator.Type,
+                               perform: (inout IndexCursorTranslator) throws -> T) rethrows -> T {
+
+    return try lock.withLock {
+        return try perform(&translators[connectionIdentifier, default: type.init()])
+    }
+}
+
+private func withTranslator<T>(for connectionIdentifier: ConnectionIdentifier,
+                               using type: IndexCursorTranslator.Type,
+                               perform: (IndexCursorTranslator) throws -> T) rethrows -> T {
+
+    let translator = lock.withLock {
+        return translators[connectionIdentifier, default: type.init()]
+    }
+    return try perform(translator)
+}
+
 private struct ConnectionIdentifier: Hashable {
     let type: Int
     let connection: AnyHashable
@@ -32,11 +52,15 @@ struct IndexedConnectionWrapper<Connection: IndexedConnection>: ContextBasedConn
     }
 
     private func cursor(for index: Int) throws -> String {
-        return try translators[identifier, default: Connection.Translator()].cursor(for: index)
+        return try withTranslator(for: identifier, using: Connection.Translator.self) { translator in
+            return try translator.cursor(for: index)
+        }
     }
 
     private func index(for cursor: String) throws -> Int {
-        return try translators[identifier, default: Connection.Translator()].index(for: cursor)
+        return try withTranslator(for: identifier, using: Connection.Translator.self) { translator in
+            return try translator.index(for: cursor)
+        }
     }
 
     func context(first: Int?, after: String?, last: Int?, before: String?, eventLoop: EventLoopGroup) -> EventLoopFuture<Context> {

Sources/GraphZahl/Utils/Lock.swift

@@ -0,0 +1,39 @@
+#if os(Linux)
+    import Glibc
+#else
+    import Darwin.C
+#endif
+
+final class Lock {
+    private var mutex = pthread_mutex_t()
+
+    init() {
+        let result = pthread_mutex_init(&mutex, nil)
+
+        guard result == 0 else {
+            fatalError("Failed to initialize Lock: \(result)")
+        }
+    }
+
+    deinit {
+        pthread_mutex_destroy(&mutex)
+    }
+
+    func withLock<T>(_ closure: () throws -> (T)) rethrows -> T {
+        acquire()
+        defer { release() }
+        return try closure()
+    }
+
+    func acquire() {
+        let result = pthread_mutex_lock(&mutex)
+
+        guard result == 0 else {
+            fatalError("Failed to aquire Lock: \(result)")
+        }
+    }
+
+    func release() {
+        pthread_mutex_unlock(&mutex)
+    }
+}