Chore: Restructure Repository for SvelteKit

src/lib/server-adapters/suwayomi/chapters.ts

@@ -0,0 +1,86 @@
+export const GET_CHAPTERS = `
+  query GetChapters($mangaId: Int!) {
+    chapters(condition: { mangaId: $mangaId }) {
+      nodes {
+        id name chapterNumber sourceOrder isRead isDownloaded isBookmarked
+        pageCount mangaId uploadDate realUrl lastPageRead lastReadAt scanlator
+      }
+    }
+  }
+`
+
+export const GET_RECENTLY_UPDATED = `
+  query GetRecentlyUpdated {
+    chapters(orderBy: FETCHED_AT, orderByType: DESC, first: 300) {
+      nodes {
+        id name chapterNumber sourceOrder isRead lastPageRead mangaId fetchedAt
+        manga { id title thumbnailUrl inLibrary }
+      }
+    }
+  }
+`
+
+export const FETCH_CHAPTERS = `
+  mutation FetchChapters($mangaId: Int!) {
+    fetchChapters(input: { mangaId: $mangaId }) {
+      chapters {
+        id name chapterNumber sourceOrder isRead isDownloaded isBookmarked
+        pageCount mangaId uploadDate realUrl lastPageRead lastReadAt scanlator
+      }
+    }
+  }
+`
+
+export const FETCH_CHAPTER_PAGES = `
+  mutation FetchChapterPages($chapterId: Int!) {
+    fetchChapterPages(input: { chapterId: $chapterId }) { pages }
+  }
+`
+
+export const MARK_CHAPTER_READ = `
+  mutation MarkChapterRead($id: Int!, $isRead: Boolean!) {
+    updateChapter(input: { id: $id, patch: { isRead: $isRead } }) {
+      chapter { id isRead }
+    }
+  }
+`
+
+export const MARK_CHAPTERS_READ = `
+  mutation MarkChaptersRead($ids: [Int!]!, $isRead: Boolean!) {
+    updateChapters(input: { ids: $ids, patch: { isRead: $isRead } }) {
+      chapters { id isRead }
+    }
+  }
+`
+
+export const UPDATE_CHAPTERS_PROGRESS = `
+  mutation UpdateChaptersProgress($ids: [Int!]!, $isRead: Boolean, $isBookmarked: Boolean, $lastPageRead: Int) {
+    updateChapters(input: { ids: $ids, patch: { isRead: $isRead, isBookmarked: $isBookmarked, lastPageRead: $lastPageRead } }) {
+      chapters { id isRead isBookmarked lastPageRead }
+    }
+  }
+`
+
+export const DELETE_DOWNLOADED_CHAPTERS = `
+  mutation DeleteDownloadedChapters($ids: [Int!]!) {
+    deleteDownloadedChapters(input: { ids: $ids }) {
+      chapters { id isDownloaded }
+    }
+  }
+`
+
+export const SET_CHAPTER_META = `
+  mutation SetChapterMeta($chapterId: Int!, $key: String!, $value: String!) {
+    setChapterMeta(input: { meta: { chapterId: $chapterId, key: $key, value: $value } }) {
+      meta { key value }
+    }
+  }
+`
+
+export const DELETE_CHAPTER_META = `
+  mutation DeleteChapterMeta($chapterId: Int!, $key: String!) {
+    deleteChapterMeta(input: { chapterId: $chapterId, key: $key }) {
+      meta { key value }
+    }
+  }
+`

src/lib/server-adapters/suwayomi/downloads.ts

@@ -0,0 +1,105 @@
+const QUEUE_FRAGMENT = `
+  state
+  queue {
+    progress state tries
+    chapter {
+      id name pageCount mangaId
+      manga { id title thumbnailUrl }
+    }
+  }
+`
+
+export const GET_DOWNLOAD_STATUS = `
+  query GetDownloadStatus {
+    downloadStatus { ${QUEUE_FRAGMENT} }
+  }
+`
+
+export const ENQUEUE_DOWNLOAD = `
+  mutation EnqueueDownload($chapterId: Int!) {
+    enqueueChapterDownload(input: { id: $chapterId }) {
+      downloadStatus { ${QUEUE_FRAGMENT} }
+    }
+  }
+`
+
+export const ENQUEUE_CHAPTERS_DOWNLOAD = `
+  mutation EnqueueChaptersDownload($chapterIds: [Int!]!) {
+    enqueueChapterDownloads(input: { ids: $chapterIds }) {
+      downloadStatus { state }
+    }
+  }
+`
+
+export const DEQUEUE_DOWNLOAD = `
+  mutation DequeueDownload($chapterId: Int!) {
+    dequeueChapterDownload(input: { id: $chapterId }) {
+      downloadStatus { state }
+    }
+  }
+`
+
+export const DEQUEUE_CHAPTERS_DOWNLOAD = `
+  mutation DequeueChaptersDownload($chapterIds: [Int!]!) {
+    dequeueChapterDownloads(input: { ids: $chapterIds }) {
+      downloadStatus { ${QUEUE_FRAGMENT} }
+    }
+  }
+`
+
+export const REORDER_DOWNLOAD = `
+  mutation ReorderDownload($chapterId: Int!, $to: Int!) {
+    reorderChapterDownload(input: { chapterId: $chapterId, to: $to }) {
+      downloadStatus { ${QUEUE_FRAGMENT} }
+    }
+  }
+`
+
+export const START_DOWNLOADER = `
+  mutation StartDownloader {
+    startDownloader(input: {}) {
+      downloadStatus { ${QUEUE_FRAGMENT} }
+    }
+  }
+`
+
+export const STOP_DOWNLOADER = `
+  mutation StopDownloader {
+    stopDownloader(input: {}) {
+      downloadStatus { ${QUEUE_FRAGMENT} }
+    }
+  }
+`
+
+export const CLEAR_DOWNLOADER = `
+  mutation ClearDownloader {
+    clearDownloader(input: {}) {
+      downloadStatus { ${QUEUE_FRAGMENT} }
+    }
+  }
+`
+
+export const FETCH_SOURCE_MANGA = `
+  mutation FetchSourceManga($source: LongString!, $type: FetchSourceMangaType!, $page: Int!, $query: String, $filters: [FilterChangeInput!]) {
+    fetchSourceManga(input: { source: $source, type: $type, page: $page, query: $query, filters: $filters }) {
+      mangas { id title thumbnailUrl inLibrary }
+      hasNextPage
+    }
+  }
+`
+
+export const SET_DOWNLOADS_PATH = `
+  mutation SetDownloadsPath($path: String!) {
+    setSettings(input: { settings: { downloadsPath: $path } }) {
+      settings { downloadsPath }
+    }
+  }
+`
+
+export const SET_LOCAL_SOURCE_PATH = `
+  mutation SetLocalSourcePath($path: String!) {
+    setSettings(input: { settings: { localSourcePath: $path } }) {
+      settings { localSourcePath }
+    }
+  }
+`

