feat: synchronize account icons across game profiles

2026-07-31 11:21:08 +00:00
parent c8adeeb47b
commit 5f20413552
87 changed files with 5755 additions and 280 deletions
@@ -0,0 +1,460 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+
+import type { TurnDaemonCommand, TurnDaemonCommandResult } from '@sammo-ts/common';
+import { createGamePostgresConnector, type GamePrisma, type GamePrismaClient } from '@sammo-ts/infra';
+import type { MapDefinition, ScenarioConfig, ScenarioMeta, TurnSchedule } from '@sammo-ts/logic';
+
+import { createDatabaseTurnHooks, type DatabaseTurnHooks } from '../src/turn/databaseHooks.js';
+import { EngineStateManager } from '../src/turn/engineStateManager.js';
+import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
+import type { TurnGeneral, TurnWorldSnapshot, TurnWorldState } from '../src/turn/types.js';
+import { createTurnDaemonCommandHandler } from '../src/turn/worldCommandHandler.js';
+import { loadTurnWorldFromDatabase } from '../src/turn/worldLoader.js';
+
+const databaseUrl = process.env.IMMEDIATE_ACTION_DATABASE_URL;
+const integration = describe.skipIf(!databaseUrl);
+const worldId = 991_741;
+const targetGeneralId = 991_741;
+const npcGeneralId = 991_742;
+const foreignGeneralId = 991_743;
+const rollbackRequestId = 'integration:engine:account-icon:rollback';
+const actorMismatchRequestId = 'integration:engine:account-icon:actor-mismatch';
+const successRequestId = 'integration:engine:account-icon:success';
+const noGeneralRequestId = 'integration:engine:account-icon:no-general';
+const rollbackConstraint = 'account_icon_rollback_test';
+const targetUserId = 'account-icon-target-user';
+const npcUserId = 'account-icon-npc-user';
+const foreignUserId = 'account-icon-foreign-user';
+const initialPicture = 'account-icon-old.jpg';
+const initialImageServer = 0;
+const nextPicture = 'account-icon-new.png';
+const nextImageServer = 1;
+const rollbackRevision = '2026-07-31T09:05:00.000Z';
+const successRevision = '2026-07-31T09:10:00.000Z';
+const schedule: TurnSchedule = { entries: [{ startMinute: 0, tickMinutes: 10 }] };
+
+const assertDedicatedDatabase = (rawUrl: string): void => {
+    const schema = new URL(rawUrl).searchParams.get('schema');
+    if (!schema?.endsWith('immediate_action_integration')) {
+        throw new Error(`Refusing to mutate non-dedicated schema: ${schema ?? '(missing)'}`);
+    }
+};
+
+const scenarioConfig: ScenarioConfig = {
+    stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 50, npcMin: 10, chiefMin: 65 },
+    iconPath: '',
+    map: {},
+    const: {},
+    environment: {
+        mapName: 'che',
+        unitSet: 'che',
+    },
+};
+
+const scenarioMeta: ScenarioMeta = {
+    title: '계정 아이콘 영속성 통합',
+    startYear: 190,
+    life: null,
+    fiction: null,
+    history: [],
+    ignoreDefaultEvents: false,
+};
+
+const map: MapDefinition = {
+    id: 'account-icon-integration',
+    name: '계정 아이콘 영속성 통합',
+    cities: [],
+};
+
+const state: TurnWorldState = {
+    id: worldId,
+    currentYear: 190,
+    currentMonth: 1,
+    tickSeconds: 600,
+    lastTurnTime: new Date('2026-07-31T09:00:00.000Z'),
+    meta: {
+        killturn: 24,
+        lastTurnTime: '2026-07-31T09:00:00.000Z',
+        scenarioMeta,
+    },
+};
+
+const buildGeneral = (overrides: Partial<TurnGeneral>): TurnGeneral => ({
+    id: targetGeneralId,
+    userId: targetUserId,
+    name: '아이콘통합장수',
+    nationId: 0,
+    cityId: 0,
+    troopId: 0,
+    stats: { leadership: 50, strength: 50, intelligence: 50 },
+    turnTime: new Date('2026-07-31T09:10:00.000Z'),
+    recentWarTime: null,
+    role: {
+        items: { horse: null, weapon: null, book: null, item: null },
+        personality: null,
+        specialDomestic: null,
+        specialWar: null,
+    },
+    triggerState: { flags: {}, counters: {}, modifiers: {}, meta: {} },
+    meta: { killturn: 24, preserved: 'yes' },
+    penalty: {},
+    officerLevel: 0,
+    experience: 0,
+    dedication: 0,
+    injury: 0,
+    gold: 1_000,
+    rice: 1_000,
+    crew: 0,
+    crewTypeId: 0,
+    train: 0,
+    atmos: 0,
+    age: 20,
+    npcState: 0,
+    picture: initialPicture,
+    imageServer: initialImageServer,
+    ...overrides,
+});
+
+const targetGeneral = buildGeneral({});
+const npcGeneral = buildGeneral({
+    id: npcGeneralId,
+    userId: npcUserId,
+    name: '빙의NPC',
+    npcState: 1,
+});
+const foreignGeneral = buildGeneral({
+    id: foreignGeneralId,
+    userId: foreignUserId,
+    name: '타사용자장수',
+});
+const generals = [targetGeneral, npcGeneral, foreignGeneral];
+
+const buildCommand = (
+    requestId: string,
+    userId: string,
+    iconRevision: string,
+    picture = nextPicture,
+    imageServer = nextImageServer
+): Extract<TurnDaemonCommand, { type: 'adjustGeneralIcon' }> => ({
+    type: 'adjustGeneralIcon',
+    requestId,
+    userId,
+    picture,
+    imageServer,
+    iconRevision,
+});
+
+const toGeneralCreate = (general: TurnGeneral): GamePrisma.GeneralCreateManyInput => ({
+    id: general.id,
+    userId: general.userId,
+    name: general.name,
+    nationId: general.nationId,
+    cityId: general.cityId,
+    troopId: general.troopId,
+    npcState: general.npcState,
+    leadership: general.stats.leadership,
+    strength: general.stats.strength,
+    intel: general.stats.intelligence,
+    officerLevel: general.officerLevel,
+    experience: general.experience,
+    dedication: general.dedication,
+    injury: general.injury,
+    gold: general.gold,
+    rice: general.rice,
+    crew: general.crew,
+    crewTypeId: general.crewTypeId,
+    train: general.train,
+    atmos: general.atmos,
+    turnTime: general.turnTime,
+    recentWarTime: general.recentWarTime,
+    age: general.age,
+    picture: general.picture,
+    imageServer: general.imageServer,
+    meta: general.meta as GamePrisma.InputJsonValue,
+    penalty: general.penalty as GamePrisma.InputJsonValue,
+});
+
+integration('adjustGeneralIcon PostgreSQL persistence', () => {
+    let db: GamePrismaClient;
+    let disconnect: (() => Promise<void>) | undefined;
+    let hooks: DatabaseTurnHooks | undefined;
+
+    beforeAll(async () => {
+        assertDedicatedDatabase(databaseUrl!);
+        const connector = createGamePostgresConnector({ url: databaseUrl! });
+        await connector.connect();
+        db = connector.prisma;
+        disconnect = () => connector.disconnect();
+
+        await db.$executeRawUnsafe(`ALTER TABLE input_event DROP CONSTRAINT IF EXISTS ${rollbackConstraint}`);
+        await db.inputEvent.deleteMany({
+            where: {
+                requestId: {
+                    in: [rollbackRequestId, actorMismatchRequestId, successRequestId, noGeneralRequestId],
+                },
+            },
+        });
+        await db.rankData.deleteMany({
+            where: { generalId: { in: generals.map((general) => general.id) } },
+        });
+        await db.general.deleteMany({
+            where: { id: { in: generals.map((general) => general.id) } },
+        });
+        await db.worldState.deleteMany({ where: { id: worldId } });
+
+        await db.worldState.create({
+            data: {
+                id: worldId,
+                scenarioCode: 'account-icon-integration',
+                currentYear: state.currentYear,
+                currentMonth: state.currentMonth,
+                tickSeconds: state.tickSeconds,
+                config: JSON.parse(JSON.stringify(scenarioConfig)) as GamePrisma.InputJsonValue,
+                meta: state.meta as GamePrisma.InputJsonValue,
+            },
+        });
+        await db.general.createMany({
+            data: generals.map(toGeneralCreate),
+        });
+    });
+
+    afterAll(async () => {
+        await hooks?.close();
+        if (!db) {
+            await disconnect?.();
+            return;
+        }
+        await db.$executeRawUnsafe(`ALTER TABLE input_event DROP CONSTRAINT IF EXISTS ${rollbackConstraint}`);
+        await db.inputEvent.deleteMany({
+            where: {
+                requestId: {
+                    in: [rollbackRequestId, actorMismatchRequestId, successRequestId, noGeneralRequestId],
+                },
+            },
+        });
+        await db.rankData.deleteMany({
+            where: { generalId: { in: generals.map((general) => general.id) } },
+        });
+        await db.general.deleteMany({
+            where: { id: { in: generals.map((general) => general.id) } },
+        });
+        await db.worldState.deleteMany({ where: { id: worldId } });
+        await disconnect?.();
+    });
+
+    it('commits the authenticated human icon with input_event and rolls both back on failure', async () => {
+        const snapshot: TurnWorldSnapshot = {
+            generals,
+            cities: [],
+            nations: [],
+            troops: [],
+            diplomacy: [],
+            events: [],
+            initialEvents: [],
+            scenarioConfig,
+            scenarioMeta,
+            map,
+        };
+        const world = new InMemoryTurnWorld(state, snapshot, { schedule });
+        const handler = createTurnDaemonCommandHandler({ world });
+        hooks = await createDatabaseTurnHooks(databaseUrl!, world);
+        const stateManager = new EngineStateManager();
+        stateManager.register('world', {
+            capture: () => world.captureState(),
+            restore: (captured) => world.restoreState(captured),
+        });
+        const execute = async (
+            command: Extract<TurnDaemonCommand, { type: 'adjustGeneralIcon' }>
+        ): Promise<TurnDaemonCommandResult> => {
+            if (!hooks?.hooks.executeCommand || !command.requestId) {
+                throw new Error('Database command execution hook is unavailable.');
+            }
+            return stateManager.transaction(() =>
+                hooks!.hooks.executeCommand!(command.requestId!, async (context) => {
+                    const result = await handler.handle(command, context);
+                    if (!result) {
+                        throw new Error('adjustGeneralIcon command was not handled.');
+                    }
+                    return result;
+                })
+            );
+        };
+        const createInputEvent = async (
+            command: Extract<TurnDaemonCommand, { type: 'adjustGeneralIcon' }>,
+            actorUserId = command.userId
+        ): Promise<void> => {
+            await db.inputEvent.create({
+                data: {
+                    requestId: command.requestId!,
+                    target: 'ENGINE',
+                    eventType: command.type,
+                    actorUserId,
+                    status: 'PROCESSING',
+                    lockedBy: 'account-icon-integration-worker',
+                    leaseUntil: new Date('2026-07-31T09:30:00.000Z'),
+                    attempts: 1,
+                    payload: command as GamePrisma.InputJsonValue,
+                },
+            });
+        };
+
+        const rollbackCommand = buildCommand(rollbackRequestId, targetUserId, rollbackRevision, 'must-rollback.png', 7);
+        await createInputEvent(rollbackCommand);
+        await db.$executeRawUnsafe(`
+            ALTER TABLE input_event
+            ADD CONSTRAINT ${rollbackConstraint}
+            CHECK (request_id <> '${rollbackRequestId}' OR status <> 'SUCCEEDED')
+        `);
+        await expect(execute(rollbackCommand)).rejects.toThrow(`violates check constraint "${rollbackConstraint}"`);
+        expect(world.getGeneralById(targetGeneralId)).toMatchObject({
+            picture: initialPicture,
+            imageServer: initialImageServer,
+            meta: { killturn: 24, preserved: 'yes' },
+        });
+        await expect(db.general.findUniqueOrThrow({ where: { id: targetGeneralId } })).resolves.toMatchObject({
+            picture: initialPicture,
+            imageServer: initialImageServer,
+            meta: { killturn: 24, preserved: 'yes' },
+        });
+        await expect(
+            db.inputEvent.findUniqueOrThrow({ where: { requestId: rollbackRequestId } })
+        ).resolves.toMatchObject({
+            status: 'PROCESSING',
+            result: null,
+            lockedBy: 'account-icon-integration-worker',
+        });
+        await db.$executeRawUnsafe(`ALTER TABLE input_event DROP CONSTRAINT ${rollbackConstraint}`);
+
+        const actorMismatchCommand = buildCommand(
+            actorMismatchRequestId,
+            targetUserId,
+            rollbackRevision,
+            'actor-mismatch.png',
+            8
+        );
+        await createInputEvent(actorMismatchCommand, foreignUserId);
+        await expect(execute(actorMismatchCommand)).rejects.toThrow('actor does not match');
+        expect(world.getGeneralById(targetGeneralId)).toMatchObject({
+            picture: initialPicture,
+            imageServer: initialImageServer,
+        });
+        await expect(db.general.findUniqueOrThrow({ where: { id: targetGeneralId } })).resolves.toMatchObject({
+            picture: initialPicture,
+            imageServer: initialImageServer,
+        });
+        await expect(
+            db.inputEvent.findUniqueOrThrow({ where: { requestId: actorMismatchRequestId } })
+        ).resolves.toMatchObject({
+            status: 'PROCESSING',
+            result: null,
+        });
+
+        const successCommand = buildCommand(successRequestId, targetUserId, successRevision);
+        await createInputEvent(successCommand);
+        await expect(execute(successCommand)).resolves.toEqual({
+            type: 'adjustGeneralIcon',
+            ok: true,
+            generalId: targetGeneralId,
+            updated: true,
+        });
+        expect(world.getGeneralById(targetGeneralId)).toMatchObject({
+            picture: nextPicture,
+            imageServer: nextImageServer,
+            meta: {
+                killturn: 24,
+                preserved: 'yes',
+                accountIconUpdatedAt: successRevision,
+            },
+        });
+        expect(world.getGeneralById(npcGeneralId)).toMatchObject({
+            picture: initialPicture,
+            imageServer: initialImageServer,
+        });
+        expect(world.getGeneralById(foreignGeneralId)).toMatchObject({
+            picture: initialPicture,
+            imageServer: initialImageServer,
+        });
+        await expect(db.general.findUniqueOrThrow({ where: { id: targetGeneralId } })).resolves.toMatchObject({
+            picture: nextPicture,
+            imageServer: nextImageServer,
+            meta: {
+                killturn: 24,
+                preserved: 'yes',
+                accountIconUpdatedAt: successRevision,
+            },
+        });
+        await expect(db.general.findUniqueOrThrow({ where: { id: npcGeneralId } })).resolves.toMatchObject({
+            picture: initialPicture,
+            imageServer: initialImageServer,
+        });
+        await expect(db.general.findUniqueOrThrow({ where: { id: foreignGeneralId } })).resolves.toMatchObject({
+            picture: initialPicture,
+            imageServer: initialImageServer,
+        });
+        await expect(
+            db.inputEvent.findUniqueOrThrow({ where: { requestId: successRequestId } })
+        ).resolves.toMatchObject({
+            status: 'SUCCEEDED',
+            result: {
+                type: 'adjustGeneralIcon',
+                ok: true,
+                generalId: targetGeneralId,
+                updated: true,
+            },
+            error: null,
+            lockedBy: null,
+            leaseUntil: null,
+            completedAt: expect.any(Date),
+        });
+
+        const noGeneralCommand = buildCommand(noGeneralRequestId, npcUserId, successRevision, 'npc-must-stay.png', 9);
+        await createInputEvent(noGeneralCommand);
+        await expect(execute(noGeneralCommand)).resolves.toEqual({
+            type: 'adjustGeneralIcon',
+            ok: true,
+            generalId: null,
+            updated: false,
+        });
+        expect(world.getGeneralById(npcGeneralId)).toMatchObject({
+            picture: initialPicture,
+            imageServer: initialImageServer,
+        });
+        await expect(db.general.findUniqueOrThrow({ where: { id: npcGeneralId } })).resolves.toMatchObject({
+            picture: initialPicture,
+            imageServer: initialImageServer,
+            meta: { killturn: 24, preserved: 'yes' },
+        });
+        await expect(
+            db.inputEvent.findUniqueOrThrow({ where: { requestId: noGeneralRequestId } })
+        ).resolves.toMatchObject({
+            status: 'SUCCEEDED',
+            result: {
+                type: 'adjustGeneralIcon',
+                ok: true,
+                generalId: null,
+                updated: false,
+            },
+        });
+
+        const reloaded = await loadTurnWorldFromDatabase({ databaseUrl: databaseUrl! });
+        expect(reloaded.snapshot.generals.find((entry) => entry.id === targetGeneralId)).toMatchObject({
+            picture: nextPicture,
+            imageServer: nextImageServer,
+            meta: {
+                killturn: 24,
+                preserved: 'yes',
+                accountIconUpdatedAt: successRevision,
+            },
+        });
+        expect(reloaded.snapshot.generals.find((entry) => entry.id === npcGeneralId)).toMatchObject({
+            picture: initialPicture,
+            imageServer: initialImageServer,
+            npcState: 1,
+        });
+        expect(reloaded.snapshot.generals.find((entry) => entry.id === foreignGeneralId)).toMatchObject({
+            picture: initialPicture,
+            imageServer: initialImageServer,
+            userId: foreignUserId,
+        });
+    });
+});