Merge branch 'main' into feature/city-page-parity

# Conflicts: # docs/frontend-legacy-parity.md
2026-07-26 05:12:45 +00:00
parent 37048c9be7 2030c1240b
commit 4a3a6abf77
12 changed files with 1384 additions and 487 deletions
@@ -3,7 +3,14 @@ import { z } from 'zod';

 import { authedProcedure, router } from '../../trpc.js';
 import { asNumber, asRecord, parseJson, LiteHashDRBG } from '@sammo-ts/common';
-import { loadWarTraitModules, WarTraitLoader, WAR_TRAIT_KEYS, isWarTraitKey } from '@sammo-ts/logic';
+import {
+    ItemLoader,
+    isItemKey,
+    loadWarTraitModules,
+    WarTraitLoader,
+    WAR_TRAIT_KEYS,
+    isWarTraitKey,
+} from '@sammo-ts/logic';
 import type { InheritBuffType } from '@sammo-ts/logic';
 import {
    appendInheritanceLog,
@@ -23,8 +30,8 @@ const BUFF_KEYS: InheritBuffType[] = [
    'warAvoidRatio',
    'warCriticalRatio',
    'warMagicTrialProb',
-    'success',
-    'fail',
+    'domesticSuccessProb',
+    'domesticFailProb',
    'warAvoidRatioOppose',
    'warCriticalRatioOppose',
    'warMagicTrialProbOppose',
@@ -34,8 +41,8 @@ const BUFF_LABELS: Record<InheritBuffType, string> = {
    warAvoidRatio: '회피 확률 증가',
    warCriticalRatio: '필살 확률 증가',
    warMagicTrialProb: '전투계략 시도 확률 증가',
-    success: '내정 성공률 증가',
-    fail: '내정 실패율 감소',
+    domesticSuccessProb: '내정 성공률 증가',
+    domesticFailProb: '내정 실패율 감소',
    warAvoidRatioOppose: '상대 회피 확률 감소',
    warCriticalRatioOppose: '상대 필살 확률 감소',
    warMagicTrialProbOppose: '상대 전투계략 시도 확률 감소',
@@ -58,6 +65,37 @@ const parseBuffRecord = (raw: unknown): Record<string, number> => {

 const serializeBuffRecord = (buff: Record<string, number>): string => JSON.stringify(buff);

+const readBuffLevel = (buff: Record<string, number>, key: InheritBuffType): number => {
+    const compatibilityKey = key === 'domesticSuccessProb' ? 'success' : key === 'domesticFailProb' ? 'fail' : null;
+    return Math.max(0, Math.min(5, Math.floor(buff[key] ?? (compatibilityKey ? buff[compatibilityKey] : 0) ?? 0)));
+};
+
+const loadAvailableUniqueItems = async (worldState: WorldStateRow) => {
+    const configuredItems = asRecord(asRecord(worldState.config).const).allItems;
+    const enabledKeys: Array<Parameters<ItemLoader['load']>[0]> = [];
+    for (const entries of Object.values(asRecord(configuredItems))) {
+        for (const [key, amount] of Object.entries(asRecord(entries))) {
+            if (asNumber(amount, 0) !== 0 && isItemKey(key)) {
+                enabledKeys.push(key);
+            }
+        }
+    }
+
+    const loader = new ItemLoader();
+    const items = await Promise.all(
+        [...new Set(enabledKeys)].map(async (key) => {
+            const item = await loader.load(key);
+            return {
+                key,
+                name: item.name,
+                rawName: item.rawName,
+                info: item.info ?? '',
+            };
+        })
+    );
+    return items.sort((left, right) => left.name.localeCompare(right.name, 'ko'));
+};
+
 const resolveWorld = async (ctx: { db: { worldState: { findFirst: () => Promise<unknown> } } }) => {
    const worldState = await ctx.db.worldState.findFirst();
    if (!worldState || typeof worldState !== 'object') {
@@ -199,6 +237,9 @@ export const inheritRouter = router({
                special2Code: true,
                meta: true,
                turnTime: true,
+                leadership: true,
+                strength: true,
+                intel: true,
            },
        });

@@ -219,7 +260,7 @@ export const inheritRouter = router({
        const inheritConst = resolveInheritConstants(worldState);
        const buffState = parseBuffRecord(asRecord(general.meta).inheritBuff);
        const buffLevels = BUFF_KEYS.reduce<Record<string, number>>((acc, key) => {
-            acc[key] = Math.max(0, Math.min(5, Math.floor(buffState[key] ?? 0)));
+            acc[key] = readBuffLevel(buffState, key);
            return acc;
        }, {});

@@ -240,11 +281,14 @@ export const inheritRouter = router({
            info: trait.info ?? '',
        }));

-        const others = await ctx.db.general.findMany({
-            where: { id: { not: general.id }, userId: { not: null } },
-            select: { id: true, name: true },
-            orderBy: { id: 'asc' },
-        });
+        const [others, availableUnique] = await Promise.all([
+            ctx.db.general.findMany({
+                where: { id: { not: general.id }, npcState: { lt: 2 }, userId: { not: null } },
+                select: { id: true, name: true },
+                orderBy: { id: 'asc' },
+            }),
+            loadAvailableUniqueItems(worldState),
+        ]);

        return {
            items,
@@ -260,10 +304,16 @@ export const inheritRouter = router({
                resetTurnTime: resetTurnLevel,
            },
            availableSpecialWar: warSpecials,
+            availableUnique,
            availableTargetGenerals: others,
            turnTimeZones: buildTurnTimeZoneList(Math.max(1, Math.round(worldState.tickSeconds / 60))),
            isUnited,
            currentSpecialWar: general.special2Code ?? 'None',
+            currentStat: {
+                leadership: general.leadership,
+                strength: general.strength,
+                intel: general.intel,
+            },
        };
    }),
    getLogs: authedProcedure
@@ -285,7 +335,7 @@ export const inheritRouter = router({
                },
                orderBy: { id: 'desc' },
                take: 30,
-                select: { id: true, year: true, month: true, text: true },
+                select: { id: true, year: true, month: true, text: true, createdAt: true },
            });
            return logs;
        }),
@@ -318,7 +368,7 @@ export const inheritRouter = router({
            }

            const buff = parseBuffRecord(asRecord(general.meta).inheritBuff);
-            const prevLevel = Math.max(0, Math.min(5, Math.floor(buff[input.type] ?? 0)));
+            const prevLevel = readBuffLevel(buff, input.type);
            if (input.level === prevLevel) {
                throw new TRPCError({ code: 'BAD_REQUEST', message: '이미 구입했습니다.' });
            }
@@ -417,7 +467,12 @@ export const inheritRouter = router({
                },
            });

-            await setInheritancePoint(ctx.db, userId, 'previous', currentPoint - inheritConst.inheritSpecificSpecialPoint);
+            await setInheritancePoint(
+                ctx.db,
+                userId,
+                'previous',
+                currentPoint - inheritConst.inheritSpecificSpecialPoint
+            );
            await appendInheritanceLog(
                ctx.db,
                userId,
@@ -460,7 +515,8 @@ export const inheritRouter = router({
        }

        const meta = asRecord(general.meta);
-        const prevList = parseJson<string[]>(typeof meta.prev_types_special2 === 'string' ? meta.prev_types_special2 : null) ?? [];
+        const prevList =
+            parseJson<string[]>(typeof meta.prev_types_special2 === 'string' ? meta.prev_types_special2 : null) ?? [];
        prevList.push(general.special2Code);

        await patchGeneral(ctx, general.id, {
@@ -473,7 +529,13 @@ export const inheritRouter = router({
        });

        await setInheritancePoint(ctx.db, userId, 'previous', currentPoint - cost);
-        await appendInheritanceLog(ctx.db, userId, worldState.currentYear, worldState.currentMonth, `${cost} 포인트로 전투 특기 초기화`);
+        await appendInheritanceLog(
+            ctx.db,
+            userId,
+            worldState.currentYear,
+            worldState.currentMonth,
+            `${cost} 포인트로 전투 특기 초기화`
+        );
        return { ok: true };
    }),
    resetTurnTime: authedProcedure.mutation(async ({ ctx }) => {
@@ -624,9 +686,7 @@ export const inheritRouter = router({
            const finalBonus =
                bonusSum === 0
                    ? buildRandomBonus(
-                          new LiteHashDRBG(
-                              `${asRecord(worldState.meta).hiddenSeed ?? 'inherit'}:ResetStat:${userId}`
-                          ),
+                          new LiteHashDRBG(`${asRecord(worldState.meta).hiddenSeed ?? 'inherit'}:ResetStat:${userId}`),
                          [input.leadership, input.strength, input.intel]
                      )
                    : (bonus as [number, number, number]);
@@ -674,9 +734,7 @@ export const inheritRouter = router({
            if (seasonValue !== null) {
                const userState = await readUserStateMeta(ctx.db, userId);
                const resetSeasons = readResetSeasons(userState);
-                const nextSeasons = resetSeasons.includes(seasonValue)
-                    ? resetSeasons
-                    : [...resetSeasons, seasonValue];
+                const nextSeasons = resetSeasons.includes(seasonValue) ? resetSeasons : [...resetSeasons, seasonValue];
                await writeUserStateMeta(ctx.db, userId, {
                    ...userState,
                    last_stat_reset: nextSeasons,
@@ -709,7 +767,10 @@ export const inheritRouter = router({
        }
        const meta = asRecord(general.meta);
        if (meta.inheritRandomUnique !== undefined && meta.inheritRandomUnique !== null) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: '이미 구입 명령을 내렸습니다. 다음 턴까지 기다려주세요.' });
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: '이미 구입 명령을 내렸습니다. 다음 턴까지 기다려주세요.',
+            });
        }

        await patchGeneral(ctx, general.id, {
@@ -803,7 +864,9 @@ export const inheritRouter = router({
                throw new TRPCError({ code: 'BAD_REQUEST', message: '자신의 정보는 확인할 수 없습니다.' });
            }

-            const ownerName = typeof asRecord(target.meta).ownerName === 'string' ? (asRecord(target.meta).ownerName as string) : target.userId;
+            const rawOwnerName = asRecord(target.meta).ownerName;
+            const ownerName =
+                typeof rawOwnerName === 'string' && rawOwnerName.trim().length > 0 ? rawOwnerName : '알수없음';

            await setInheritancePoint(ctx.db, userId, 'previous', currentPoint - inheritConst.inheritCheckOwnerPoint);
            await appendInheritanceLog(
@@ -0,0 +1,266 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import type { GameSessionTokenPayload } from '@sammo-ts/common/auth/gameToken';
+import type { RedisConnector } from '@sammo-ts/infra';
+
+import { RedisAccessTokenStore } from '../src/auth/accessTokenStore.js';
+import { InMemoryFlushStore } from '../src/auth/flushStore.js';
+import type { DatabaseClient, GameApiContext, GeneralRow } from '../src/context.js';
+import type { TurnDaemonTransport } from '../src/daemon/transport.js';
+import { appRouter } from '../src/router.js';
+
+const buildGeneral = (overrides: Partial<GeneralRow> = {}): GeneralRow => ({
+    id: 7,
+    userId: 'user-1',
+    name: '유비',
+    nationId: 1,
+    cityId: 1,
+    troopId: 0,
+    npcState: 0,
+    affinity: null,
+    bornYear: 180,
+    deadYear: 300,
+    picture: null,
+    imageServer: 0,
+    leadership: 70,
+    strength: 45,
+    intel: 85,
+    injury: 0,
+    experience: 0,
+    dedication: 0,
+    officerLevel: 1,
+    gold: 1000,
+    rice: 1000,
+    crew: 0,
+    crewTypeId: 0,
+    train: 0,
+    atmos: 0,
+    weaponCode: 'None',
+    bookCode: 'None',
+    horseCode: 'None',
+    itemCode: 'None',
+    turnTime: new Date('2026-07-26T00:00:00Z'),
+    recentWarTime: null,
+    age: 20,
+    startAge: 20,
+    personalCode: 'None',
+    specialCode: 'None',
+    special2Code: 'che_선봉',
+    lastTurn: {},
+    meta: {},
+    penalty: {},
+    createdAt: new Date('2026-07-26T00:00:00Z'),
+    updatedAt: new Date('2026-07-26T00:00:00Z'),
+    ...overrides,
+});
+
+const buildAuth = (userId = 'user-1'): GameSessionTokenPayload => ({
+    version: 1,
+    profile: 'che:default',
+    issuedAt: '2026-07-26T00:00:00.000Z',
+    expiresAt: '2026-07-27T00:00:00.000Z',
+    sessionId: `session-${userId}`,
+    user: {
+        id: userId,
+        username: userId,
+        displayName: userId,
+        roles: [],
+    },
+    sanctions: {},
+});
+
+const worldState = {
+    id: 1,
+    scenarioCode: 'default',
+    currentYear: 200,
+    currentMonth: 4,
+    tickSeconds: 3600,
+    config: {
+        const: {
+            availableSpecialWar: ['che_선봉'],
+            allItems: {
+                weapon: {
+                    che_무기_12_칠성검: 1,
+                    che_무기_01_단도: 0,
+                },
+            },
+        },
+    },
+    meta: { hiddenSeed: 'test-seed', isUnited: 0, season: 1 },
+    updatedAt: new Date('2026-07-26T00:00:00Z'),
+};
+
+const buildContext = (options: {
+    auth?: GameSessionTokenPayload | null;
+    general?: GeneralRow | null;
+    target?: GeneralRow | null;
+    inheritancePoint?: number;
+}) => {
+    const auth = options.auth === undefined ? buildAuth() : options.auth;
+    const general = options.general === undefined ? buildGeneral() : options.general;
+    const target =
+        options.target === undefined
+            ? buildGeneral({ id: 8, userId: 'user-2', name: '조조', meta: { ownerName: '위유저' } })
+            : options.target;
+    const requestCommand = vi.fn(async (command: { type: string; generalId: number }) => ({
+        type: command.type,
+        ok: true,
+        generalId: command.generalId,
+    }));
+    const pointUpsert = vi.fn(async () => ({}));
+    const logCreate = vi.fn(async () => ({}));
+    const findMany = vi.fn(async () => (target ? [{ id: target.id, name: target.name }] : []));
+    const db = {
+        $queryRaw: vi.fn(async () => [{ value: options.inheritancePoint ?? 10_000 }]),
+        worldState: {
+            findFirst: vi.fn(async () => worldState),
+        },
+        general: {
+            findFirst: vi.fn(async ({ where }: { where: { userId: string } }) =>
+                general?.userId === where.userId ? general : null
+            ),
+            findMany,
+            findUnique: vi.fn(async ({ where }: { where: { id: number } }) =>
+                target?.id === where.id ? target : null
+            ),
+        },
+        inheritancePoint: {
+            upsert: pointUpsert,
+        },
+        inheritanceLog: {
+            create: logCreate,
+            findMany: vi.fn(async () => []),
+        },
+        inheritanceUserState: {
+            findUnique: vi.fn(async () => null),
+            upsert: vi.fn(async () => ({})),
+        },
+    };
+    const accessTokenStore = new RedisAccessTokenStore(
+        {
+            get: async () => null,
+            set: async () => null,
+        },
+        'che:default'
+    );
+    const context: GameApiContext = {
+        db: db as unknown as DatabaseClient,
+        redis: {} as RedisConnector['client'],
+        turnDaemon: { requestCommand } as unknown as TurnDaemonTransport,
+        battleSim: {} as GameApiContext['battleSim'],
+        profile: { id: 'che', scenario: 'default', name: 'che:default' },
+        auth,
+        uploadDir: 'uploads',
+        uploadPath: '/uploads',
+        uploadPublicUrl: null,
+        accessTokenStore,
+        flushStore: new InMemoryFlushStore(),
+        gameTokenSecret: 'test-secret',
+    };
+    return { context, requestCommand, pointUpsert, logCreate, findMany };
+};
+
+describe('inherit router actor and permission boundaries', () => {
+    it('rejects unauthenticated status and mutations', async () => {
+        const fixture = buildContext({ auth: null });
+        const caller = appRouter.createCaller(fixture.context);
+
+        await expect(caller.inherit.getStatus()).rejects.toMatchObject({ code: 'UNAUTHORIZED' });
+        await expect(caller.inherit.buyHiddenBuff({ type: 'warAvoidRatio', level: 1 })).rejects.toMatchObject({
+            code: 'UNAUTHORIZED',
+        });
+        expect(fixture.requestCommand).not.toHaveBeenCalled();
+    });
+
+    it('builds status only from the authenticated user general and filters target generals like ref', async () => {
+        const fixture = buildContext({});
+        const status = await appRouter.createCaller(fixture.context).inherit.getStatus();
+
+        expect(status.currentStat).toEqual({ leadership: 70, strength: 45, intel: 85 });
+        expect(status.availableTargetGenerals).toEqual([{ id: 8, name: '조조' }]);
+        expect(status.availableUnique).toEqual([
+            expect.objectContaining({ key: 'che_무기_12_칠성검', rawName: '칠성검' }),
+        ]);
+        expect(status.buffLevels).toHaveProperty('domesticSuccessProb', 0);
+        expect(fixture.findMany).toHaveBeenCalledWith({
+            where: { id: { not: 7 }, npcState: { lt: 2 }, userId: { not: null } },
+            select: { id: true, name: true },
+            orderBy: { id: 'asc' },
+        });
+    });
+
+    it('does not dispatch or charge when the authenticated user owns no general', async () => {
+        const fixture = buildContext({
+            auth: buildAuth('user-2'),
+            general: buildGeneral({ userId: 'user-1' }),
+        });
+
+        await expect(
+            appRouter.createCaller(fixture.context).inherit.buyHiddenBuff({
+                type: 'domesticSuccessProb',
+                level: 1,
+            })
+        ).rejects.toMatchObject({
+            code: 'PRECONDITION_FAILED',
+            message: '장수가 존재하지 않습니다.',
+        });
+        expect(fixture.requestCommand).not.toHaveBeenCalled();
+        expect(fixture.pointUpsert).not.toHaveBeenCalled();
+    });
+
+    it('mutates only the authenticated user general and inheritance balance', async () => {
+        const fixture = buildContext({ inheritancePoint: 1000 });
+
+        await expect(
+            appRouter.createCaller(fixture.context).inherit.buyHiddenBuff({
+                type: 'domesticSuccessProb',
+                level: 1,
+            })
+        ).resolves.toEqual({ ok: true, remainPoint: 800 });
+
+        expect(fixture.requestCommand).toHaveBeenCalledWith(
+            expect.objectContaining({
+                type: 'patchGeneral',
+                generalId: 7,
+                patch: expect.objectContaining({
+                    meta: expect.objectContaining({
+                        inheritBuff: JSON.stringify({ domesticSuccessProb: 1 }),
+                    }),
+                }),
+            })
+        );
+        expect(fixture.pointUpsert).toHaveBeenCalledWith(
+            expect.objectContaining({
+                where: { userId_key: { userId: 'user-1', key: 'previous' } },
+                update: { value: 800 },
+            })
+        );
+    });
+
+    it('reveals a target owner to the caller without using the caller general id from input', async () => {
+        const fixture = buildContext({ inheritancePoint: 1500 });
+
+        await expect(
+            appRouter.createCaller(fixture.context).inherit.checkOwner({ targetGeneralId: 8 })
+        ).resolves.toEqual({
+            ok: true,
+            ownerName: '위유저',
+            targetName: '조조',
+        });
+        expect(fixture.pointUpsert).toHaveBeenCalledWith(
+            expect.objectContaining({
+                where: { userId_key: { userId: 'user-1', key: 'previous' } },
+                update: { value: 500 },
+            })
+        );
+        expect(fixture.logCreate).toHaveBeenCalledWith({
+            data: {
+                userId: 'user-1',
+                year: 200,
+                month: 4,
+                text: '1000 포인트로 장수 소유자 확인',
+            },
+        });
+        expect(fixture.requestCommand).not.toHaveBeenCalled();
+    });
+});