src/lib/server-adapters/suwayomi/extensions.ts

@@ -0,0 +1,191 @@
+export const GET_EXTENSIONS = `
+  query GetExtensions {
+    extensions {
+      nodes {
+        apkName pkgName name lang versionName
+        isInstalled isObsolete hasUpdate iconUrl
+      }
+    }
+  }
+`
+
+export const GET_SOURCES = `
+  query GetSources {
+    sources {
+      nodes {
+        id name lang displayName iconUrl isNsfw
+        isConfigurable supportsLatest
+        extension { pkgName }
+      }
+    }
+  }
+`
+
+export const GET_SOURCE_SETTINGS = `
+  query GetSourceSettings($id: LongString!) {
+    source(id: $id) {
+      id
+      displayName
+      preferences {
+        ... on CheckBoxPreference {
+          type: __typename
+          CheckBoxTitle: title
+          CheckBoxSummary: summary
+          CheckBoxDefault: default
+          CheckBoxCurrentValue: currentValue
+          key
+        }
+        ... on SwitchPreference {
+          type: __typename
+          SwitchPreferenceTitle: title
+          SwitchPreferenceSummary: summary
+          SwitchPreferenceDefault: default
+          SwitchPreferenceCurrentValue: currentValue
+          key
+        }
+        ... on ListPreference {
+          type: __typename
+          ListPreferenceTitle: title
+          ListPreferenceSummary: summary
+          ListPreferenceDefault: default
+          ListPreferenceCurrentValue: currentValue
+          entries
+          entryValues
+          key
+        }
+        ... on EditTextPreference {
+          type: __typename
+          EditTextPreferenceTitle: title
+          EditTextPreferenceSummary: summary
+          EditTextPreferenceDefault: default
+          EditTextPreferenceCurrentValue: currentValue
+          dialogTitle
+          dialogMessage
+          key
+        }
+        ... on MultiSelectListPreference {
+          type: __typename
+          MultiSelectListPreferenceTitle: title
+          MultiSelectListPreferenceSummary: summary
+          MultiSelectListPreferenceDefault: default
+          MultiSelectListPreferenceCurrentValue: currentValue
+          entries
+          entryValues
+          key
+        }
+      }
+    }
+  }
+`
+
+export const GET_SETTINGS = `
+  query GetSettings {
+    settings { extensionRepos }
+  }
+`
+
+export const GET_SERVER_SECURITY = `
+  query GetServerSecurity {
+    settings {
+      authMode authUsername
+      socksProxyEnabled socksProxyHost socksProxyPort socksProxyVersion socksProxyUsername
+      flareSolverrEnabled flareSolverrUrl flareSolverrTimeout
+      flareSolverrSessionName flareSolverrSessionTtl flareSolverrAsResponseFallback
+    }
+  }
+`
+
+export const FETCH_EXTENSIONS = `
+  mutation FetchExtensions {
+    fetchExtensions(input: {}) {
+      extensions {
+        apkName pkgName name lang versionName
+        isInstalled isObsolete hasUpdate iconUrl
+      }
+    }
+  }
+`
+
+export const UPDATE_EXTENSION = `
+  mutation UpdateExtension($id: String!, $install: Boolean, $uninstall: Boolean, $update: Boolean) {
+    updateExtension(input: { id: $id, patch: { install: $install, uninstall: $uninstall, update: $update } }) {
+      extension { apkName pkgName name isInstalled hasUpdate }
+    }
+  }
+`
+
+export const UPDATE_EXTENSIONS = `
+  mutation UpdateExtensions($ids: [String!]!, $install: Boolean, $uninstall: Boolean, $update: Boolean) {
+    updateExtensions(input: { ids: $ids, patch: { install: $install, uninstall: $uninstall, update: $update } }) {
+      extensions { apkName pkgName name isInstalled hasUpdate }
+    }
+  }
+`
+
+export const INSTALL_EXTERNAL_EXTENSION = `
+  mutation InstallExternalExtension($url: String!) {
+    installExternalExtension(input: { extensionUrl: $url }) {
+      extension { apkName pkgName name isInstalled }
+    }
+  }
+`
+
+export const UPDATE_SOURCE_PREFERENCE = `
+  mutation UpdateSourcePreference($source: LongString!, $change: SourcePreferenceChangeInput!) {
+    updateSourcePreference(input: { source: $source, change: $change }) {
+      source { id displayName }
+    }
+  }
+`
+
+export const SET_SOURCE_META = `
+  mutation SetSourceMeta($sourceId: LongString!, $key: String!, $value: String!) {
+    setSourceMeta(input: { meta: { sourceId: $sourceId, key: $key, value: $value } }) {
+      meta { key value }
+    }
+  }
+`
+
+export const DELETE_SOURCE_META = `
+  mutation DeleteSourceMeta($sourceId: LongString!, $key: String!) {
+    deleteSourceMeta(input: { sourceId: $sourceId, key: $key }) {
+      meta { key value }
+    }
+  }
+`
+
+export const SET_EXTENSION_REPOS = `
+  mutation SetExtensionRepos($repos: [String!]!) {
+    setSettings(input: { settings: { extensionRepos: $repos } }) {
+      settings { extensionRepos }
+    }
+  }
+`
+
+export const SET_SERVER_AUTH = `
+  mutation SetServerAuth($authMode: AuthMode!, $authUsername: String!, $authPassword: String!) {
+    setSettings(input: { settings: { authMode: $authMode, authUsername: $authUsername, authPassword: $authPassword } }) {
+      settings { authMode authUsername }
+    }
+  }
+`
+
+export const CLEAR_CACHED_IMAGES = `
+  mutation ClearCachedImages($cachedPages: Boolean, $cachedThumbnails: Boolean, $downloadedThumbnails: Boolean) {
+    clearCachedImages(input: {
+      cachedPages: $cachedPages
+      cachedThumbnails: $cachedThumbnails
+      downloadedThumbnails: $downloadedThumbnails
+    }) {
+      cachedPages cachedThumbnails downloadedThumbnails
+    }
+  }
+`
+
+export const RESET_SETTINGS = `
+  mutation ResetSettings {
+    resetSettings(input: {}) {
+      settings { extensionRepos }
+    }
+  }
+`

