Use new "metas" mutations

2026-01-24 21:04:06 +01:00
parent 14d7ec0ae5
commit 474b98abb5
16 changed files with 791 additions and 347 deletions
--- a/src/features/category/services/CategoryMetadata.ts
+++ b/src/features/category/services/CategoryMetadata.ts
@@ -80,7 +80,7 @@ export const updateCategoryMetadata = async <
    category: CategoryIdInfo & GqlMetaHolder,
    metadataKey: MetadataKey,
    value: ICategoryMetadata[MetadataKey],
-): Promise<void[]> =>
+): Promise<void> =>
    requestUpdateCategoryMetadata(category, [
        [metadataKey, convertAppMetadataToGqlMetadata({ [metadataKey]: value })[metadataKey]],
    ]);
@@ -89,6 +89,6 @@ export const createUpdateCategoryMetadata =
    <Settings extends CategoryMetadataKeys>(
        category: CategoryIdInfo & GqlMetaHolder,
        handleError: (error: any) => void = defaultPromiseErrorHandler('createUpdateCategoryMetadata'),
-    ): ((...args: OmitFirst<Parameters<typeof updateCategoryMetadata<Settings>>>) => Promise<void | void[]>) =>
+    ): ((...args: OmitFirst<Parameters<typeof updateCategoryMetadata<Settings>>>) => Promise<void>) =>
    (metadataKey, value) =>
        updateCategoryMetadata(category, metadataKey, value).catch(handleError);
--- a/src/features/manga/services/MangaMetadata.ts
+++ b/src/features/manga/services/MangaMetadata.ts
@@ -68,7 +68,7 @@ export const updateMangaMetadata = async <
    manga: MangaIdInfo & GqlMetaHolder,
    metadataKey: MetadataKey,
    value: MangaMetadata[MetadataKey],
-): Promise<void[]> =>
+): Promise<void> =>
    requestUpdateMangaMetadata(manga, [
        [metadataKey, convertAppMetadataToGqlMetadata({ [metadataKey]: value })[metadataKey]],
    ]);
@@ -77,6 +77,6 @@ export const createUpdateMangaMetadata =
    <Settings extends MangaMetadataKeys>(
        manga: MangaIdInfo & GqlMetaHolder,
        handleError: (error: any) => void = defaultPromiseErrorHandler('createUpdateMangaMetadata'),
-    ): ((...args: OmitFirst<Parameters<typeof updateMangaMetadata<Settings>>>) => Promise<void | void[]>) =>
+    ): ((...args: OmitFirst<Parameters<typeof updateMangaMetadata<Settings>>>) => Promise<void>) =>
    (metadataKey, value) =>
        updateMangaMetadata(manga, metadataKey, value).catch(handleError);
--- a/src/features/metadata/services/MetadataApolloCacheHandler.ts
+++ b/src/features/metadata/services/MetadataApolloCacheHandler.ts
@@ -8,26 +8,27 @@

 import { ReadFieldFunction } from '@apollo/client/cache/core/types/common';
 import { Reference } from '@apollo/client/utilities';
+import { MetaType } from '@/lib/graphql/generated/graphql.ts';

 export const updateMetadataList = (
-    key: string,
+    meta: MetaType[],
    existingMetas: Reference[] | undefined,
    readField: ReadFieldFunction,
-    createMetaRef: () => Reference | undefined,
+    createMetaRef: (meta: MetaType) => Reference | undefined,
    deleted: boolean = false,
-): (Reference | undefined)[] | undefined => {
+) => {
    if (!existingMetas) {
        return existingMetas;
    }

    if (deleted) {
-        return existingMetas.filter((metaRef: Reference) => readField('key', metaRef) !== key);
+        return existingMetas.filter((metaRef: Reference) => meta.some(({ key }) => key === readField('key', metaRef)));
    }

-    const exists = existingMetas.some((metaRef: Reference) => readField('key', metaRef) === key);
-    if (exists) {
-        return existingMetas;
-    }
+    const newMetas = meta.filter(({ key }) =>
+        existingMetas.every((metaRef: Reference) => readField('key', metaRef) !== key),
+    );
+    const newMetaRefs = newMetas.map(createMetaRef);

-    return [...existingMetas, createMetaRef()];
+    return [...existingMetas, ...newMetaRefs];
 };
