feat: 플레이 감사 장수 로그를 기수별로 조회

app/game-api/test/messagesRouter.test.ts

@@ -1049,6 +1049,7 @@ describe('messages router missing-flow compatibility', () => {
                     findFirst: vi.fn(async () => ({
                         currentYear: 200,
                         currentMonth: 3,
+                        meta: { serverId: 'diplomatic-response-audit' },
                         config: { environment: { mapName: 'che' } },
                         clockBaseTime: new Date('0200-03-01T00:00:00.000Z'),
                         clockTick: 1_000n,
@@ -1116,6 +1117,9 @@ describe('messages router missing-flow compatibility', () => {
             cityIds: [],
         });
         expect(setup.diplomacyUpdate).toHaveBeenCalledTimes(2);
+        expect(setup.logCreateMany).toHaveBeenCalledWith({
+            data: expect.arrayContaining([expect.objectContaining({ serverId: 'diplomatic-response-audit' })]),
+        });
         expect(setup.nationUpdate).toHaveBeenCalledWith(
             expect.objectContaining({
                 where: { id: 2 },
@@ -1147,6 +1151,9 @@ describe('messages router missing-flow compatibility', () => {
         expect(setup.diplomacyUpdate).not.toHaveBeenCalled();
         expect(setup.messageUpdateMany).toHaveBeenCalledOnce();
         expect(setup.logCreateMany).toHaveBeenCalledOnce();
+        expect(setup.logCreateMany).toHaveBeenCalledWith({
+            data: expect.arrayContaining([expect.objectContaining({ serverId: 'diplomatic-response-audit' })]),
+        });
     });
 
     it('permanently records rejection of an NPC aid-based non-aggression proposal', async () => {
@@ -1217,6 +1224,9 @@ describe('messages router missing-flow compatibility', () => {
 
         expect(result).toEqual({ result: true, reason: 'success' });
         expect(setup.diplomacyUpdate).toHaveBeenCalledTimes(2);
+        expect(setup.logCreateMany).toHaveBeenCalledWith({
+            data: expect.arrayContaining([expect.objectContaining({ serverId: 'diplomatic-response-audit' })]),
+        });
         if (action === 'stopWar') {
             expect(setup.cityUpdate).toHaveBeenCalledTimes(2);
             expect(setup.cityUpdate).toHaveBeenCalledWith({
@@ -1255,6 +1265,9 @@ describe('messages router missing-flow compatibility', () => {
         expect(setup.diplomacyUpdate).not.toHaveBeenCalled();
         expect(setup.messageUpdateMany).not.toHaveBeenCalled();
         expect(setup.logCreateMany).toHaveBeenCalledOnce();
+        expect(setup.logCreateMany).toHaveBeenCalledWith({
+            data: expect.arrayContaining([expect.objectContaining({ serverId: 'diplomatic-response-audit' })]),
+        });
     });
 
     it('does not let another nation process the diplomatic inbox row', async () => {

app/game-api/test/securityTransport.integration.test.ts

@@ -2238,6 +2238,87 @@ integration('game API security over HTTP transport', () => {
             });
             const admin = await token([`admin.playAudit.read:${profileName}`]);
             const beforeInputs = await db.inputEvent.count();
+            const logGeneralId = 99129; // No live general: death must not hide retained records.
+            const ownLogs = await Promise.all(
+                ['HISTORY', 'ACTION', 'BATTLE_BRIEF', 'BATTLE_DETAIL'].map((category) =>
+                    db.logEntry.create({
+                        data: {
+                            serverId: seasonId,
+                            generalId: logGeneralId,
+                            scope: 'GENERAL',
+                            category: category as 'HISTORY' | 'ACTION' | 'BATTLE_BRIEF' | 'BATTLE_DETAIL',
+                            year: 190,
+                            month: 1,
+                            text: `${seasonId}:${category}`,
+                        },
+                    })
+                )
+            );
+            const latest = await db.logEntry.create({
+                data: {
+                    serverId: seasonId,
+                    generalId: logGeneralId,
+                    scope: 'GENERAL',
+                    category: 'HISTORY',
+                    year: 190,
+                    month: 2,
+                    text: `${seasonId}:latest`,
+                },
+            });
+            await db.logEntry.createMany({
+                data: [null, `${seasonId}:previous`].map((serverId) => ({
+                    serverId,
+                    generalId: logGeneralId,
+                    scope: 'GENERAL' as const,
+                    category: 'HISTORY' as const,
+                    year: 190,
+                    month: 1,
+                    text: `${seasonId}:excluded`,
+                })),
+            });
+            for (const [index, type] of ['generalHistory', 'generalAction', 'battleResult', 'battleDetail'].entries()) {
+                const result = await get('generalLogs', admin, {
+                    generalId: logGeneralId,
+                    type,
+                    month: { year: 190, month: 1 },
+                });
+                expect(result.status).toBe(200);
+                expect(result.body).toMatchObject({
+                    result: {
+                        data: {
+                            coverage: 'IDENTIFIED_LOGS_ONLY',
+                            items: [{ id: ownLogs[index]!.id }],
+                            nextCursor: null,
+                        },
+                    },
+                });
+                expect(JSON.stringify(result.body)).not.toContain(`${seasonId}:excluded`);
+            }
+            expect(
+                (await get('generalLogs', admin, { generalId: logGeneralId, type: 'generalHistory', limit: 1 })).body
+            ).toMatchObject({ result: { data: { items: [{ id: latest.id }], nextCursor: latest.id } } });
+            expect(
+                (
+                    await get('generalLogs', admin, {
+                        generalId: logGeneralId,
+                        type: 'generalHistory',
+                        limit: 1,
+                        cursor: latest.id,
+                    })
+                ).body
+            ).toMatchObject({ result: { data: { items: [{ id: ownLogs[0]!.id }], nextCursor: null } } });
+            for (const invalid of [
+                { limit: 201 },
+                { cursor: 0 },
+                { month: { year: 190, month: 3 } },
+                { month: { year: 189, month: 12 } },
+            ]) {
+                expect(
+                    (await get('generalLogs', admin, { generalId: logGeneralId, type: 'generalHistory', ...invalid }))
+                        .status
+                ).toBe(400);
+            }
+
             expect((await get('generalDetail', admin, { id: generalId })).body).toMatchObject({
                 result: { data: { collected: true, general: { id: generalId, name: current.name } } },
             });
@@ -2512,6 +2593,7 @@ integration('game API security over HTTP transport', () => {
             );
             await expect.poll(async () => (await get('capabilities', admin)).status).toBe(401);
         } finally {
+            await db.logEntry.deleteMany({ where: { text: { startsWith: `${seasonId}:` } } });
             await db.playAuditMonth.deleteMany({ where: { serverId: seasonId } });
             await db.generalTurn.deleteMany({ where: { generalId, turnIdx: { in: [9001, 9002] } } });
             await db.nation.deleteMany({ where: { id: { in: [99121, 99122] } } });

app/game-api/test/selectPool.integration.test.ts

@@ -338,7 +338,7 @@ integration('scenario 903 select pool through the durable turn daemon', () => {
         ).toBe(initial.name);
         expect(
             await db.logEntry.count({
-                where: { meta: { path: ['ownerUserId'], equals: userId } },
+                where: { serverId: profile, meta: { path: ['ownerUserId'], equals: userId } },
             })
         ).toBe(2);
         if (realtimeHub) {
@@ -432,7 +432,7 @@ integration('scenario 903 select pool through the durable turn daemon', () => {
         ).toBe(target.uniqueName);
         expect(
             await db.logEntry.count({
-                where: { meta: { path: ['ownerUserId'], equals: userId } },
+                where: { serverId: profile, meta: { path: ['ownerUserId'], equals: userId } },
             })
         ).toBe(4);