src/lib/server-adapters/suwayomi/index.ts

@@ -0,0 +1,517 @@
+import type {
+  ServerAdapter,
+  ServerConfig,
+  ServerStatus,
+  MangaFilters,
+  MangaMeta,
+  PaginatedResult,
+  Page,
+  DownloadItem,
+  UpdateResult,
+} from '$lib/server-adapters/types'
+import type { Manga, Chapter, Extension, Source, Tracker } from '$lib/types'
+
+interface GQLResponse<T> {
+  data: T
+  errors?: { message: string }[]
+}
+
+const GET_LIBRARY = `
+  query GetLibrary {
+    mangas(condition: { inLibrary: true }) {
+      nodes {
+        id title thumbnailUrl inLibrary downloadCount unreadCount bookmarkCount
+        description status author artist genre inLibraryAt lastFetchedAt
+        source { id name displayName }
+        chapters { totalCount }
+        lastReadChapter { id chapterNumber }
+        firstUnreadChapter { id chapterNumber }
+      }
+    }
+  }
+`
+
+const GET_MANGA = `
+  query GetManga($id: Int!) {
+    manga(id: $id) {
+      id title description thumbnailUrl status author artist genre inLibrary realUrl
+      inLibraryAt lastFetchedAt updateStrategy
+      source { id name displayName }
+      lastReadChapter { id chapterNumber lastPageRead }
+      firstUnreadChapter { id chapterNumber }
+      highestNumberedChapter { id chapterNumber }
+    }
+  }
+`
+
+const GET_CHAPTERS = `
+  query GetChapters($mangaId: Int!) {
+    chapters(condition: { mangaId: $mangaId }) {
+      nodes {
+        id name chapterNumber sourceOrder isRead isDownloaded isBookmarked
+        pageCount mangaId uploadDate realUrl lastPageRead lastReadAt scanlator
+      }
+    }
+  }
+`
+
+const GET_DOWNLOAD_STATUS = `
+  query GetDownloadStatus {
+    downloadStatus {
+      state
+      queue {
+        progress state tries
+        chapter {
+          id name pageCount mangaId
+          manga { id title thumbnailUrl }
+        }
+      }
+    }
+  }
+`
+
+const GET_EXTENSIONS = `
+  query GetExtensions {
+    extensions {
+      nodes {
+        apkName pkgName name lang versionName
+        isInstalled isObsolete hasUpdate iconUrl
+      }
+    }
+  }
+`
+
+const GET_SOURCES = `
+  query GetSources {
+    sources {
+      nodes {
+        id name lang displayName iconUrl isNsfw
+        isConfigurable supportsLatest
+      }
+    }
+  }
+`
+
+const GET_TRACKERS = `
+  query GetTrackers {
+    trackers {
+      nodes {
+        id name icon isLoggedIn isTokenExpired authUrl
+        supportsPrivateTracking supportsReadingDates supportsTrackDeletion
+        scores
+        statuses { value name }
+      }
+    }
+  }
+`
+
+const FETCH_MANGA = `
+  mutation FetchManga($id: Int!) {
+    fetchManga(input: { id: $id }) {
+      manga {
+        id title description thumbnailUrl status author artist genre inLibrary realUrl
+        source { id name displayName }
+      }
+    }
+  }
+`
+
+const FETCH_SOURCE_MANGA = `
+  mutation FetchSourceManga($source: LongString!, $type: FetchSourceMangaType!, $page: Int!, $query: String) {
+    fetchSourceManga(input: { source: $source, type: $type, page: $page, query: $query }) {
+      mangas { id title thumbnailUrl inLibrary }
+      hasNextPage
+    }
+  }
+`
+
+const UPDATE_MANGA = `
+  mutation UpdateManga($id: Int!, $inLibrary: Boolean) {
+    updateManga(input: { id: $id, patch: { inLibrary: $inLibrary } }) {
+      manga { id inLibrary }
+    }
+  }
+`
+
+const SET_MANGA_META = `
+  mutation SetMangaMeta($mangaId: Int!, $key: String!, $value: String!) {
+    setMangaMeta(input: { meta: { mangaId: $mangaId, key: $key, value: $value } }) {
+      meta { key value }
+    }
+  }
+`
+
+const FETCH_CHAPTERS = `
+  mutation FetchChapters($mangaId: Int!) {
+    fetchChapters(input: { mangaId: $mangaId }) {
+      chapters {
+        id name chapterNumber sourceOrder isRead isDownloaded isBookmarked
+        pageCount mangaId uploadDate realUrl lastPageRead lastReadAt scanlator
+      }
+    }
+  }
+`
+
+const FETCH_CHAPTER_PAGES = `
+  mutation FetchChapterPages($chapterId: Int!) {
+    fetchChapterPages(input: { chapterId: $chapterId }) { pages }
+  }
+`
+
+const MARK_CHAPTER_READ = `
+  mutation MarkChapterRead($id: Int!, $isRead: Boolean!) {
+    updateChapter(input: { id: $id, patch: { isRead: $isRead } }) {
+      chapter { id isRead }
+    }
+  }
+`
+
+const MARK_CHAPTERS_READ = `
+  mutation MarkChaptersRead($ids: [Int!]!, $isRead: Boolean!) {
+    updateChapters(input: { ids: $ids, patch: { isRead: $isRead } }) {
+      chapters { id isRead }
+    }
+  }
+`
+
+const ENQUEUE_DOWNLOAD = `
+  mutation EnqueueDownload($chapterId: Int!) {
+    enqueueChapterDownload(input: { id: $chapterId }) {
+      downloadStatus { state }
+    }
+  }
+`
+
+const DEQUEUE_DOWNLOAD = `
+  mutation DequeueDownload($chapterId: Int!) {
+    dequeueChapterDownload(input: { id: $chapterId }) {
+      downloadStatus { state }
+    }
+  }
+`
+
+const CLEAR_DOWNLOADER = `
+  mutation ClearDownloader {
+    clearDownloader(input: {}) {
+      downloadStatus { state }
+    }
+  }
+`
+
+const FETCH_EXTENSIONS = `
+  mutation FetchExtensions {
+    fetchExtensions(input: {}) {
+      extensions {
+        apkName pkgName name lang versionName
+        isInstalled isObsolete hasUpdate iconUrl
+      }
+    }
+  }
+`
+
+const UPDATE_EXTENSION = `
+  mutation UpdateExtension($id: String!, $install: Boolean, $uninstall: Boolean, $update: Boolean) {
+    updateExtension(input: { id: $id, patch: { install: $install, uninstall: $uninstall, update: $update } }) {
+      extension { apkName pkgName name isInstalled hasUpdate }
+    }
+  }
+`
+
+const BIND_TRACK = `
+  mutation BindTrack($mangaId: Int!, $trackerId: Int!, $remoteId: LongString!) {
+    bindTrack(input: { mangaId: $mangaId, trackerId: $trackerId, remoteId: $remoteId }) {
+      trackRecord { id trackerId remoteId }
+    }
+  }
+`
+
+const TRACK_PROGRESS = `
+  mutation TrackProgress($mangaId: Int!) {
+    trackProgress(input: { mangaId: $mangaId }) {
+      trackRecords { id trackerId lastChapterRead status }
+    }
+  }
+`
+
+const UPDATE_LIBRARY = `
+  mutation UpdateLibrary {
+    updateLibrary(input: {}) {
+      updateStatus { jobsInfo { isRunning finishedJobs totalJobs } }
+    }
+  }
+`
+
+function mapChapter(raw: Record<string, unknown>): Chapter {
+  return {
+    id: raw.id as number,
+    name: raw.name as string,
+    chapterNumber: raw.chapterNumber as number,
+    sourceOrder: raw.sourceOrder as number,
+    read: (raw.isRead as boolean) ?? false,
+    downloaded: (raw.isDownloaded as boolean) ?? false,
+    bookmarked: (raw.isBookmarked as boolean) ?? false,
+    pageCount: (raw.pageCount as number) ?? 0,
+    mangaId: raw.mangaId as number,
+    fetchedAt: raw.fetchedAt as string | undefined,
+    uploadDate: raw.uploadDate as string | null | undefined,
+    realUrl: raw.realUrl as string | null | undefined,
+    lastPageRead: raw.lastPageRead as number | undefined,
+    lastReadAt: raw.lastReadAt as string | undefined,
+    scanlator: raw.scanlator as string | null | undefined,
+    manga: raw.manga as Chapter['manga'],
+  }
+}
+
+function mapManga(raw: Record<string, unknown>): Manga {
+  const inLibraryAt = raw.inLibraryAt as string | null | undefined
+  return {
+    ...(raw as unknown as Manga),
+    tags: raw.genre as string[] | undefined,
+    addedAt: inLibraryAt ? new Date(inLibraryAt).getTime() : undefined,
+    lastReadAt: raw.lastReadChapter
+      ? Date.now()
+      : undefined,
+  }
+}
+
+function mapExtension(raw: Record<string, unknown>): Extension {
+  return {
+    ...(raw as unknown as Extension),
+    id: raw.pkgName as string,
+  }
+}
+
+function mapDownloadItem(raw: Record<string, unknown>): DownloadItem {
+  const chapter = raw.chapter as Record<string, unknown>
+  const manga = chapter?.manga as Record<string, unknown>
+  return {
+    chapterId: String(chapter?.id),
+    mangaId: String(chapter?.mangaId ?? manga?.id),
+    chapterName: chapter?.name as string,
+    mangaTitle: manga?.title as string,
+    progress: (raw.progress as number) ?? 0,
+    state: mapDownloadState(raw.state as string),
+  }
+}
+
+function mapDownloadState(state: string): DownloadItem['state'] {
+  switch (state) {
+    case 'DOWNLOADING': return 'downloading'
+    case 'FINISHED':    return 'finished'
+    case 'ERROR':       return 'error'
+    default:            return 'queued'
+  }
+}
+
+export class SuwayomiAdapter implements ServerAdapter {
+  private baseUrl = 'http://127.0.0.1:4567'
+  private authHeader: string | null = null
+
+  async connect(config: ServerConfig) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, '')
+    if (config.credentials) {
+      const { username, password } = config.credentials
+      this.authHeader = 'Basic ' + btoa(`${username}:${password}`)
+    }
+  }
+
+  async getStatus(): Promise<ServerStatus> {
+    try {
+      const res = await fetch(`${this.baseUrl}/api/graphql`, {
+        method: 'POST',
+        headers: this.headers(),
+        body: JSON.stringify({ query: '{ aboutServer { name } }' }),
+      })
+      return res.ok ? 'connected' : 'error'
+    } catch {
+      return 'disconnected'
+    }
+  }
+
+  private headers(): Record<string, string> {
+    const h: Record<string, string> = { 'Content-Type': 'application/json' }
+    if (this.authHeader) h['Authorization'] = this.authHeader
+    return h
+  }
+
+  private async gql<T>(query: string, variables?: Record<string, unknown>): Promise<T> {
+    const res = await fetch(`${this.baseUrl}/api/graphql`, {
+      method: 'POST',
+      headers: this.headers(),
+      body: JSON.stringify({ query, variables }),
+    })
+    if (!res.ok) throw new Error(`Suwayomi HTTP ${res.status}`)
+    const json: GQLResponse<T> = await res.json()
+    if (json.errors?.length) throw new Error(json.errors[0].message)
+    return json.data
+  }
+
+  async getManga(id: string): Promise<Manga> {
+    const data = await this.gql<{ manga: Record<string, unknown> }>(
+      GET_MANGA, { id: Number(id) }
+    )
+    return mapManga(data.manga)
+  }
+
+  async getMangaList(filters: MangaFilters): Promise<PaginatedResult<Manga>> {
+    if (filters.inLibrary) {
+      const data = await this.gql<{ mangas: { nodes: Record<string, unknown>[] } }>(GET_LIBRARY)
+      return { items: data.mangas.nodes.map(mapManga), hasNextPage: false }
+    }
+    const data = await this.gql<{ mangas: { nodes: Record<string, unknown>[] } }>(GET_LIBRARY)
+    return { items: data.mangas.nodes.map(mapManga), hasNextPage: false }
+  }
+
+  async searchManga(query: string, sourceId?: string): Promise<Manga[]> {
+    if (!sourceId) return []
+    const data = await this.gql<{
+      fetchSourceManga: { mangas: Record<string, unknown>[] }
+    }>(FETCH_SOURCE_MANGA, {
+      source: sourceId,
+      type: 'SEARCH',
+      page: 1,
+      query,
+    })
+    return data.fetchSourceManga.mangas.map(mapManga)
+  }
+
+  async addToLibrary(mangaId: string) {
+    await this.gql(UPDATE_MANGA, { id: Number(mangaId), inLibrary: true })
+  }
+
+  async removeFromLibrary(mangaId: string) {
+    await this.gql(UPDATE_MANGA, { id: Number(mangaId), inLibrary: false })
+  }
+
+  async updateMangaMeta(id: string, meta: Partial<MangaMeta>) {
+    for (const [key, value] of Object.entries(meta)) {
+      if (value === undefined) continue
+      await this.gql(SET_MANGA_META, {
+        mangaId: Number(id),
+        key,
+        value: String(value),
+      })
+    }
+  }
+
+  async getChapters(mangaId: string): Promise<Chapter[]> {
+    const data = await this.gql<{ chapters: { nodes: Record<string, unknown>[] } }>(
+      GET_CHAPTERS, { mangaId: Number(mangaId) }
+    )
+    return data.chapters.nodes.map(mapChapter)
+  }
+
+  async getChapter(id: string): Promise<Chapter> {
+    const chapters = await this.gql<{ chapters: { nodes: Record<string, unknown>[] } }>(
+      GET_CHAPTERS, { mangaId: 0 }
+    )
+    const found = chapters.chapters.nodes.find(c => String(c.id) === id)
+    if (!found) throw new Error(`Chapter ${id} not found`)
+    return mapChapter(found)
+  }
+
+  async getChapterPages(id: string): Promise<Page[]> {
+    const data = await this.gql<{ fetchChapterPages: { pages: string[] } }>(
+      FETCH_CHAPTER_PAGES, { chapterId: Number(id) }
+    )
+    return data.fetchChapterPages.pages.map((url, index) => ({ index, url }))
+  }
+
+  async markChapterRead(id: string, read: boolean) {
+    await this.gql(MARK_CHAPTER_READ, { id: Number(id), isRead: read })
+  }
+
+  async markChaptersRead(ids: string[], read: boolean) {
+    await this.gql(MARK_CHAPTERS_READ, { ids: ids.map(Number), isRead: read })
+  }
+
+  async getDownloads(): Promise<DownloadItem[]> {
+    const data = await this.gql<{
+      downloadStatus: { queue: Record<string, unknown>[] }
+    }>(GET_DOWNLOAD_STATUS)
+    return data.downloadStatus.queue.map(mapDownloadItem)
+  }
+
+  async enqueueDownload(chapterId: string) {
+    await this.gql(ENQUEUE_DOWNLOAD, { chapterId: Number(chapterId) })
+  }
+
+  async dequeueDownload(chapterId: string) {
+    await this.gql(DEQUEUE_DOWNLOAD, { chapterId: Number(chapterId) })
+  }
+
+  async clearDownloads() {
+    await this.gql(CLEAR_DOWNLOADER)
+  }
+
+  async getExtensions(): Promise<Extension[]> {
+    await this.gql(FETCH_EXTENSIONS)
+    const data = await this.gql<{ extensions: { nodes: Record<string, unknown>[] } }>(
+      GET_EXTENSIONS
+    )
+    return data.extensions.nodes.map(mapExtension)
+  }
+
+  async installExtension(id: string) {
+    await this.gql(UPDATE_EXTENSION, { id, install: true })
+  }
+
+  async uninstallExtension(id: string) {
+    await this.gql(UPDATE_EXTENSION, { id, uninstall: true })
+  }
+
+  async updateExtension(id: string) {
+    await this.gql(UPDATE_EXTENSION, { id, update: true })
+  }
+
+  async getSources(): Promise<Source[]> {
+    const data = await this.gql<{ sources: { nodes: Source[] } }>(GET_SOURCES)
+    return data.sources.nodes
+  }
+
+  async browseSource(sourceId: string, page: number): Promise<PaginatedResult<Manga>> {
+    const data = await this.gql<{
+      fetchSourceManga: { mangas: Record<string, unknown>[]; hasNextPage: boolean }
+    }>(FETCH_SOURCE_MANGA, {
+      source: sourceId,
+      type: 'LATEST',
+      page,
+    })
+    return {
+      items: data.fetchSourceManga.mangas.map(mapManga),
+      hasNextPage: data.fetchSourceManga.hasNextPage,
+    }
+  }
+
+  async getTrackers(): Promise<Tracker[]> {
+    const data = await this.gql<{ trackers: { nodes: Tracker[] } }>(GET_TRACKERS)
+    return data.trackers.nodes
+  }
+
+  async linkTracker(mangaId: string, trackerId: string, remoteId: string) {
+    await this.gql(BIND_TRACK, {
+      mangaId: Number(mangaId),
+      trackerId: Number(trackerId),
+      remoteId,
+    })
+  }
+
+  async syncTracking(mangaId: string) {
+    await this.gql(TRACK_PROGRESS, { mangaId: Number(mangaId) })
+  }
+
+  async checkForUpdates(mangaIds?: string[]): Promise<UpdateResult[]> {
+    if (mangaIds?.length) {
+      const results: UpdateResult[] = []
+      for (const id of mangaIds) {
+        const before = await this.getChapters(id)
+        await this.gql(FETCH_CHAPTERS, { mangaId: Number(id) })
+        const after = await this.getChapters(id)
+        results.push({ mangaId: id, newChapters: after.length - before.length })
+      }
+      return results
+    }
+    await this.gql(UPDATE_LIBRARY)
+    return []
+  }
+}

