Mirrored_Repos/yattee
1
0
Fork 0
mirror of https://github.com/yattee/yattee.git synced 2026-10-24 13:42:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Let an account change the playlists it owns

Browse Source 
Reading a server-side playlist was all the app could do: the write half of
both APIs was missing, and the only thing that knew which credential to use
was the subscription layer. So playlists arrive here as an account concern —
hand AccountService an account and it finds the instance, reads the secret,
refuses what the backend cannot do, and records what the answer implies
about the login.

Capabilities decide, never the instance type: a privacy setting sent to a
backend that has none is dropped rather than refused, because the playlist
is still perfectly creatable there. Every call captures the credential it
used and re-reads it before recording an outcome, so a late 401 cannot
reject the login the user just fixed, nor a late success clear a rejection
it never earned.

Removal is where the backends stop being alike. Invidious names the row
itself with an indexId that survives refetches, so it removes directly.
Piped removes by position, and a position is only true of the fetch that
minted it — so the playlist is refetched and the position checked to still
hold the same video before anything is deleted. That narrows the window; it
cannot close it, and only the refetch afterwards shows what really happened.

The cache exists so that refetch cannot be forgotten. Every mutation goes
through it and republishes what it touched — on failure as much as on
success, because a write that reported failure may still have landed — and
nothing is ever edited optimistically. It is in memory alone: the data
belongs to a login rather than to this device, and a stored Piped entry id
would be aimed at whatever occupies that slot next launch. A per-account
generation fences results that come back after the account was cleared,
since clearing has never cancelled the request that was filling it.

Along the way, clients minted per instance sent no User-Agent at all —
instances that whitelist the Yattee prefix answered them with a 401 the
shared client never earned. The factory now bakes the app's User-Agent in
at construction, where no request can outrun it.
This commit is contained in:
Arkadiusz Fal
2026-09-02 23:29:13 +02:00
parent de4ee9a728
commit b2741bbb32
12 changed files with 1926 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

162
Yattee/Services/API/InvidiousAPI.swift
View File

@@ -648,6 +648,168 @@ actor InvidiousAPI: InstanceAPI {
customHeaders: ["Cookie": "SID=\(sid)"]
)
}
// MARK: - Playlist Management
/// Creates a playlist owned by the logged-in user.
///
/// Invidious answers 201 with `{"title", "playlistId"}` — not the whole
/// playlist — so the returned value carries the new id and the title that
/// was asked for, and nothing else. Callers that need the rest refetch.
/// - Parameters:
/// - title: The playlist title
/// - privacy: Who may see it. Required by the server, which rejects the
/// request outright when it is missing.
/// - instance: The Invidious instance
/// - sid: The session ID from login
/// - Returns: The created playlist, with no videos
func createPlaylist(
title: String,
privacy: PlaylistPrivacy,
instance: Instance,
sid: String
) async throws -> Playlist {
struct CreateRequest: Encodable, Sendable {
let title: String
let privacy: String
}
struct CreateResponse: Decodable, Sendable {
let playlistId: String
let title: String?
}
let body = try JSONEncoder().encode(CreateRequest(title: title, privacy: privacy.rawValue))
let endpoint = GenericEndpoint(
path: "/api/v1/auth/playlists",
method: .post,
headers: authHeaders(sid: sid),
body: body
)
let response: CreateResponse = try await httpClient.fetch(endpoint, baseURL: instance.url)
return Playlist(id: .global(response.playlistId), title: response.title ?? title)
}
/// Edits a playlist's title, description or privacy.
///
/// Title and privacy are sent even when unchanged: Invidious reads a missing
/// field as "leave it alone" for the description but validates the other two
/// on every request, so a partial body is rejected rather than merged.
/// Answers 204 with no body.
/// - Parameters:
/// - id: The playlist ID
/// - title: The title to store
/// - description: The description to store, or `nil` to leave it alone
/// - privacy: The visibility to store
/// - instance: The Invidious instance
/// - sid: The session ID from login
func updatePlaylist(
id: String,
title: String,
description: String?,
privacy: PlaylistPrivacy,
instance: Instance,
sid: String
) async throws {
struct UpdateRequest: Encodable, Sendable {
let title: String
let privacy: String
/// Omitted from the JSON when nil, which is how the server is told
/// to keep the description it already has.
let description: String?
}
let body = try JSONEncoder().encode(
UpdateRequest(title: title, privacy: privacy.rawValue, description: description)
)
let endpoint = GenericEndpoint(
path: "/api/v1/auth/playlists/\(id)",
method: .patch,
headers: authHeaders(sid: sid),
body: body
)
try await httpClient.sendRequest(endpoint, baseURL: instance.url)
}
/// Deletes one of the user's playlists. Answers 204 with no body.
/// - Parameters:
/// - id: The playlist ID
/// - instance: The Invidious instance
/// - sid: The session ID from login
func deletePlaylist(id: String, instance: Instance, sid: String) async throws {
let endpoint = GenericEndpoint(
path: "/api/v1/auth/playlists/\(id)",
method: .delete,
headers: authHeaders(sid: sid)
)
try await httpClient.sendRequest(endpoint, baseURL: instance.url)
}
/// Appends a video to one of the user's playlists.
///
/// The 201 response carries the row the server minted, including the
/// `indexId` it can later be removed by. It is deliberately not decoded:
/// the whole playlist is refetched after every mutation, and a row parsed
/// from a response is one more thing that can disagree with the server.
/// - Parameters:
/// - playlistID: The playlist to add to
/// - videoID: The video to add
/// - instance: The Invidious instance
/// - sid: The session ID from login
func addVideoToPlaylist(
playlistID: String,
videoID: String,
instance: Instance,
sid: String
) async throws {
struct AddRequest: Encodable, Sendable {
let videoId: String
}
let body = try JSONEncoder().encode(AddRequest(videoId: videoID))
let endpoint = GenericEndpoint(
path: "/api/v1/auth/playlists/\(playlistID)/videos",
method: .post,
headers: authHeaders(sid: sid),
body: body
)
try await httpClient.sendRequest(endpoint, baseURL: instance.url)
}
/// Removes one row from one of the user's playlists.
///
/// Addressed by `indexId`, the per-entry token the fetch handed out — never
/// by position. The server names the same row by it across refetches, so a
/// removal cannot land on whatever moved into that position meanwhile.
/// Answers 204 with no body.
/// - Parameters:
/// - playlistID: The playlist to remove from
/// - indexID: The entry's `indexId` from ``userPlaylistSnapshot(id:instance:sid:)``
/// - instance: The Invidious instance
/// - sid: The session ID from login
func removeVideoFromPlaylist(
playlistID: String,
indexID: String,
instance: Instance,
sid: String
) async throws {
let endpoint = GenericEndpoint(
path: "/api/v1/auth/playlists/\(playlistID)/videos/\(indexID)",
method: .delete,
headers: authHeaders(sid: sid)
)
try await httpClient.sendRequest(endpoint, baseURL: instance.url)
}
/// The headers every authenticated write carries. `Content-Type` is set for
/// all of them, including the bodiless ones, so a proxy in front of the
/// instance cannot guess something else.
private nonisolated func authHeaders(sid: String) -> [String: String] {
["Cookie": "SID=\(sid)", "Content-Type": "application/json"]
}
}
// MARK: - Video Proxy