ds4/src/migration/migrationHelpers.js

// SPDX-FileCopyrightText: 2021 Johannes Loher
//
// SPDX-License-Identifier: MIT

import { DS4Actor } from "../documents/actor/actor";
import { DS4Item } from "../documents/item/item";
import { logger } from "../utils/logger";
import { getGame } from "../utils/utils";

/** @typedef {(effectData: object) => Record<string, unknown> | undefined} EffectUpdateDataGetter */

/** @typedef {(itemData: object) => Record<string, unknown> | undefined} ItemUpdateDataGetter */

/**
 * Migrate world items.
 * @param {ItemUpdateDataGetter} getItemUpdateData  A function for getting the update data for a given item data object
 * @returns {Promise<void>} A promise that resolves once the migration is complete
 */
export async function migrateItems(getItemUpdateData) {
    for (const item of getGame().items ?? []) {
        try {
            const updateData = getItemUpdateData(item.toObject());
            if (updateData) {
                logger.info(`Migrating Item document ${item.name} (${item.id})`);
                await item.update(updateData), { enforceTypes: false };
            }
        } catch (err) {
            logger.error(`Error during migration of Item document ${item.name} (${item.id}), continuing anyways.`, err);
        }
    }
}

/** @typedef {(actorData: object>) => Record<string, unknown> | undefined} ActorUpdateDataGetter */

/**
 * Migrate world actors.
 * @param {ActorUpdateDataGetter} getActorUpdateData    A function for getting the update data for a given actor data object
 * @returns {Promise<void>} A promise that resolves once the migration is complete
 */
export async function migrateActors(getActorUpdateData) {
    for (const actor of getGame().actors ?? []) {
        try {
            const updateData = getActorUpdateData(actor.toObject());
            if (updateData) {
                logger.info(`Migrating Actor document ${actor.name} (${actor.id})`);
                await actor.update(updateData);
            }
        } catch (err) {
            logger.error(
                `Error during migration of Actor document ${actor.name} (${actor.id}), continuing anyways.`,
                err,
            );
        }
    }
}

/** @typedef {(scene: Scene) => Record<string, unknown> | undefined} SceneUpdateDataGetter */

/**
 * Migrate world scenes.
 * @param {SceneUpdateDataGetter} getSceneUpdateData    A function for getting the update data for a given scene data object
 * @returns {Promise<void>} A promise that resolves once the migration is complete
 */
export async function migrateScenes(getSceneUpdateData) {
    for (const scene of getGame().scenes ?? []) {
        try {
            const updateData = getSceneUpdateData(scene);
            if (updateData) {
                logger.info(`Migrating Scene document ${scene.name} (${scene.id})`);
                await scene.update(updateData);
                // We need to clear the old syntehtic actors from the cache
                scene.tokens.forEach((t) => (t._actor = null));
            }
        } catch (err) {
            logger.error(
                `Error during migration of Scene document ${scene.name} (${scene.id}), continuing anyways.`,
                err,
            );
        }
    }
}

/** @typedef {(pack: CompendiumCollection) => Promise<void>} CompendiumMigrator */

/**
 * Migrate world compendium packs.
 * @param {CompendiumMigrator} migrateCompendium A function for migrating a single compendium pack
 * @returns {Promise<void>} A promise that resolves once the migration is complete
 */
export async function migrateCompendiums(migrateCompendium) {
    for (const compendium of getGame().packs ?? []) {
        if (compendium.metadata.package !== "world") continue;
        if (!["Actor", "Item", "Scene"].includes(compendium.metadata.type)) continue;
        await migrateCompendium(compendium);
    }
}

/**
 * Get a function to create item update data based on the given function to update embedded documents.
 * @param {EffectUpdateDataGetter} [getEffectUpdateData]    A function to generate effect update data
 * @returns {ItemUpdateDataGetter} A function to get item update data
 */
export function getItemUpdateDataGetter(getEffectUpdateData) {
    return (itemData) => {
        let hasEffectUpdates = false;
        const effects = itemData.effects?.map((effectData) => {
            const update = getEffectUpdateData(effectData);
            if (update) {
                hasEffectUpdates = true;
                return foundry.utils.mergeObject(effectData, update, { inplace: false, performDeletions: true });
            } else {
                return effectData;
            }
        });
        return hasEffectUpdates ? { effects } : undefined;
    };
}

/**
 * Get a function to create actor update data based on the given function to update embedded documents.
 * @param {ItemUpdateDataGetter} [getItemUpdateData]        A function to generate item update data
 * @param {EffectUpdateDataGetter} [getEffectUpdateData]    A function to generate effect update data
 * @returns {ActorUpdateDataGetter} A function to get actor update data
 */