src/lib/server-adapters/suwayomi/manga.ts

@@ -0,0 +1,196 @@
+export const GET_LIBRARY = `
+  query GetLibrary {
+    mangas(condition: { inLibrary: true }) {
+      nodes {
+        id title thumbnailUrl inLibrary downloadCount unreadCount bookmarkCount
+        description status author artist genre inLibraryAt lastFetchedAt
+        source { id name displayName }
+        chapters { totalCount }
+        lastReadChapter { id chapterNumber }
+        firstUnreadChapter { id chapterNumber }
+      }
+    }
+  }
+`
+
+export const GET_MANGA = `
+  query GetManga($id: Int!) {
+    manga(id: $id) {
+      id title description thumbnailUrl status author artist genre inLibrary realUrl
+      inLibraryAt lastFetchedAt updateStrategy
+      source { id name displayName }
+      lastReadChapter { id chapterNumber lastPageRead }
+      firstUnreadChapter { id chapterNumber }
+      highestNumberedChapter { id chapterNumber }
+    }
+  }
+`
+
+export const GET_CATEGORIES = `
+  query GetCategories {
+    categories {
+      nodes {
+        id name order default includeInUpdate includeInDownload
+        mangas {
+          nodes { id title thumbnailUrl inLibrary downloadCount unreadCount }
+        }
+      }
+    }
+  }
+`
+
+export const MANGAS_BY_GENRE = `
+  query MangasByGenre($filter: MangaFilterInput, $first: Int, $offset: Int) {
+    mangas(filter: $filter, first: $first, offset: $offset, orderBy: IN_LIBRARY_AT, orderByType: DESC) {
+      nodes {
+        id title thumbnailUrl inLibrary genre status
+        source { id displayName }
+      }
+      pageInfo { hasNextPage }
+      totalCount
+    }
+  }
+`
+
+export const LIBRARY_UPDATE_STATUS = `
+  query LibraryUpdateStatus {
+    libraryUpdateStatus {
+      jobsInfo {
+        isRunning finishedJobs totalJobs skippedMangasCount skippedCategoriesCount
+      }
+      mangaUpdates {
+        status
+        manga { id title thumbnailUrl unreadCount }
+      }
+    }
+    lastUpdateTimestamp { timestamp }
+  }
+`
+
+export const FETCH_MANGA = `
+  mutation FetchManga($id: Int!) {
+    fetchManga(input: { id: $id }) {
+      manga {
+        id title description thumbnailUrl status author artist genre inLibrary realUrl
+        source { id name displayName }
+      }
+    }
+  }
+`
+
+export const UPDATE_MANGA = `
+  mutation UpdateManga($id: Int!, $inLibrary: Boolean) {
+    updateManga(input: { id: $id, patch: { inLibrary: $inLibrary } }) {
+      manga { id inLibrary }
+    }
+  }
+`
+
+export const UPDATE_MANGAS = `
+  mutation UpdateMangas($ids: [Int!]!, $inLibrary: Boolean) {
+    updateMangas(input: { ids: $ids, patch: { inLibrary: $inLibrary } }) {
+      mangas { id inLibrary }
+    }
+  }
+`
+
+export const UPDATE_MANGA_CATEGORIES = `
+  mutation UpdateMangaCategories($mangaId: Int!, $addTo: [Int!]!, $removeFrom: [Int!]!) {
+    updateMangaCategories(input: { id: $mangaId, patch: { addToCategories: $addTo, removeFromCategories: $removeFrom } }) {
+      manga { id }
+    }
+  }
+`
+
+export const UPDATE_MANGAS_CATEGORIES = `
+  mutation UpdateMangasCategories($ids: [Int!]!, $addTo: [Int!]!, $removeFrom: [Int!]!) {
+    updateMangasCategories(input: { ids: $ids, patch: { addToCategories: $addTo, removeFromCategories: $removeFrom } }) {
+      mangas { id }
+    }
+  }
+`
+
+export const CREATE_CATEGORY = `
+  mutation CreateCategory($name: String!) {
+    createCategory(input: { name: $name }) {
+      category { id name order default includeInUpdate includeInDownload }
+    }
+  }
+`
+
+export const UPDATE_CATEGORY = `
+  mutation UpdateCategory($id: Int!, $name: String) {
+    updateCategory(input: { id: $id, patch: { name: $name } }) {
+      category { id name order }
+    }
+  }
+`
+
+export const DELETE_CATEGORY = `
+  mutation DeleteCategory($id: Int!) {
+    deleteCategory(input: { categoryId: $id }) {
+      category { id }
+    }
+  }
+`
+
+export const UPDATE_CATEGORY_ORDER = `
+  mutation UpdateCategoryOrder($id: Int!, $position: Int!) {
+    updateCategoryOrder(input: { id: $id, position: $position }) {
+      categories { id name order default includeInUpdate includeInDownload }
+    }
+  }
+`
+
+export const UPDATE_LIBRARY = `
+  mutation UpdateLibrary {
+    updateLibrary(input: {}) {
+      updateStatus { jobsInfo { isRunning finishedJobs totalJobs } }
+    }
+  }
+`
+
+export const UPDATE_LIBRARY_MANGA = `
+  mutation UpdateLibraryManga($mangaId: Int!) {
+    updateLibraryManga(input: { mangaId: $mangaId }) {
+      updateStatus { jobsInfo { isRunning finishedJobs totalJobs } }
+    }
+  }
+`
+
+export const SET_MANGA_META = `
+  mutation SetMangaMeta($mangaId: Int!, $key: String!, $value: String!) {
+    setMangaMeta(input: { meta: { mangaId: $mangaId, key: $key, value: $value } }) {
+      meta { key value }
+    }
+  }
+`
+
+export const DELETE_MANGA_META = `
+  mutation DeleteMangaMeta($mangaId: Int!, $key: String!) {
+    deleteMangaMeta(input: { mangaId: $mangaId, key: $key }) {
+      meta { key value }
+    }
+  }
+`
+
+export const CREATE_BACKUP = `
+  mutation CreateBackup {
+    createBackup(input: {}) { url }
+  }
+`
+
+export const RESTORE_BACKUP = `
+  mutation RestoreBackup($backup: Upload!) {
+    restoreBackup(input: { backup: $backup }) {
+      id
+      status { mangaProgress state totalManga }
+    }
+  }
+`
+
+export const GET_RESTORE_STATUS = `
+  query GetRestoreStatus($id: String!) {
+    restoreStatus(id: $id) { mangaProgress state totalManga }
+  }
+`

