Move metadata files into new folder

src/modules/metadata/services/MetadataConverter.ts

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+import { MetaType } from '@/lib/graphql/generated/graphql.ts';
+import { AllowedMetadataValueTypes, Metadata } from '@/modules/metadata/Metadata.types.ts';
+
+export const convertValueFromMetadata = <T extends AllowedMetadataValueTypes = AllowedMetadataValueTypes>(
+    value: string,
+): T => {
+    if (!Number.isNaN(+value)) {
+        return +value as T;
+    }
+
+    if (value === 'true' || value === 'false') {
+        return (value === 'true') as T;
+    }
+
+    if (value === 'undefined') {
+        return undefined as T;
+    }
+
+    if (value === 'null') {
+        return null as T;
+    }
+
+    return value as T;
+};
+
+export const convertFromGqlMeta = (gqlMetadata?: MetaType[]): Metadata | undefined => {
+    if (!gqlMetadata) {
+        return undefined;
+    }
+
+    const metadata: Metadata = {};
+    gqlMetadata.forEach(({ key, value }) => {
+        metadata[key] = value;
+    });
+
+    return metadata;
+};
+
+export const convertToGqlMeta = (metadata?: Metadata): MetaType[] | undefined => {
+    if (!metadata) {
+        return undefined;
+    }
+
+    return Object.entries(metadata).map(([key, value]) => ({ key, value }));
+};

src/modules/metadata/services/MetadataMigrations.ts

@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+import { APP_METADATA_KEY_PREFIX, METADATA_MIGRATIONS } from '@/modules/metadata/Metadata.constants.ts';
+import {
+    doesMetadataKeyExistIn,
+    getAppMetadataFrom,
+    getMetadataKey,
+} from '@/modules/metadata/services/MetadataReader.ts';
+import { IMetadataMigration, Metadata } from '@/modules/metadata/Metadata.types.ts';
+
+export const getAppKeyPrefixForMigration = (migrationId: number): string => {
+    const appKeyPrefix = METADATA_MIGRATIONS.slice(0, migrationId)
+        .reverse()
+        .find((migration) => !!migration.appKeyPrefix);
+
+    return appKeyPrefix?.appKeyPrefix?.newPrefix ?? APP_METADATA_KEY_PREFIX;
+};
+
+export const applyAppKeyPrefixMigration = (meta: Metadata, migration: IMetadataMigration): Metadata => {
+    const migratedMetadata: Metadata = { ...meta };
+
+    if (!migration.appKeyPrefix) {
+        return migratedMetadata;
+    }
+
+    const { oldPrefix, newPrefix } = migration.appKeyPrefix;
+
+    const oldAppMetadata = getAppMetadataFrom(meta, oldPrefix);
+    const newAppMetadata = getAppMetadataFrom(meta, newPrefix);
+
+    const missingMetadataKeys = Object.keys(oldAppMetadata).filter((key) => !Object.keys(newAppMetadata).includes(key));
+
+    const isMissingOldMetadata = missingMetadataKeys.length;
+    if (isMissingOldMetadata) {
+        missingMetadataKeys.forEach((oldKey) => {
+            const keyWithNewPrefix = oldKey.replace(oldPrefix, newPrefix);
+            migratedMetadata[keyWithNewPrefix] = oldAppMetadata[oldKey];
+        });
+    }
+
+    return migratedMetadata;
+};
+
+const applyMetadataValueMigration = (meta: Metadata, migration: IMetadataMigration, appKeyPrefix: string): Metadata => {
+    const migratedMetadata: Metadata = { ...meta };
+
+    if (!migration.values) {
+        return migratedMetadata;
+    }
+
+    const appMetadata = getAppMetadataFrom(meta, appKeyPrefix);
+    const metadataValueChanges = migration.values;
+
+    metadataValueChanges.forEach(({ key, oldValue, newValue }) => {
+        const migrateValue = (metaKey: string) => {
+            if (meta[metaKey] === oldValue) {
+                migratedMetadata[metaKey] = newValue;
+            }
+        };
+
+        const migrateValueOfAllAppKeys = key === undefined;
+        if (migrateValueOfAllAppKeys) {
+            Object.keys(appMetadata).forEach((metaKey) => {
+                migrateValue(metaKey);
+            });
+            return;
+        }
+
+        if (!doesMetadataKeyExistIn(meta, key, appKeyPrefix)) {
+            return;
+        }
+
+        migrateValue(getMetadataKey(key, appKeyPrefix));
+    });
+
+    return migratedMetadata;
+};
+
+const applyMetadataKeyMigration = (meta: Metadata, migration: IMetadataMigration): Metadata => {
+    const migratedMetadata: Metadata = { ...meta };
+
+    if (!migration.keys) {
+        return migratedMetadata;
+    }
+
+    const metadataKeyChanges = migration.keys;
+
+    metadataKeyChanges.forEach(({ oldKey, newKey }) => {
+        if (!doesMetadataKeyExistIn(meta, oldKey)) {
+            return;
+        }
+
+        if (doesMetadataKeyExistIn(meta, newKey)) {
+            return;
+        }
+
+        migratedMetadata[getMetadataKey(newKey)] = meta[getMetadataKey(oldKey)];
+    });
+
+    return migratedMetadata;
+};
+
+export const applyMetadataMigrations = (meta?: Metadata): Metadata | undefined => {
+    if (!meta) {
+        return undefined;
+    }
+
+    const migrationToMetadata: [number, Metadata][] = [[0, meta]];
+
+    METADATA_MIGRATIONS.forEach((migration, index) => {
+        const migrationId = index + 1;
+        const metadataToMigrate = migrationToMetadata[migrationId - 1][1];
+        const appKeyPrefixMigrated = applyAppKeyPrefixMigration(metadataToMigrate, migration);
+        const metadataValuesMigrated = applyMetadataValueMigration(
+            appKeyPrefixMigrated,
+            migration,
+            getAppKeyPrefixForMigration(migrationId),
+        );
+        const metadataKeysMigrated = applyMetadataKeyMigration(metadataValuesMigrated, migration);
+
+        migrationToMetadata.push([migrationId, metadataKeysMigrated]);
+    });
+
+    const appliedMigration = migrationToMetadata.length > 1;
+    if (!appliedMigration) {
+        return { ...meta };
+    }
+
+    return migrationToMetadata.pop()![1];
+};