--- a/src/features/metadata/services/MetadataUpdater.ts
+++ b/src/features/metadata/services/MetadataUpdater.ts
@@ -9,7 +9,6 @@
 import { requestManager } from '@/lib/requests/RequestManager.ts';
 import { CategoryIdInfo } from '@/features/category/Category.types.ts';
 import {
-    AllowedMetadataValueTypes,
    AppMetadataKeys,
    GqlMetaHolder,
    MetadataHolder,
@@ -22,83 +21,82 @@ import { convertToGqlMeta } from '@/features/metadata/services/MetadataConverter
 import { SourceIdInfo } from '@/features/source/Source.types.ts';
 import { ChapterIdInfo } from '@/features/chapter/Chapter.types.ts';

-const requestUpdateMetadataValue = async (
-    metadataHolder: GqlMetaHolder,
-    holderType: MetadataHolderType,
-    key: AppMetadataKeys,
-    value: AllowedMetadataValueTypes,
-    keyPrefixes?: string[],
-    isMetadataKey: boolean = false,
-): Promise<void> => {
-    const metadataKey = isMetadataKey ? key : getMetadataKey(key, keyPrefixes);
-
-    switch (holderType) {
-        case 'category':
-            await requestManager.setCategoryMeta((metadataHolder as CategoryIdInfo).id, metadataKey, value).response;
-            break;
-        case 'chapter':
-            await requestManager.setChapterMeta((metadataHolder as ChapterIdInfo).id, metadataKey, value).response;
-            break;
-        case 'global':
-            await requestManager.setGlobalMetadata(metadataKey, value).response;
-            break;
-        case 'manga':
-            await requestManager.setMangaMeta((metadataHolder as MangaIdInfo).id, metadataKey, value).response;
-            break;
-        case 'source':
-            await requestManager.setSourceMeta((metadataHolder as SourceIdInfo).id, metadataKey, value).response;
-            break;
-        default:
-            throw new Error(`requestUpdateMetadataValue: unknown holderType "${holderType}"`);
-    }
-};
-
-const requestUpdateMetadata = async (
+const requestUpdateMetadataValues = async (
    metadataHolder: GqlMetaHolder,
    holderType: MetadataHolderType,
    keysToValues: MetadataKeyValuePair[],
    keyPrefixes?: string[],
-    isMetadataKey?: boolean,
-): Promise<void[]> =>
-    Promise.all(
-        keysToValues.map(([key, value]) =>
-            requestUpdateMetadataValue(metadataHolder, holderType, key, value, keyPrefixes, isMetadataKey),
-        ),
-    );
+    isMetadataKey: boolean = false,
+): Promise<void> => {
+    const metas = keysToValues.map(([key, value]) => ({
+        key: isMetadataKey ? key : getMetadataKey(key, keyPrefixes),
+        value: `${value}`,
+    }));
+
+    switch (holderType) {
+        case 'category':
+            await requestManager.setCategoryMeta({
+                items: [{ categoryIds: [(metadataHolder as CategoryIdInfo).id], metas }],
+            }).response;
+            break;
+        case 'chapter':
+            await requestManager.setChapterMeta({
+                items: [{ chapterIds: [(metadataHolder as ChapterIdInfo).id], metas }],
+            }).response;
+            break;
+        case 'global':
+            await requestManager.setGlobalMetadata({
+                metas,
+            }).response;
+            break;
+        case 'manga':
+            await requestManager.setMangaMeta({
+                items: [{ mangaIds: [(metadataHolder as MangaIdInfo).id], metas }],
+            }).response;
+            break;
+        case 'source':
+            await requestManager.setSourceMeta({
+                items: [{ sourceIds: [(metadataHolder as SourceIdInfo).id], metas }],
+            }).response;
+            break;
+        default:
+            throw new Error(`requestUpdateMetadataValues: unknown holderType "${holderType}"`);
+    }
+};

 export const requestUpdateServerMetadata = async (
    keysToValues: MetadataKeyValuePair[],
    keyPrefixes?: string[],
    isMetadataKey?: boolean,
-): Promise<void[]> => requestUpdateMetadata({}, 'global', keysToValues, keyPrefixes, isMetadataKey);
+): Promise<void> => requestUpdateMetadataValues({}, 'global', keysToValues, keyPrefixes, isMetadataKey);

 export const requestUpdateMangaMetadata = async (
    manga: MangaIdInfo & GqlMetaHolder,
    keysToValues: MetadataKeyValuePair[],
    keyPrefixes?: string[],
    isMetadataKey?: boolean,
-): Promise<void[]> => requestUpdateMetadata(manga, 'manga', keysToValues, keyPrefixes, isMetadataKey);
+): Promise<void> => requestUpdateMetadataValues(manga, 'manga', keysToValues, keyPrefixes, isMetadataKey);

 export const requestUpdateChapterMetadata = async (
    chapter: ChapterIdInfo & GqlMetaHolder,
    keysToValues: MetadataKeyValuePair[],
    keyPrefixes?: string[],
    isMetadataKey?: boolean,
-): Promise<void[]> => requestUpdateMetadata(chapter, 'chapter', keysToValues, keyPrefixes, isMetadataKey);
+): Promise<void> => requestUpdateMetadataValues(chapter, 'chapter', keysToValues, keyPrefixes, isMetadataKey);

 export const requestUpdateCategoryMetadata = async (
    category: CategoryIdInfo & GqlMetaHolder,
    keysToValues: MetadataKeyValuePair[],
    keyPrefixes?: string[],
    isMetadataKey?: boolean,
-): Promise<void[]> => requestUpdateMetadata(category, 'category', keysToValues, keyPrefixes, isMetadataKey);
+): Promise<void> => requestUpdateMetadataValues(category, 'category', keysToValues, keyPrefixes, isMetadataKey);

 export const requestUpdateSourceMetadata = async (
    source: SourceIdInfo & GqlMetaHolder,
    keysToValue: MetadataKeyValuePair[],
    keyPrefixes?: string[],
    isMetadataKey?: boolean,
-): Promise<void[]> => requestUpdateMetadata(source, 'source', keysToValue, keyPrefixes, isMetadataKey);
+): Promise<void> => requestUpdateMetadataValues(source, 'source', keysToValue, keyPrefixes, isMetadataKey);

 export const getMetadataUpdateFunction = (
    type: MetadataHolderType,
@@ -108,7 +106,7 @@ export const getMetadataUpdateFunction = (
        | (ChapterIdInfo & MetadataHolder)
        | (CategoryIdInfo & MetadataHolder)
        | (SourceIdInfo & MetadataHolder),
-): ((keyValuePair: MetadataKeyValuePair[], keyPrefixes?: string[], isMetadataKey?: boolean) => Promise<void[]>) => {
+): ((keyValuePair: MetadataKeyValuePair[], prefixes?: string[], isMetadataKey?: boolean) => Promise<void>) => {
    switch (type) {
        case 'global':
            return (...args) => requestUpdateServerMetadata(...args);
@@ -144,81 +142,79 @@ export const getMetadataUpdateFunction = (
    }
 };

-export const requestDeleteMetadataValue = async (
-    metadataHolder: GqlMetaHolder,
-    holderType: MetadataHolderType,
-    key: AppMetadataKeys,
-    keyPrefixes?: string[],
-    isMetadataKey: boolean = false,
-): Promise<void> => {
-    const metadataKey = isMetadataKey ? key : getMetadataKey(key, keyPrefixes);
-
-    switch (holderType) {
-        case 'category':
-            await requestManager.deleteCategoryMeta((metadataHolder as CategoryIdInfo).id, metadataKey).response;
-            break;
-        case 'chapter':
-            await requestManager.deleteChapterMeta((metadataHolder as ChapterIdInfo).id, metadataKey).response;
-            break;
-        case 'global':
-            await requestManager.deleteGlobalMeta(metadataKey).response;
-            break;
-        case 'manga':
-            await requestManager.deleteMangaMeta((metadataHolder as MangaIdInfo).id, metadataKey).response;
-            break;
-        case 'source':
-            await requestManager.deleteSourceMeta((metadataHolder as SourceIdInfo).id, metadataKey).response;
-            break;
-        default:
-            throw new Error(`requestDeleteMetadataValue: unknown holderType "${holderType}"`);
-    }
-};
-
-async function requestDeleteMetadata(
+const requestDeleteMetadataValues = async (
    metadataHolder: GqlMetaHolder,
    holderType: MetadataHolderType,
    keys: AppMetadataKeys[],
    keyPrefixes?: string[],
-    isMetadataKey?: boolean,
-): Promise<void[]> {
-    return Promise.all(
-        keys.map((key) => requestDeleteMetadataValue(metadataHolder, holderType, key, keyPrefixes, isMetadataKey)),
-    );
-}
+    isMetadataKey: boolean = false,
+): Promise<void> => {
+    const metadataKeys = keys.map((key) => (isMetadataKey ? key : getMetadataKey(key, keyPrefixes)));
+
+    switch (holderType) {
+        case 'category':
+            await requestManager.deleteCategoryMeta({
+                items: [{ categoryIds: [(metadataHolder as CategoryIdInfo).id], keys: metadataKeys }],
+            }).response;
+            break;
+        case 'chapter':
+            await requestManager.deleteChapterMeta({
+                items: [{ chapterIds: [(metadataHolder as ChapterIdInfo).id], keys: metadataKeys }],
+            }).response;
+            break;
+        case 'global':
+            await requestManager.deleteGlobalMeta({
+                keys: metadataKeys,
+            }).response;
+            break;
+        case 'manga':
+            await requestManager.deleteMangaMeta({
+                items: [{ mangaIds: [(metadataHolder as MangaIdInfo).id], keys: metadataKeys }],
+            }).response;
+            break;
+        case 'source':
+            await requestManager.deleteSourceMeta({
+                items: [{ sourceIds: [(metadataHolder as SourceIdInfo).id], keys: metadataKeys }],
+            }).response;
+            break;
+        default:
+            throw new Error(`requestDeleteMetadataValues: unknown holderType "${holderType}"`);
+    }
+};

 export const requestDeleteServerMetadata = async (
    keys: AppMetadataKeys[],
    keyPrefixes?: string[],
    isMetadataKey?: boolean,
-): Promise<void[]> => requestDeleteMetadata({}, 'global', keys, keyPrefixes, isMetadataKey);
+): Promise<void> => requestDeleteMetadataValues({}, 'global', keys, keyPrefixes, isMetadataKey);

 export const requestDeleteMangaMetadata = async (
    manga: MangaIdInfo & GqlMetaHolder,
    keys: AppMetadataKeys[],
    keyPrefixes?: string[],
    isMetadataKey?: boolean,
-): Promise<void[]> => requestDeleteMetadata(manga, 'manga', keys, keyPrefixes, isMetadataKey);
+): Promise<void> => requestDeleteMetadataValues(manga, 'manga', keys, keyPrefixes, isMetadataKey);

 export const requestDeleteChapterMetadata = async (
    chapter: ChapterIdInfo & GqlMetaHolder,
    keys: AppMetadataKeys[],
    keyPrefixes?: string[],
    isMetadataKey?: boolean,
-): Promise<void[]> => requestDeleteMetadata(chapter, 'chapter', keys, keyPrefixes, isMetadataKey);
+): Promise<void> => requestDeleteMetadataValues(chapter, 'chapter', keys, keyPrefixes, isMetadataKey);

 export const requestDeleteCategoryMetadata = async (
    category: CategoryIdInfo & GqlMetaHolder,
    keys: AppMetadataKeys[],
    keyPrefixes?: string[],
    isMetadataKey?: boolean,
-): Promise<void[]> => requestDeleteMetadata(category, 'category', keys, keyPrefixes, isMetadataKey);
+): Promise<void> => requestDeleteMetadataValues(category, 'category', keys, keyPrefixes, isMetadataKey);

 export const requestDeleteSourceMetadata = async (
    source: SourceIdInfo & GqlMetaHolder,
    keys: AppMetadataKeys[],
    keyPrefixes?: string[],
    isMetadataKey?: boolean,
-): Promise<void[]> => requestDeleteMetadata(source, 'source', keys, keyPrefixes, isMetadataKey);
+): Promise<void> => requestDeleteMetadataValues(source, 'source', keys, keyPrefixes, isMetadataKey);

 export const getMetadataDeleteFunction = (
    type: MetadataHolderType,
@@ -228,7 +224,7 @@ export const getMetadataDeleteFunction = (
        | (ChapterIdInfo & MetadataHolder)
        | (CategoryIdInfo & MetadataHolder)
        | (SourceIdInfo & MetadataHolder),
-): ((metadataToDelete: AppMetadataKeys[], keyPrefixes?: string[], isMetadataKey?: boolean) => Promise<void[]>) => {
+): ((metadataToDelete: AppMetadataKeys[], keyPrefixes?: string[], isMetadataKey?: boolean) => Promise<void>) => {
    switch (type) {
        case 'global':
            return (...args) => requestDeleteServerMetadata(...args);
--- a/src/features/reader/services/ReaderService.ts
+++ b/src/features/reader/services/ReaderService.ts
@@ -289,6 +289,7 @@ export class ReaderService {
            return;
        }
        const key = getMetadataKey(setting, profile !== undefined ? [profile?.toString()] : undefined);
+        const metaValue = JSON.stringify(value);

        const { cache } = requestManager.graphQLClient.client;

@@ -299,7 +300,7 @@ export class ReaderService {
                data: {
                    __typename: 'GlobalMetaType',
                    key,
-                    value: JSON.stringify(value),
+                    value: metaValue,
                },
            });
            cache.modify({
@@ -307,7 +308,12 @@ export class ReaderService {
                    metas(existingMetas, { readField }) {
                        return {
                            ...existingMetas,
-                            nodes: updateMetadataList(key, existingMetas?.nodes, readField, () => reference),
+                            nodes: updateMetadataList(
+                                [{ key, value: metaValue }],
+                                existingMetas?.nodes,
+                                readField,
+                                () => reference,
+                            ),
                        };
                    },
                },
@@ -319,14 +325,19 @@ export class ReaderService {
                    __typename: 'MangaMetaType',
                    mangaId: manga.id,
                    key,
-                    value: JSON.stringify(value),
+                    value: metaValue,
                },
            });
            cache.modify({
                id: cache.identify({ __typename: 'MangaType', id: manga.id }),
                fields: {
                    meta(existingMetas, { readField }) {
-                        return updateMetadataList(key, existingMetas, readField, () => reference);
+                        return updateMetadataList(
+                            [{ key, value: metaValue }],
+                            existingMetas,
+                            readField,
+                            () => reference,
+                        );
                    },
                },
            });
@@ -363,8 +374,8 @@ export class ReaderService {
        }

        const deleteSetting = isGlobalSetting
-            ? () => requestManager.deleteGlobalMeta(key).response
-            : () => requestManager.deleteMangaMeta(manga.id, key).response;
+            ? () => requestManager.deleteGlobalMeta({ keys: [key] }).response
+            : () => requestManager.deleteMangaMeta({ items: [{ mangaIds: [manga.id], keys: [key] }] }).response;
        deleteSetting().catch((e) =>
            makeToast(t`Could not save the reader settings to the server`, 'error', getErrorMessage(e)),
        );
--- a/src/features/reader/settings/ReaderSettingsMetadata.ts
+++ b/src/features/reader/settings/ReaderSettingsMetadata.ts
@@ -224,7 +224,7 @@ export const updateReaderSettings = async <Setting extends keyof IReaderSettings
    value: IReaderSettings[Setting],
    isGlobal: boolean = false,
    profile?: ReadingMode,
-): Promise<void[]> => {
+): Promise<void> => {
    const isGlobalSetting = isGlobal || GLOBAL_READER_SETTING_KEYS.includes(setting);
    if (isGlobalSetting) {
        return requestUpdateServerMetadata(
@@ -244,6 +244,6 @@ export const createUpdateReaderSettings =
        manga: Pick<MangaType, 'id'> & GqlMetaHolder,
        handleError: (error: any) => void = defaultPromiseErrorHandler('createUpdateReaderSettings'),
        profile?: ReadingMode,
-    ): ((...args: OmitFirst<Parameters<typeof updateReaderSettings<Settings>>>) => Promise<void | void[]>) =>
+    ): ((...args: OmitFirst<Parameters<typeof updateReaderSettings<Settings>>>) => Promise<void>) =>
    (setting, value, isGlobal) =>
        updateReaderSettings(manga, setting, value, isGlobal, profile).catch(handleError);
--- a/src/features/settings/services/ServerSettingsMetadata.ts
+++ b/src/features/settings/services/ServerSettingsMetadata.ts
@@ -64,12 +64,11 @@ export const updateMetadataServerSettings = async <
 >(
    setting: Setting,
    value: MetadataServerSettings[Setting],
-): Promise<void[]> =>
-    requestUpdateServerMetadata([[setting, convertSettingsToMetadata({ [setting]: value })[setting]]]);
+): Promise<void> => requestUpdateServerMetadata([[setting, convertSettingsToMetadata({ [setting]: value })[setting]]]);

 export const createUpdateMetadataServerSettings =
    <Settings extends MetadataServerSettingKeys>(
        handleError: (error: any) => void = defaultPromiseErrorHandler('createUpdateMetadataServerSettings'),
-    ): ((...args: Parameters<typeof updateMetadataServerSettings<Settings>>) => Promise<void | void[]>) =>
+    ): ((...args: Parameters<typeof updateMetadataServerSettings<Settings>>) => Promise<void>) =>
    (setting, value) =>
        updateMetadataServerSettings(setting, value).catch(handleError);
--- a/src/features/source/services/SourceMetadata.ts
+++ b/src/features/source/services/SourceMetadata.ts
@@ -50,7 +50,7 @@ export const updateSourceMetadata = async <
    source: SourceIdInfo & GqlMetaHolder,
    metadataKey: MetadataKey,
    value: ISourceMetadata[MetadataKey],
-): Promise<void[]> =>
+): Promise<void> =>
    requestUpdateSourceMetadata(source, [
        [metadataKey, convertAppMetadataToGqlMetadata({ [metadataKey]: value })[metadataKey]],
    ]);
@@ -59,6 +59,6 @@ export const createUpdateSourceMetadata =
    <Settings extends SourceMetadataKeys>(
        source: SourceIdInfo & GqlMetaHolder,
        handleError: (error: any) => void = defaultPromiseErrorHandler('createUpdateSourceMetadata'),
-    ): ((...args: OmitFirst<Parameters<typeof updateSourceMetadata<Settings>>>) => Promise<void | void[]>) =>
+    ): ((...args: OmitFirst<Parameters<typeof updateSourceMetadata<Settings>>>) => Promise<void>) =>
    (metadataKey, value) =>
        updateSourceMetadata(source, metadataKey, value).catch(handleError);