Add Modern Clean Architecture

Author: sergdort

.DS_Store

@@ -0,0 +1,70 @@
+### macOS ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### Xcode ###
+# Xcode
+#
+# gitignore contributors: remember to update Global/Xcode.gitignore, Objective-C.gitignore & Swift.gitignore
+
+## User settings
+xcuserdata/
+
+## compatibility with Xcode 8 and earlier (ignoring not required starting Xcode 9)
+*.xcscmblueprint
+*.xccheckout
+
+## compatibility with Xcode 3 and earlier (ignoring not required starting Xcode 4)
+build/
+DerivedData/
+*.moved-aside
+*.pbxuser
+!default.pbxuser
+*.mode1v3
+!default.mode1v3
+*.mode2v3
+!default.mode2v3
+*.perspectivev3
+!default.perspectivev3
+
+### Xcode Patch ###
+*.xcodeproj/*
+!*.xcodeproj/project.pbxproj
+!*.xcodeproj/xcshareddata/
+!*.xcworkspace/contents.xcworkspacedata
+/*.gcno
+
+### Projects ###
+*.xcodeproj
+*.xcworkspace
+
+### Tuist derived files ###
+graph.dot
+Derived/
+
+### Tuist managed dependencies ###
+Tuist/.build

.gitignore

@@ -0,0 +1,2 @@
+[tools]
+tuist = "4.16.1"

.mise.toml

@@ -0,0 +1,15 @@
+{
+  "originHash" : "cb9339b11ed9d7d2ecad83323078648becec11b51488c8702396ac0d9ffb1283",
+  "pins" : [
+    {
+      "identity" : "swift-syntax",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/apple/swift-syntax.git",
+      "state" : {
+        "revision" : "0687f71944021d616d34d922343dcef086855920",
+        "version" : "600.0.1"
+      }
+    }
+  ],
+  "version" : 3
+}

.package.resolved

@@ -0,0 +1,30 @@
+import Apollo
+import ApolloAPI
+import Foundation
+import Combine
+
+public extension ApolloClient {
+    func fetch<Query: GraphQLQuery>(query: Query) async throws -> Query.Data {
+        let holder = CancellableHolder()
+        return try await withTaskCancellationHandler {
+            try await withCheckedThrowingContinuation { continuation in
+                holder.value = self.fetch(query: query) { result in
+                    switch result {
+                    case .success(let gqlResutl):
+                        if let data = gqlResutl.data {
+                            continuation.resume(returning: data)
+                        } else if let error = gqlResutl.errors?.first {
+                            continuation.resume(throwing: error)
+                        } else {
+                            continuation.resume(throwing: NoDataError())
+                        }
+                    case .failure(let error):
+                        continuation.resume(throwing: error)
+                    }
+                }
+            }
+        } onCancel: {
+            holder.cancel()
+        }
+    }
+}

Projects/Core/ApolloExtensions/ApolloClient+Extensions.swift

@@ -0,0 +1,22 @@
+import Foundation
+import Apollo
+
+final class CancellableHolder: @unchecked Sendable {
+    private var lock = NSRecursiveLock()
+    private var innerCancellable: Cancellable?
+
+    private func synced<Result>(_ action: () throws -> Result) rethrows -> Result {
+        lock.lock()
+        defer { lock.unlock() }
+        return try action()
+    }
+
+    var value: Cancellable? {
+        get { synced { innerCancellable } }
+        set { synced { innerCancellable = newValue } }
+    }
+
+    func cancel() {
+        synced { innerCancellable?.cancel() }
+    }
+}

Projects/Core/ApolloExtensions/CancellableHolder.swift

@@ -0,0 +1,4 @@
+
+public struct NoDataError: Error {
+    public init() {}
+}

Projects/Core/ApolloExtensions/NoDataError.swift

@@ -0,0 +1,9 @@
+import SwiftCompilerPlugin
+import SwiftSyntaxMacros
+
+@main
+struct Plugin: CompilerPlugin {
+    let providingMacros: [Macro.Type] = [
+        InvertedDependency.self
+    ]
+}

Projects/Core/DependenciesMacro/InvertedDependencyMacro.swift

@@ -0,0 +1,69 @@
+import SwiftSyntax
+import SwiftSyntaxMacros
+import SwiftDiagnostics
+
+public struct InvertedDependency: Macro {
+    public func expand(
+        declaration: DeclSyntax,
+        context: MacroExpansionContext
+    ) throws -> DeclSyntax {
+        guard let protocolDecl = declaration.as(ProtocolDeclSyntax.self) else {
+            throw DependencyKeyMacroErrors.shouldBeAttachedToAProtocol
+        }
+        
+        // Retrieve the protocol name
+        let protocolName = protocolDecl.name.text
+
+        // Generate the dependency key enum and unimplemented struct
+        let enumCode = """
+        enum \(protocolName)DependencyKey: TestDependencyKey {
+            struct Unimplemented: \(protocolName) {
+                \(protocolDecl.memberBlock.members.compactMap { member -> String? in
+                    guard let funcDecl = member.decl.as(FunctionDeclSyntax.self) else { return nil }
+                    let funcName = funcDecl.name.text
+                    let returnType = funcDecl.signature.returnClause?.description ?? ""
+                    let isThrowing = funcDecl.signature.effectSpecifiers?.throwsClause != nil
+                    let throwsAttribute = isThrowing ? "throws" : ""
+                    return "func \(funcName)\(funcDecl.signature.parameterClause) \(throwsAttribute)\(returnType) { unimplemented(#function) }"
+                }
+                .joined(separator: "\n"))
+            }
+        
+            static var testValue: \(protocolName) {
+                Unimplemented()
+            }
+        }
+        """
+
+        // Generate the DependencyValues extension
+        let extensionCode = """
+        public extension DependencyValues {
+            var \(protocolName.firstLowercased()): \(protocolName) {
+                get { self[\(protocolName)DependencyKey.self] }
+                set { self[\(protocolName)DependencyKey.self] = newValue }
+            }
+        }
+        """
+
+        return DeclSyntax(stringLiteral: "\(enumCode)\n\n\(extensionCode)")
+    }
+}
+
+fileprivate extension String {
+    /// Returns the string with the first character lowercased, for naming conventions.
+    func firstLowercased() -> String {
+        return prefix(1).lowercased() + dropFirst()
+    }
+}
+
+struct TextMessage: DiagnosticMessage {
+    var message: String
+    
+    var diagnosticID: SwiftDiagnostics.MessageID
+    
+    var severity: SwiftDiagnostics.DiagnosticSeverity
+}
+
+enum DependencyKeyMacroErrors: Error {
+    case shouldBeAttachedToAProtocol
+}

Projects/Core/DependenciesMacros/InvertedDependency.swift

@@ -0,0 +1,9 @@
+import SwiftCompilerPlugin
+import SwiftSyntaxMacros
+
+@main
+struct Plugin: CompilerPlugin {
+    let providingMacros: [Macro.Type] = [
+        InvertedDependency.self
+    ]
+}

Projects/Core/DependenciesMacros/Plugin.swift

@@ -0,0 +1,63 @@
+import Foundation
+
+public final class FileCache {
+  private let fileManager = FileManager.default
+  private let directory: String
+
+  public init(name: String) {
+    self.directory = "\(Bundle.main.bundleIdentifier ?? "")/" + (name.hasPrefix("/") ? String(name.dropFirst()) : name)
+  }
+
+  public func loadFile(path: String) throws -> Data {
+    let fileURL = directoryURL.appendingPathComponent(path)
+    return try Data(contentsOf: fileURL)
+  }
+
+  public func persist(data: Data, path: String) throws {
+    let path = path.hasPrefix("/") ? String(path.dropFirst()) : path
+    try createDirectoryIfNeeded()
+    let fileURL = directoryURL.appendingPathComponent(path)
+    let fileDirectoryURL = fileURL.deletingLastPathComponent()
+    try createDirectoryIfNeeded(for: fileDirectoryURL)
+
+    if fileManager.fileExists(atPath: fileURL.path) {
+      try fileManager.removeItem(at: fileURL)
+    }
+
+    try data.write(to: fileURL, options: .atomic)
+  }
+  
+  public func exists(atPath path: String) -> Bool {
+    let fileURL = directoryURL.appendingPathComponent(path)
+    return fileManager.fileExists(atPath: fileURL.path)
+  }
+
+  public func persist<T: Encodable>(item: T, encoder: JSONEncoder, path: String) throws {
+    let data = try encoder.encode(item)
+    try persist(data: data, path: path)
+  }
+
+  private func createDirectoryIfNeeded() throws {
+    if fileManager.fileExists(atPath: directoryURL.path) == false {
+      try fileManager.createDirectory(
+        at: directoryURL,
+        withIntermediateDirectories: true,
+        attributes: nil
+      )
+    }
+  }
+
+  private func createDirectoryIfNeeded(for url: URL) throws {
+    if fileManager.fileExists(atPath: url.path) == false {
+      try fileManager.createDirectory(at: url, withIntermediateDirectories: true, attributes: nil)
+    }
+  }
+
+  private var directoryURL: URL {
+    cacheDirectory().appendingPathComponent(directory)
+  }
+
+  private func cacheDirectory() -> URL {
+    return fileManager.urls(for: .cachesDirectory, in: .userDomainMask)[0]
+  }
+}

Projects/Core/FileCache/FileCache.swift

@@ -0,0 +1,80 @@
+import Foundation
+
+public protocol DataFetching {
+    func fetch(resource: Resource) async throws -> Data
+}
+
+public final class HTTPClient: DataFetching {
+    private let session: URLSessionProtocol
+    private let environment: Environment
+    private let urlComponentsInterceptor: URLComponentsInterceptor
+    
+    public init(
+        session: URLSessionProtocol = URLSession.shared,
+        environment: Environment,
+        urlComponentsInterceptor: URLComponentsInterceptor
+    ) {
+        self.session = session
+        self.environment = environment
+        self.urlComponentsInterceptor = urlComponentsInterceptor
+    }
+    
+    public func fetch(resource: Resource) async throws -> Data {
+        let request = request(for: resource)
+        
+        do {
+            let (data, response) = try await session.data(for: request)
+            
+            guard let httpResponse = response as? HTTPURLResponse, (200 ... 299).contains(httpResponse.statusCode) else {
+                throw NetworkError.invalidResponse
+            }
+            
+            return data
+        } catch let error as URLError where error.code == .notConnectedToInternet {
+            throw NetworkError.notConnectedToInternet
+        } catch let error as URLError where error.code == .cancelled {
+            throw NetworkError.cancelled
+        } catch let error as NetworkError {
+            throw error
+        } catch {
+            throw NetworkError.networkError(error)
+        }
+    }
+    
+    private func request(for resource: Resource) -> URLRequest {
+        var components = URLComponents()
+        
+        components.scheme = environment.schema
+        components.host = environment.host
+        components.path = "/" + environment.version + resource.path
+        components.queryItems = resource.query.map { key, value in URLQueryItem(name: key, value: value) }
+        
+        urlComponentsInterceptor.modify(components: &components)
+        
+        var request = URLRequest(url: components.url!)
+        request.httpMethod = resource.method.rawValue
+        
+        return request
+    }
+}
+
+public enum NetworkError: Error {
+    case networkError(Error)
+    case invalidResponse
+    case cancelled
+    case notConnectedToInternet
+}
+
+public extension HTTPClient {
+    struct Environment {
+        let schema: String
+        let host: String
+        let version: String
+        
+        public init(schema: String, host: String, version: String) {
+            self.schema = schema
+            self.host = host
+            self.version = version
+        }
+    }
+}

Projects/Core/HTTPClient/HTTPClient.swift

@@ -0,0 +1,5 @@
+public enum HTTPMethod: String {
+    case GET
+    case POST
+    case DELETE
+}