src/modules/metadata/services/MetadataReader.ts

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+import { APP_METADATA_KEY_PREFIX, GLOBAL_METADATA_KEYS } from '@/modules/metadata/Metadata.constants.ts';
+import { DEFAULT_DEVICE, getActiveDevice } from '@/modules/device/services/Device.ts';
+import { applyMetadataMigrations } from '@/modules/metadata/services/MetadataMigrations.ts';
+import { convertValueFromMetadata } from '@/modules/metadata/services/MetadataConverter.ts';
+import {
+    AllowedMetadataValueTypes,
+    AppMetadataKeys,
+    Metadata,
+    MetadataHolder,
+} from '@/modules/metadata/Metadata.types.ts';
+
+export const getMetadataKey = (key: string, appPrefix: string = APP_METADATA_KEY_PREFIX) => {
+    const isGlobalMetadataKey = GLOBAL_METADATA_KEYS.includes(key as AppMetadataKeys);
+    const addActiveDevicePrefix = !isGlobalMetadataKey && getActiveDevice() !== DEFAULT_DEVICE;
+
+    return `${appPrefix}${addActiveDevicePrefix ? `${getActiveDevice()}_` : ''}${key}`;
+};
+
+export const doesMetadataKeyExistIn = (meta: Metadata | undefined, key: string, appPrefix?: string): boolean =>
+    Object.prototype.hasOwnProperty.call(meta ?? {}, getMetadataKey(key, appPrefix));
+
+export const getMetadataValueFrom = <Key extends AppMetadataKeys, Value extends AllowedMetadataValueTypes>(
+    { meta }: MetadataHolder,
+    key: Key,
+    defaultValue?: Value,
+    applyMigrations: boolean = true,
+): Value | undefined => {
+    const metadata = applyMigrations ? applyMetadataMigrations(meta) : meta;
+
+    if (metadata === undefined || !doesMetadataKeyExistIn(metadata, key)) {
+        return defaultValue;
+    }
+
+    return convertValueFromMetadata(metadata[getMetadataKey(key)]);
+};
+
+export const getMetadataFrom = <METADATA extends Partial<Metadata<AppMetadataKeys, AllowedMetadataValueTypes>>>(
+    { meta }: MetadataHolder,
+    metadataWithDefaultValues: METADATA,
+    applyMigrations?: boolean,
+): METADATA => {
+    const appMetadata = {} as METADATA;
+
+    Object.entries(metadataWithDefaultValues).forEach(([key, defaultValue]) => {
+        appMetadata[key as AppMetadataKeys] = getMetadataValueFrom(
+            { meta },
+            key as AppMetadataKeys,
+            defaultValue,
+            applyMigrations,
+        );
+    });
+
+    return appMetadata;
+};
+
+export const getAppMetadataFrom = (meta: Metadata, appPrefix: string = APP_METADATA_KEY_PREFIX): Metadata => {
+    const appMetadata: Metadata = {};
+
+    Object.entries(meta).forEach(([key, value]) => {
+        if (key.startsWith(appPrefix)) {
+            appMetadata[key] = value;
+        }
+    });
+
+    return appMetadata;
+};

