Storage Module

// 1. Define schema with all models
let schema = Schema([
    Conversation.self,
    Message.self,
    Settings.self
])

// 2. Create persistent container
let modelConfiguration = ModelConfiguration(
    schema: schema,
    isStoredInMemoryOnly: false  // Persists to disk
)

self.modelContainer = try ModelContainer(
    for: schema,
    configurations: [modelConfiguration]
)

// 3. Create repositories (not exposed directly to Views)
let mainContext = modelContainer.mainContext

self.conversationRepository = ConversationRepositoryImpl(
    modelContext: mainContext
)
self.messageRepository = MessageRepositoryImpl(
    modelContext: mainContext
)
self.settingsRepository = SettingsRepositoryImpl(
    modelContext: mainContext
)

// 4. Keychain for secure token storage
self.keychainStore = KeychainStore(accessGroup: nil)

// Protocol (public API)
public protocol ConversationRepository: Sendable {
    func create(title: String, personaName: String?) async throws -> ConversationDTO
    func rename(id: UUID, title: String) async throws
    func delete(id: UUID) async throws
    func list(limit: Int, after: Date?) async throws -> [ConversationDTO]
}

// DTO (lightweight, Sendable)
public struct ConversationDTO: Identifiable, Sendable, Equatable {
    public let id: UUID
    public let title: String
    public let personaName: String?
    public let createdAt: Date
    public let updatedAt: Date
}

// Implementation (internal)
@MainActor
final class ConversationRepositoryImpl: ConversationRepository {
    private let modelContext: ModelContext
    
    // Uses SwiftData internally, returns DTOs
    // Full error handling and logging
    // Tested comprehensively
}

// From actual code - secure token storage
let keychain = KeychainStore(accessGroup: nil)

// Save (used by Auth module for tokens)
try keychain.setString(accessToken, for: KeychainStore.Keys.authAccessToken)
try keychain.setString(refreshToken, for: KeychainStore.Keys.authRefreshToken)

// Retrieve (used by AuthInterceptor for requests)
let token = try? keychain.getString(KeychainStore.Keys.authAccessToken)

// Delete (on sign out)
try? keychain.delete(KeychainStore.Keys.authAccessToken)

// Standard keys (pre-defined)
KeychainStore.Keys.authAccessToken     // "auth_access_token"
KeychainStore.Keys.authRefreshToken    // "auth_refresh_token"

// 1. Create model
@Model
class SavedPrompt {
    @Attribute(.unique) var id: UUID
    var title: String
    var content: String
    var category: String?
    var createdAt: Date
}

// 2. Add DTO
struct SavedPromptDTO: Identifiable, Sendable {
    let id: UUID
    let title: String
    let content: String
    let category: String?
    
    init(_ model: SavedPrompt) {
        self.id = model.id
        self.title = model.title
        self.content = model.content
        self.category = model.category
    }
}

// 3. Create repository
protocol SavedPromptRepository: Sendable {
    func create(title: String, content: String) async throws -> SavedPromptDTO
    func list() async throws -> [SavedPromptDTO]
    func delete(id: UUID) async throws
}

// 4. Add to schema in CompositionRoot
let schema = Schema([
    Conversation.self,
    Message.self,
    Settings.self,
    SavedPrompt.self  // Add this
])