Initial project setup - Phases 1-3 complete

ProxyCore/Sources/DataLayer/Repositories/ComposeRepository.swift

@@ -0,0 +1,32 @@
+import Foundation
+import GRDB
+
+public final class ComposeRepository: Sendable {
+    private let db: DatabaseManager
+
+    public init(db: DatabaseManager = .shared) {
+        self.db = db
+    }
+
+    public func observeRequests() -> ValueObservation<ValueReducers.Fetch<[ComposeRequest]>> {
+        ValueObservation.tracking { db in
+            try ComposeRequest.order(Column("createdAt").desc).fetchAll(db)
+        }
+    }
+
+    public func insert(_ request: inout ComposeRequest) throws {
+        try db.dbPool.write { db in try request.insert(db) }
+    }
+
+    public func update(_ request: ComposeRequest) throws {
+        try db.dbPool.write { db in try request.update(db) }
+    }
+
+    public func delete(id: Int64) throws {
+        try db.dbPool.write { db in _ = try ComposeRequest.deleteOne(db, id: id) }
+    }
+
+    public func deleteAll() throws {
+        try db.dbPool.write { db in _ = try ComposeRequest.deleteAll(db) }
+    }
+}

ProxyCore/Sources/DataLayer/Repositories/RulesRepository.swift

@@ -0,0 +1,128 @@
+import Foundation
+import GRDB
+
+public final class RulesRepository: Sendable {
+    private let db: DatabaseManager
+
+    public init(db: DatabaseManager = .shared) {
+        self.db = db
+    }
+
+    // MARK: - SSL Proxying
+
+    public func observeSSLEntries() -> ValueObservation<ValueReducers.Fetch<[SSLProxyingEntry]>> {
+        ValueObservation.tracking { db in
+            try SSLProxyingEntry.order(Column("createdAt").desc).fetchAll(db)
+        }
+    }
+
+    public func fetchAllSSLEntries() throws -> [SSLProxyingEntry] {
+        try db.dbPool.read { db in
+            try SSLProxyingEntry.fetchAll(db)
+        }
+    }
+
+    public func insertSSLEntry(_ entry: inout SSLProxyingEntry) throws {
+        try db.dbPool.write { db in try entry.insert(db) }
+    }
+
+    public func deleteSSLEntry(id: Int64) throws {
+        try db.dbPool.write { db in _ = try SSLProxyingEntry.deleteOne(db, id: id) }
+    }
+
+    public func deleteAllSSLEntries() throws {
+        try db.dbPool.write { db in _ = try SSLProxyingEntry.deleteAll(db) }
+    }
+
+    // MARK: - Block List
+
+    public func observeBlockListEntries() -> ValueObservation<ValueReducers.Fetch<[BlockListEntry]>> {
+        ValueObservation.tracking { db in
+            try BlockListEntry.order(Column("createdAt").desc).fetchAll(db)
+        }
+    }
+
+    public func insertBlockEntry(_ entry: inout BlockListEntry) throws {
+        try db.dbPool.write { db in try entry.insert(db) }
+    }
+
+    public func updateBlockEntry(_ entry: BlockListEntry) throws {
+        try db.dbPool.write { db in try entry.update(db) }
+    }
+
+    public func deleteBlockEntry(id: Int64) throws {
+        try db.dbPool.write { db in _ = try BlockListEntry.deleteOne(db, id: id) }
+    }
+
+    public func deleteAllBlockEntries() throws {
+        try db.dbPool.write { db in _ = try BlockListEntry.deleteAll(db) }
+    }
+
+    // MARK: - Breakpoint Rules
+
+    public func observeBreakpointRules() -> ValueObservation<ValueReducers.Fetch<[BreakpointRule]>> {
+        ValueObservation.tracking { db in
+            try BreakpointRule.order(Column("createdAt").desc).fetchAll(db)
+        }
+    }
+
+    public func insertBreakpointRule(_ rule: inout BreakpointRule) throws {
+        try db.dbPool.write { db in try rule.insert(db) }
+    }
+
+    public func updateBreakpointRule(_ rule: BreakpointRule) throws {
+        try db.dbPool.write { db in try rule.update(db) }
+    }
+
+    public func deleteBreakpointRule(id: Int64) throws {
+        try db.dbPool.write { db in _ = try BreakpointRule.deleteOne(db, id: id) }
+    }
+
+    public func deleteAllBreakpointRules() throws {
+        try db.dbPool.write { db in _ = try BreakpointRule.deleteAll(db) }
+    }
+
+    // MARK: - Map Local Rules
+
+    public func observeMapLocalRules() -> ValueObservation<ValueReducers.Fetch<[MapLocalRule]>> {
+        ValueObservation.tracking { db in
+            try MapLocalRule.order(Column("createdAt").desc).fetchAll(db)
+        }
+    }
+
+    public func insertMapLocalRule(_ rule: inout MapLocalRule) throws {
+        try db.dbPool.write { db in try rule.insert(db) }
+    }
+
+    public func updateMapLocalRule(_ rule: MapLocalRule) throws {
+        try db.dbPool.write { db in try rule.update(db) }
+    }
+
+    public func deleteMapLocalRule(id: Int64) throws {
+        try db.dbPool.write { db in _ = try MapLocalRule.deleteOne(db, id: id) }
+    }
+
+    public func deleteAllMapLocalRules() throws {
+        try db.dbPool.write { db in _ = try MapLocalRule.deleteAll(db) }
+    }
+
+    // MARK: - DNS Spoof Rules
+
+    public func observeDNSSpoofRules() -> ValueObservation<ValueReducers.Fetch<[DNSSpoofRule]>> {
+        ValueObservation.tracking { db in
+            try DNSSpoofRule.order(Column("createdAt").desc).fetchAll(db)
+        }
+    }
+
+    public func insertDNSSpoofRule(_ rule: inout DNSSpoofRule) throws {
+        try db.dbPool.write { db in try rule.insert(db) }
+    }
+
+    public func deleteDNSSpoofRule(id: Int64) throws {
+        try db.dbPool.write { db in _ = try DNSSpoofRule.deleteOne(db, id: id) }
+    }
+
+    public func deleteAllDNSSpoofRules() throws {
+        try db.dbPool.write { db in _ = try DNSSpoofRule.deleteAll(db) }
+    }
+}

