till/wordeck-native
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor(big-bang): cards-native → wordeck-native

Browse source 
Code + Identity-Rename zur Vorbereitung auf Apple-Dev-Portal-Aktion
(Bundle ev.mana.wordeck, App-Group group.ev.mana.wordeck, AASA
applinks:wordeck.com). Build bleibt funktional, aber gegen die
neue text-only-API können image-occlusion-Creates 422 zurückgeben —
das wird mit der Wordeck-Native v1.0-Welle (parallele Apple-Aktion)
sauber gemacht.

Umbenennung:
- 41 Files: cardecky/Cardecky → wordeck/Wordeck (Display, Strings,
  Kommentare)
- 57 Files: CardsNative → WordeckNative, CardsAPI → WordeckAPI,
  CardsTheme → WordeckTheme, CardsBrand → WordeckBrand, CardsWidget →
  WordeckWidget, CardsDueWidget → WordeckDueWidget
- Bundle-ID ev.mana.cardecky → ev.mana.wordeck (project.yml,
  Info.plist, entitlements, Keychain-Service, App-Group)
- AASA applinks:cardecky.mana.how → applinks:wordeck.com
- API-Base cardecky-api.mana.how → api.wordeck.com
- 10 Files renamed (App-Entry, API-Extensions, Theme, Widget,
  Entitlements, Tests)
- xcodeproj regenerated via xcodegen → WordeckNative.xcodeproj
- MaskRegionsTests.swift gelöscht (image-occlusion entfällt mit
  Wordeck text-only)

Forgejo-Repo git.mana.how/till/cards-native → wordeck-native umbenannt
(Auto-Redirect aktiv). Lokales Verzeichnis Code/cards-native/ bleibt
vorerst — wird beim nächsten Apple-Setup mit Bundle-Test umbenannt.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Till JS 2026-05-17 23:10:42 +02:00
parent 4f154bfb39
commit 542082772a
83 changed files with 691 additions and 648 deletions
Download patch file Download diff file Expand all files Collapse all files

421
Sources/Core/API/WordeckAPI.swift Normal file
View file