src/lib/server-adapters/suwayomi/types.ts

@@ -0,0 +1,67 @@
+import type { Manga, Chapter, Extension } from '$lib/types'
+import type { DownloadItem } from '$lib/server-adapters/types'
+
+export interface GQLResponse<T> {
+  data: T
+  errors?: { message: string }[]
+}
+
+export function mapManga(raw: Record<string, unknown>): Manga {
+  const inLibraryAt = raw.inLibraryAt as string | null | undefined
+  return {
+    ...(raw as unknown as Manga),
+    tags: raw.genre as string[] | undefined,
+    addedAt: inLibraryAt ? new Date(inLibraryAt).getTime() : undefined,
+    lastReadAt: raw.lastReadChapter ? Date.now() : undefined,
+  }
+}
+
+export function mapChapter(raw: Record<string, unknown>): Chapter {
+  return {
+    id: raw.id as number,
+    name: raw.name as string,
+    chapterNumber: raw.chapterNumber as number,
+    sourceOrder: raw.sourceOrder as number,
+    read: (raw.isRead as boolean) ?? false,
+    downloaded: (raw.isDownloaded as boolean) ?? false,
+    bookmarked: (raw.isBookmarked as boolean) ?? false,
+    pageCount: (raw.pageCount as number) ?? 0,
+    mangaId: raw.mangaId as number,
+    fetchedAt: raw.fetchedAt as string | undefined,
+    uploadDate: raw.uploadDate as string | null | undefined,
+    realUrl: raw.realUrl as string | null | undefined,
+    lastPageRead: raw.lastPageRead as number | undefined,
+    lastReadAt: raw.lastReadAt as string | undefined,
+    scanlator: raw.scanlator as string | null | undefined,
+    manga: raw.manga as Chapter['manga'],
+  }
+}
+
+export function mapExtension(raw: Record<string, unknown>): Extension {
+  return {
+    ...(raw as unknown as Extension),
+    id: raw.pkgName as string,
+  }
+}
+
+export function mapDownloadItem(raw: Record<string, unknown>): DownloadItem {
+  const chapter = raw.chapter as Record<string, unknown>
+  const manga = chapter?.manga as Record<string, unknown>
+  return {
+    chapterId: String(chapter?.id),
+    mangaId: String(chapter?.mangaId ?? manga?.id),
+    chapterName: chapter?.name as string,
+    mangaTitle: manga?.title as string,
+    progress: (raw.progress as number) ?? 0,
+    state: mapDownloadState(raw.state as string),
+  }
+}
+
+function mapDownloadState(state: string): DownloadItem['state'] {
+  switch (state) {
+    case 'DOWNLOADING': return 'downloading'
+    case 'FINISHED':    return 'finished'
+    case 'ERROR':       return 'error'
+    default:            return 'queued'
+  }
+}

