fix: move card favourite star to bottom-right so it no longer overlaps the overflow button (v0.3.3.4)
build / Assemble debug APK (push) Failing after 9s

This commit is contained in:
Incido Developer committed 2026-08-17 12:59:10 +12:00
1 parent 5b82d2a9fe
commit 089926377c
44 files changed
+5490 -140

No files matched your search

+4
View File
@@ -55,4 +55,8 @@ dependencies {
// ObjectBox runtime
implementation(libs.objectbox.android)
implementation(libs.objectbox.kotlin)
// v0.3.1.2 — EXIF orientation tag handling for image attachments
// (see NoteRepositoryImpl.normalizeImageOrientation).
implementation(libs.androidx.exifinterface)
}
@@ -7,12 +7,31 @@ import org.incido.data.entity.MyObjectBox
/**
* Singleton holder for the process-wide [BoxStore]. Initialised once from
* the Application/Activity context.
*
* v0.3.2.0 — kept an `encryptionKey` parameter for forward compatibility,
* but the open-source ObjectBox 4.0.3 distribution doesn't expose a
* public `encryptionKey(byte[])` method on [io.objectbox.BoxStoreBuilder].
* At-rest encryption is only available in ObjectBox Sync / Pro; the
* `:composeApp` `ObjectBoxKeyProvider` keeps the wrapping logic
* ready for when the API becomes available (or for migration to the
* commercial build). For now the store always opens unencrypted.
*/
object ObjectBoxStore {
@Volatile
private var instance: BoxStore? = null
fun init(context: Context): BoxStore =
/**
* Initialise the singleton [BoxStore]. Idempotent — repeated calls
* return the existing instance.
*
* @param context application context
* @param encryptionKey reserved for future at-rest encryption support
* (currently a no-op — ObjectBox 4.0.3 OSS doesn't expose the
* API). The key is wrapped via Android Keystore by
* `ObjectBoxKeyProvider` and ready to plug in.
*/
@Suppress("UNUSED_PARAMETER")
fun init(context: Context, encryptionKey: ByteArray? = null): BoxStore =
instance ?: synchronized(this) {
instance ?: MyObjectBox.builder()
.androidContext(context.applicationContext)
@@ -20,6 +39,17 @@ object ObjectBoxStore {
.also { instance = it }
}
/**
* Close + drop the singleton. Reserved for future use when
* toggling encryption requires re-opening the store with a new key.
*/
fun reset() {
synchronized(this) {
instance?.close()
instance = null
}
}
fun get(): BoxStore =
instance ?: error("ObjectBoxStore not initialised — call init(context) first")
}
@@ -0,0 +1,53 @@
package org.incido.data.entity
import io.objectbox.annotation.Entity
import io.objectbox.annotation.Id
import io.objectbox.annotation.Index
import org.incido.domain.model.NoteAttachment
/**
* v0.3.1.0 — One uploaded file (photo, document, etc.) attached to a
* note. File **bytes** live directly in the database (ObjectBox
* stores `ByteArray` columns natively) so the entire note + its
* attachments are backed up and restored as a single unit, with no
* filesystem paths to keep in sync.
*
* [bytes] is intentionally NOT part of [NoteAttachment] in the
* domain layer — list snapshots stay cheap because they don't load
* the (potentially large) blob. Callers fetch bytes on demand via
* [org.incido.domain.repository.NoteRepository.getAttachmentBytes].
*/
@Entity
data class NoteAttachmentEntity(
@Id var id: Long = 0,
@Index var noteId: Long = 0,
var mimeType: String = "",
var displayName: String = "",
var createdAt: Long = 0,
var sizeBytes: Long = 0,
var bytes: ByteArray = ByteArray(0),
)
internal fun NoteAttachmentEntity.toDomain(): NoteAttachment = NoteAttachment(
id = id,
noteId = noteId,
mimeType = mimeType,
displayName = displayName,
createdAt = createdAt,
sizeBytes = sizeBytes,
)
/**
* Inverse mapper from the domain layer — used when the editor or
* the share-into flow persists a freshly-imported attachment. The
* [id] field is left at 0L so ObjectBox assigns a fresh id on put.
*/
internal fun NoteAttachment.toEntity(): NoteAttachmentEntity = NoteAttachmentEntity(
id = 0L,
noteId = noteId,
mimeType = mimeType,
displayName = displayName,
createdAt = createdAt,
sizeBytes = sizeBytes,
bytes = ByteArray(0), // never serialised from the domain — bytes are set explicitly in the impl
)
@@ -1,16 +1,26 @@
package org.incido.data.repository
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.graphics.Matrix
import androidx.exifinterface.media.ExifInterface
import io.objectbox.BoxStore
import io.objectbox.kotlin.boxFor
import io.objectbox.query.QueryBuilder
import io.objectbox.reactive.DataSubscription
import java.io.ByteArrayInputStream
import java.io.ByteArrayOutputStream
import java.util.concurrent.Callable
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.callbackFlow
import kotlinx.coroutines.flow.flowOn
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import org.incido.data.entity.HashtagEntity
import org.incido.data.entity.HashtagEntity_
import org.incido.data.entity.NoteAttachmentEntity
import org.incido.data.entity.NoteAttachmentEntity_
import org.incido.data.entity.NoteEntity
import org.incido.data.entity.NoteEntity_
import org.incido.data.entity.NoteHashtagCrossRef
@@ -20,6 +30,7 @@ import org.incido.data.entity.toEntity
import org.incido.domain.model.Hashtag
import org.incido.domain.model.HashtagUsage
import org.incido.domain.model.Note
import org.incido.domain.model.NoteAttachment
import org.incido.domain.repository.NoteRepository
/**
@@ -42,6 +53,8 @@ class NoteRepositoryImpl(
private val noteBox = boxStore.boxFor<NoteEntity>()
private val tagBox = boxStore.boxFor<HashtagEntity>()
private val xrefBox = boxStore.boxFor<NoteHashtagCrossRef>()
/** v0.3.1.0 — attachment rows (bytes stored inline as ByteArray). */
private val attachmentBox = boxStore.boxFor<NoteAttachmentEntity>()
// ---------------------------------------------------------------------
// List / observation streams
@@ -77,17 +90,42 @@ class NoteRepositoryImpl(
awaitClose { sub.cancel() }
}.flowOn(Dispatchers.Default)
override fun observeHashtagsByRecentUse(): Flow<List<HashtagUsage>> = callbackFlow {
// ObjectBox fires its observer with the full current query state
// immediately on subscribe, so the observer alone is the source
// of truth — no manual trySend that would race the subscription
// and double the work of the snapshot.
val sub = noteBox.query().build().subscribe().observer { _ ->
trySend(hashtagUsageSnapshot())
}
override fun searchFavorites(query: String): Flow<List<Note>> = callbackFlow {
trySend(snapshotFavoritesSearch(query))
val sub = noteBox.query().build().subscribe().observer { trySend(snapshotFavoritesSearch(query)) }
awaitClose { sub.cancel() }
}.flowOn(Dispatchers.Default)
override fun searchUntagged(query: String): Flow<List<Note>> = callbackFlow {
trySend(snapshotUntaggedSearch(query))
val sub = noteBox.query().build().subscribe().observer { trySend(snapshotUntaggedSearch(query)) }
awaitClose { sub.cancel() }
}.flowOn(Dispatchers.Default)
override fun observeHashtagsByRecentUse(): Flow<List<HashtagUsage>> = callbackFlow {
// The snapshot reads from noteBox + xrefBox + tagBox, so we must
// subscribe to ALL three — otherwise a change that only touches
// tagBox (new hashtag) or xrefBox (new cross-ref) is missed.
// The first observer fire from any of the three gives us the
// initial snapshot, so no manual pre-subscribe trySend is needed.
// We hold the Query objects (not the Subscription handles) so we
// can release the underlying native handle when the flow ends.
// In ObjectBox 4.0.3 `Query<T>` implements `java.io.Closeable`
// — the way to tear it down is `.close()`, not `.cancel()`.
val noteQuery = noteBox.query().build()
val tagQuery = tagBox.query().build()
val xrefQuery = xrefBox.query().build()
val emit: (Any) -> Unit = { _ -> trySend(hashtagUsageSnapshot()) }
noteQuery.subscribe().observer(emit)
tagQuery.subscribe().observer(emit)
xrefQuery.subscribe().observer(emit)
awaitClose {
noteQuery.close()
tagQuery.close()
xrefQuery.close()
}
}.flowOn(Dispatchers.Default)
override fun observeAllHashtags(): Flow<List<String>> = callbackFlow {
trySend(allHashtagsSnapshot().sorted())
val sub = noteBox.query().build().subscribe().observer {
@@ -110,6 +148,83 @@ class NoteRepositoryImpl(
awaitClose { sub.cancel() }
}.flowOn(Dispatchers.Default)
override fun observeAttachments(noteId: Long): Flow<List<NoteAttachment>> = callbackFlow {
trySend(attachmentsByNoteId()[noteId].orEmpty())
val query = attachmentBox.query()
.equal(NoteAttachmentEntity_.noteId, noteId)
.build()
query.subscribe().observer { trySend(attachmentsByNoteId()[noteId].orEmpty()) }
awaitClose { query.close() }
}.flowOn(Dispatchers.Default)
override suspend fun getAttachmentBytes(id: Long): ByteArray? {
return attachmentBox.get(id)?.bytes
}
override suspend fun addAttachment(
noteId: Long,
bytes: ByteArray,
mimeType: String,
displayName: String,
): Long {
// v0.3.1.2 — honour the EXIF Orientation tag on inbound images
// (camera intent usually writes landscape pixels + an EXIF
// rotation). Done at storage time so every render path
// (editor thumbnail, card thumbnail, full-screen viewer) sees
// the photo the right way up. Non-images pass through unchanged.
val storedBytes: ByteArray = if (mimeType.startsWith("image/")) {
withContext(Dispatchers.IO) { normalizeImageOrientation(bytes) }
} else {
bytes
}
val entity = NoteAttachmentEntity(
noteId = noteId,
mimeType = mimeType,
displayName = displayName,
createdAt = System.currentTimeMillis(),
sizeBytes = storedBytes.size.toLong(),
bytes = storedBytes,
)
return attachmentBox.put(entity)
}
/**
* v0.3.1.2 — rotate [bytes] to match the EXIF Orientation tag, then
* re-encode as JPEG so the stored bytes have no orientation flag
* (downstream renderers — editor thumbnail, card thumbnail, viewer
* — all decode raw pixels without honouring EXIF, so we bake the
* rotation into the bitmap at storage time). Returns the input
* unchanged when the orientation is normal, the bitmap can't be
* decoded, or the rotation fails for any reason.
*/
private fun normalizeImageOrientation(bytes: ByteArray): ByteArray {
val bmp = BitmapFactory.decodeByteArray(bytes, 0, bytes.size) ?: return bytes
val angle = ExifInterface(ByteArrayInputStream(bytes))
.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)
.let {
when (it) {
ExifInterface.ORIENTATION_ROTATE_90 -> 90f
ExifInterface.ORIENTATION_ROTATE_180 -> 180f
ExifInterface.ORIENTATION_ROTATE_270 -> 270f
else -> 0f
}
}
if (angle == 0f) return bytes
val matrix = Matrix().apply { postRotate(angle) }
val rotated = Bitmap.createBitmap(bmp, 0, 0, bmp.width, bmp.height, matrix, true)
bmp.recycle()
val out = ByteArrayOutputStream().use { baos ->
rotated.compress(Bitmap.CompressFormat.JPEG, 92, baos)
rotated.recycle()
baos.toByteArray()
}
return out
}
override suspend fun removeAttachment(id: Long) {
attachmentBox.remove(id)
}
// ---------------------------------------------------------------------
// Writes
// ---------------------------------------------------------------------
@@ -134,6 +249,14 @@ class NoteRepositoryImpl(
if (orphanXrefs.isNotEmpty()) {
xrefBox.remove(*orphanXrefs.map { it.id }.toLongArray())
}
// v0.3.1.0: cascade to attachments so we don't leak blobs.
val orphanAttachments: List<NoteAttachmentEntity> = attachmentBox.query()
.equal(NoteAttachmentEntity_.noteId, id)
.build()
.find()
if (orphanAttachments.isNotEmpty()) {
attachmentBox.remove(*orphanAttachments.map { it.id }.toLongArray())
}
}
override suspend fun setFavorite(id: Long, isFavorite: Boolean) {
@@ -143,7 +266,53 @@ class NoteRepositoryImpl(
noteBox.put(entity)
}
/**
* Persist [note] and reconcile its hashtag set inside a single
* ObjectBox transaction. See [NoteRepository.saveNoteWithHashtags]
* for why atomicity matters (drawer Recent-Tags refresh bug fixed
* in v0.3.0.5).
*/
override suspend fun saveNoteWithHashtags(
note: Note,
hashtagsToAdd: Set<String>,
hashtagsToRemove: Set<String>,
): Note {
val now = System.currentTimeMillis()
val toPersist = if (note.id == 0L) {
note.copy(createdAt = now, updatedAt = now).toEntity()
} else {
note.copy(updatedAt = now).toEntity()
}
// callInTx batches all puts into one transaction, so the per-box
// observers subscribed by observeHashtagsByRecentUse fire ONCE at
// commit time with the final committed state. Without this, the
// tagBox observer could fire between the tagBox.put and the
// xrefBox.put, leaving the snapshot stuck on emptyList().
return boxStore.callInTx(Callable {
val assignedId = noteBox.put(toPersist)
val saved = noteBox.get(assignedId)?.toDomain()
?: note.copy(id = assignedId)
hashtagsToRemove.forEach { removeHashtagInternal(saved.id, it) }
hashtagsToAdd.forEach { addHashtagInternal(saved.id, it) }
saved
})
}
override suspend fun addHashtag(noteId: Long, name: String) {
addHashtagInternal(noteId, name)
}
override suspend fun removeHashtag(noteId: Long, name: String) {
removeHashtagInternal(noteId, name)
}
/**
* Synchronous helper so the implementation can call it from inside
* `boxStore.callInTx { ... }` (which expects a non-suspending
* Callable). The public [addHashtag] / [removeHashtag] methods also
* delegate here for a single source of truth.
*/
private fun addHashtagInternal(noteId: Long, name: String) {
val normalised = Hashtag.normalise(name)
if (!normalised.matches(Regex("^[a-z0-9][a-z0-9._-]{0,30}$"))) return
@@ -169,7 +338,7 @@ class NoteRepositoryImpl(
xrefBox.put(NoteHashtagCrossRef(noteId = noteId, hashtagId = tag.id))
}
override suspend fun removeHashtag(noteId: Long, name: String) {
private fun removeHashtagInternal(noteId: Long, name: String) {
val normalised = Hashtag.normalise(name)
val tag: HashtagEntity = tagBox.query()
.equal(HashtagEntity_.name, normalised, QueryBuilder.StringOrder.CASE_INSENSITIVE)
@@ -202,14 +371,34 @@ class NoteRepositoryImpl(
}
}
/**
* v0.3.1.0 — same shape as [hashtagsByNoteId], but for attachments.
* Returns `noteId -> List<NoteAttachment>` (metadata only — no bytes)
* sorted by [NoteAttachment.createdAt] ascending. Used by
* [decorate] to populate `Note.attachments` for list / search
* snapshots without touching the blob column.
*/
private fun attachmentsByNoteId(): Map<Long, List<NoteAttachment>> {
val all: List<NoteAttachmentEntity> = attachmentBox.all
if (all.isEmpty()) return emptyMap()
return all
.map { it.toDomain() }
.groupBy { it.noteId }
.mapValues { (_, rows) -> rows.sortedBy { it.createdAt } }
}
private fun decorate(entities: List<NoteEntity>): List<Note> {
val tags = hashtagsByNoteId()
val attachments = attachmentsByNoteId()
return entities.sortedWith(
compareByDescending<NoteEntity> { it.isFavorite }
.thenByDescending { it.updatedAt }
).map { e ->
val base = e.toDomain()
base.copy(hashtags = tags[e.id].orEmpty())
base.copy(
hashtags = tags[e.id].orEmpty(),
attachments = attachments[e.id].orEmpty(),
)
}
}
@@ -259,6 +448,71 @@ class NoteRepositoryImpl(
return decorate(untaggedEntities)
}
/**
* Context-aware search across favourites only. Blank [query]
* degrades to [snapshotFavorites]. Otherwise runs the same
* content + hashtag-name matching as [snapshotSearch] and
* intersects with `isFavorite = true`.
*/
private fun snapshotFavoritesSearch(query: String): List<Note> {
val q = query.trim()
if (q.isEmpty()) return snapshotFavorites()
val allIds: Set<Long> = snapshotSearchMatchingNoteIds(q)
if (allIds.isEmpty()) return emptyList()
val entities: List<NoteEntity> = allIds.mapNotNull { id -> noteBox.get(id) }
.filter { it.isFavorite }
return decorate(entities)
}
/**
* Context-aware search across untagged notes only. Blank [query]
* degrades to [snapshotUntagged]. Otherwise runs the content
* matching from [snapshotSearch] and intersects with notes that
* have zero hashtags (tag matching is irrelevant for untagged).
*/
private fun snapshotUntaggedSearch(query: String): List<Note> {
val q = query.trim()
if (q.isEmpty()) return snapshotUntagged()
val noteIdsWithTags: Set<Long> = xrefBox.all.mapTo(HashSet(xrefBox.all.size)) { it.noteId }
val contentMatches: List<Long> = noteBox.query()
.contains(NoteEntity_.content, q, QueryBuilder.StringOrder.CASE_INSENSITIVE)
.build()
.find()
.map { it.id }
val matching: List<NoteEntity> = contentMatches
.mapNotNull { id -> noteBox.get(id) }
.filter { it.id !in noteIdsWithTags }
return decorate(matching)
}
/**
* Shared content + tag-name matcher used by [snapshotSearch] and
* [snapshotFavoritesSearch]. Returns the set of matching note ids.
*/
private fun snapshotSearchMatchingNoteIds(query: String): Set<Long> {
// Match against content (contains, case-insensitive).
val contentMatches: List<Long> = noteBox.query()
.contains(NoteEntity_.content, query, QueryBuilder.StringOrder.CASE_INSENSITIVE)
.build()
.find()
.map { it.id }
// Match against hashtag names (case-insensitive exact equality).
val matchingTag: HashtagEntity? = tagBox.query()
.equal(HashtagEntity_.name, query, QueryBuilder.StringOrder.CASE_INSENSITIVE)
.build()
.findFirst()
val tagMatches: List<Long> = if (matchingTag == null) emptyList() else {
xrefBox.query()
.equal(NoteHashtagCrossRef_.hashtagId, matchingTag.id)
.build()
.find()
.map { it.noteId }
}
return (contentMatches + tagMatches).toSet()
}
private fun snapshotForHashtag(name: String): List<Note> {
val normalised = Hashtag.normalise(name)
val tag: HashtagEntity = tagBox.query()
@@ -278,7 +532,11 @@ class NoteRepositoryImpl(
private fun noteByIdSnapshot(id: Long): Note? {
val entity = noteBox.get(id) ?: return null
val tags = hashtagsByNoteId()[id].orEmpty()
return entity.toDomain().copy(hashtags = tags)
val attachments = attachmentsByNoteId()[id].orEmpty()
return entity.toDomain().copy(
hashtags = tags,
attachments = attachments,
)
}
/** Build [HashtagUsage] for every distinct tag, sorted by lastUsedAt DESC. */
@@ -14,7 +14,18 @@ data class Note(
val color: NoteColor = NoteColor.NONE,
/** Tags attached to this note (normalised lowercase, sorted ascending). */
val hashtags: List<String> = emptyList(),
/**
* v0.3.1.0 — files attached to this note (photo / document / etc).
* Metadata only; bytes are loaded on demand via
* [org.incido.domain.repository.NoteRepository.getAttachmentBytes].
* Sorted by [NoteAttachment.createdAt] ascending (oldest first)
* so the UI can render them in stable order.
*/
val attachments: List<NoteAttachment> = emptyList(),
) {
/** Convenience: the first image attachment, or `null` if none. */
val firstImageAttachment: NoteAttachment?
get() = attachments.firstOrNull { it.isImage }
companion object {
private const val UNTITLED = "Untitled"
@@ -0,0 +1,27 @@
package org.incido.domain.model
/**
* v0.3.1.0 — Metadata for a single file attached to a note.
*
* **Bytes are not part of this model.** They're stored in the
* database alongside the metadata row (see
* `NoteAttachmentEntity.bytes`) and loaded on demand via
* `NoteRepository.getAttachmentBytes(id)`. Keeping bytes out of the
* domain list payload means list snapshots stay cheap even for
* notes with many large attachments.
*/
data class NoteAttachment(
val id: Long,
val noteId: Long,
/** e.g. `image/jpeg`, `application/pdf`, `text/plain`. */
val mimeType: String,
/** User-visible filename (or generated name like `IMG_20260815.jpg`). */
val displayName: String,
/** Epoch millis, for stable ordering. */
val createdAt: Long,
/** Cached size in bytes — cheap to read; lets the UI show file sizes without loading bytes. */
val sizeBytes: Long,
) {
/** Convenience: true for any image-prefixed mime type. */
val isImage: Boolean get() = mimeType.startsWith("image/")
}
@@ -3,6 +3,7 @@ package org.incido.domain.repository
import kotlinx.coroutines.flow.Flow
import org.incido.domain.model.HashtagUsage
import org.incido.domain.model.Note
import org.incido.domain.model.NoteAttachment
/**
* Persistence boundary for [Note]s. The UI layer depends on this interface
@@ -43,6 +44,22 @@ interface NoteRepository {
/** Only notes that have zero hashtags, sorted by updatedAt DESC. */
fun observeUntagged(): Flow<List<Note>>
/**
* Context-aware search across **favourites only** — matches
* [Note.content] (contains, case-insensitive) AND any of the note's
* hashtags (case-insensitive equality), sorted by favourites first
* then newest-first. Blank [query] returns the same as
* [observeFavorites].
*/
fun searchFavorites(query: String): Flow<List<Note>>
/**
* Context-aware search across **untagged notes only** — matches
* [Note.content] (contains, case-insensitive), sorted newest-first.
* Blank [query] returns the same as [observeUntagged].
*/
fun searchUntagged(query: String): Flow<List<Note>>
/** Only notes tagged with [name] (normalised form), sorted by updatedAt DESC. */
fun observeNotesForHashtag(name: String): Flow<List<Note>>
@@ -81,4 +98,61 @@ interface NoteRepository {
* auto-deleted (cleanup is the future "tag browser" feature).
*/
suspend fun removeHashtag(noteId: Long, name: String)
/**
* Persist [note] and reconcile its hashtag set in a single database
* transaction: insert [hashtagsToAdd] (creating backing rows for any
* new tag names) and remove [hashtagsToRemove].
*
* Atomicity matters: the implementation wraps the upsert and the
* hashtag writes in a single store transaction so the observers
* subscribed by [observeHashtagsByRecentUse] fire **once** at commit
* time with the final state. Without that, three separate puts in
* sequence (noteBox, then tagBox, then cross-refBox) caused the
* drawer's hashtag-usage snapshot to read a transient empty
* cross-ref box and leave `emptyList()` stuck in the StateFlow —
* the new tag would only appear after some unrelated noteBox
* mutation (e.g. toggling the favourite star). See v0.3.0.5.
*
* Returns the persisted [Note] (with its assigned id when [note] was
* new). [hashtagsToAdd] / [hashtagsToRemove] should be in their
* normalised form (lowercase, no leading `#`, already validated).
*/
suspend fun saveNoteWithHashtags(
note: Note,
hashtagsToAdd: Set<String>,
hashtagsToRemove: Set<String>,
): Note
// --- Attachments (v0.3.1.0) ---
/**
* Stream of attachments (metadata only, no bytes) belonging to
* [noteId], sorted by [NoteAttachment.createdAt] ascending. Emits
* a fresh list whenever any attachment row changes for this note.
*/
fun observeAttachments(noteId: Long): Flow<List<NoteAttachment>>
/**
* Fetch the raw bytes for an attachment row. Returns `null` if no
* row exists with [id]. Use sparingly — bytes are the largest
* column in the store.
*/
suspend fun getAttachmentBytes(id: Long): ByteArray?
/**
* Insert a new attachment row for [noteId]. [bytes] is stored
* verbatim in the database (ObjectBox `ByteArray` column). The
* generated id is returned so the caller can reference the row
* (e.g. for display or removal).
*/
suspend fun addAttachment(
noteId: Long,
bytes: ByteArray,
mimeType: String,
displayName: String,
): Long
/** Delete an attachment by id. Idempotent. */
suspend fun removeAttachment(id: Long)
}