src/modules/metadata/services/MetadataUpdater.ts

@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) Contributors to the Suwayomi project
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+import { requestManager } from '@/lib/requests/requests/RequestManager.ts';
+import { SourceType } from '@/lib/graphql/generated/graphql.ts';
+import { ChapterIdInfo } from '@/modules/chapter/services/Chapters.ts';
+import { MangaIdInfo } from '@/modules/manga/services/Mangas.ts';
+import { CategoryIdInfo } from '@/modules/category/Category.types.ts';
+import { getMetadataKey } from '@/modules/metadata/services/MetadataReader.ts';
+import {
+    AllowedMetadataValueTypes,
+    AppMetadataKeys,
+    GqlMetaHolder,
+    MetadataKeyValuePair,
+} from '@/modules/metadata/Metadata.types.ts';
+
+type MetadataHolderType = 'manga' | 'chapter' | 'category' | 'global' | 'source';
+
+export const requestUpdateMetadataValue = async (
+    metadataHolder: GqlMetaHolder,
+    holderType: MetadataHolderType,
+    key: AppMetadataKeys,
+    value: AllowedMetadataValueTypes,
+): Promise<void> => {
+    const metadataKey = getMetadataKey(key);
+
+    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 Pick<SourceType, 'id'>).id, metadataKey, value)
+                .response;
+            break;
+        default:
+            throw new Error(`requestUpdateMetadataValue: unknown holderType "${holderType}"`);
+    }
+};
+
+export const requestUpdateMetadata = async (
+    metadataHolder: GqlMetaHolder,
+    holderType: MetadataHolderType,
+    keysToValues: MetadataKeyValuePair[],
+): Promise<void[]> =>
+    Promise.all(keysToValues.map(([key, value]) => requestUpdateMetadataValue(metadataHolder, holderType, key, value)));
+
+export const requestUpdateServerMetadata = async (keysToValues: MetadataKeyValuePair[]): Promise<void[]> =>
+    requestUpdateMetadata({}, 'global', keysToValues);
+
+export const requestUpdateMangaMetadata = async (
+    manga: MangaIdInfo & GqlMetaHolder,
+    keysToValues: MetadataKeyValuePair[],
+): Promise<void[]> => requestUpdateMetadata(manga, 'manga', keysToValues);
+
+export const requestUpdateChapterMetadata = async (
+    chapter: ChapterIdInfo & GqlMetaHolder,
+    keysToValues: MetadataKeyValuePair[],
+): Promise<void[]> => requestUpdateMetadata(chapter, 'chapter', keysToValues);
+
+export const requestUpdateCategoryMetadata = async (
+    category: CategoryIdInfo & GqlMetaHolder,
+    keysToValues: MetadataKeyValuePair[],
+): Promise<void[]> => requestUpdateMetadata(category, 'category', keysToValues);
+
+export const requestUpdateSourceMetadata = async (
+    source: Pick<SourceType, 'id'> & GqlMetaHolder,
+    keysToValue: MetadataKeyValuePair[],
+): Promise<void[]> => requestUpdateMetadata(source, 'source', keysToValue);