export function getActorUpdateDataGetter(getItemUpdateData, getEffectUpdateData) {
    return (actorData) => {
        let hasItemUpdates = false;
        const items = actorData.items?.map((itemData) => {
            const update = getItemUpdateData?.(itemData);
            if (update) {
                hasItemUpdates = true;
                return foundry.utils.mergeObject(itemData, update, { inplace: false, performDeletions: true });
            } else {
                return itemData;
            }
        });
        let hasEffectUpdates = false;
        const effects = actorData.effects?.map((effectData) => {
            const update = getEffectUpdateData?.(effectData);
            if (update) {
                hasEffectUpdates = true;
                return foundry.utils.mergeObject(effectData, update, { inplace: false, performDeletions: true });
            } else {
                return effectData;
            }
        });
        const result = {
            items: hasItemUpdates ? items : undefined,
            effects: hasEffectUpdates ? effects : undefined,
        };
        return hasItemUpdates | hasEffectUpdates ? result : undefined;
    };
}

/**
 * Get a function to create scene update data that adjusts the actors of the tokens of the scene according to the given function.
 * @param {ActorUpdateDataGetter} [getItemUpdateData]   The function to generate actor update data
 * @returns {SceneUpdateDataGetter} A function to get scene update data
 */
export function getSceneUpdateDataGetter(getActorUpdateData) {
    return (scene) => {
        const tokens = scene.tokens.map((token) => {
            const t = token.toObject();
            if (!t.actorId || t.actorLink) {
                t.actorData = {};
            } else if (!getGame().actors?.has(t.actorId)) {
                t.actorId = null;
                t.actorData = {};
            } else if (!t.actorLink) {
                const actorData = foundry.utils.deepClone(t.actorData);
                actorData.type = token.actor?.type;
                const update = getActorUpdateData?.(actorData);
                if (update !== undefined) {
                    ["items", "effects"].forEach((embeddedName) => {
                        const embeddedUpdates = update[embeddedName];
                        if (!embeddedUpdates?.length) return;
                        const updates = new Map(embeddedUpdates.flatMap((u) => (u && u._id ? [[u._id, u]] : [])));
                        const originals = t.actorData[embeddedName];
                        if (!originals) return;
                        originals.forEach((original) => {
                            if (!original._id) return;
                            const update = updates.get(original._id);
                            if (update) foundry.utils.mergeObject(original, update, { performDeletions: true });
                        });
                        delete update[embeddedName];
                    });
                    foundry.utils.mergeObject(t.actorData, update);
                }
            }
            return t;
        });
        return { tokens };
    };
}

/**
 * @typedef {object} UpdateDataGetters
 * @property {ItemUpdateDataGetter}     [getItemUpdateData]
 * @property {ActorUpdateDataGetter}    [getActorUpdateData]
 * @property {SceneUpdateDataGetter}    [getSceneUpdateData]
 */

/**
 * Get a compendium migrator for the given update data getters.
 * @param {UpdateDataGetters} [updateDataGetters={}]        The functions to use for getting update data
 * @param {{migrateToTemplateEarly?: boolean}} [options={}] Additional options for the compendium migrator
 * @returns {CompendiumMigrator} The resulting compendium migrator
 */
export function getCompendiumMigrator(
    { getItemUpdateData, getActorUpdateData, getSceneUpdateData } = {},
    { migrateToTemplateEarly = true } = {},
) {
    return async (pack) => {
        const type = pack.metadata.type;
        if (!["Actor", "Item", "Scene"].includes(type)) return;
        const wasLocked = pack.locked;
        await pack.configure({ locked: false });
        if (migrateToTemplateEarly) {
            await pack.migrate();
        }

        const documents = await pack.getDocuments();

        for (const doc of documents) {
            try {
                logger.info(`Migrating document ${doc.name} (${doc.id}) in compendium ${pack.collection}`);
                if (doc instanceof DS4Item && getItemUpdateData) {
                    const updateData = getItemUpdateData(doc.toObject());
                    updateData && (await doc.update(updateData));
                } else if (doc instanceof DS4Actor && getActorUpdateData) {
                    const updateData = getActorUpdateData(doc.toObject());
                    updateData && (await doc.update(updateData));
                } else if (doc instanceof Scene && getSceneUpdateData) {
                    const updateData = getSceneUpdateData(doc);
                    updateData && (await doc.update(updateData));
                }
            } catch (err) {
                logger.error(
                    `Error during migration of document ${doc.name} (${doc.id}) in compendium ${pack.collection}, continuing anyways.`,
                    err,
                );
            }
        }

        if (!migrateToTemplateEarly) {
            await pack.migrate();
        }
        await pack.configure({ locked: wasLocked });
    };
}