src/lib/server-adapters/types.ts

@@ -0,0 +1,94 @@
+import type {
+  Manga,
+  Chapter,
+  Extension,
+  Source,
+  Tracker,
+} from '$lib/types'
+
+export interface ServerConfig {
+  baseUrl: string
+  credentials?: { username: string; password: string }
+}
+
+export type ServerStatus = 'connected' | 'disconnected' | 'error'
+
+export interface MangaFilters {
+  inLibrary?: boolean
+  status?: MangaStatus
+  tags?: string[]
+  unread?: boolean
+  sourceId?: string
+}
+
+export type MangaStatus = 'ONGOING' | 'COMPLETED' | 'LICENSED' | 'PUBLISHING_FINISHED' | 'CANCELLED' | 'ON_HIATUS'
+
+export interface PaginatedResult<T> {
+  items: T[]
+  hasNextPage: boolean
+  total?: number
+}
+
+export interface MangaMeta {
+  customTitle?: string
+  customCover?: string
+  notes?: string
+  [key: string]: unknown
+}
+
+export interface Page {
+  index: number
+  url: string
+  imageData?: string
+}
+
+export interface DownloadItem {
+  chapterId: string
+  mangaId: string
+  chapterName: string
+  mangaTitle: string
+  progress: number
+  state: 'queued' | 'downloading' | 'finished' | 'error'
+}
+
+export interface UpdateResult {
+  mangaId: string
+  newChapters: number
+}
+
+export interface ServerAdapter {
+  connect(config: ServerConfig): Promise<void>
+  getStatus(): Promise<ServerStatus>
+
+  getManga(id: string): Promise<Manga>
+  getMangaList(filters: MangaFilters): Promise<PaginatedResult<Manga>>
+  searchManga(query: string, sourceId?: string): Promise<Manga[]>
+  addToLibrary(mangaId: string): Promise<void>
+  removeFromLibrary(mangaId: string): Promise<void>
+  updateMangaMeta(id: string, meta: Partial<MangaMeta>): Promise<void>
+
+  getChapters(mangaId: string): Promise<Chapter[]>
+  getChapter(id: string): Promise<Chapter>
+  getChapterPages(id: string): Promise<Page[]>
+  markChapterRead(id: string, read: boolean): Promise<void>
+  markChaptersRead(ids: string[], read: boolean): Promise<void>
+
+  getDownloads(): Promise<DownloadItem[]>
+  enqueueDownload(chapterId: string): Promise<void>
+  dequeueDownload(chapterId: string): Promise<void>
+  clearDownloads(): Promise<void>
+
+  getExtensions(): Promise<Extension[]>
+  installExtension(id: string): Promise<void>
+  uninstallExtension(id: string): Promise<void>
+  updateExtension(id: string): Promise<void>
+
+  getSources(): Promise<Source[]>
+  browseSource(sourceId: string, page: number): Promise<PaginatedResult<Manga>>
+
+  getTrackers(): Promise<Tracker[]>
+  linkTracker(mangaId: string, trackerId: string, remoteId: string): Promise<void>
+  syncTracking(mangaId: string): Promise<void>
+
+  checkForUpdates(mangaIds?: string[]): Promise<UpdateResult[]>
+}