ProxyCore/Sources/DataLayer/Repositories/TrafficRepository.swift

@@ -0,0 +1,110 @@
+import Foundation
+import GRDB
+
+public final class TrafficRepository: Sendable {
+    private let db: DatabaseManager
+
+    public init(db: DatabaseManager = .shared) {
+        self.db = db
+    }
+
+    // MARK: - Domain Groups
+
+    public func observeDomainGroups() -> ValueObservation<ValueReducers.Fetch<[DomainGroup]>> {
+        ValueObservation.tracking { db in
+            try DomainGroup.fetchAll(db, sql: """
+                SELECT domain, COUNT(*) as requestCount
+                FROM captured_traffic
+                WHERE isHidden = 0
+                GROUP BY domain
+                ORDER BY MAX(startedAt) DESC
+                """)
+        }
+    }
+
+    // MARK: - Traffic for Domain
+
+    public func observeTraffic(forDomain domain: String) -> ValueObservation<ValueReducers.Fetch<[CapturedTraffic]>> {
+        ValueObservation.tracking { db in
+            try CapturedTraffic
+                .filter(Column("domain") == domain)
+                .filter(Column("isHidden") == false)
+                .order(Column("startedAt").desc)
+                .fetchAll(db)
+        }
+    }
+
+    // MARK: - Pinned
+
+    public func observePinnedTraffic() -> ValueObservation<ValueReducers.Fetch<[CapturedTraffic]>> {
+        ValueObservation.tracking { db in
+            try CapturedTraffic
+                .filter(Column("isPinned") == true)
+                .order(Column("startedAt").desc)
+                .fetchAll(db)
+        }
+    }
+
+    // MARK: - Single Request
+
+    public func traffic(byId id: Int64) throws -> CapturedTraffic? {
+        try db.dbPool.read { db in
+            try CapturedTraffic.fetchOne(db, id: id)
+        }
+    }
+
+    // MARK: - Write Operations
+
+    public func insert(_ traffic: inout CapturedTraffic) throws {
+        try db.dbPool.write { db in
+            try traffic.insert(db)
+        }
+    }
+
+    public func updateResponse(
+        requestId: String,
+        statusCode: Int,
+        statusText: String,
+        responseHeaders: String?,
+        responseBody: Data?,
+        responseBodySize: Int,
+        responseContentType: String?,
+        completedAt: Double,
+        durationMs: Int
+    ) throws {
+        try db.dbPool.write { db in
+            try db.execute(sql: """
+                UPDATE captured_traffic SET
+                    statusCode = ?, statusText = ?,
+                    responseHeaders = ?, responseBody = ?,
+                    responseBodySize = ?, responseContentType = ?,
+                    completedAt = ?, durationMs = ?
+                WHERE requestId = ?
+                """, arguments: [
+                    statusCode, statusText,
+                    responseHeaders, responseBody,
+                    responseBodySize, responseContentType,
+                    completedAt, durationMs,
+                    requestId
+                ])
+        }
+    }
+
+    public func togglePin(id: Int64, isPinned: Bool) throws {
+        try db.dbPool.write { db in
+            try db.execute(sql: "UPDATE captured_traffic SET isPinned = ? WHERE id = ?", arguments: [isPinned, id])
+        }
+    }
+
+    public func deleteAll() throws {
+        try db.dbPool.write { db in
+            _ = try CapturedTraffic.deleteAll(db)
+        }
+    }
+
+    public func deleteForDomain(_ domain: String) throws {
+        try db.dbPool.write { db in
+            _ = try CapturedTraffic.filter(Column("domain") == domain).deleteAll(db)
+        }
+    }
+}