Daniel D’Aquino
3a0acfaba1
This commit implements a new layer called NostrNetworkManager, responsible for managing interactions with the Nostr network, and providing a higher level API that is easier and more secure to use for the layer above it. It also integrates it with the rest of the app, by moving RelayPool and PostBox into NostrNetworkManager, along with all their usages. Changelog-Added: Added NIP-65 relay list support Changelog-Changed: Improved robustness of relay list handling Signed-off-by: Daniel D’Aquino <daniel@daquino.me>
270 lines
14 KiB
Swift
270 lines
14 KiB
Swift
//
|
|
// DraftsModel.swift
|
|
// damus
|
|
//
|
|
// Created by Terry Yiu on 2/12/23.
|
|
//
|
|
|
|
import Foundation
|
|
import SwiftUICore
|
|
import UIKit
|
|
|
|
/// Represents artifacts in a post draft, which is rendered by `PostView`
|
|
///
|
|
/// ## Implementation notes
|
|
///
|
|
/// - This is NOT `Codable` because we store these persistently as NIP-37 drafts in NostrDB, instead of directly encoding the object.
|
|
/// - `NSMutableAttributedString` is the bottleneck for making this `Codable`, and replacing that with another type requires a very large refactor.
|
|
/// - Encoding/decoding logic is lossy, and is not fully round-trippable. This class does a best effort attempt at encoding and recovering as much information as possible, but the information is dispersed into many different places, types, and functions around the code, making round-trip guarantees very difficult without severely refactoring `PostView`, `TextViewWrapper`, and other associated classes, unfortunately. These are the known limitations at the moment:
|
|
/// - Image metadata is lost on decoding
|
|
/// - The `filtered_pubkeys` filter effectively gets applied upon encoding, causing them to change upon decoding
|
|
///
|
|
class DraftArtifacts: Equatable {
|
|
/// The text content of the note draft
|
|
///
|
|
/// ## Implementation notes
|
|
///
|
|
/// - This serves as the backing model for `PostView` and `TextViewWrapper`. It might be cleaner to use a specialized data model for this in the future and render to attributed string in real time, but that will require a big refactor. See https://github.com/damus-io/damus/issues/1862#issuecomment-2585756932
|
|
var content: NSMutableAttributedString
|
|
/// A list of media items that have been attached to the note draft.
|
|
var media: [UploadedMedia]
|
|
/// The references for this note, which will be translated into tags once the event is published.
|
|
var references: [RefId]
|
|
/// Pubkeys that should be filtered out from the references
|
|
///
|
|
/// For example, when replying to an event, the user can select which pubkey mentions they want to keep, and which ones to remove.
|
|
var filtered_pubkeys: Set<Pubkey> = []
|
|
|
|
/// A unique ID for this draft that allows us to address these if we need to.
|
|
///
|
|
/// This will be the unique identifier in the NIP-37 note
|
|
let id: String
|
|
|
|
init(content: NSMutableAttributedString = NSMutableAttributedString(string: ""), media: [UploadedMedia] = [], references: [RefId], id: String) {
|
|
self.content = content
|
|
self.media = media
|
|
self.references = references
|
|
self.id = id
|
|
}
|
|
|
|
static func == (lhs: DraftArtifacts, rhs: DraftArtifacts) -> Bool {
|
|
return (
|
|
lhs.media == rhs.media &&
|
|
lhs.content.string == rhs.content.string // Comparing the text content is not perfect but acceptable in this case because attributes for our post editor are determined purely from text content
|
|
)
|
|
}
|
|
|
|
|
|
// MARK: Encoding and decoding functions to and from NIP-37 nostr events
|
|
|
|
/// Converts the draft artifacts into a NIP-37 draft event that can be saved into NostrDB or any Nostr relay
|
|
///
|
|
/// - Parameters:
|
|
/// - action: The post action for this draft, which provides necessary context for the draft (e.g. Is it meant to highlight something? Reply to something?)
|
|
/// - damus_state: The damus state, needed for encrypting, fetching Nostr data depedencies, and forming the NIP-37 draft
|
|
/// - references: references in the post?
|
|
/// - Returns: The NIP-37 draft packaged in a way that can be easily wrapped/unwrapped.
|
|
func to_nip37_draft(action: PostAction, damus_state: DamusState) throws -> NIP37Draft? {
|
|
guard let keypair = damus_state.keypair.to_full() else { return nil }
|
|
let post = build_post(state: damus_state, action: action, draft: self)
|
|
guard let note = post.to_event(keypair: keypair) else { return nil }
|
|
return try NIP37Draft(unwrapped_note: note, draft_id: self.id, keypair: keypair)
|
|
}
|
|
|
|
/// Instantiates a draft object from a NIP-37 draft
|
|
/// - Parameters:
|
|
/// - nip37_draft: The NIP-37 draft object
|
|
/// - damus_state: Damus state of the user who wants to load this draft object. Needed for pulling profiles from Ndb, and decrypting contents.
|
|
/// - Returns: A draft artifacts object, or `nil` if such cannot be loaded.
|
|
static func from(nip37_draft: NIP37Draft, damus_state: DamusState) -> DraftArtifacts? {
|
|
return Self.from(
|
|
event: nip37_draft.unwrapped_note,
|
|
draft_id: nip37_draft.id ?? UUID().uuidString, // Generate random UUID as the draft ID if none is specified. It is always better to have an ID that we can use for addressing later.
|
|
damus_state: damus_state
|
|
)
|
|
}
|
|
|
|
/// Load a draft artifacts object from a plain, unwrapped NostrEvent
|
|
///
|
|
/// This function will parse the contents of a Nostr Event and turn it into an editable draft that we can use.
|
|
///
|
|
/// - Parameters:
|
|
/// - event: The Nostr event to use as a template
|
|
/// - draft_id: The unique ID of this draft, used for keeping draft identities stable. UUIDs are recommended but not required.
|
|
/// - damus_state: The user's Damus state, used for fetching profiles in NostrDB
|
|
/// - Returns: The draft that can be loaded into `PostView`.
|
|
static func from(event: NostrEvent, draft_id: String, damus_state: DamusState) -> DraftArtifacts {
|
|
let parsed_blocks = parse_note_content(content: .init(note: event, keypair: damus_state.keypair))
|
|
return Self.from(parsed_blocks: parsed_blocks, references: Array(event.references), draft_id: draft_id, damus_state: damus_state)
|
|
}
|
|
|
|
/// Load a draft artifacts object from parsed Nostr event blocks
|
|
///
|
|
/// - Parameters:
|
|
/// - parsed_blocks: The blocks parsed from a Nostr event
|
|
/// - references: The references in the Nostr event
|
|
/// - draft_id: The unique ID of the draft as per NIP-37
|
|
/// - damus_state: Damus state, used for fetching profile info in NostrDB
|
|
/// - Returns: The draft that can be loaded into `PostView`.
|
|
static func from(parsed_blocks: Blocks, references: [RefId], draft_id: String, damus_state: DamusState) -> DraftArtifacts {
|
|
let rich_text_content: NSMutableAttributedString = .init(string: "")
|
|
var media: [UploadedMedia] = []
|
|
for block in parsed_blocks.blocks {
|
|
switch block {
|
|
case .mention(let mention):
|
|
if case .pubkey(let pubkey) = mention.ref {
|
|
// A profile reference, format things properly.
|
|
let profile = damus_state.ndb.lookup_profile(pubkey)?.unsafeUnownedValue?.profile
|
|
let profile_name = DisplayName(profile: profile, pubkey: pubkey).username
|
|
guard let url_address = URL(string: block.asString) else {
|
|
rich_text_content.append(.init(string: block.asString))
|
|
continue
|
|
}
|
|
let attributed_string = NSMutableAttributedString(
|
|
string: "@\(profile_name)",
|
|
attributes: [
|
|
.link: url_address,
|
|
.foregroundColor: UIColor(Color.accentColor)
|
|
]
|
|
)
|
|
rich_text_content.append(attributed_string)
|
|
}
|
|
else if case .note(_) = mention.ref {
|
|
// These note references occur when we quote a note, and since that is tracked via `PostAction` in `PostView`, ignore it here to avoid attaching the same event twice in a note
|
|
continue
|
|
}
|
|
else {
|
|
// Other references
|
|
rich_text_content.append(.init(string: block.asString))
|
|
}
|
|
case .url(let url):
|
|
if isSupportedImage(url: url) {
|
|
// Image, add that to our media attachments
|
|
// TODO: Add metadata decoding support
|
|
media.append(UploadedMedia(localURL: url, uploadedURL: url, metadata: .none))
|
|
continue
|
|
}
|
|
else {
|
|
// Normal URL, plain text
|
|
rich_text_content.append(.init(string: block.asString))
|
|
}
|
|
case .invoice(_), .relay(_), .hashtag(_), .text(_):
|
|
// Everything else is currently plain text.
|
|
rich_text_content.append(.init(string: block.asString))
|
|
}
|
|
}
|
|
return DraftArtifacts(content: rich_text_content, media: media, references: references, id: draft_id)
|
|
}
|
|
}
|
|
|
|
|
|
/// Holds and keeps track of the note post drafts throughout the app.
|
|
class Drafts: ObservableObject {
|
|
@Published var post: DraftArtifacts? = nil
|
|
@Published var replies: [NoteId: DraftArtifacts] = [:]
|
|
@Published var quotes: [NoteId: DraftArtifacts] = [:]
|
|
/// The drafts we have for highlights
|
|
///
|
|
/// ## Implementation notes
|
|
/// - Although in practice we also load drafts based on the highlight source for better UX (making it easier to find a draft), we need the keys to be of type `HighlightContentDraft` because we need the selected text information to be able to construct the NIP-37 draft, as well as to load that into post view.
|
|
@Published var highlights: [HighlightContentDraft: DraftArtifacts] = [:]
|
|
|
|
/// Loads drafts from storage (NostrDB + UserDefaults)
|
|
func load(from damus_state: DamusState) {
|
|
guard let note_ids = damus_state.settings.draft_event_ids?.compactMap({ NoteId(hex: $0) }) else { return }
|
|
for note_id in note_ids {
|
|
let txn = damus_state.ndb.lookup_note(note_id)
|
|
guard let note = txn?.unsafeUnownedValue else { continue }
|
|
// Implementation note: This currently fails silently, because:
|
|
// 1. Errors are unlikely and not expected
|
|
// 2. It is not mission critical to recover from this error
|
|
// 3. The changes that add a error view sheet with useful info is not yet merged in as of writing.
|
|
try? self.load(wrapped_draft_note: note, with: damus_state)
|
|
}
|
|
}
|
|
|
|
/// Loads a specific NIP-37 note into this class
|
|
func load(wrapped_draft_note: NdbNote, with damus_state: DamusState) throws {
|
|
// Extract draft info from the NIP-37 note
|
|
guard let full_keypair = damus_state.keypair.to_full() else { return }
|
|
guard let nip37_draft = try NIP37Draft(wrapped_note: wrapped_draft_note, keypair: full_keypair) else { return }
|
|
guard let known_kind = nip37_draft.unwrapped_note.known_kind else { return }
|
|
guard let draft_artifacts = DraftArtifacts.from(
|
|
nip37_draft: nip37_draft,
|
|
damus_state: damus_state
|
|
) else { return }
|
|
|
|
// Find out where to place these drafts
|
|
let blocks = parse_note_content(content: .note(nip37_draft.unwrapped_note))
|
|
switch known_kind {
|
|
case .text:
|
|
if let replied_to_note_id = nip37_draft.unwrapped_note.direct_replies() {
|
|
self.replies[replied_to_note_id] = draft_artifacts
|
|
}
|
|
else {
|
|
for block in blocks.blocks {
|
|
if case .mention(let mention) = block {
|
|
if case .note(let note_id) = mention.ref {
|
|
self.quotes[note_id] = draft_artifacts
|
|
return
|
|
}
|
|
}
|
|
}
|
|
self.post = draft_artifacts
|
|
}
|
|
case .highlight:
|
|
guard let highlight = HighlightContentDraft(from: nip37_draft.unwrapped_note) else { return }
|
|
self.highlights[highlight] = draft_artifacts
|
|
default:
|
|
return
|
|
}
|
|
}
|
|
|
|
/// Saves the drafts tracked by this class persistently using NostrDB + UserDefaults
|
|
func save(damus_state: DamusState) {
|
|
var draft_events: [NdbNote] = []
|
|
post_artifact_block: if let post_artifacts = self.post {
|
|
let nip37_draft = try? post_artifacts.to_nip37_draft(action: .posting(.user(damus_state.pubkey)), damus_state: damus_state)
|
|
guard let wrapped_note = nip37_draft?.wrapped_note else { break post_artifact_block }
|
|
draft_events.append(wrapped_note)
|
|
}
|
|
for (replied_to_note_id, reply_artifacts) in self.replies {
|
|
guard let replied_to_note = damus_state.ndb.lookup_note(replied_to_note_id)?.unsafeUnownedValue?.to_owned() else { continue }
|
|
let nip37_draft = try? reply_artifacts.to_nip37_draft(action: .replying_to(replied_to_note), damus_state: damus_state)
|
|
guard let wrapped_note = nip37_draft?.wrapped_note else { continue }
|
|
draft_events.append(wrapped_note)
|
|
}
|
|
for (quoted_note_id, quote_note_artifacts) in self.quotes {
|
|
guard let quoted_note = damus_state.ndb.lookup_note(quoted_note_id)?.unsafeUnownedValue?.to_owned() else { continue }
|
|
let nip37_draft = try? quote_note_artifacts.to_nip37_draft(action: .quoting(quoted_note), damus_state: damus_state)
|
|
guard let wrapped_note = nip37_draft?.wrapped_note else { continue }
|
|
draft_events.append(wrapped_note)
|
|
}
|
|
for (highlight, highlight_note_artifacts) in self.highlights {
|
|
let nip37_draft = try? highlight_note_artifacts.to_nip37_draft(action: .highlighting(highlight), damus_state: damus_state)
|
|
guard let wrapped_note = nip37_draft?.wrapped_note else { continue }
|
|
draft_events.append(wrapped_note)
|
|
}
|
|
|
|
for draft_event in draft_events {
|
|
// Implementation note: We do not support draft synchronization with relays yet.
|
|
// TODO: Once it is time to implement draft syncing with relays, please consider the following:
|
|
// - Privacy: Sending drafts to the network leaks metadata about app activity, and may break user expectations
|
|
// - Down-sync conflict resolution: Consider how to solve conflicts for different draft versions holding the same ID (e.g. edited in Damus, then another client, then Damus again)
|
|
damus_state.nostrNetwork.pool.send_raw_to_local_ndb(.typical(.event(draft_event)))
|
|
}
|
|
|
|
damus_state.settings.draft_event_ids = draft_events.map({ $0.id.hex() })
|
|
}
|
|
}
|
|
|
|
// MARK: - Convenience extensions
|
|
|
|
fileprivate extension Array {
|
|
mutating func appendIfNotNil(_ element: Element?) {
|
|
if let element = element {
|
|
self.append(element)
|
|
}
|
|
}
|
|
}
|