@ -0,0 +1,421 @@
import Foundation
import ManaCore
// swiftlint:disable file_length
// swiftlint:disable type_body_length
/// Cards-spezifischer API-Client. Wrapper um `AuthenticatedTransport`
/// aus ManaCore, der die Wordeck-Endpoints kennt. Marketplace-Moderation
/// + Self-Endpoints + AI-Generation sind in `WordeckAPI+Marketplace.swift`
/// und `WordeckAPI+Generation.swift` ausgelagert.
actor WordeckAPI {
let transport: AuthenticatedTransport
let decoder: JSONDecoder
init(auth: AuthClient) {
transport = AuthenticatedTransport(baseURL: AppConfig.apiBaseURL, auth: auth)
decoder = JSONDecoder()
decoder.dateDecodingStrategy = .iso8601withFractional
}
/// Health-Probe — verifiziert dass wordeck-api erreichbar ist
/// und der eigene JWT akzeptiert wird.
func healthCheck() async throws -> Bool {
let (_, http) = try await transport.request(path: "/healthz")
return http.statusCode == 200
}
// MARK: - Decks
/// `GET /api/v1/decks?archived=false` — alle aktiven Decks des Users.
/// Optional: `forkedFromMarketplaceOnly` filtert auf Inbox-Decks
/// (für den Inbox-Banner).
func listDecks(forkedFromMarketplaceOnly: Bool = false) async throws -> [Deck] {
var path = "/api/v1/decks"
if forkedFromMarketplaceOnly {
path += "?forked_from_marketplace=true"
}
let (data, http) = try await transport.request(path: path)
try ensureOK(http, data: data)
let body = try decoder.decode(DeckListResponse.self, from: data)
return body.decks
}
/// `GET /api/v1/cards?deck_id=...` — Anzahl Karten in einem Deck.
/// Web macht das pro Deck einzeln; identisches Pattern hier.
func cardCount(deckId: String) async throws -> Int {
let (data, http) = try await transport.request(path: "/api/v1/cards?deck_id=\(deckId)")
try ensureOK(http, data: data)
return try decoder.decode(CardListResponse.self, from: data).total
}
/// `GET /api/v1/cards?deck_id=...` — komplette Liste der Karten
/// für den Browse-Modus im DeckDetailView.
func listCards(deckId: String) async throws -> [Card] {
let (data, http) = try await transport.request(path: "/api/v1/cards?deck_id=\(deckId)")
try ensureOK(http, data: data)
return try decoder.decode(CardListResponse.self, from: data).cards
}
/// `GET /api/v1/decks/:deckId/distractors` — N zufällige Feldwerte
/// aus anderen Karten desselben Decks. Server-Schema erlaubt nur
/// `front`, `back`, `answer`, `question` als field.
func distractors(
deckId: String,
cardId: String,
field: String = "answer",
count: Int = 3
) async throws -> [String] {
let path = "/api/v1/decks/\(deckId)/distractors?card_id=\(cardId)&field=\(field)&count=\(count)"
let (data, http) = try await transport.request(path: path)
try ensureOK(http, data: data)
return try decoder.decode(DistractorsResponse.self, from: data).distractors
}
/// `GET /api/v1/reviews/due?deck_id=...&limit=500` — Anzahl fälliger
/// Reviews in einem Deck.
func dueCount(deckId: String) async throws -> Int {
let (data, http) = try await transport.request(
path: "/api/v1/reviews/due?deck_id=\(deckId)&limit=500"
)
try ensureOK(http, data: data)
return try decoder.decode(DueReviewsResponse.self, from: data).total
}
// MARK: - Marketplace
/// `GET /api/v1/marketplace/explore` — Featured + Trending.
func explore() async throws -> ExploreResponse {
let (data, http) = try await transport.request(path: "/api/v1/marketplace/explore")
try ensureOK(http, data: data)
return try decoder.decode(ExploreResponse.self, from: data)
}
/// `GET /api/v1/marketplace/decks` — Browse mit Filtern.
func browseMarketplace(
query: String? = nil,
sort: MarketplaceSort = .recent,
language: String? = nil,
limit: Int = 20,
offset: Int = 0
) async throws -> BrowseResponse {
var items: [URLQueryItem] = [
.init(name: "sort", value: sort.rawValue),
.init(name: "limit", value: "\(limit)"),
.init(name: "offset", value: "\(offset)")
]
if let query, !query.trimmingCharacters(in: .whitespaces).isEmpty {
items.append(.init(name: "q", value: query))
}
if let language {
items.append(.init(name: "language", value: language))
}
var components = URLComponents()
components.queryItems = items
let queryString = components.percentEncodedQuery ?? ""
let path = "/api/v1/marketplace/decks?\(queryString)"
let (data, http) = try await transport.request(path: path)
try ensureOK(http, data: data)
return try decoder.decode(BrowseResponse.self, from: data)
}
/// `GET /api/v1/marketplace/decks/:slug`.
func publicDeck(slug: String) async throws -> PublicDeckDetail {
let (data, http) = try await transport.request(path: "/api/v1/marketplace/decks/\(slug)")
try ensureOK(http, data: data)
return try decoder.decode(PublicDeckDetail.self, from: data)
}
/// `POST /api/v1/marketplace/decks/:slug/subscribe` — Auto-Fork
/// passiert serverseitig, Response liefert `private_deck_id`.
@discardableResult
func subscribe(slug: String) async throws -> SubscribeResponse {
let (data, http) = try await transport.request(
path: "/api/v1/marketplace/decks/\(slug)/subscribe",
method: "POST"
)
try ensureOK(http, data: data)
return try decoder.decode(SubscribeResponse.self, from: data)
}
/// `DELETE /api/v1/marketplace/decks/:slug/subscribe`.
func unsubscribe(slug: String) async throws {
let (data, http) = try await transport.request(
path: "/api/v1/marketplace/decks/\(slug)/subscribe",
method: "DELETE"
)
try ensureOK(http, data: data)
}
// MARK: - Media
/// `POST /api/v1/media/upload` — Multipart-Upload. Max 25 MiB.
/// Erlaubte MIMEs: image/*, audio/*, video/*.
func uploadMedia(data: Data, filename: String, mimeType: String) async throws -> MediaUploadResponse {
let boundary = "wordeck-native-\(UUID().uuidString)"
let body = makeMultipartBody(
file: data,
filename: filename,
mimeType: mimeType,
boundary: boundary
)
let (response, http) = try await transport.request(
path: "/api/v1/media/upload",
method: "POST",
body: body,
contentType: "multipart/form-data; boundary=\(boundary)"
)
try ensureOK(http, data: response)
return try decoder.decode(MediaUploadResponse.self, from: response)
}
/// `GET /api/v1/media/:id` — streamt das Media-File. Antwortet mit
/// raw bytes (kein JSON), Caller schreibt das auf Disk via MediaCache.
func fetchMedia(id: String) async throws -> Data {
let (data, http) = try await transport.request(path: "/api/v1/media/\(id)")
guard (200 ..< 300).contains(http.statusCode) else {
throw AuthError.serverError(status: http.statusCode, code: nil, message: "media fetch failed")
}
return data
}
/// `DELETE /api/v1/media/:id` — Soft-Forget. (Endpoint heute nicht
/// implementiert serverseitig; Stub bleibt für späteren Use.)
func deleteMedia(id _: String) async throws {
throw AuthError.serverError(status: 501, code: nil, message: "media delete not implemented on server")
}
// MARK: - Deck-Mutations
/// `POST /api/v1/decks` — Deck anlegen.
@discardableResult
func createDeck(_ body: DeckCreateBody) async throws -> Deck {
let data = try makeJSON(body)
let (responseData, http) = try await transport.request(
path: "/api/v1/decks",
method: "POST",
body: data
)
try ensureOK(http, data: responseData)
return try decoder.decode(Deck.self, from: responseData)
}
/// `PATCH /api/v1/decks/:id` — Deck-Felder ändern.
@discardableResult
func updateDeck(id: String, body: DeckUpdateBody) async throws -> Deck {
let data = try makeJSON(body)
let (responseData, http) = try await transport.request(
path: "/api/v1/decks/\(id)",
method: "PATCH",
body: data
)
try ensureOK(http, data: responseData)
return try decoder.decode(Deck.self, from: responseData)
}
/// `DELETE /api/v1/decks/:id` — Deck löschen (kaskadiert Cards + Reviews).
func deleteDeck(id: String) async throws {
let (data, http) = try await transport.request(
path: "/api/v1/decks/\(id)",
method: "DELETE"
)
try ensureOK(http, data: data)
}
/// `POST /api/v1/decks/:id/duplicate` — Server-seitige Kopie mit
/// "(Kopie)"-Suffix, ohne FSRS-Verlauf, ohne Marketplace-Pointer.
@discardableResult
func duplicateDeck(id: String) async throws -> Deck {
let (data, http) = try await transport.request(
path: "/api/v1/decks/\(id)/duplicate",
method: "POST"
)
try ensureOK(http, data: data)
return try decoder.decode(Deck.self, from: data)
}
/// `POST /api/v1/marketplace/private/:deckId/pull-update` — Smart-Merge-
/// Pull. Holt neue/geänderte Karten aus der jüngsten Marketplace-Version
/// in das geforkte private Deck. Removed-Karten bleiben lokal (User-
/// Choice gewinnt). 422 wenn das Deck kein Fork ist.
func pullUpdate(deckId: String) async throws -> PullUpdateResponse {
let (data, http) = try await transport.request(
path: "/api/v1/marketplace/private/\(deckId)/pull-update",
method: "POST"
)
try ensureOK(http, data: data)
return try decoder.decode(PullUpdateResponse.self, from: data)
}
// MARK: - Marketplace-Publish
/// `POST /api/v1/marketplace/authors/me` — Author-Profil upserten.
/// Pflicht-Schritt vor dem ersten Deck-Init im Marketplace.
func upsertAuthor(_ body: AuthorUpsertBody) async throws {
let payload = try makeJSON(body)
let (data, http) = try await transport.request(
path: "/api/v1/marketplace/authors/me",
method: "POST",
body: payload
)
try ensureOK(http, data: data)
}
/// `GET /api/v1/marketplace/authors/me` — eigenes Author-Profil
/// lesen, gibt `nil` zurück wenn noch keins existiert.
func myAuthor() async throws -> Bool {
let (data, http) = try await transport.request(path: "/api/v1/marketplace/authors/me")
try ensureOK(http, data: data)
// Server liefert entweder Author-Objekt oder JSON-null.
if let raw = try? JSONSerialization.jsonObject(with: data), raw is NSNull {
return false
}
return true
}
/// `POST /api/v1/marketplace/decks` — Marketplace-Deck-Init.
/// Erstellt nur Metadaten; Karten folgen via `publishMarketplaceVersion`.
@discardableResult
func initMarketplaceDeck(_ body: MarketplaceDeckInitBody) async throws -> PublicDeck {
let payload = try makeJSON(body)
let (data, http) = try await transport.request(
path: "/api/v1/marketplace/decks",
method: "POST",
body: payload
)
try ensureOK(http, data: data)
return try decoder.decode(PublicDeck.self, from: data)
}
/// `POST /api/v1/marketplace/decks/:slug/publish` — neue Version
/// publishen. Karten werden serverseitig durch AI-Moderation geschickt.
func publishMarketplaceVersion(
slug: String,
body: MarketplacePublishBody
) async throws -> MarketplacePublishResponse {
let payload = try makeJSON(body)
let (data, http) = try await transport.request(
path: "/api/v1/marketplace/decks/\(slug)/publish",
method: "POST",
body: payload
)
try ensureOK(http, data: data)
return try decoder.decode(MarketplacePublishResponse.self, from: data)
}
// MARK: - Card-Mutations
/// `POST /api/v1/cards` — Karte anlegen. Server validiert `fields`
/// gegen den Card-Type und erstellt automatisch Reviews
/// (1 für basic, 2 für basic-reverse, N für cloze).
@discardableResult
func createCard(_ body: CardCreateBody) async throws -> Card {
let data = try makeJSON(body)
let (responseData, http) = try await transport.request(
path: "/api/v1/cards",
method: "POST",
body: data
)
try ensureOK(http, data: responseData)
return try decoder.decode(Card.self, from: responseData)
}
/// `PATCH /api/v1/cards/:id` — nur `fields` und `media_refs`
/// sind änderbar.
@discardableResult
func updateCard(id: String, body: CardUpdateBody) async throws -> Card {
let data = try makeJSON(body)
let (responseData, http) = try await transport.request(
path: "/api/v1/cards/\(id)",
method: "PATCH",
body: data
)
try ensureOK(http, data: responseData)
return try decoder.decode(Card.self, from: responseData)
}
/// `DELETE /api/v1/cards/:id` — Karte + zugehörige Reviews löschen
/// (Cascade auf DB-Ebene).
func deleteCard(id: String) async throws {
let (data, http) = try await transport.request(
path: "/api/v1/cards/\(id)",
method: "DELETE"
)
try ensureOK(http, data: data)
}
// MARK: - Study
/// `GET /api/v1/reviews/due?deck_id=...&limit=500` — fällige Reviews
/// inklusive zugehöriger Card-Daten. Hot-Path für die Study-View.
func dueReviews(deckId: String, limit: Int = 500) async throws -> [DueReview] {
let (data, http) = try await transport.request(
path: "/api/v1/reviews/due?deck_id=\(deckId)&limit=\(limit)"
)
try ensureOK(http, data: data)
return try decoder.decode(DueReviewsListResponse.self, from: data).reviews
}
/// `POST /api/v1/reviews/:cardId/:subIndex/grade` — gibt eine
/// Bewertung ab. Server rechnet FSRS, antwortet mit aktualisiertem
/// Review.
@discardableResult
func gradeReview(
cardId: String,
subIndex: Int,
rating: Rating,
reviewedAt: Date = .now
) async throws -> Review {
let body = try makeJSON(GradeReviewBody(rating: rating, reviewedAt: reviewedAt))
let (data, http) = try await transport.request(
path: "/api/v1/reviews/\(cardId)/\(subIndex)/grade",
method: "POST",
body: body
)
try ensureOK(http, data: data)
return try decoder.decode(Review.self, from: data)
}
// MARK: - JSON-Encoding
func makeJSON(_ value: some Encodable) throws -> Data {
let encoder = JSONEncoder()
encoder.dateEncodingStrategy = .iso8601
return try encoder.encode(value)
}
// MARK: - Helpers
func ensureOK(_ http: HTTPURLResponse, data: Data) throws {
guard (200 ..< 300).contains(http.statusCode) else {
let message = (try? JSONDecoder().decode(CardsServerError.self, from: data))?.error
throw AuthError.serverError(status: http.statusCode, code: nil, message: message)
}
}
}
// swiftlint:enable type_body_length
private struct CardsServerError: Decodable {
let error: String?
}
extension JSONDecoder.DateDecodingStrategy {
/// Cards-API liefert ISO8601 mit Fractional-Seconds aus
/// `.toISOString()`. Standard-Strategy `.iso8601` akzeptiert die
/// fractional seconds nicht — wir nutzen einen eigenen Formatter.
static let iso8601withFractional: JSONDecoder.DateDecodingStrategy = .custom { decoder in
let container = try decoder.singleValueContainer()
let raw = try container.decode(String.self)
let f = ISO8601DateFormatter()
f.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
if let date = f.date(from: raw) { return date }
f.formatOptions = [.withInternetDateTime]
if let date = f.date(from: raw) { return date }
throw DecodingError.dataCorruptedError(
in: container,
debugDescription: "Cannot decode ISO8601 date: \(raw)"
)
}
}