Metadata lookups

import { getGenres } from 'komga-sdk';

const result = await getGenres(undefined, { client });
if (!result.error) {
  for (const genre of result.data ?? []) console.log(genre);
}

const libraryGenres = await getGenres(
  { library_id: ['library-123'] },
  { client },
);
const collectionGenres = await getGenres(
  { collection_id: 'collection-123' },
  { client },
);

import { getTags, getBookTags, getSeriesTags } from 'komga-sdk';

const [allTags, bookTags, seriesTags] = await Promise.all([
  getTags({ library_id: ['library-123'] }, { client }),
  getBookTags({ library_id: ['library-123'] }, { client }),
  getSeriesTags({ library_id: 'library-123' }, { client }),
]);

console.log(allTags.data, bookTags.data, seriesTags.data);

import { getAuthors } from 'komga-sdk';

const result = await getAuthors(
  {
    search: 'Toriyama',
    role: 'writer',
    library_id: ['library-123'],
    page: 0,
    size: 50,
  },
  { client },
);

if (!result.error) {
  for (const author of result.data?.content ?? []) {
    console.log(`${author.name} (${author.role})`);
  }
}

import { getAuthorsNames, getAuthorsRoles } from 'komga-sdk';

const names = await getAuthorsNames({ search: 'Tor' }, { client });
const roles = await getAuthorsRoles({ client });
console.log(names.data, roles.data);

import {
  getPublishers,
  getLanguages,
  getAgeRatings,
  getSharingLabels,
} from 'komga-sdk';

const filters = { library_id: ['library-123'] };
const [publishers, languages, ratings, labels] = await Promise.all([
  getPublishers(filters, { client }),
  getLanguages(filters, { client }),
  getAgeRatings(filters, { client }),
  getSharingLabels(filters, { client }),
]);

console.log({
  publishers: publishers.data ?? [],
  languages: languages.data ?? [],
  ratings: ratings.data ?? [],
  labels: labels.data ?? [],
});

import {
  getGenres,
  getTags,
  getPublishers,
  getLanguages,
  getAgeRatings,
  getAuthorsRoles,
} from 'komga-sdk';

async function getFilterOptions(libraryId?: string) {
  const filters = libraryId ? { library_id: [libraryId] } : undefined;
  const [genres, tags, publishers, languages, ageRatings, authorRoles] =
    await Promise.all([
      getGenres(filters, { client }),
      getTags(filters, { client }),
      getPublishers(filters, { client }),
      getLanguages(filters, { client }),
      getAgeRatings(filters, { client }),
      getAuthorsRoles({ client }),
    ]);

  return {
    genres: genres.data ?? [],
    tags: tags.data ?? [],
    publishers: publishers.data ?? [],
    languages: languages.data ?? [],
    ageRatings: ageRatings.data ?? [],
    authorRoles: authorRoles.data ?? [],
  };
}

import { getAuthorsNames } from 'komga-sdk';

async function searchAuthors(search: string): Promise<string[]> {
  if (search.trim().length < 2) return [];
  const result = await getAuthorsNames({ search }, { client });
  return result.error ? [] : result.data ?? [];
}

import {
  getAuthors,
  getGenres,
  getPublishers,
  getTags,
} from 'komga-sdk';

async function getLibrarySummary(libraryId: string) {
  const filters = { library_id: [libraryId] };
  const [genres, tags, publishers, authors] = await Promise.all([
    getGenres(filters, { client }),
    getTags(filters, { client }),
    getPublishers(filters, { client }),
    getAuthors({ ...filters, page: 0, size: 1 }, { client }),
  ]);

  return {
    genreCount: genres.data?.length ?? 0,
    tagCount: tags.data?.length ?? 0,
    publisherCount: publishers.data?.length ?? 0,
    authorCount: authors.data?.totalElements ?? 0,
  };
}

import { getGenres, KomgaApiError, unwrap } from 'komga-sdk';

const result = await getGenres(undefined, { client });
if (result.error) {
  console.error(`Metadata request failed (${result.response?.status})`, result.error);
}

try {
  const genres = unwrap(await getGenres(undefined, { client }));
  console.log(genres);
} catch (error) {
  if (error instanceof KomgaApiError) {
    console.error(error.status, error.body);
  } else {
    throw error;
  }
}