Add new single multipurpose metadata update mutation

2026-01-25 20:32:56 +01:00
parent 474b98abb5
commit 64df9a9489
14 changed files with 830 additions and 213 deletions
--- a/src/features/category/services/CategoryMetadata.ts
+++ b/src/features/category/services/CategoryMetadata.ts
@@ -7,7 +7,7 @@
 */

 import { useEffect, useMemo } from 'react';
-import { requestUpdateCategoryMetadata } from '@/features/metadata/services/MetadataUpdater.ts';
+import { requestCategoryMetadataUpdate } from '@/features/metadata/services/MetadataUpdater.ts';
 import { defaultPromiseErrorHandler } from '@/lib/DefaultPromiseErrorHandler.ts';
 import { LibraryOptions } from '@/features/library/Library.types.ts';
 import { CategoryIdInfo, CategoryMetadataKeys, ICategoryMetadata } from '@/features/category/Category.types.ts';
@@ -81,9 +81,9 @@ export const updateCategoryMetadata = async <
    metadataKey: MetadataKey,
    value: ICategoryMetadata[MetadataKey],
 ): Promise<void> =>
-    requestUpdateCategoryMetadata(category, [
-        [metadataKey, convertAppMetadataToGqlMetadata({ [metadataKey]: value })[metadataKey]],
-    ]);
+    requestCategoryMetadataUpdate(category, {
+        update: [[metadataKey, convertAppMetadataToGqlMetadata({ [metadataKey]: value })[metadataKey]]],
+    });

 export const createUpdateCategoryMetadata =
    <Settings extends CategoryMetadataKeys>(
--- a/src/features/manga/services/MangaMetadata.ts
+++ b/src/features/manga/services/MangaMetadata.ts
@@ -17,7 +17,7 @@ import {
    MetadataHolder,
 } from '@/features/metadata/Metadata.types.ts';
 import { convertFromGqlMeta } from '@/features/metadata/services/MetadataConverter.ts';
-import { requestUpdateMangaMetadata } from '@/features/metadata/services/MetadataUpdater.ts';
+import { requestMangaMetadataUpdate } from '@/features/metadata/services/MetadataUpdater.ts';
 import { defaultPromiseErrorHandler } from '@/lib/DefaultPromiseErrorHandler.ts';

 const DEFAULT_MANGA_METADATA: MangaMetadata = {
@@ -69,9 +69,9 @@ export const updateMangaMetadata = async <
    metadataKey: MetadataKey,
    value: MangaMetadata[MetadataKey],
 ): Promise<void> =>
-    requestUpdateMangaMetadata(manga, [
-        [metadataKey, convertAppMetadataToGqlMetadata({ [metadataKey]: value })[metadataKey]],
-    ]);
+    requestMangaMetadataUpdate(manga, {
+        update: [[metadataKey, convertAppMetadataToGqlMetadata({ [metadataKey]: value })[metadataKey]]],
+    });

 export const createUpdateMangaMetadata =
    <Settings extends MangaMetadataKeys>(
--- a/src/features/metadata/services/MetadataMigrations.ts
+++ b/src/features/metadata/services/MetadataMigrations.ts
@@ -24,7 +24,7 @@ import { extractOriginalKey, getMetadataKey } from '@/features/metadata/Metadata
 import { MangaIdInfo } from '@/features/manga/Manga.types.ts';
 import { CategoryIdInfo } from '@/features/category/Category.types.ts';
 import { defaultPromiseErrorHandler } from '@/lib/DefaultPromiseErrorHandler.ts';
-import { getMetadataDeleteFunction, getMetadataUpdateFunction } from '@/features/metadata/services/MetadataUpdater.ts';
+import { getMetadataUpdateFunction } from '@/features/metadata/services/MetadataUpdater.ts';
 import { SourceIdInfo } from '@/features/source/Source.types.ts';
 import { ChapterIdInfo } from '@/features/chapter/Chapter.types.ts';

@@ -295,7 +295,6 @@ const commitMigratedMetadata = (
    ]) as MetadataKeyValuePair[];

    const updateMetadata = getMetadataUpdateFunction(type, metadataHolder ?? { id: -1, meta: {} });
-    const deleteMetadata = getMetadataDeleteFunction(type, metadataHolder ?? { id: -1, meta: {} });

    useEffectFn(() => {
        (async () => {
@@ -317,9 +316,12 @@ const commitMigratedMetadata = (
            commitedMigrations.add(itemMigrationKey);

            try {
-                await updateMetadata([...metadataToUpdate], undefined, true);
-                await deleteMetadata(metadataKeysToDelete, undefined, true);
-                await updateMetadata([['migration', METADATA_MIGRATIONS.length]]);
+                await updateMetadata({
+                    update: metadataToUpdate,
+                    delete: metadataKeysToDelete,
+                    migrate: [['migration', METADATA_MIGRATIONS.length]],
+                    isMetadataKey: true,
+                });
            } catch (e) {
                commitedMigrations.delete(itemMigrationKey);

--- a/src/features/metadata/services/MetadataUpdater.ts
+++ b/src/features/metadata/services/MetadataUpdater.ts
@@ -21,82 +21,96 @@ import { convertToGqlMeta } from '@/features/metadata/services/MetadataConverter
 import { SourceIdInfo } from '@/features/source/Source.types.ts';
 import { ChapterIdInfo } from '@/features/chapter/Chapter.types.ts';

-const requestUpdateMetadataValues = async (
+type MetadataUpdateOptions = {
+    update?: MetadataKeyValuePair[];
+    delete?: AppMetadataKeys[];
+    /**
+     * Only ever pass the "migration" key value pair into this.
+     */
+    migrate?: MetadataKeyValuePair[];
+    keyPrefixes?: string[];
+    /**
+     * Applies to "update" and "delete" metadata value pairs. "migrate" is excluded from this and is always expected to not be already converted to a metadata key
+     */
+    isMetadataKey?: boolean;
+};
+
+const requestMetadataUpdate = async (
    metadataHolder: GqlMetaHolder,
    holderType: MetadataHolderType,
-    keysToValues: MetadataKeyValuePair[],
-    keyPrefixes?: string[],
-    isMetadataKey: boolean = false,
+    {
+        update: keysToValues = [],
+        delete: keysToDelete = [],
+        migrate: keysToMigrate = [],
+        keyPrefixes,
+        isMetadataKey = false,
+    }: MetadataUpdateOptions,
 ): Promise<void> => {
-    const metas = keysToValues.map(([key, value]) => ({
+    if (keysToMigrate?.length > 1 || (keysToMigrate?.length === 1 && keysToMigrate[0][0] !== 'migration')) {
+        throw new Error(
+            `requestMetadataUpdate: "migrate" option must only contain a single key-value pair with the key "migration"`,
+        );
+    }
+
+    const updateMetas = keysToValues.map(([key, value]) => ({
        key: isMetadataKey ? key : getMetadataKey(key, keyPrefixes),
        value: `${value}`,
    }));
+    const deleteKeys = keysToDelete.map((key) => (isMetadataKey ? key : getMetadataKey(key, keyPrefixes)));
+    const migrateMetas = keysToMigrate.map(([key, value]) => ({
+        key: getMetadataKey(key, keyPrefixes),
+        value: `${value}`,
+    }));
+
+    const updateMetaInput = {
+        updateInput: { metas: updateMetas },
+        deleteInput: { keys: deleteKeys },
+        migrateInput: { metas: migrateMetas },
+    };

    switch (holderType) {
        case 'category':
-            await requestManager.setCategoryMeta({
-                items: [{ categoryIds: [(metadataHolder as CategoryIdInfo).id], metas }],
-            }).response;
+            await requestManager.updateCategoryMeta([(metadataHolder as CategoryIdInfo).id], updateMetaInput).response;
            break;
        case 'chapter':
-            await requestManager.setChapterMeta({
-                items: [{ chapterIds: [(metadataHolder as ChapterIdInfo).id], metas }],
-            }).response;
+            await requestManager.updateChapterMeta([(metadataHolder as ChapterIdInfo).id], updateMetaInput).response;
            break;
        case 'global':
-            await requestManager.setGlobalMetadata({
-                metas,
-            }).response;
+            await requestManager.updateGlobalMeta(updateMetaInput).response;
            break;
        case 'manga':
-            await requestManager.setMangaMeta({
-                items: [{ mangaIds: [(metadataHolder as MangaIdInfo).id], metas }],
-            }).response;
+            await requestManager.updateMangaMeta([(metadataHolder as MangaIdInfo).id], updateMetaInput).response;
            break;
        case 'source':
-            await requestManager.setSourceMeta({
-                items: [{ sourceIds: [(metadataHolder as SourceIdInfo).id], metas }],
-            }).response;
+            await requestManager.updateSourceMeta([(metadataHolder as SourceIdInfo).id], updateMetaInput).response;
            break;
        default:
-            throw new Error(`requestUpdateMetadataValues: unknown holderType "${holderType}"`);
+            throw new Error(`requestMetadataUpdate: unknown holderType "${holderType}"`);
    }
 };

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

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

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

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

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

 export const getMetadataUpdateFunction = (
    type: MetadataHolderType,
@@ -106,154 +120,33 @@ export const getMetadataUpdateFunction = (
        | (ChapterIdInfo & MetadataHolder)
        | (CategoryIdInfo & MetadataHolder)
        | (SourceIdInfo & MetadataHolder),
-): ((keyValuePair: MetadataKeyValuePair[], prefixes?: string[], isMetadataKey?: boolean) => Promise<void>) => {
+): ((options: MetadataUpdateOptions) => Promise<void>) => {
    switch (type) {
        case 'global':
-            return (...args) => requestUpdateServerMetadata(...args);
+            return (options) => requestServerMetadataUpdate(options);
        case 'manga':
-            return (...args) =>
-                requestUpdateMangaMetadata(
+            return (options) =>
+                requestMangaMetadataUpdate(
                    { id: (metadataHolder as MangaIdInfo).id, meta: convertToGqlMeta(metadataHolder.meta) },
-                    ...args,
+                    options,
                );
        case 'chapter':
-            return (...args) =>
-                requestUpdateChapterMetadata(
+            return (options) =>
+                requestChapterMetadataUpdate(
                    { id: (metadataHolder as ChapterIdInfo).id, meta: convertToGqlMeta(metadataHolder.meta) },
-                    ...args,
+                    options,
                );
        case 'category':
-            return (...args) =>
-                requestUpdateCategoryMetadata(
+            return (options) =>
+                requestCategoryMetadataUpdate(
                    { id: (metadataHolder as CategoryIdInfo).id, meta: convertToGqlMeta(metadataHolder.meta) },
-                    ...args,
+                    options,
                );
        case 'source':
-            return (...args) =>
-                requestUpdateSourceMetadata(
-                    {
-                        id: (metadataHolder as SourceIdInfo).id,
-                        meta: convertToGqlMeta(metadataHolder.meta),
-                    },
-                    ...args,
-                );
-        default:
-            throw new Error(`Unexpected "type" (${type})`);
-    }
-};
-
-const requestDeleteMetadataValues = async (
-    metadataHolder: GqlMetaHolder,
-    holderType: MetadataHolderType,
-    keys: AppMetadataKeys[],
-    keyPrefixes?: string[],
-    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> => requestDeleteMetadataValues({}, 'global', keys, keyPrefixes, isMetadataKey);
-
-export const requestDeleteMangaMetadata = async (
-    manga: MangaIdInfo & GqlMetaHolder,
-    keys: AppMetadataKeys[],
-    keyPrefixes?: string[],
-    isMetadataKey?: boolean,
-): Promise<void> => requestDeleteMetadataValues(manga, 'manga', keys, keyPrefixes, isMetadataKey);
-
-export const requestDeleteChapterMetadata = async (
-    chapter: ChapterIdInfo & GqlMetaHolder,
-    keys: AppMetadataKeys[],
-    keyPrefixes?: string[],
-    isMetadataKey?: boolean,
-): Promise<void> => requestDeleteMetadataValues(chapter, 'chapter', keys, keyPrefixes, isMetadataKey);
-
-export const requestDeleteCategoryMetadata = async (
-    category: CategoryIdInfo & GqlMetaHolder,
-    keys: AppMetadataKeys[],
-    keyPrefixes?: string[],
-    isMetadataKey?: boolean,
-): Promise<void> => requestDeleteMetadataValues(category, 'category', keys, keyPrefixes, isMetadataKey);
-
-export const requestDeleteSourceMetadata = async (
-    source: SourceIdInfo & GqlMetaHolder,
-    keys: AppMetadataKeys[],
-    keyPrefixes?: string[],
-    isMetadataKey?: boolean,
-): Promise<void> => requestDeleteMetadataValues(source, 'source', keys, keyPrefixes, isMetadataKey);
-
-export const getMetadataDeleteFunction = (
-    type: MetadataHolderType,
-    metadataHolder:
-        | MetadataHolder
-        | (MangaIdInfo & MetadataHolder)
-        | (ChapterIdInfo & MetadataHolder)
-        | (CategoryIdInfo & MetadataHolder)
-        | (SourceIdInfo & MetadataHolder),
-): ((metadataToDelete: AppMetadataKeys[], keyPrefixes?: string[], isMetadataKey?: boolean) => Promise<void>) => {
-    switch (type) {
-        case 'global':
-            return (...args) => requestDeleteServerMetadata(...args);
-        case 'manga':
-            return (...args) =>
-                requestDeleteMangaMetadata(
-                    { id: (metadataHolder as MangaIdInfo).id, meta: convertToGqlMeta(metadataHolder.meta) },
-                    ...args,
-                );
-        case 'chapter':
-            return (...args) =>
-                requestDeleteChapterMetadata(
-                    { id: (metadataHolder as ChapterIdInfo).id, meta: convertToGqlMeta(metadataHolder.meta) },
-                    ...args,
-                );
-        case 'category':
-            return (...args) =>
-                requestDeleteCategoryMetadata(
-                    { id: (metadataHolder as CategoryIdInfo).id, meta: convertToGqlMeta(metadataHolder.meta) },
-                    ...args,
-                );
-        case 'source':
-            return (...args) =>
-                requestDeleteSourceMetadata(
-                    {
-                        id: (metadataHolder as SourceIdInfo).id,
-                        meta: convertToGqlMeta(metadataHolder.meta),
-                    },
-                    ...args,
+            return (options) =>
+                requestSourceMetadataUpdate(
+                    { id: (metadataHolder as SourceIdInfo).id, meta: convertToGqlMeta(metadataHolder.meta) },
+                    options,
                );
        default:
            throw new Error(`Unexpected "type" (${type})`);
--- a/src/features/reader/settings/ReaderSettingsMetadata.ts
+++ b/src/features/reader/settings/ReaderSettingsMetadata.ts
@@ -10,8 +10,8 @@ import { useEffect, useMemo } from 'react';
 // eslint-disable-next-line import/no-extraneous-dependencies,no-restricted-imports
 import { requestManager } from '@/lib/requests/RequestManager.ts';
 import {
-    requestUpdateMangaMetadata,
-    requestUpdateServerMetadata,
+    requestMangaMetadataUpdate,
+    requestServerMetadataUpdate,
 } from '@/features/metadata/services/MetadataUpdater.ts';
 import { MangaType } from '@/lib/graphql/generated/graphql.ts';
 import { IReaderSettings, IReaderSettingsWithDefaultFlag, ReadingMode } from '@/features/reader/Reader.types.ts';
@@ -227,17 +227,16 @@ export const updateReaderSettings = async <Setting extends keyof IReaderSettings
 ): Promise<void> => {
    const isGlobalSetting = isGlobal || GLOBAL_READER_SETTING_KEYS.includes(setting);
    if (isGlobalSetting) {
-        return requestUpdateServerMetadata(
-            [[setting, convertSettingsToMetadata({ [setting]: value })[setting]]],
-            profile !== undefined ? [profile?.toString()] : undefined,
-        );
+        return requestServerMetadataUpdate({
+            update: [[setting, convertSettingsToMetadata({ [setting]: value })[setting]]],
+            keyPrefixes: profile !== undefined ? [profile?.toString()] : undefined,
+        });
    }

-    return requestUpdateMangaMetadata(
-        manga,
-        [[setting, convertSettingsToMetadata({ [setting]: value })[setting]]],
-        profile !== undefined ? [profile?.toString()] : undefined,
-    );
+    return requestMangaMetadataUpdate(manga, {
+        update: [[setting, convertSettingsToMetadata({ [setting]: value })[setting]]],
+        keyPrefixes: profile !== undefined ? [profile?.toString()] : undefined,
+    });
 };
 export const createUpdateReaderSettings =
    <Settings extends keyof IReaderSettings>(
--- a/src/features/settings/services/ServerSettingsMetadata.ts
+++ b/src/features/settings/services/ServerSettingsMetadata.ts
@@ -8,7 +8,7 @@

 import { useEffect, useMemo } from 'react';
 import { requestManager } from '@/lib/requests/RequestManager.ts';
-import { requestUpdateServerMetadata } from '@/features/metadata/services/MetadataUpdater.ts';
+import { requestServerMetadataUpdate } from '@/features/metadata/services/MetadataUpdater.ts';
 import { defaultPromiseErrorHandler } from '@/lib/DefaultPromiseErrorHandler.ts';
 import { SERVER_SETTINGS_METADATA_DEFAULT } from '@/features/settings/Settings.constants.ts';
 import { MetadataServerSettingKeys, MetadataServerSettings } from '@/features/settings/Settings.types.ts';
@@ -64,7 +64,8 @@ export const updateMetadataServerSettings = async <
 >(
    setting: Setting,
    value: MetadataServerSettings[Setting],
-): Promise<void> => requestUpdateServerMetadata([[setting, convertSettingsToMetadata({ [setting]: value })[setting]]]);
+): Promise<void> =>
+    requestServerMetadataUpdate({ update: [[setting, convertSettingsToMetadata({ [setting]: value })[setting]]] });

 export const createUpdateMetadataServerSettings =
    <Settings extends MetadataServerSettingKeys>(
--- a/src/features/source/services/SourceMetadata.ts
+++ b/src/features/source/services/SourceMetadata.ts
@@ -7,7 +7,7 @@
 */

 import { useEffect, useMemo } from 'react';
-import { requestUpdateSourceMetadata } from '@/features/metadata/services/MetadataUpdater.ts';
+import { requestSourceMetadataUpdate } from '@/features/metadata/services/MetadataUpdater.ts';
 import { defaultPromiseErrorHandler } from '@/lib/DefaultPromiseErrorHandler.ts';
 import { ISourceMetadata, SourceIdInfo, SourceMetadataKeys } from '@/features/source/Source.types.ts';
 import { convertFromGqlMeta } from '@/features/metadata/services/MetadataConverter.ts';
@@ -51,9 +51,9 @@ export const updateSourceMetadata = async <
    metadataKey: MetadataKey,
    value: ISourceMetadata[MetadataKey],
 ): Promise<void> =>
-    requestUpdateSourceMetadata(source, [
-        [metadataKey, convertAppMetadataToGqlMetadata({ [metadataKey]: value })[metadataKey]],
-    ]);
+    requestSourceMetadataUpdate(source, {
+        update: [[metadataKey, convertAppMetadataToGqlMetadata({ [metadataKey]: value })[metadataKey]]],
+    });

 export const createUpdateSourceMetadata =
    <Settings extends SourceMetadataKeys>(