fix(core,board,ecommerce,page,gdpr): 목록 컨텍스트 왕복·엔진 렌더 파이프 결함 일괄 수정 + 공개문서 정리

세 갈래의 결함을 한 브랜치에서 정리한다.

## 목록 컨텍스트 왕복 시 URL 상태 소실 ( @jiwonpapa 님께서 제보해주셨습니다.)

목록에서 상세·형제 상세(이전/다음)·작성/수정 폼에 다녀오면 보고 있던
page/search/category/filters 가 사라지던 문제를 전 도메인에서 수정했다.

- 엔진(engine-v1.54.2): `mergeQuery: true` 만 적고 `query` 를 생략하면 병합이
 통째로 건너뛰어지던 함정을 교정 — `ActionDispatcher.handleNavigate`/`handleReplaceUrl`.
- 게시판·이커머스·페이지·회원·마이페이지·gdpr 등 9개 확장 레이아웃의 왕복 leg 전수
 적용(mergeQuery: true). 의도적 리셋(검색/필터 초기화·탭 전환·프리셋)은 면제 주석으로 구분.
- 무한스크롤 목록(브랜드·상품 공통정보·고시정보)의 새로고침이 URL 검색·정렬을 떨구던
 결함 수정.
- 재발 차단: audit 룰 `layout-list-context-navigate-merge-query`(목록 클러스터 자동 도출,
 page/필터 URL 신호 4종) + `layout-navigate-path-absolute`(navigate path 동작 키워드 금지).

## cellChildren 등 반복 렌더에서 단일 바인딩 파이프 미적용 ( @glitter-gim 님께서 제보해주셨습니다.)

목록 표의 각 칸에 넣은 날짜·숫자 서식(`{{row.x | datetime(...)}}`)이 빈 값이 되거나
서식 없는 원본으로 나오던 문제를, 표현식 판정 로직이 엔진 전역에 복제되며 갈라진
구조적 결함으로 진단하고 판정 경로를 단일화했다(engine-v1.54.3).

- `RenderHelpers`(renderItemChildren·evaluateIfCondition)·`ConditionEvaluator`·
 `DataBindingEngine.resolveObject`·`DynamicRenderer` props 5곳에 단일 바인딩 파이프 분기 추가.
- 계획: `g7-scalable-lobster.md`(렌더 경로 비대칭 결함 일괄 수정).

## 공개 문서 내부 도구 귀속 제거

release 에 포함되는 공개 문서(`docs/**`)에서 내부 audit 룰 ID 귀속 서술을
도구 비귀속 표현("정적 검사")으로 정리. 재발 차단 룰 `public-no-internal-audit-reference` 신설.

전 계층 테스트(PHPUnit·Vitest·Playwright)·회귀 테스트 동반, 버전/CHANGELOG/활성 디렉토리 동기 완료.
This commit is contained in:
HeuJung committed 2026-07-26 15:17:56 +09:00
1 parent b3efcb8366
commit b505ac7ba7
184 files changed
+3830 -448

No files matched your search

@@ -6,6 +6,10 @@
## [0.1.0] - 2026-07-01
### Fixed
- 메모 목록에서 작성·수정 화면에 다녀오면 보고 있던 페이지가 사라지고 1페이지로 되돌아가던 문제를 수정했습니다. (#75 @jiwonpapa 님께서 제보해주셨습니다.)
### Changed
- 메모 관리 화면의 콘텐츠 카드 외형을 sirsoft-admin_basic 표준 시맨틱 (.admin-card) 과 정합 — 다른 관리자 화면과 같은 결로 통일.
@@ -142,7 +142,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/memos"
"path": "/admin/memos",
"mergeQuery": true,
"query": {}
}
}
],
@@ -183,7 +185,9 @@
{
"handler": "navigate",
"params": {
"path": "/admin/memos"
"path": "/admin/memos",
"mergeQuery": true,
"query": {}
}
}
],
@@ -75,7 +75,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/memos/create"
"path": "/admin/memos/create",
"mergeQuery": true,
"query": {}
}
}
],
@@ -18,6 +18,8 @@
### Fixed
- 관리자 게시글 목록에서 글을 열어 이전글·다음글로 넘어가거나 수정 후 돌아올 때 보고 있던 페이지·검색어·분류가 사라지던 문제를 수정했습니다. 목록 ↔ 상세 ↔ 이전/다음 글 ↔ 작성·수정 폼 어디로 오가든 목록 상태가 유지되며, 신고 관리와 게시판 목록도 동일하게 개선됐습니다. 새로고침 버튼도 걸어 둔 검색·필터를 지운 채 새로 부르지 않고 보고 있던 목록을 그대로 다시 부릅니다. (#75 @jiwonpapa 님께서 제보해주셨습니다.)
- 관리자 게시글 목록에서 뒤쪽 페이지를 보던 중 검색하거나 게시 상태를 바꾸면 그 페이지 번호가 그대로 유지돼 결과가 없는 빈 화면이 열리던 문제를 수정했습니다. 검색과 상태 변경은 1페이지부터 보여주며, 사용자가 고른 표시 개수와 정렬은 그대로 유지됩니다. 검색창에서 엔터를 치는 경우와 검색 버튼을 누르는 경우가 서로 다르게 동작하던 것도 함께 맞췄습니다. (#75 @jiwonpapa 님께서 제보해주셨습니다.)
- 첨부파일을 사용하지 않는 게시판을 아무것도 바꾸지 않고 저장해도 "허용 파일 확장자를 최소 1개 이상 입력하세요" 오류가 나며 저장이 막히던 문제를 수정했습니다. 첨부를 쓰지 않는 게시판에서는 허용 확장자를 비워 두어도 정상적으로 저장됩니다. 게시판 환경설정의 기본값도 동일하게 동작합니다. (#78 @jiwonpapa 님께서 제보해주셨습니다.)
- 새 글 표시 기간을 "0시간"(새 글 표시 안 함)으로 저장할 수 없던 문제를 수정했습니다. 0은 원래 새 글 배지를 끄는 값으로 동작하도록 되어 있었으나 저장 단계에서 막혀 있었습니다.
- 게시판 환경설정에서 제목·댓글 최소 길이를 0(제한 없음)으로 저장할 수 없던 문제를 수정했습니다. 내용 최소 길이는 0이 허용되어 같은 화면에서 항목마다 동작이 달랐습니다.
@@ -0,0 +1,347 @@
/**
* @file admin-list-context-round-trip.test.ts
* @description 관리자 게시판 목록 컨텍스트 왕복 시 URL 목록 상태 보존 회귀 (#75)
*
* 결함: 목록(`/admin/board/{slug}`) 에서 상세로 들어간 뒤 이전글/다음글/폼취소/삭제후복귀를
* 거치면 navigate 가 `mergeQuery` 없이 실행되어 page/search/category/filters 가 URL 에서
* 사라졌다. 그 뒤 '목록' 버튼은 복원할 상태가 없어 1페이지로 되돌아간다.
*
* 검증 방식 2단:
* 1. 실 레이아웃 JSON 전수 분석 — 클러스터 내 navigate 가 모두 `mergeQuery: true` 인지
* 2. 실 액션을 엔진에 태워 실행(`triggerAction`) — 선언이 실제 목적지 URL 로 이어지는지
* 손으로 쓴 조각이 아니라 실 레이아웃 JSON 을 읽는다. 실파일이 규약을 어기면 red 여야 한다.
* 선언만 검사하면 "JSON 에 리터럴이 적혀 있다" 까지만 고정되고 병합 결과는 미검증으로 남는다.
*
* @scenario leg=row_click|prev|next|form_cancel|delete_return
* @effects navigation_preserves_list_query
*
* @vitest-environment jsdom
*/
import { describe, it, expect, afterEach } from 'vitest';
import fs from 'fs';
import path from 'path';
import {
createLayoutTest,
createMockComponentRegistryWithBasics,
} from '@core/template-engine/__tests__/utils/layoutTestUtils';
const LAYOUTS_ROOT = path.resolve(__dirname, '../../../layouts/admin');
/**
* 레이아웃 파일 → 그 화면이 속한 목록 클러스터.
*
* 클러스터는 파일 단위로 다르다. 예를 들어 게시판 목록(`/admin/boards`)에서 특정 게시판의
* 글 목록(`/admin/board/{slug}`)으로 가는 것은 왕복이 아니라 **다른 목록으로의 진입**이므로
* 병합 대상이 아니다. 확장 전체에 하나의 목록 목록을 적용하면 이런 이동까지 위반으로 잡힌다.
*/
const CLUSTER_FILES: Array<[string, string]> = [
['admin_board_posts_index.json', '/admin/board/*'],
['admin_board_post_detail.json', '/admin/board/*'],
['admin_board_post_form.json', '/admin/board/*'],
['partials/admin_board_post_detail/_post_card_content.json', '/admin/board/*'],
['partials/admin_board_post_detail/_reply_card_content.json', '/admin/board/*'],
['admin_board_index.json', '/admin/boards'],
['admin_board_form.json', '/admin/boards'],
['admin_board_reports_index.json', '/admin/boards/reports'],
['admin_board_reports_detail.json', '/admin/boards/reports'],
['partials/admin_board_reports_detail/_card_report_info.json', '/admin/boards/reports'],
];
type NavAction = {
handler: string;
comment?: string;
params: { path?: string; mergeQuery?: unknown; query?: unknown };
};
/**
* JSON 트리에서 navigate/replaceUrl 액션을 모두 수집합니다.
*
* @param node 순회 시작 노드
* @returns 액션 목록
*/
function collectNavActions(node: unknown): NavAction[] {
const out: NavAction[] = [];
const walk = (n: unknown): void => {
if (Array.isArray(n)) {
n.forEach(walk);
return;
}
if (!n || typeof n !== 'object') return;
const obj = n as Record<string, unknown>;
if (
(obj.handler === 'navigate' || obj.handler === 'replaceUrl') &&
obj.params &&
typeof obj.params === 'object'
) {
out.push(obj as unknown as NavAction);
}
Object.values(obj).forEach(walk);
};
walk(node);
return out;
}
/**
* 목적지 경로를 비교용 표준형(`{{expr}}` → `*`)으로 바꿉니다.
*
* @param raw 원본 경로
* @returns 표준형 경로 (판정 불가 시 null)
*/
function normalizePath(raw: unknown): string | null {
if (typeof raw !== 'string' || raw === '') return null;
const p = raw.replace(/\{\{[^}]*\}\}/g, '*').split('?')[0].replace(/\/+$/, '');
return p.startsWith('/') ? p : null;
}
/**
* 경로가 목록 라우트와 같은 클러스터인지 판정합니다.
*
* @param dest 표준형 목적지
* @param list 표준형 목록 라우트
* @returns 같은 클러스터 여부
*/
function inFamily(dest: string, list: string): boolean {
return dest === list || dest.startsWith(`${list}/`);
}
/**
* 레이아웃 파일을 읽어 파싱합니다.
*
* @param rel 레이아웃 루트 기준 상대 경로
* @returns 파싱된 JSON
*/
function readLayout(rel: string): unknown {
return JSON.parse(fs.readFileSync(path.join(LAYOUTS_ROOT, rel), 'utf8'));
}
describe('#75 관리자 게시판 목록 컨텍스트 왕복 — mergeQuery 전수', () => {
it.each(CLUSTER_FILES)('%s (클러스터 %s) 내 navigate 는 모두 mergeQuery: true', (rel, list) => {
const offenders = collectNavActions(readLayout(rel))
.filter((a) => {
if (typeof a.comment === 'string' && a.comment.includes('audit:allow')) return false;
const dest = normalizePath(a.params.path);
if (!dest) return a.params.mergeQuery !== undefined && a.params.mergeQuery !== true;
if (!inFamily(dest, list)) return false;
return a.params.mergeQuery !== true;
})
.map((a) => `${a.params.path} (mergeQuery=${JSON.stringify(a.params.mergeQuery)})`);
expect(offenders, `목록 상태를 떨구는 navigate: \n ${offenders.join('\n ')}`).toEqual([]);
});
});
describe('#75 개별 leg 고정', () => {
/**
* 특정 목적지로 가는 첫 navigate 액션을 찾습니다.
*
* @param rel 레이아웃 상대 경로
* @param destPath 목적지 경로(원문 그대로)
* @returns 액션
*/
const leg = (rel: string, destPath: string): NavAction => {
const hit = collectNavActions(readLayout(rel)).find((a) => a.params.path === destPath);
if (!hit) throw new Error(`${rel} 에서 "${destPath}" navigate 를 찾지 못했습니다.`);
return hit;
};
it('상세 이전글 leg 이 목록 상태를 승계한다', () => {
const a = leg(
'partials/admin_board_post_detail/_post_card_content.json',
'/admin/board/{{route.slug}}/post/{{post?.data?.navigation?.prev?.id}}'
);
expect(a.params.mergeQuery).toBe(true);
});
it('상세 다음글 leg 이 목록 상태를 승계한다', () => {
const a = leg(
'partials/admin_board_post_detail/_post_card_content.json',
'/admin/board/{{route.slug}}/post/{{post?.data?.navigation?.next?.id}}'
);
expect(a.params.mergeQuery).toBe(true);
});
it("상세 '목록' 버튼이 목록 상태를 복원한다", () => {
const a = leg('admin_board_post_detail.json', '/admin/board/{{route.slug}}');
expect(a.params.mergeQuery).toBe(true);
});
it('목록 행 클릭이 목록 상태를 상세로 나른다', () => {
const a = leg('admin_board_posts_index.json', '/admin/board/{{row.slug}}/post/{{row.id}}');
expect(a.params.mergeQuery).toBe(true);
});
it('삭제 확인 후 복귀 navigate 의 mergeQuery 가 분기 표현식이 아니다', () => {
const dynamic = collectNavActions(readLayout('admin_board_post_detail.json')).filter(
(a) => 'mergeQuery' in a.params && typeof a.params.mergeQuery !== 'boolean'
);
expect(dynamic.map((a) => a.params.path)).toEqual([]);
});
});
// ---------------------------------------------------------------------------
// 실행 검증 — 실 액션을 엔진에 태워 목적지 URL 을 확인한다
// ---------------------------------------------------------------------------
/**
* 실 JSON 액션을 현재 URL 상태에서 실행하고 목적지를 돌려줍니다.
*
* @param action 실 레이아웃 JSON 에서 뽑은 navigate 액션
* @returns navigate 목적지 경로
*/
async function runNav(action: NavAction): Promise<string> {
const utils = createLayoutTest(
{
version: '1.0.0',
layout_name: 'nav_action_probe',
data_sources: [],
components: [{ type: 'basic', name: 'Div', props: { 'data-testid': 'probe' } }],
} as never,
{ componentRegistry: createMockComponentRegistryWithBasics() as never, locale: 'ko' }
);
await utils.render();
await utils.triggerAction({ type: 'click', ...action } as never);
const dest = utils.getNavigationHistory()[0];
utils.cleanup();
return dest;
}
/**
* 목적지 URL 의 쿼리스트링을 파싱합니다.
*
* @param dest navigate 목적지
* @returns URLSearchParams
*/
function queryOf(dest: string): URLSearchParams {
return new URLSearchParams(dest.includes('?') ? dest.slice(dest.indexOf('?')) : '');
}
/**
* 특정 목적지로 가는 첫 navigate 액션을 찾습니다.
*
* @param rel 레이아웃 상대 경로
* @param destPath 목적지 경로(원문 그대로)
* @returns 액션
*/
function navLeg(rel: string, destPath: string): NavAction {
const hit = collectNavActions(readLayout(rel)).find((a) => a.params.path === destPath);
if (!hit) throw new Error(`${rel} 에서 "${destPath}" navigate 를 찾지 못했습니다.`);
return hit;
}
describe('#75 관리자 게시판 목록 컨텍스트 왕복 — 실행 결과 URL', () => {
afterEach(() => {
window.history.replaceState({}, '', '/');
});
const legs: Array<[string, string]> = [
['이전글', '/admin/board/{{route.slug}}/post/{{post?.data?.navigation?.prev?.id}}'],
['다음글', '/admin/board/{{route.slug}}/post/{{post?.data?.navigation?.next?.id}}'],
];
it.each(legs)('%s leg 실행 시 page/search/category 가 모두 살아남는다', async (_label, destPath) => {
window.history.replaceState({}, '', '/admin/board/free/post/45?page=2&search=테스트&category=공지');
const q = queryOf(await runNav(navLeg('partials/admin_board_post_detail/_post_card_content.json', destPath)));
expect(q.get('page')).toBe('2');
expect(q.get('search')).toBe('테스트');
expect(q.get('category')).toBe('공지');
});
it("상세 '목록' 버튼 실행 시 목록 상태가 그대로 복귀된다", async () => {
window.history.replaceState({}, '', '/admin/board/free/post/45?page=2&search=테스트');
const q = queryOf(await runNav(navLeg('admin_board_post_detail.json', '/admin/board/{{route.slug}}')));
expect(q.get('page')).toBe('2');
expect(q.get('search')).toBe('테스트');
});
it('검색 실행(Enter) 은 page 를 떨구고 표시 개수는 유지한다', async () => {
window.history.replaceState({}, '', '/admin/board/free?page=5&per_page=30&sort_by=created_at');
const action = collectNavActions(readLayout('admin_board_posts_index.json')).find(
(a) => (a as unknown as { type?: string }).type === 'keypress'
);
expect(action, 'admin_board_posts_index.json 에 검색 Enter navigate 가 없습니다.').toBeTruthy();
const q = queryOf(await runNav(action as NavAction));
// page 는 새 검색이므로 1페이지로 되돌린다(파라미터 제거). 되돌리지 않으면 결과의 5페이지로 가 빈 화면이 열린다.
expect(q.get('page')).toBeNull();
expect(q.get('per_page')).toBe('30');
expect(q.get('sort_by')).toBe('created_at');
});
it('이전글 → 목록 순서로 이어가도 목록 페이지가 복원된다', async () => {
window.history.replaceState({}, '', '/admin/board/free/post/45?page=2&search=테스트');
// ① 이전글로 이동 → 이동 결과를 실제 URL 로 반영 (다음 leg 의 mergeQuery 입력)
const afterPrev = await runNav(
navLeg(
'partials/admin_board_post_detail/_post_card_content.json',
'/admin/board/{{route.slug}}/post/{{post?.data?.navigation?.prev?.id}}'
)
);
window.history.replaceState({}, '', afterPrev);
// ② 그 상태에서 '목록' 복귀
const q = queryOf(await runNav(navLeg('admin_board_post_detail.json', '/admin/board/{{route.slug}}')));
expect(q.get('page')).toBe('2');
expect(q.get('search')).toBe('테스트');
});
});
// ---------------------------------------------------------------------------
// 검색·필터 변경 시 page 되돌림 (#75)
//
// mergeQuery 는 현재 페이지까지 함께 나른다. 그래서 목록을 좁히는 조건(검색어·카테고리·상태)을
// 바꾸는 액션은 page 를 명시적으로 되돌려야 한다. 되돌리지 않으면 5페이지를 보던 중 검색했을 때
// 결과의 5페이지로 이동해 빈 화면이 열린다. 한 화면 안에서 진입점마다 갈리면(버튼은 되돌리고
// Enter 는 안 되돌림) 같은 기능이 다르게 동작한다.
// ---------------------------------------------------------------------------
/** 목록을 좁히는 조건 키 — 바뀌면 결과 건수가 달라지므로 page 를 되돌려야 한다. */
const NARROWING_KEY = /^(filters\[\d+\]\[value\]|search|search_keyword|category|status|target_status|type)$/;
/** page 되돌림으로 인정하는 값 — `""`(파라미터 제거) 또는 1. */
function isPageReset(value: unknown): boolean {
return value === '' || value === 1 || value === '1';
}
describe('#75 검색·필터 액션은 page 를 되돌린다 — 전수', () => {
it.each([['admin_board_posts_index.json'], ['admin_board_reports_index.json']])(
'%s 의 조건 변경 navigate 는 모두 page 를 되돌린다',
(rel) => {
const offenders = collectNavActions(readLayout(rel))
.filter((a) => {
const q = a.params.query;
if (!q || typeof q !== 'object' || Array.isArray(q)) return false;
const keys = Object.keys(q as Record<string, unknown>);
if (!keys.some((k) => NARROWING_KEY.test(k))) return false;
return !isPageReset((q as Record<string, unknown>).page);
})
.map((a) => `${a.params.path} → ${JSON.stringify(a.params.query)}`);
expect(offenders, `조건을 바꾸면서 page 를 그대로 두는 navigate: \n ${offenders.join('\n ')}`).toEqual(
[]
);
}
);
// mergeQuery 가 이미 현재 정렬을 나르므로, 검색 액션이 정렬을 다시 적어 보낼 필요가 없다.
// 열거가 남아 있으면 다음 편집자가 "여기에 적힌 값이 정렬의 근거" 로 오해한다 (기본값은 데이터소스가 정한다).
it('신고 목록 검색 액션은 정렬 키를 다시 적어 보내지 않는다', () => {
const search = (readLayout('admin_board_reports_index.json') as {
named_actions: { searchBoardReports: NavAction };
}).named_actions.searchBoardReports;
const keys = Object.keys(search.params.query as Record<string, unknown>);
expect(keys).not.toContain('sort_by');
expect(keys).not.toContain('sort_order');
});
});
@@ -325,7 +325,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/boards"
"path": "/admin/boards",
"mergeQuery": true,
"query": {}
}
}
]
@@ -357,7 +359,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/boards"
"path": "/admin/boards",
"mergeQuery": true,
"query": {}
}
}
]
@@ -69,11 +69,13 @@
},
"actions": [
{
"comment": "새로고침은 보고 있던 목록을 그대로 다시 부르는 것이다 — 페이지/검색을 유지한다 (#75).",
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/boards",
"mergeQuery": false
"mergeQuery": true,
"query": {}
}
}
],
@@ -102,7 +104,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/boards/create"
"path": "/admin/boards/create",
"mergeQuery": true,
"query": {}
}
}
],
@@ -341,8 +345,8 @@
"handler": "navigate",
"params": {
"path": "/admin/boards/{{row.slug}}/edit",
"mergeQuery": false,
"query": []
"mergeQuery": true,
"query": {}
}
},
"manage_posts": {
@@ -638,10 +642,15 @@
"target": "copy_confirm_modal"
},
{
"comment": "복사 생성 폼으로 이동 — copy_id 는 query 로 넘긴다. mergeQuery 는 path 의 인라인 쿼리스트링을 버리므로 path 에 붙여두면 사라진다 (#75).",
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/boards/create?copy_id={{_global.modal_data.id}}"
"path": "/admin/boards/create",
"mergeQuery": true,
"query": {
"copy_id": "{{_global.modal_data.id}}"
}
}
}
]
@@ -120,7 +120,8 @@
"handler": "navigate",
"params": {
"path": "/admin/board/{{route.slug}}/post/{{route?.id}}",
"mergeQuery": false
"mergeQuery": true,
"query": {}
}
}
],
@@ -147,7 +148,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/board/{{route.slug}}"
"path": "/admin/board/{{route.slug}}",
"mergeQuery": true,
"query": {}
}
}
],
@@ -377,10 +380,12 @@
"if": "{{_global.modal_data?.type === 'comment'}}"
},
{
"comment": "삭제 후 복귀 — 게시글이면 목록으로, 답변이면 원글 상세로 돌아간다. 어느 쪽이든 목록 클러스터 안이므로 목록 상태를 유지한다. 종전에는 mergeQuery 가 분기 표현식이라 답변 삭제 경로에서만 페이지/검색이 조용히 사라졌다 (#75).",
"handler": "navigate",
"params": {
"path": "{{_global.modal_data?.type === 'post' ? '/admin/board/' + route.slug : '/admin/board/' + route.slug + '/post/' + route.id}}",
"mergeQuery": "{{_global.modal_data?.type === 'post'}}"
"mergeQuery": true,
"query": {}
},
"if": "{{_global.modal_data?.type !== 'comment'}}"
},
@@ -139,7 +139,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "{{route?.id ? '/admin/board/' + route.slug + '/post/' + route.id : '/admin/board/' + route.slug}}"
"path": "{{route?.id ? '/admin/board/' + route.slug + '/post/' + route.id : '/admin/board/' + route.slug}}",
"mergeQuery": true,
"query": {}
}
}
],
@@ -206,7 +208,9 @@
{
"handler": "navigate",
"params": {
"path": "/admin/board/{{route.slug}}/post/{{route?.id ?? result?.data?.id}}"
"path": "/admin/board/{{route.slug}}/post/{{route?.id ?? result?.data?.id}}",
"mergeQuery": true,
"query": {}
}
}
],
@@ -430,7 +434,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "{{route?.id ? '/admin/board/' + route.slug + '/post/' + route.id : '/admin/board/' + route.slug}}"
"path": "{{route?.id ? '/admin/board/' + route.slug + '/post/' + route.id : '/admin/board/' + route.slug}}",
"mergeQuery": true,
"query": {}
}
}
],
@@ -498,7 +504,9 @@
{
"handler": "navigate",
"params": {
"path": "/admin/board/{{route.slug}}/post/{{route?.id ?? result?.data?.id}}"
"path": "/admin/board/{{route.slug}}/post/{{route?.id ?? result?.data?.id}}",
"mergeQuery": true,
"query": {}
}
}
],
@@ -148,11 +148,13 @@
},
"actions": [
{
"comment": "새로고침은 보고 있던 목록을 그대로 다시 부르는 것이다 — 페이지/검색/필터를 유지한다 (#75).",
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/board/{{route.slug}}",
"mergeQuery": false
"mergeQuery": true,
"query": {}
}
}
],
@@ -180,7 +182,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/board/{{route.slug}}/create"
"path": "/admin/board/{{route.slug}}/create",
"mergeQuery": true,
"query": {}
}
}
],
@@ -273,11 +277,13 @@
{
"type": "keypress",
"key": "Enter",
"comment": "검색 실행 — 검색 버튼과 동일하게 page 는 1페이지로 되돌린다. 되돌리지 않으면 5페이지를 보던 중 검색 시 결과의 5페이지로 가 빈 화면이 열린다 (#75).",
"handler": "navigate",
"params": {
"path": "/admin/board/{{route.slug}}",
"mergeQuery": true,
"query": {
"page": "",
"filters[0][field]": "{{_local.searchField || 'all'}}",
"filters[0][value]": "{{$event.target.value}}",
"filters[0][operator]": "like"
@@ -498,12 +504,14 @@
"actions": [
{
"type": "change",
"comment": "상태 필터 변경 — 카테고리 필터와 동일하게 page 를 1페이지로 되돌린다. 되돌리지 않으면 뒤쪽 페이지에서 필터를 바꿀 때 빈 화면이 열린다 (#75).",
"handler": "navigate",
"params": {
"path": "/admin/board/{{route.slug}}",
"mergeQuery": true,
"query": {
"status": "{{$event.target.value}}"
"status": "{{$event.target.value}}",
"page": 1
}
}
}
@@ -556,6 +564,7 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 초기화 버튼 — 목록 상태를 전부 비우는 것이 이 버튼의 목적이므로 병합하지 않는다.",
"type": "click",
"handler": "navigate",
"params": {
@@ -589,11 +598,13 @@
"actions": [
{
"type": "click",
"comment": "검색 실행 — 열거한 검색 조건만 덮어쓰고 정렬/페이지당 개수 등 나머지 목록 상태는 유지한다. page 는 새 검색이므로 1페이지로 되돌린다 (#75).",
"handler": "navigate",
"params": {
"path": "/admin/board/{{route.slug}}",
"mergeQuery": false,
"mergeQuery": true,
"query": {
"page": "",
"filters[0][field]": "{{_local.searchField || 'all'}}",
"filters[0][value]": "{{_local.searchQuery || ''}}",
"filters[0][operator]": "like",
@@ -835,7 +846,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/board/{{row.slug}}/post/{{row.id}}"
"path": "/admin/board/{{row.slug}}/post/{{row.id}}",
"mergeQuery": true,
"query": {}
}
}
]
@@ -1127,7 +1140,7 @@
"params": {
"path": "/admin/board/{{route.slug}}",
"mergeQuery": true,
"query": []
"query": {}
}
},
{
@@ -105,7 +105,8 @@
"handler": "navigate",
"params": {
"path": "/admin/boards/reports/{{route.id}}",
"mergeQuery": false
"mergeQuery": true,
"query": {}
}
}
],
@@ -132,7 +133,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/boards/reports"
"path": "/admin/boards/reports",
"mergeQuery": true,
"query": {}
}
}
],
@@ -338,7 +341,8 @@
"handler": "navigate",
"params": {
"path": "/admin/boards/reports/{{route.id}}",
"mergeQuery": false
"mergeQuery": true,
"query": {}
}
}
],
@@ -66,11 +66,13 @@
],
"named_actions": {
"searchBoardReports": {
"comment": "검색 실행 — 열거한 검색 조건만 덮어쓰고 페이지당 개수 등 나머지 목록 상태는 유지한다. page 는 새 검색이므로 1페이지로 되돌린다 (#75).",
"handler": "navigate",
"params": {
"path": "/admin/boards/reports",
"mergeQuery": false,
"mergeQuery": true,
"query": {
"page": "",
"filters[0][field]": "{{_local.searchField || 'all'}}",
"filters[0][value]": "{{_local.searchQuery || ''}}",
"filters[0][operator]": "like",
@@ -78,9 +80,7 @@
"type": "{{((_global.typeFilter ?? query['type[]'] ?? []) || []).length > 0 ? (_global.typeFilter ?? query['type[]']) : null}}",
"target_status": "{{((_global.targetStatusFilter ?? query['target_status[]'] ?? []) || []).length > 0 ? (_global.targetStatusFilter ?? query['target_status[]']) : null}}",
"reported_at_from": "{{_global.dateFrom !== undefined ? _global.dateFrom : (query.reported_at_from || '')}}",
"reported_at_to": "{{_global.dateTo !== undefined ? _global.dateTo : (query.reported_at_to || '')}}",
"sort_by": "{{query.sort_by || 'last_reported_at'}}",
"sort_order": "{{query.sort_order || 'desc'}}"
"reported_at_to": "{{_global.dateTo !== undefined ? _global.dateTo : (query.reported_at_to || '')}}"
}
}
}
@@ -120,11 +120,13 @@
},
"actions": [
{
"comment": "새로고침은 보고 있던 목록을 그대로 다시 부르는 것이다 — 페이지/검색/필터를 유지한다 (#75).",
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/boards/reports",
"mergeQuery": false
"mergeQuery": true,
"query": {}
}
}
],
@@ -1244,6 +1246,7 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 초기화 버튼 — 목록 상태를 전부 비우는 것이 이 버튼의 목적이므로 병합하지 않는다.",
"type": "click",
"handler": "navigate",
"params": {
@@ -2202,7 +2205,9 @@
"view": {
"handler": "navigate",
"params": {
"path": "/admin/boards/reports/{{$args[1]?.id}}"
"path": "/admin/boards/reports/{{$args[1]?.id}}",
"mergeQuery": true,
"query": {}
}
},
"go_to_board": {
@@ -347,6 +347,7 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 탭 전환 — 탭마다 다루는 대상이 달라 이전 탭의 목록 상태를 물려받으면 오히려 잘못된 화면이 된다.",
"handler": "navigate",
"params": {
"path": "/admin/boards/settings",
@@ -155,10 +155,15 @@
"if": "{{post?.data?.board?.use_reply && !post?.data?.is_notice && (post?.data?.depth ?? 0) < (post?.data?.board?.max_reply_depth ?? 1) && post?.data?.status !== 'blinded' && post?.data?.status !== 'deleted' && !post?.data?.deleted_at}}",
"actions": [
{
"comment": "답변 작성 폼으로 이동 — parent_id 는 query 로 넘긴다. mergeQuery 는 path 의 인라인 쿼리스트링을 버리므로 path 에 붙여두면 사라진다 (#75).",
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/board/{{route.slug}}/create?parent_id={{post?.data?.id}}"
"path": "/admin/board/{{route.slug}}/create",
"mergeQuery": true,
"query": {
"parent_id": "{{post?.data?.id}}"
}
}
}
],
@@ -261,7 +266,9 @@
"edit": {
"handler": "navigate",
"params": {
"path": "/admin/board/{{route.slug}}/{{post?.data?.id}}/edit"
"path": "/admin/board/{{route.slug}}/{{post?.data?.id}}/edit",
"mergeQuery": true,
"query": {}
}
},
"blind": {
@@ -1166,7 +1173,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/board/{{route.slug}}/post/{{post?.data?.navigation?.prev?.id}}"
"path": "/admin/board/{{route.slug}}/post/{{post?.data?.navigation?.prev?.id}}",
"mergeQuery": true,
"query": {}
}
}
],
@@ -1228,7 +1237,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/board/{{route.slug}}/post/{{post?.data?.navigation?.next?.id}}"
"path": "/admin/board/{{route.slug}}/post/{{post?.data?.navigation?.next?.id}}",
"mergeQuery": true,
"query": {}
}
}
],
@@ -154,7 +154,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/board/{{route.slug}}/post/{{item.id}}"
"path": "/admin/board/{{route.slug}}/post/{{item.id}}",
"mergeQuery": true,
"query": {}
}
}
],
@@ -766,7 +766,7 @@
"params": {
"actions": [
{ "handler": "setState", "params": { "target": "global", "activeBoardSettingsTab": "notification_definitions" } },
{ "handler": "replaceUrl", "params": { "query": { "tab": "notification_definitions" } } }
{ "comment": "audit:allow layout-list-context-navigate-merge-query 다른 탭으로 넘어가는 이동이다 — 알림 정의 탭은 자기 검색어와 페이지를 따로 갖는 별개의 목록이라 신고 정책 탭의 조건을 물려주지 않는다.", "handler": "replaceUrl", "params": { "query": { "tab": "notification_definitions" } } }
]
}
}
@@ -915,7 +915,7 @@
"params": {
"actions": [
{ "handler": "setState", "params": { "target": "global", "activeBoardSettingsTab": "notification_definitions" } },
{ "handler": "replaceUrl", "params": { "query": { "tab": "notification_definitions" } } }
{ "comment": "audit:allow layout-list-context-navigate-merge-query 다른 탭으로 넘어가는 이동이다 — 알림 정의 탭은 자기 검색어와 페이지를 따로 갖는 별개의 목록이라 신고 정책 탭의 조건을 물려주지 않는다.", "handler": "replaceUrl", "params": { "query": { "tab": "notification_definitions" } } }
]
}
}
@@ -0,0 +1,79 @@
/**
* 관리자 게시글 목록 컨텍스트 왕복 — 목록 상태(page/검색)가 상세·폼을 거쳐도 살아남는지 (공개 이슈 #75).
*
* 결함: 목록 클러스터(목록 ↔ 상세 ↔ 작성/수정 폼) 안의 이동에 `mergeQuery` 가 빠져 있어,
* 2페이지에서 글을 열었다가 목록으로 돌아오면 1페이지로 되돌아갔다. 특히 폼 '취소' 버튼은
* 목적지가 삼항 표현식이라 정적 검사에서도 오래 빠져 있었다 — 저장 leg 만 고쳐지고 취소 leg 는
* 남아 "저장하면 2페이지 유지 / 취소하면 1페이지 리셋" 비대칭이 생겼다.
*
* 단위/정적:
* - modules/_bundled/sirsoft-board/resources/js/__tests__/layouts/admin-list-context-round-trip.test.ts
* 가 실 JSON 의 액션 params 를 전수 고정
* - audit 룰 layout-list-context-navigate-merge-query 가 표현식 경로까지 판정해 재발 차단
* 이 spec 은 브라우저 수준(실제 주소창 URL)을 담당한다.
*
* 시드 의존: 샘플 시드의 자유게시판(`free`, 30건) — 관리자 목록 15건/페이지이므로 2페이지가 존재한다.
*
* @scenario board-list-context-round-trip
* @axes leg=enter leg=back
* @effects list_return_preserves_query
*/
import { test, expect, authenticatePage } from '../../fixtures/board-auth';
const SLUG = 'free';
const LIST_URL = `/admin/board/${SLUG}`;
/**
* 현재 URL 의 쿼리 파라미터를 돌려줍니다.
*
* @param url 페이지 URL
* @returns 쿼리 파라미터
*/
function queryOf(url: string): URLSearchParams {
return new URL(url).searchParams;
}
test.describe('관리자 게시글 목록 컨텍스트 왕복 (#75)', () => {
// @scenario leg=enter
// @effects list_return_preserves_query
test('2페이지에서 글 제목을 누르면 상세 URL 에 page 가 실린다', async ({ page, boardManageToken }) => {
await authenticatePage(page, boardManageToken);
await page.goto(`${LIST_URL}?page=2`);
await page.waitForLoadState('networkidle', { timeout: 30_000 });
// 제목 Span 이 이동 액션을 갖는다 (행 전체가 아니라 제목만 클릭 대상).
await page.locator('tbody tr span.cursor-pointer').first().click();
await page.waitForURL(new RegExp(`/admin/board/${SLUG}/post/\\d+`), { timeout: 30_000 });
expect(queryOf(page.url()).get('page')).toBe('2');
});
// @scenario leg=back
// @effects list_return_preserves_query
test('상세에서 목록으로 돌아오면 2페이지가 복원된다', async ({ page, boardManageToken }) => {
await authenticatePage(page, boardManageToken);
await page.goto(`${LIST_URL}?page=2`);
await page.waitForLoadState('networkidle', { timeout: 30_000 });
await page.locator('tbody tr span.cursor-pointer').first().click();
await page.waitForURL(new RegExp(`/admin/board/${SLUG}/post/\\d+`), { timeout: 30_000 });
await page.waitForLoadState('networkidle', { timeout: 30_000 });
await page.locator('#back_button').click();
await page.waitForURL(new RegExp(`/admin/board/${SLUG}\\?`), { timeout: 30_000 });
expect(queryOf(page.url()).get('page')).toBe('2');
});
// @scenario leg=back
// @effects list_return_preserves_query
test('작성 폼에서 취소하면 보고 있던 페이지로 돌아온다', async ({ page, boardManageToken }) => {
await authenticatePage(page, boardManageToken);
await page.goto(`${LIST_URL}/create?page=2`);
await page.waitForLoadState('networkidle', { timeout: 30_000 });
await page.locator('#header_cancel_button').click();
await page.waitForURL(new RegExp(`/admin/board/${SLUG}\\?`), { timeout: 30_000 });
expect(queryOf(page.url()).get('page')).toBe('2');
});
});
@@ -0,0 +1,156 @@
/**
* 목록 컨텍스트 왕복 — 이전글/다음글 leg 의 URL 목록 상태 보존 (공개 이슈 #75).
*
* 결함: 목록에서 상세로 들어갈 때는 `mergeQuery: true` 로 page/search/category 가 상세 URL 에
* 실렸지만, 상세의 이전글/다음글 버튼은 규약에서 누락돼 `del` 하나만 남기고 나머지를 전부
* 떨궜다. 그 뒤 '목록' 버튼은 복원할 상태가 없어 1페이지로 되돌아갔다.
*
* 이 spec 은 시드 의존을 최소화한다 — 샘플 시드의 자유게시판(`free`, 28건/3페이지)만 있으면
* 돌아간다. 별도 전용 게시판(navtest) 시드를 요구하는 board-post-navigation.spec.ts 와 달리
* skip 없이 실행된다.
*
* 단위/렌더링:
* - templates/_bundled/sirsoft-basic/src/__tests__/layouts/board-post-navigation-list-return.test.tsx
* 가 실 `_navigation.json` 의 액션 params 로 mergeQuery 왕복을 고정
* - .claude/scripts/audit/rules/layout-list-context-navigate-merge-query.cjs 가 전 저장소 재발 차단
* 이 spec 은 브라우저 수준(실제 URL + 목록 API 요청 파라미터)을 담당한다.
*
* @scenario board-list-context-round-trip
* @axes leg=enter leg=back leg=prev leg=next
* @effects navigation_preserves_list_query,
* list_return_preserves_query
*/
import { test, expect } from '@playwright/test';
const BOARD_SLUG = 'free';
const LIST_URL = `/board/${BOARD_SLUG}`;
/**
* 현재 URL 의 쿼리 파라미터를 돌려줍니다.
*
* @param url 페이지 URL
* @returns 쿼리 파라미터
*/
function queryOf(url: string): URLSearchParams {
return new URL(url).searchParams;
}
/**
* 목록의 게시글 행 로케이터.
*
* basic 형 목록의 행은 `<a>` 가 아니라 navigate 액션이 달린 Button 이며, 접근성 이름이
* "번호 제목 … 작성일 조회수" 형태다. 페이지네이션 버튼("페이지 1")과 구분하기 위해
* 번호로 시작하는 이름만 고른다.
*
* @param page Playwright 페이지
* @returns 행 로케이터
*/
function postRows(page: import('@playwright/test').Page) {
return page.getByRole('button', { name: /^\d+\s+\S/ });
}
/**
* 목록 2페이지로 진입해 첫 글 상세까지 들어갑니다.
*
* @param page Playwright 페이지
* @returns 진입한 상세 URL
*/
async function enterDetailFromPage2(page: import('@playwright/test').Page): Promise<string> {
await page.goto(`${LIST_URL}?page=2`);
await page.waitForLoadState('networkidle', { timeout: 30_000 });
await postRows(page).first().click();
await page.waitForURL(new RegExp(`/board/${BOARD_SLUG}/\\d+`), { timeout: 30_000 });
await page.waitForLoadState('networkidle', { timeout: 30_000 });
return page.url();
}
test.describe('목록 컨텍스트 왕복 — 이전글/다음글 (#75)', () => {
// @scenario leg=enter
// @effects list_return_preserves_query
test('목록 2페이지에서 상세로 들어가면 page 가 상세 URL 에 실린다', async ({ page }) => {
const detailUrl = await enterDetailFromPage2(page);
expect(detailUrl).toContain(`/board/${BOARD_SLUG}/`);
expect(queryOf(detailUrl).get('page')).toBe('2');
});
// @scenario leg=prev
// @effects navigation_preserves_list_query
test('이전글로 이동해도 page 가 유지된다', async ({ page }) => {
await enterDetailFromPage2(page);
const prev = page.getByRole('button', { name: /(이전글|Previous)(?!\s*page)/i }).first();
await prev.click();
await page.waitForLoadState('networkidle', { timeout: 30_000 });
expect(queryOf(page.url()).get('page')).toBe('2');
});
// @scenario leg=next
// @effects navigation_preserves_list_query
test('다음글로 이동해도 page 가 유지된다', async ({ page }) => {
await enterDetailFromPage2(page);
const next = page.getByRole('button', { name: /(다음글|Next)(?!\s*page)/i }).first();
await next.click();
await page.waitForLoadState('networkidle', { timeout: 30_000 });
expect(queryOf(page.url()).get('page')).toBe('2');
});
// @scenario leg=prev, leg=back
// @effects navigation_preserves_list_query, list_return_preserves_query
test('이전글 3회 연속 후 목록으로 돌아가도 2페이지가 복원된다', async ({ page }) => {
await enterDetailFromPage2(page);
for (let i = 0; i < 3; i++) {
const prev = page.getByRole('button', { name: /(이전글|Previous)(?!\s*page)/i }).first();
if (!(await prev.isVisible().catch(() => false))) break;
await prev.click();
await page.waitForLoadState('networkidle', { timeout: 30_000 });
expect(queryOf(page.url()).get('page'), `${i + 1}회차 이전글 이동에서 page 소실`).toBe('2');
}
// 목록 복귀 — 목록 API 가 실제로 2페이지를 요청해야 한다.
// 직전 이동 직후에는 상세가 다시 렌더되며 버튼이 교체되므로, 버튼이 안정된 뒤 클릭한다.
const listButton = page.getByRole('button', { name: /(목록|Back to List)$/i }).first();
await expect(listButton).toBeVisible({ timeout: 30_000 });
const [listRequest] = await Promise.all([
page.waitForRequest(
(req) => req.url().includes('/posts') && req.url().includes('page=2'),
{ timeout: 30_000 }
),
listButton.click(),
]);
expect(listRequest.url()).toContain('page=2');
await page.waitForURL(new RegExp(`/board/${BOARD_SLUG}\\?`), { timeout: 30_000 });
expect(queryOf(page.url()).get('page')).toBe('2');
});
// @scenario leg=prev
// @effects navigation_preserves_list_query
test('검색어가 걸린 상태에서도 이전글 이동이 검색어를 유지한다', async ({ page }) => {
await page.goto(`${LIST_URL}?page=1&search=맛집`);
await page.waitForLoadState('networkidle', { timeout: 30_000 });
const row = postRows(page).first();
if (!(await row.isVisible().catch(() => false))) {
test.skip(true, '검색 결과가 없어 이 축을 실행할 수 없습니다.');
return;
}
await row.click();
await page.waitForURL(new RegExp(`/board/${BOARD_SLUG}/\\d+`), { timeout: 30_000 });
await page.waitForLoadState('networkidle', { timeout: 30_000 });
expect(queryOf(page.url()).get('search')).toBe('맛집');
const prev = page.getByRole('button', { name: /(이전글|Previous)(?!\s*page)/i }).first();
if (await prev.isVisible().catch(() => false)) {
await prev.click();
await page.waitForLoadState('networkidle', { timeout: 30_000 });
expect(queryOf(page.url()).get('search')).toBe('맛집');
}
});
});
@@ -0,0 +1,46 @@
feature: 목록 컨텍스트 왕복 시 URL 목록 상태 보존
description: |
페이지네이션 목록 화면과 그에 딸린 상세·형제 상세(이전글/다음글)·작성/수정 폼·확인 모달은
하나의 "목록 클러스터" 다. 이 클러스터 안에서의 모든 이동은 URL 에 실린 목록 상태
(page / search / category / filters[*] / 정렬 / per_page)를 손실 없이 이어받아야 한다.
공개 이슈 #75 (@jiwonpapa) 는 이 규약의 **부분 적용**이 원인이었다.
- 45-1 에서 목록 진입(enter)·목록 복귀(back) leg 에는 mergeQuery:true 가 적용됐다.
- 그러나 같은 화면의 이전글/다음글(prev/next) leg 은 누락돼 `del` 하나만 남기고
page/search/category 를 전부 떨궜다.
- 그 뒤 '목록' 버튼은 복원할 상태가 없어 1페이지로 되돌아갔다.
따라서 변별 축은 글 유형이 아니라 **이동 leg** 이다. post_kind 와는 직교하지 않는다 —
답글·공지 상세에는 prev/next leg 자체가 존재하지 않으며, 그 부재는
board-post-navigation.yaml 의 navigation_null_for_reply / navigation_null_for_notice 가 담당한다.
수정 범위는 게시판에 한정되지 않는다. 동일 결함이 관리자 게시판·이커머스·페이지·회원·
마이페이지 등 9개 확장에 걸쳐 있었고, 전 저장소를 한 번에 교정했다. 재발은 audit 룰
`layout-list-context-navigate-merge-query` (error) 가 차단한다.
axes:
# 목록 클러스터 안에서 발생하는 이동 leg. 하나라도 빠지면 그 지점에서 상태가 끊긴다.
leg: [enter, back, prev, next] # 목록→상세 / 상세→목록 / 이전글 / 다음글
effects:
- navigation_preserves_list_query # 형제 상세(prev/next) 이동이 목록 상태를 승계
- list_return_preserves_query # 목록 복귀가 상세 URL 의 목록 상태를 그대로 복원
test_files:
- modules/_bundled/sirsoft-board/tests/Playwright/specs/user/board-list-context-round-trip.spec.ts
- modules/_bundled/sirsoft-board/tests/Playwright/specs/admin/board-admin-list-context-round-trip.spec.ts
- templates/_bundled/sirsoft-basic/src/__tests__/layouts/board-post-navigation-list-return.test.tsx
- modules/_bundled/sirsoft-board/resources/js/__tests__/layouts/admin-list-context-round-trip.test.ts
- modules/_bundled/sirsoft-ecommerce/resources/js/__tests__/layouts/admin-list-context-round-trip.test.ts
- modules/_bundled/sirsoft-page/resources/js/__tests__/layouts/admin-list-context-round-trip.test.ts
- templates/_bundled/sirsoft-admin_basic/src/__tests__/layouts/admin-list-context-round-trip.test.ts
- .claude/scripts/audit/__tests__/layout-list-context-navigate-merge-query.test.cjs
validation:
note: |
leg 4종은 E2E(board-list-context-round-trip.spec.ts)가 실제 브라우저 URL 과 목록 API 요청
파라미터로 실측한다. 확장별 레이아웃 테스트는 실 JSON 의 액션 params 를 읽어 클러스터 내
navigate 가 전부 mergeQuery:true 인지 전수 고정하고, audit 룰 테스트가 저장소 전체 잔여
위반 0건을 회귀로 못박는다. 엔진 게이트(mergeQuery:true + query 생략) 는
ActionDispatcher.test.ts 가 navigate/replaceUrl 양쪽에서 검증한다.
@@ -28,6 +28,9 @@ axes:
# navigation 결과를 가르는 핵심 변별 축은 글 유형(post_kind).
# 카테고리 유무·목록 위치·비밀/블라인드 변종은 effects 와 개별 테스트 메서드로 커버한다.
post_kind: [original, reply, notice] # 원글(정상 순회) / 답글(미노출) / 공지(미노출)
# 목록 상태 보존(#75)의 변별 축은 "어느 leg 으로 이동했는가" 이며 post_kind 와 직교하지 않는다
# (답글·공지에는 이전/다음 leg 자체가 없다). 별도 기능으로 분리한다 →
# tests/scenarios/board-list-context-round-trip.yaml
effects:
- navigation_limited_to_same_category # 47-1: 동일 카테고리 글만 prev/next
@@ -38,12 +41,14 @@ effects:
- navigation_blinded_excluded # 47-2: 블라인드 제외 (기존 유지)
- navigation_boundary_null # 47-3: 첫/마지막 글 prev/next null
- list_return_preserves_query # 45-1: 행 클릭→상세→목록 복귀 시 query 보존
- navigation_preserves_list_query # 75: 이전글/다음글 leg 도 목록 상태(page/search/category)를 승계
test_files:
- modules/_bundled/sirsoft-board/tests/Feature/User/PostNavigationTest.php
- modules/_bundled/sirsoft-board/tests/Feature/User/PostNavigationApiTest.php
- templates/_bundled/sirsoft-basic/src/__tests__/layouts/board-post-navigation-list-return.test.tsx
- modules/_bundled/sirsoft-board/tests/Playwright/specs/user/board-post-navigation.spec.ts
- modules/_bundled/sirsoft-board/tests/Playwright/specs/user/board-list-context-round-trip.spec.ts
validation:
note: |
@@ -18,6 +18,14 @@
### Fixed
- 휴대폰으로 관리자 주문 목록을 볼 때 왼쪽 위 '뒤로' 버튼을 누르면 이전 화면이 아니라 빈 페이지로 넘어가던 문제를 수정했습니다.
- 관리자 주문·상품·쿠폰·배송정책·리뷰·마일리지 목록에서 상세나 등록/수정 화면에 다녀오면 걸어 둔 필터와 페이지가 사라지던 문제를 수정했습니다. 필터를 여러 개 건 상태에서 주문 하나를 확인하고 돌아와도 조건이 그대로 유지됩니다. 정렬·표시 개수를 바꾸거나 새로고침해도 걸어 둔 조건은 그대로입니다. 반대로 초기화 버튼과 프리셋 적용은 종전처럼 조건을 새로 세팅합니다. (#75 @jiwonpapa 님께서 제보해주셨습니다.)
- 관리자 브랜드·상품 공통정보·상품 고시정보 목록에서 검색어(브랜드는 정렬 포함)를 걸어 둔 채 새로고침 버튼을 누르면 걸어 둔 검색이 풀려 전체 목록으로 돌아가던 문제를 수정했습니다. 이제 새로고침은 보던 조건 그대로 다시 불러옵니다. (#75 @jiwonpapa 님께서 제보해주셨습니다.)
- 관리자 주문 목록에서 '이 주문자의 주문 검색'을 실행하면 검색창은 비어 보이는데 직전 검색어가 계속 적용돼 결과가 어긋나던 문제를 수정했습니다. 비회원 주문자명으로 검색할 때 회원 지정 조건이 함께 걸려 결과가 비어 보이던 문제도 함께 해소되며, 주문 상세의 주문자 카드에서 같은 검색을 실행할 때도 동일하게 적용됩니다. (#75 @jiwonpapa 님께서 제보해주셨습니다.)
- 관리자 브랜드 관리에서 브랜드명으로 검색하면 결과가 항상 비어 있던 문제를 수정했습니다. 이제 브랜드명·slug·웹사이트 주소 중 하나만 일치해도 검색됩니다.
- 관리자 상품 등록/수정 화면의 배송 정보에서 '배송정책 등록' 버튼을 눌러도 아무 반응이 없던 문제를 수정했습니다. 이제 배송정책 등록 화면으로 이동합니다.
- 관리자 브랜드·상품 카테고리·상품 공통정보·상품 고시정보 목록에서 왼쪽 목록의 항목을 고르면 걸어 둔 검색어(브랜드는 정렬 포함)가 사라지던 문제를 수정했습니다. 항목 선택은 선택 상태만 주소에 기록하고 목록 조건은 그대로 둡니다. (#75 @jiwonpapa 님께서 제보해주셨습니다.)
- 관리자 쿠폰 목록에서 '등록' 으로 들어가거나 상품을 새로 저장한 직후, 보고 있던 목록의 조건이 사라져 취소·복귀 시 1페이지로 돌아가던 문제를 수정했습니다. (#75 @jiwonpapa 님께서 제보해주셨습니다.)
- 상품을 장바구니에 담거나 바로 구매할 때, 표시 언어(로케일)나 관리자의 옵션 이름 수정과 무관하게 선택한 옵션이 정확히 담기도록 개선했습니다. 특정 상황에서 "해당 옵션 조합을 찾을 수 없습니다" 오류로 담기가 실패하던 문제가 해소됩니다.
- 오류 안내가 뜨기는 하지만 내용이 비어 있던 문제를 수정했습니다. 서버가 알려 준 실패 사유가 그대로 표시됩니다.
- 헤더에서 통화나 배송 국가를 바꿀 때 저장에 실패해도 아무 안내 없이 넘어가던 문제를 수정했습니다. 실패하면 그 이유가 화면에 표시됩니다.
@@ -0,0 +1,344 @@
/**
* @file admin-list-context-round-trip.test.ts
* @description 관리자 이커머스 목록 컨텍스트 왕복 시 URL 목록 상태 보존 회귀 (#75)
*
* 결함: 주문/상품/쿠폰/배송정책/리뷰/마일리지 목록에서 상세·폼으로 들어갔다 돌아오면
* navigate 가 `mergeQuery` 없이 실행되어 page 와 필터 20여 종이 URL 에서 사라졌다.
* 필터를 여러 개 건 상태일수록 손실이 크다.
*
* 검증 방식 2단:
* 1. 실 레이아웃 JSON 전수 분석 — 클러스터 내 navigate 가 모두 `mergeQuery: true` 인지
* 2. 실 액션을 엔진에 태워 실행(`triggerAction`) — 선언이 실제 목적지 URL 로 이어지는지
* 손으로 쓴 조각이 아니라 실파일을 읽는다. 선언만 검사하면 "JSON 에 리터럴이 적혀 있다"
* 까지만 고정되고 병합 결과는 미검증으로 남는다.
*
* @scenario leg=row_click|detail_return|form_cancel|filter_apply
* @effects navigation_preserves_list_query
*
* @vitest-environment jsdom
*/
import { describe, it, expect, afterEach } from 'vitest';
import fs from 'fs';
import path from 'path';
import {
createLayoutTest,
createMockComponentRegistryWithBasics,
} from '@core/template-engine/__tests__/utils/layoutTestUtils';
const LAYOUTS_ROOT = path.resolve(__dirname, '../../../layouts/admin');
/** 이 확장이 소유한 페이지네이션 목록 라우트 */
const LIST_ROUTES = [
'/admin/ecommerce/orders',
'/admin/ecommerce/products',
'/admin/ecommerce/reviews',
'/admin/ecommerce/promotion-coupons',
'/admin/ecommerce/shipping-policies',
'/admin/ecommerce/mileage-transactions',
];
/** 목록 클러스터에 속하는 레이아웃 파일 */
const CLUSTER_FILES = [
'admin_ecommerce_order_detail.json',
'admin_ecommerce_order_index.json',
'admin_ecommerce_order_list.json',
'admin_ecommerce_product_form.json',
'admin_ecommerce_product_list.json',
'admin_ecommerce_product_review_index.json',
'admin_ecommerce_promotion_coupon_form.json',
'admin_ecommerce_promotion_coupon_list.json',
'admin_ecommerce_shipping_policy_form.json',
'admin_ecommerce_shipping_policy_list.json',
'partials/admin_ecommerce_mileage_transaction_index/_filters.json',
'partials/admin_ecommerce_mileage_transaction_index/_transactions_table.json',
'partials/admin_ecommerce_order_detail/_partial_order_info.json',
'partials/admin_ecommerce_order_list/_partial_filter_section.json',
'partials/admin_ecommerce_order_list/_partial_order_datagrid.json',
'partials/admin_ecommerce_order_list/_partial_preset_section.json',
'partials/admin_ecommerce_product_form/_modal_delete_confirm.json',
'partials/admin_ecommerce_product_list/_partial_filter_section.json',
'partials/admin_ecommerce_product_list/_partial_product_datagrid.json',
'partials/admin_ecommerce_promotion_coupon_list/_partial_coupon_datagrid.json',
'partials/admin_ecommerce_promotion_coupon_list/_partial_filter_section.json',
'partials/admin_ecommerce_shipping_policy_list/_modal_copy.json',
'partials/admin_ecommerce_shipping_policy_list/_partial_datagrid.json',
'partials/admin_ecommerce_shipping_policy_list/_partial_filter.json',
];
/**
* 목적지 경로(`path`)가 없는 선택형 navigate/replaceUrl 을 가진 목록 화면.
*
* `path` 를 생략한 액션은 "현재 URL 을 유지한 채 쿼리만 바꾼다" 는 뜻이라 목록 화면
* 자신에게 작용한다. 그런데 `mergeQuery` 가 없으면 엔진이 대체 분기로 가 쿼리를
* **통째로** 새 값으로 바꿔치므로, 방금 건 검색어·정렬이 항목 선택 한 번에 사라진다.
* 목적지가 문자열로 안 적혀 있어 경로 기반 검사(`normalizePath`)의 사각지대다.
*/
const SELF_QUERY_FILES = [
'partials/admin_ecommerce_brand_index/_panel_brand_list.json',
'partials/admin_ecommerce_category_index/_panel_category_list.json',
'partials/admin_ecommerce_product_common_info_index/_panel_list.json',
'partials/admin_ecommerce_product_notice_index/_panel_list.json',
];
type NavAction = {
handler: string;
comment?: string;
params: { path?: string; mergeQuery?: unknown; query?: unknown };
};
/**
* JSON 트리에서 navigate/replaceUrl 액션을 모두 수집합니다.
*
* @param node 순회 시작 노드
* @returns 액션 목록
*/
function collectNavActions(node: unknown): NavAction[] {
const out: NavAction[] = [];
const walk = (n: unknown): void => {
if (Array.isArray(n)) {
n.forEach(walk);
return;
}
if (!n || typeof n !== 'object') return;
const obj = n as Record<string, unknown>;
if (
(obj.handler === 'navigate' || obj.handler === 'replaceUrl') &&
obj.params &&
typeof obj.params === 'object'
) {
out.push(obj as unknown as NavAction);
}
Object.values(obj).forEach(walk);
};
walk(node);
return out;
}
/**
* 목적지 경로를 비교용 표준형(`{{expr}}` → `*`)으로 바꿉니다.
*
* @param raw 원본 경로
* @returns 표준형 경로 (판정 불가 시 null)
*/
function normalizePath(raw: unknown): string | null {
if (typeof raw !== 'string' || raw === '') return null;
const p = raw.replace(/\{\{[^}]*\}\}/g, '*').split('?')[0].replace(/\/+$/, '');
return p.startsWith('/') ? p : null;
}
/**
* 경로가 목록 라우트와 같은 클러스터인지 판정합니다.
*
* @param dest 표준형 목적지
* @param list 표준형 목록 라우트
* @returns 같은 클러스터 여부
*/
function inFamily(dest: string, list: string): boolean {
return dest === list || dest.startsWith(`${list}/`);
}
/**
* 레이아웃 파일을 읽어 파싱합니다.
*
* @param rel 레이아웃 루트 기준 상대 경로
* @returns 파싱된 JSON
*/
function readLayout(rel: string): unknown {
return JSON.parse(fs.readFileSync(path.join(LAYOUTS_ROOT, rel), 'utf8'));
}
describe('#75 관리자 이커머스 목록 컨텍스트 왕복 — mergeQuery 전수', () => {
it.each(CLUSTER_FILES)('%s 의 클러스터 내 navigate 는 모두 mergeQuery: true', (rel) => {
const offenders = collectNavActions(readLayout(rel))
.filter((a) => {
if (typeof a.comment === 'string' && a.comment.includes('audit:allow')) return false;
const dest = normalizePath(a.params.path);
if (!dest) return false;
if (!LIST_ROUTES.some((l) => inFamily(dest, l))) return false;
return a.params.mergeQuery !== true;
})
.map((a) => `${a.params.path} (mergeQuery=${JSON.stringify(a.params.mergeQuery)})`);
expect(offenders, `목록 상태를 떨구는 navigate: \n ${offenders.join('\n ')}`).toEqual([]);
});
});
describe('#75 목적지가 자기 자신인 액션도 목록 상태를 유지한다', () => {
it.each(SELF_QUERY_FILES)('%s 의 path 없는 navigate/replaceUrl 은 mergeQuery: true', (rel) => {
const offenders = collectNavActions(readLayout(rel))
.filter((a) => {
if (typeof a.comment === 'string' && a.comment.includes('audit:allow')) return false;
if (normalizePath(a.params.path) !== null) return false;
return a.params.mergeQuery !== true;
})
.map((a) => `${a.handler} query=${JSON.stringify(a.params.query)}`);
expect(
offenders,
`현재 URL 의 검색어·정렬을 통째로 덮어쓰는 액션: \n ${offenders.join('\n ')}`
).toEqual([]);
});
it('브랜드를 선택해도 걸어둔 검색어와 정렬이 URL 에 남는다', async () => {
window.history.replaceState({}, '', '/admin/ecommerce/brands?search=나이키&sort=name_desc');
const action = collectNavActions(
readLayout('partials/admin_ecommerce_brand_index/_panel_brand_list.json')
).find((a) => a.handler === 'replaceUrl' && normalizePath(a.params.path) === null);
expect(action, '브랜드 선택 replaceUrl 을 찾지 못했습니다.').toBeTruthy();
await runAction(action as NavAction);
const q = new URLSearchParams(window.location.search);
expect(q.get('search')).toBe('나이키');
expect(q.get('sort')).toBe('name_desc');
expect(q.get('mode')).toBe('view');
});
});
describe('#75 주문자명 검색은 회원 지정 필터를 함께 비운다', () => {
/**
* `orderer_uuid`(회원 지정)와 `search_field=orderer_name`(이름 문자열)은 서로 배타적이다.
* `mergeQuery: true` 가 붙은 뒤로는 이전 화면의 `orderer_uuid` 가 살아남으므로,
* 이름 검색을 걸면 두 조건이 AND 로 겹쳐 결과가 비어 보인다. 이름 검색을 실행하는
* 모든 leg 이 `orderer_uuid` 를 명시적으로 비워야 한다.
*/
const ORDERER_SEARCH_LEGS: Array<[string, string]> = [
['목록 데이터그리드', 'partials/admin_ecommerce_order_list/_partial_order_datagrid.json'],
['주문 상세 주문자 카드', 'partials/admin_ecommerce_order_detail/_partial_order_info.json'],
];
it.each(ORDERER_SEARCH_LEGS)('%s 의 주문자명 검색이 orderer_uuid 를 비운다', (_label, rel) => {
const actions = collectNavActions(readLayout(rel)).filter(
(a) =>
a.params.query !== null &&
typeof a.params.query === 'object' &&
(a.params.query as Record<string, unknown>).search_field === 'orderer_name'
);
expect(actions.length, '주문자명 검색 navigate 를 찾지 못했습니다.').toBeGreaterThan(0);
actions.forEach((a) => {
const query = a.params.query as Record<string, unknown>;
expect(Object.keys(query)).toContain('orderer_uuid');
expect(query.orderer_uuid).toBe('');
});
});
});
describe('#75 주문 목록 ↔ 상세 왕복 leg 고정', () => {
it('주문 행 클릭이 필터/페이지를 상세로 나른다', () => {
const actions = collectNavActions(
readLayout('partials/admin_ecommerce_order_list/_partial_order_datagrid.json')
).filter((a) => String(a.params.path ?? '').startsWith('/admin/ecommerce/orders/{{'));
expect(actions.length).toBeGreaterThan(0);
actions.forEach((a) => expect(a.params.mergeQuery).toBe(true));
});
it("주문 상세 '목록' 버튼이 필터/페이지를 복원한다", () => {
const a = collectNavActions(readLayout('admin_ecommerce_order_detail.json')).find(
(x) => x.params.path === '/admin/ecommerce/orders'
);
expect(a, "주문 상세의 '목록' navigate 를 찾지 못했습니다.").toBeTruthy();
expect(a?.params.mergeQuery).toBe(true);
});
});
// ---------------------------------------------------------------------------
// 실행 검증 — 실 액션을 엔진에 태워 목적지 URL 을 확인한다
// ---------------------------------------------------------------------------
/**
* 실 JSON 액션을 현재 URL 상태에서 실행하고 목적지를 돌려줍니다.
*
* @param action 실 레이아웃 JSON 에서 뽑은 navigate 액션
* @returns navigate 목적지 경로
*/
async function runNav(action: NavAction): Promise<string> {
return (await runAction(action)) as string;
}
/**
* 실 JSON 액션을 현재 URL 상태에서 실행합니다.
*
* `navigate` 는 목적지가 navigation history 에 쌓이지만 `replaceUrl` 은 주소만 바꾸므로
* 히스토리가 비어 있다. 결과 확인은 호출 측이 목적으로 나눠서 한다 —
* navigate 는 반환값, replaceUrl 은 `window.location`.
*
* @param action 실 레이아웃 JSON 에서 뽑은 navigate/replaceUrl 액션
* @returns navigate 목적지 경로 (replaceUrl 이면 undefined)
*/
async function runAction(action: NavAction): Promise<string | undefined> {
const utils = createLayoutTest(
{
version: '1.0.0',
layout_name: 'nav_action_probe',
data_sources: [],
components: [{ type: 'basic', name: 'Div', props: { 'data-testid': 'probe' } }],
} as never,
{ componentRegistry: createMockComponentRegistryWithBasics() as never, locale: 'ko' }
);
await utils.render();
await utils.triggerAction({ type: 'click', ...action } as never);
const dest = utils.getNavigationHistory()[0];
utils.cleanup();
return dest;
}
/**
* 목적지 URL 의 쿼리스트링을 파싱합니다.
*
* @param dest navigate 목적지
* @returns URLSearchParams
*/
function queryOf(dest: string): URLSearchParams {
return new URLSearchParams(dest.includes('?') ? dest.slice(dest.indexOf('?')) : '');
}
describe('#75 주문 목록 ↔ 상세 왕복 — 실행 결과 URL', () => {
afterEach(() => {
window.history.replaceState({}, '', '/');
});
/** 필터를 여러 개 건 목록 URL — 이 화면이 손실 폭이 가장 크다 */
const LIST_URL =
'/admin/ecommerce/orders?page=2&per_page=20&search_field=orderer_name&search=홍길동&order_status=confirmed';
it('주문 행 클릭이 필터 전부를 상세 URL 로 나른다', async () => {
window.history.replaceState({}, '', LIST_URL);
const action = collectNavActions(
readLayout('partials/admin_ecommerce_order_list/_partial_order_datagrid.json')
).find((a) => String(a.params.path ?? '').startsWith('/admin/ecommerce/orders/{{'));
expect(action, '주문 행 클릭 navigate 를 찾지 못했습니다.').toBeTruthy();
const q = queryOf(await runNav(action as NavAction));
expect(q.get('page')).toBe('2');
expect(q.get('per_page')).toBe('20');
expect(q.get('search_field')).toBe('orderer_name');
expect(q.get('search')).toBe('홍길동');
expect(q.get('order_status')).toBe('confirmed');
});
it("주문 상세 '목록' 버튼이 필터 전부를 목록으로 복원한다", async () => {
window.history.replaceState(
{},
'',
'/admin/ecommerce/orders/1024?page=2&per_page=20&search=홍길동&order_status=confirmed'
);
const action = collectNavActions(readLayout('admin_ecommerce_order_detail.json')).find(
(x) => x.params.path === '/admin/ecommerce/orders'
);
const q = queryOf(await runNav(action as NavAction));
expect(q.get('page')).toBe('2');
expect(q.get('per_page')).toBe('20');
expect(q.get('search')).toBe('홍길동');
expect(q.get('order_status')).toBe('confirmed');
});
});
@@ -144,7 +144,8 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/brands",
"mergeQuery": false
"mergeQuery": true,
"query": {}
}
}
],
@@ -318,7 +318,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders"
"path": "/admin/ecommerce/orders",
"mergeQuery": true,
"query": {}
}
}
]
@@ -185,7 +185,8 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders",
"mergeQuery": false
"mergeQuery": true,
"query": {}
}
}
]
@@ -380,11 +380,9 @@
],
"actions": [
{
"comment": "브라우저 히스토리 뒤로가기 — navigate 는 path 를 주소로 해석하므로 \"back\" 을 주면 /back 으로 이동한다",
"type": "click",
"handler": "navigate",
"params": {
"path": "back"
}
"handler": "navigateBack"
}
]
},
@@ -444,11 +442,13 @@
],
"actions": [
{
"comment": "새로고침은 보고 있던 목록을 그대로 다시 부르는 것이다 — 페이지와 걸어둔 필터 20여 종을 유지한다 (#75).",
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders",
"mergeQuery": false
"mergeQuery": true,
"query": {}
}
}
]
@@ -122,7 +122,8 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/common-info",
"mergeQuery": false
"mergeQuery": true,
"query": {}
}
}
],
@@ -882,7 +882,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/products"
"path": "/admin/ecommerce/products",
"mergeQuery": true,
"query": {}
}
}
]
@@ -1053,10 +1055,13 @@
}
},
{
"comment": "신규 저장 후 편집 화면으로 전환 — 같은 목록 클러스터 안의 이동이므로 목록 상태를 유지한다 (#75).",
"handler": "navigate",
"if": "{{!route.itemCode}}",
"params": {
"path": "{{'/admin/ecommerce/products/' + result.data.id + '/edit'}}"
"path": "{{'/admin/ecommerce/products/' + result.data.id + '/edit'}}",
"mergeQuery": true,
"query": {}
}
}
],
@@ -424,7 +424,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/products/create"
"path": "/admin/ecommerce/products/create",
"mergeQuery": true,
"query": {}
}
}
]
@@ -134,7 +134,8 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/product-notices",
"mergeQuery": false
"mergeQuery": true,
"query": {}
}
}
],
@@ -177,10 +177,13 @@
],
"actions": [
{
"comment": "새로고침은 보고 있던 목록을 그대로 다시 부르는 것이다 — 페이지/검색/필터를 유지한다 (#75).",
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"mergeQuery": true,
"query": {},
"replace": true
}
}
@@ -406,12 +409,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"rating": "",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -438,12 +441,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"rating": "5",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -470,12 +473,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"rating": "4",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -502,12 +505,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"rating": "3",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -534,12 +537,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"rating": "2",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -566,12 +569,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"rating": "1",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -625,12 +628,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"reply_status": "",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -657,12 +660,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"reply_status": "replied",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -689,12 +692,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"reply_status": "not_replied",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -748,12 +751,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"photo": "",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -780,12 +783,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"photo": "photo",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -812,12 +815,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"photo": "normal",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -871,12 +874,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"status": "",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -903,12 +906,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"status": "visible",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -935,12 +938,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"status": "hidden",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -1282,7 +1285,7 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"search_field": "{{_local.filter.searchField !== 'product_name' ? _local.filter.searchField : ''}}",
"search_keyword": "{{_local.filter.searchKeyword ?? ''}}",
@@ -1296,6 +1299,7 @@
"per_page": "{{query.per_page || 20}}",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -1335,6 +1339,7 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 필터 초기화 — 걸려 있던 조건을 전부 비우는 것이 이 버튼의 목적이므로 병합하지 않는다.",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
@@ -1511,12 +1516,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"sort": "{{$event.target.value}}",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -1554,12 +1559,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"per_page": "{{$event.target.value}}",
"page": 1
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -2908,11 +2913,11 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/reviews",
"replace": true,
"mergeQuery": true,
"query": {
"page": "{{$args[0]}}"
},
"replace": true,
"transition_overlay_target": "review_datagrid__body"
}
}
@@ -170,7 +170,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/promotion-coupons"
"path": "/admin/ecommerce/promotion-coupons",
"mergeQuery": true,
"query": {}
}
}
]
@@ -230,7 +232,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/promotion-coupons"
"path": "/admin/ecommerce/promotion-coupons",
"mergeQuery": true,
"query": {}
}
}
]
@@ -300,7 +304,9 @@
{
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/promotion-coupons"
"path": "/admin/ecommerce/promotion-coupons",
"mergeQuery": true,
"query": {}
}
}
],
@@ -223,7 +223,7 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/promotion-coupons",
"replace": true,
"mergeQuery": true,
"query": {
"search_field": "{{_local.filter.searchField !== 'all' ? _local.filter.searchField : ''}}",
"search_keyword": "{{_local.filter.searchKeyword}}",
@@ -244,6 +244,7 @@
"created_by": "{{_local.filter.createdBy}}",
"page": 1
},
"replace": true,
"transition_overlay_target": "pc_data_table__body"
}
}
@@ -340,10 +341,13 @@
],
"actions": [
{
"comment": "쿠폰 등록 폼 진입 — 폼에서 취소하고 돌아왔을 때 보던 목록으로 복귀하려면 진입 시점에 목록 상태를 넘겨야 한다 (#75).",
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/promotion-coupon-create"
"path": "/admin/ecommerce/promotion-coupon-create",
"mergeQuery": true,
"query": {}
}
}
]
@@ -348,6 +348,7 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 탭 전환 — 탭마다 다루는 대상이 달라 이전 탭의 목록 상태를 물려받으면 오히려 잘못된 화면이 된다.",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/settings",
@@ -329,7 +329,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/shipping-policies"
"path": "/admin/ecommerce/shipping-policies",
"mergeQuery": true,
"query": {}
}
}
]
@@ -406,7 +408,9 @@
{
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/shipping-policies"
"path": "/admin/ecommerce/shipping-policies",
"mergeQuery": true,
"query": {}
}
}
],
@@ -107,7 +107,7 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/shipping-policies",
"replace": true,
"mergeQuery": true,
"query": {
"page": 1,
"search": "{{_local.filter.search || undefined}}",
@@ -116,6 +116,7 @@
"countries[]": "{{_local.filter.countries?.length > 0 ? _local.filter.countries : undefined}}",
"is_active": "{{_local.filter.is_active || undefined}}"
},
"replace": true,
"transition_overlay_target": "shipping_policy_datagrid__body"
}
}
@@ -188,7 +189,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/shipping-policies/create"
"path": "/admin/ecommerce/shipping-policies/create",
"mergeQuery": true,
"query": {}
}
}
]
@@ -268,13 +271,13 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/shipping-policies",
"replace": true,
"mergeQuery": true,
"query": {
"sort_by": "{{$event.target.value.split('_').slice(0, -1).join('_')}}",
"sort_order": "{{$event.target.value.split('_').pop()}}",
"page": 1
},
"replace": true,
"transition_overlay_target": "shipping_policy_datagrid__body"
}
}
@@ -312,12 +315,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/shipping-policies",
"replace": true,
"mergeQuery": true,
"query": {
"per_page": "{{$event.target.value}}",
"page": 1
},
"replace": true,
"transition_overlay_target": "shipping_policy_datagrid__body"
}
}
@@ -139,6 +139,7 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/brands",
"mergeQuery": true,
"query": {
"search": "{{query.search}}",
"sort": "{{$event.target.value}}"
@@ -196,8 +197,10 @@
}
},
{
"comment": "선택 상태만 주소에 기록한다 — 왼쪽 목록에 걸어둔 검색어·정렬은 그대로 둔다. 병합하지 않으면 항목을 고르는 순간 목록이 초기화된다 (#75).",
"handler": "replaceUrl",
"params": {
"mergeQuery": true,
"query": {
"id": "{{$args[0].id}}",
"mode": "view"
@@ -89,8 +89,10 @@
}
},
{
"comment": "선택 상태만 주소에 기록한다 — 왼쪽 목록에 걸어둔 조건은 그대로 둔다 (#75).",
"handler": "replaceUrl",
"params": {
"mergeQuery": true,
"query": {
"id": "{{$args[0]?.id}}",
"mode": "view"
@@ -456,11 +456,13 @@
"text": "$t:sirsoft-ecommerce.admin.mileage_transactions.search.submit",
"actions": [
{
"comment": "검색 실행 — 열거한 검색 조건만 덮어쓰고 나머지 목록 상태는 유지한다 (#75).",
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/mileage-transactions",
"replace": true,
"mergeQuery": true,
"query": {
"search_field": "{{_local.filter.searchField ?? 'member'}}",
"search_keyword": "{{_local.filter.searchKeyword ?? ''}}",
@@ -514,10 +516,12 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 필터 초기화 — 걸려 있던 조건을 전부 비우는 것이 이 버튼의 목적이므로 병합하지 않는다.",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/mileage-transactions",
"replace": true,
"mergeQuery": false,
"transition_overlay_target": "mileage_transactions_datagrid__body"
}
}
@@ -135,12 +135,13 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/mileage-transactions",
"replace": true,
"mergeQuery": true,
"query": {
"search_field": "member_id",
"search_keyword": "{{row.user_id}}",
"page": 1
},
"replace": true,
"transition_overlay_target": "mileage_transactions_datagrid__body"
}
}
@@ -581,11 +582,11 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/mileage-transactions",
"replace": true,
"mergeQuery": true,
"query": {
"page": "{{$args[0]}}"
},
"replace": true,
"transition_overlay_target": "mileage_transactions_datagrid__body"
}
},
@@ -595,12 +596,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/mileage-transactions",
"replace": true,
"mergeQuery": true,
"query": {
"sort": "{{$args[0]}}",
"page": 1
},
"replace": true,
"transition_overlay_target": "mileage_transactions_datagrid__body"
}
},
@@ -1296,12 +1296,15 @@
}
},
"search_by_orderer": {
"comment": "주문자명으로 검색 — 회원 지정 필터(orderer_uuid)를 함께 비우지 않으면 이름 검색과 회원 필터가 겹쳐 결과가 비어 보인다 (#75).",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders",
"mergeQuery": true,
"query": {
"search_field": "orderer_name",
"search_keyword": "{{order.data?.orderer_name}}",
"orderer_uuid": "",
"page": 1
},
"transition_overlay_target": "order_product_datagrid__body"
@@ -2093,6 +2093,7 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 프리셋 적용 — 프리셋은 조건 세트를 통째로 갈아끼우는 것이므로 병합하면 직전 조건(배송정책·회원구분 등 여기 열거되지 않은 필터)이 화면에 보이지 않는 채로 남는다. 같은 화면의 _partial_preset_section.json 과 동일 규약.",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders",
@@ -2640,6 +2641,7 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 필터 초기화 — 걸려 있던 조건을 전부 비우는 것이 이 버튼의 목적이므로 병합하지 않는다.",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders",
@@ -100,12 +100,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders",
"replace": true,
"mergeQuery": true,
"query": {
"sort_by": "{{$event.target.value.split('_').slice(0,-1).join('_')}}",
"sort_order": "{{$event.target.value.split('_').pop()}}"
}
},
"replace": true
}
}
]
@@ -155,12 +155,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders",
"replace": true,
"mergeQuery": true,
"query": {
"per_page": "{{$event.target.value}}",
"page": 1
},
"replace": true,
"transition_overlay_target": "order_datagrid__body"
}
}
@@ -266,7 +266,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders/{{row.order_number}}"
"path": "/admin/ecommerce/orders/{{row.order_number}}",
"mergeQuery": true,
"query": {}
}
}
]
@@ -597,11 +599,15 @@
}
},
{
"comment": "이 주문자의 주문만 보기 — 앞선 setState 가 검색어를 비우므로 URL 의 검색 조건도 함께 비운다. 비우지 않으면 화면 입력창은 빈 채로 이전 검색어가 계속 적용된다 (#75).",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders",
"mergeQuery": true,
"query": {
"orderer_uuid": "{{row.user?.uuid}}",
"search_field": "",
"search_keyword": "",
"page": 1
},
"transition_overlay_target": "order_datagrid__body"
@@ -617,16 +623,20 @@
"params": {
"target": "_local",
"filter.searchField": "orderer_name",
"filter.searchKeyword": "{{row.address?.orderer_name || row.user?.name}}"
"filter.searchKeyword": "{{row.address?.orderer_name || row.user?.name}}",
"filter.ordererUuid": ""
}
},
{
"comment": "비회원 주문자명으로 검색 — 회원 지정 필터(orderer_uuid)를 함께 비우지 않으면 이름 검색과 회원 필터가 겹쳐 결과가 비어 보인다 (#75).",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders",
"mergeQuery": true,
"query": {
"search_field": "orderer_name",
"search_keyword": "{{row.address?.orderer_name || row.user?.name}}",
"orderer_uuid": "",
"page": 1
},
"transition_overlay_target": "order_datagrid__body"
@@ -762,11 +772,11 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders",
"replace": true,
"mergeQuery": true,
"query": {
"page": "{{$args[0]}}"
},
"replace": true,
"transition_overlay_target": "order_datagrid__body"
}
},
@@ -778,7 +788,9 @@
"view_detail": {
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders/{{$args[1].order_number}}"
"path": "/admin/ecommerce/orders/{{$args[1].order_number}}",
"mergeQuery": true,
"query": {}
}
}
}
@@ -86,6 +86,7 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 프리셋 적용 — 프리셋은 조건 세트를 통째로 갈아끼우는 것이므로 병합하면 직전 프리셋의 조건(기간·상태 등)이 남는다.",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders",
@@ -136,6 +137,7 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 프리셋 적용 — 프리셋은 조건 세트를 통째로 갈아끼우는 것이므로 병합하면 직전 프리셋의 조건(기간·상태 등)이 남는다.",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders",
@@ -188,6 +190,7 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 저장된 프리셋 적용 — 저장해 둔 조건 세트를 통째로 적용하는 것이 목적이므로 병합하면 직전 조건이 섞인다.",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders",
@@ -244,6 +247,7 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 저장된 프리셋 적용 — 저장해 둔 조건 세트를 통째로 적용하는 것이 목적이므로 병합하면 직전 조건이 섞인다.",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/orders",
@@ -241,8 +241,10 @@
}
},
{
"comment": "선택 상태만 주소에 기록한다 — 왼쪽 목록에 걸어둔 검색어는 그대로 둔다 (#75).",
"handler": "replaceUrl",
"params": {
"mergeQuery": true,
"query": {
"id": "{{item.id}}",
"mode": "view"
@@ -271,7 +271,9 @@
{
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/products"
"path": "/admin/ecommerce/products",
"mergeQuery": true,
"query": {}
}
}
],
@@ -588,10 +588,11 @@
"text": "$t:sirsoft-ecommerce.admin.product.buttons.create_shipping_policy",
"actions": [
{
"comment": "audit:allow layout-list-context-navigate-merge-query 상품 폼에서 배송정책 목록 클러스터로 나가는 이동이다 — 상품 목록의 페이지·필터를 물려주지 않는다.",
"type": "click",
"handler": "navigate",
"params": {
"url": "/admin/ecommerce/shipping-policies/create"
"path": "/admin/ecommerce/shipping-policies/create"
}
}
]
@@ -189,10 +189,11 @@
},
"actions": [
{
"comment": "audit:allow layout-list-context-navigate-merge-query 상품 폼에서 채널 연동 설정 화면으로 나가는 이동이다 — 상품 목록의 페이지·필터를 물려주지 않는다.",
"type": "click",
"handler": "navigate",
"params": {
"url": "/admin/ecommerce/integrations/naver"
"path": "/admin/ecommerce/integrations/naver"
}
}
],
@@ -546,10 +547,11 @@
},
"actions": [
{
"comment": "audit:allow layout-list-context-navigate-merge-query 상품 폼에서 채널 연동 설정 화면으로 나가는 이동이다 — 상품 목록의 페이지·필터를 물려주지 않는다.",
"type": "click",
"handler": "navigate",
"params": {
"url": "/admin/ecommerce/integrations/facebook"
"path": "/admin/ecommerce/integrations/facebook"
}
}
],
@@ -903,10 +905,11 @@
},
"actions": [
{
"comment": "audit:allow layout-list-context-navigate-merge-query 상품 폼에서 채널 연동 설정 화면으로 나가는 이동이다 — 상품 목록의 페이지·필터를 물려주지 않는다.",
"type": "click",
"handler": "navigate",
"params": {
"url": "/admin/ecommerce/integrations/google"
"path": "/admin/ecommerce/integrations/google"
}
}
],
@@ -1702,6 +1702,7 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 프리셋 적용 — 프리셋은 조건 세트를 통째로 갈아끼우는 것이므로 병합하면 직전 조건이 섞인다. 주문 목록의 프리셋 규약과 동일.",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/products",
@@ -2287,6 +2288,7 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 필터 초기화 — 걸려 있던 조건을 전부 비우는 것이 이 버튼의 목적이므로 병합하지 않는다.",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/products",
@@ -1565,7 +1565,9 @@
"edit": {
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/products/{{$args[1].product_code ?? $args[1].id}}/edit"
"path": "/admin/ecommerce/products/{{$args[1].product_code ?? $args[1].id}}/edit",
"mergeQuery": true,
"query": {}
}
},
"copy": {
@@ -215,8 +215,10 @@
}
},
{
"comment": "선택 상태만 주소에 기록한다 — 왼쪽 목록에 걸어둔 검색어는 그대로 둔다 (#75).",
"handler": "replaceUrl",
"params": {
"mergeQuery": true,
"query": {
"id": "{{template.id}}",
"mode": "view"
@@ -163,13 +163,13 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/promotion-coupons",
"replace": true,
"mergeQuery": true,
"query": {
"sort_by": "{{$event.target.value.split('_').slice(0, -1).join('_')}}",
"sort_order": "{{$event.target.value.split('_').pop()}}",
"page": 1
},
"replace": true,
"transition_overlay_target": "pc_data_table__body"
}
}
@@ -207,12 +207,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/promotion-coupons",
"replace": true,
"mergeQuery": true,
"query": {
"per_page": "{{$event.target.value}}",
"page": 1
},
"replace": true,
"transition_overlay_target": "pc_data_table__body"
}
}
@@ -311,7 +311,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/promotion-coupons/{{row.id}}/edit"
"path": "/admin/ecommerce/promotion-coupons/{{row.id}}/edit",
"mergeQuery": true,
"query": {}
}
}
]
@@ -563,11 +565,12 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/promotion-coupons",
"replace": true,
"mergeQuery": true,
"query": {
"created_by": "{{row.created_by}}",
"page": 1
},
"replace": true,
"transition_overlay_target": "pc_data_table__body"
}
}
@@ -588,11 +591,11 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/promotion-coupons",
"replace": true,
"mergeQuery": true,
"query": {
"page": "{{$args[0]}}"
},
"replace": true,
"transition_overlay_target": "pc_data_table__body"
}
},
@@ -611,7 +614,9 @@
"edit": {
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/promotion-coupons/{{$args[1].id}}/edit"
"path": "/admin/ecommerce/promotion-coupons/{{$args[1].id}}/edit",
"mergeQuery": true,
"query": {}
}
},
"issue_history": {
@@ -817,7 +822,9 @@
"edit": {
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/promotion-coupons/{{coupon.id}}/edit"
"path": "/admin/ecommerce/promotion-coupons/{{coupon.id}}/edit",
"mergeQuery": true,
"query": {}
}
},
"issue_history": {
@@ -2241,9 +2241,11 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 필터 초기화 — 걸려 있던 조건을 전부 비우는 것이 이 버튼의 목적이므로 병합하지 않는다.",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/promotion-coupons",
"mergeQuery": false,
"replace": true
}
}
@@ -2366,9 +2368,11 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 필터 초기화 — 걸려 있던 조건을 전부 비우는 것이 이 버튼의 목적이므로 병합하지 않는다.",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/promotion-coupons",
"mergeQuery": false,
"replace": true
}
}
@@ -308,11 +308,13 @@
},
"actions": [
{
"comment": "audit:allow layout-list-context-navigate-merge-query 필터 초기화 — 걸려 있던 조건을 전부 비우는 것이 이 버튼의 목적이므로 병합하지 않는다.",
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/settings",
"replace": true,
"mergeQuery": false,
"query": {
"tab": "identity_policies"
},
@@ -255,6 +255,7 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 탭 전환 — 탭마다 다루는 대상이 달라 이전 탭의 목록 상태를 물려받으면 오히려 잘못된 화면이 된다.",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/settings",
@@ -247,6 +247,7 @@
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/shipping-policies/create",
"mergeQuery": true,
"query": {
"copy_id": "{{_global.targetPolicy?.id}}"
}
@@ -346,7 +346,9 @@
"edit": {
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/shipping-policies/{{$args[1].id}}/edit"
"path": "/admin/ecommerce/shipping-policies/{{$args[1].id}}/edit",
"mergeQuery": true,
"query": {}
}
},
"copy": {
@@ -1098,9 +1098,11 @@
}
},
{
"comment": "audit:allow layout-list-context-navigate-merge-query 필터 초기화 — 걸려 있던 조건을 전부 비우는 것이 이 버튼의 목적이므로 병합하지 않는다.",
"handler": "navigate",
"params": {
"path": "/admin/ecommerce/shipping-policies"
"path": "/admin/ecommerce/shipping-policies",
"mergeQuery": false
}
}
]
@@ -3,6 +3,8 @@
namespace Modules\Sirsoft\Ecommerce\Repositories;
use App\Helpers\PermissionHelper;
use App\Search\Engines\DatabaseFulltextEngine;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Modules\Sirsoft\Ecommerce\Models\Brand;
use Modules\Sirsoft\Ecommerce\Repositories\Contracts\BrandRepositoryInterface;
@@ -34,39 +36,21 @@ class BrandRepository implements BrandRepositoryInterface
$query->where('is_active', $filters['is_active']);
}
// 검색 키워드가 있으면 Scout 사용
// 검색 키워드 — 이름(FULLTEXT) / slug / website 중 하나만 맞아도 나와야 한다.
//
// Scout 의 `search()->query(fn)` 로는 이 형태를 만들 수 없다. 그 콜백은 검색 엔진이
// 이미 맞힌 결과를 **좁히는** 자리라, slug·website 를 OR 로 덧붙여도 실제로는 AND 로
// 걸린다. 이름만 일치하고 slug·website 에는 키워드가 없는 브랜드(대부분)가 전부
// 걸러져 검색 결과가 항상 비었다. 같은 함정을 이미 겪은 페이지 검색과 동일하게
// whereFulltext 헬퍼로 한 쿼리 안에서 OR 로 묶는다.
if (! empty($filters['search'])) {
$keyword = $filters['search'];
return Brand::search($keyword)
->query(function ($query) use ($filters, $keyword, $with) {
// 권한 스코프 필터링
PermissionHelper::applyPermissionScope($query, 'sirsoft-ecommerce.brands.read');
// 상품 수 조회
$query->withCount('products');
// 활성 상태 필터
if (isset($filters['is_active'])) {
$query->where('is_active', $filters['is_active']);
}
// FULLTEXT 외 필드 OR 조건 (slug, website)
$query->where(function ($q) use ($keyword) {
$q->orWhere('slug', 'like', "%{$keyword}%")
->orWhere('website', 'like', "%{$keyword}%");
});
// 정렬 처리
$locale = $filters['locale'] ?? app()->getLocale();
$this->applySorting($query, $filters, $locale);
// Eager loading
if (! empty($with)) {
$query->with($with);
}
})
->get();
$query->where(function ($q) use ($keyword) {
DatabaseFulltextEngine::whereFulltext($q, 'name', $keyword, 'and');
$q->orWhere('slug', 'like', "%{$keyword}%")
->orWhere('website', 'like', "%{$keyword}%");
});
}
// 정렬 처리
@@ -88,7 +72,7 @@ class BrandRepository implements BrandRepositoryInterface
{
$query = $this->model->newQuery();
if (!empty($with)) {
if (! empty($with)) {
$query->with($with);
}
@@ -113,6 +97,7 @@ class BrandRepository implements BrandRepositoryInterface
{
$brand = $this->findById($id);
$brand->update($data);
return $brand->fresh();
}
@@ -122,6 +107,7 @@ class BrandRepository implements BrandRepositoryInterface
public function delete(int $id): bool
{
$brand = $this->findById($id);
return $brand->delete();
}
@@ -131,6 +117,7 @@ class BrandRepository implements BrandRepositoryInterface
public function getProductCount(int $id): int
{
$brand = $this->findById($id);
return $brand->products()->count();
}
@@ -151,10 +138,9 @@ class BrandRepository implements BrandRepositoryInterface
/**
* 정렬 조건을 쿼리에 적용합니다.
*
* @param \Illuminate\Database\Eloquent\Builder $query Eloquent 쿼리 빌더
* @param array $filters 필터 배열
* @param string $locale 로케일
* @return void
* @param Builder $query Eloquent 쿼리 빌더
* @param array $filters 필터 배열
* @param string $locale 로케일
*/
private function applySorting($query, array $filters, string $locale): void
{
@@ -190,4 +176,4 @@ class BrandRepository implements BrandRepositoryInterface
$query->orderBy("name->{$locale}")->orderBy('id');
}
}
}
}
@@ -0,0 +1,73 @@
/**
* 관리자 주문 목록 컨텍스트 왕복 — 걸어 둔 필터·페이지가 상세를 다녀와도 살아남는지 (공개 이슈 #75).
*
* 결함: 주문 목록에서 주문 하나를 열었다가 '목록' 으로 돌아오면 걸어 둔 필터와 페이지가 전부 사라져
* 1페이지 무필터 상태로 되돌아갔다. 필터를 여러 개 걸어 두고 주문을 하나씩 확인하는 실제 운영 흐름에서
* 가장 아프게 드러나는 형태다.
*
* 표식으로 `page` 와 `per_page` 를 쓴다 — 시드 주문 105건이므로 2페이지가 항상 존재한다.
*
* 커버 범위: 이 spec 은 **복귀 leg**(상세 → 목록)를 브라우저 수준에서 실측한다. 진입 leg 는
* `resources/js/__tests__/layouts/admin-list-context-round-trip.test.ts` 가 실 JSON 의 액션 params 로
* 고정하고 audit 룰 layout-list-context-navigate-merge-query 가 재발을 차단한다.
*
* @scenario order-admin-list-context-round-trip
* @axes leg=back
* @effects list_return_preserves_query
*/
import { test, expect, authenticatePage } from '../../fixtures/ecommerce-auth';
const LIST_URL = '/admin/ecommerce/orders';
const LIST_STATE = 'page=2&per_page=10';
/**
* 현재 URL 의 쿼리 파라미터를 돌려줍니다.
*
* @param url 페이지 URL
* @returns 쿼리 파라미터
*/
function queryOf(url: string): URLSearchParams {
return new URL(url).searchParams;
}
test.describe('관리자 주문 목록 컨텍스트 왕복 (#75)', () => {
// @scenario leg=back
// @effects list_return_preserves_query
test('주문 상세에서 목록으로 돌아오면 페이지와 표시 개수가 복원된다', async ({ page, ordersReadToken }) => {
await authenticatePage(page, ordersReadToken);
await page.goto(`${LIST_URL}?${LIST_STATE}`);
await page.waitForLoadState('networkidle', { timeout: 30_000 });
// 목록에서 상세로 들어간 직후와 동일한 URL 상태 (진입 leg 가 mergeQuery 로 만들어 주는 형태)
const orderNumber = await page.evaluate(async () => {
const res = await fetch('/api/modules/sirsoft-ecommerce/admin/orders?per_page=10', {
headers: {
Authorization: `Bearer ${localStorage.getItem('auth_token')}`,
Accept: 'application/json',
},
});
const json = await res.json();
// 응답 봉투 형태에 의존하지 않도록 order_number 를 가진 첫 객체를 찾는다.
const stack: unknown[] = [json];
while (stack.length > 0) {
const node = stack.pop();
if (!node || typeof node !== 'object') continue;
const rec = node as Record<string, unknown>;
if (typeof rec.order_number === 'string') return rec.order_number;
stack.push(...Object.values(rec));
}
return null;
});
expect(orderNumber, '주문 시드가 없어 왕복을 검증할 수 없습니다.').not.toBeNull();
await page.goto(`${LIST_URL}/${orderNumber}?${LIST_STATE}`);
await page.waitForLoadState('networkidle', { timeout: 30_000 });
await page.locator('#list_button').click();
await page.waitForURL(/\/admin\/ecommerce\/orders\?/, { timeout: 30_000 });
const q = queryOf(page.url());
expect(q.get('page')).toBe('2');
expect(q.get('per_page')).toBe('10');
});
});
@@ -0,0 +1,147 @@
<?php
namespace Modules\Sirsoft\Ecommerce\Tests\Unit\Repositories;
use Illuminate\Support\Facades\DB;
use Modules\Sirsoft\Ecommerce\Models\Brand;
use Modules\Sirsoft\Ecommerce\Repositories\BrandRepository;
use Modules\Sirsoft\Ecommerce\Tests\ModuleTestCase;
/**
* 브랜드 Repository 검색 회귀 테스트
*
* 결함: 브랜드명으로 검색하면 결과가 항상 0건이었다. FULLTEXT 로 이름을 맞힌 뒤
* Scout 의 query 콜백 안에서 `slug`/`website` 를 OR 로 덧붙여 검색 범위를 넓히려 했으나,
* 그 콜백은 이미 맞힌 결과를 **좁히는** 자리라 실제로는 AND 로 걸렸다. 이름만 일치하고
* slug·website 에는 키워드가 없는 브랜드(대부분)가 전부 걸러졌다.
*
* 검색은 세 필드 중 하나라도 맞으면 나와야 한다 — 이름 / slug / 웹사이트.
*/
class BrandRepositorySearchTest extends ModuleTestCase
{
protected BrandRepository $repository;
protected function setUp(): void
{
parent::setUp();
$this->repository = new BrandRepository(new Brand);
}
/**
* 테스트용 브랜드를 만듭니다.
*
* @param array<string, string> $name 로케일별 이름
* @param string $slug slug
* @param string|null $website 웹사이트 주소
* @return Brand 생성된 브랜드
*/
private function makeBrand(array $name, string $slug, ?string $website = null): Brand
{
return Brand::create([
'name' => $name,
'slug' => $slug,
'website' => $website,
'is_active' => true,
'sort_order' => 1,
]);
}
/**
* 이름 검색은 결과 행이 아니라 실행된 SQL 형태로 단언한다.
*
* InnoDB FULLTEXT 색인은 커밋 이후에만 보이므로, 트랜잭션 안에서 만든 행은 MATCH 로
* 잡히지 않는다 (코어 DatabaseFulltextEngineTest 도 같은 이유로 SQL 을 단언한다).
* 이번 결함의 본질은 "이름 조건이 slug·website 와 OR 로 묶이는가" 이므로 그 형태를 고정한다.
*/
public function test_search_combines_name_slug_website_with_or(): void
{
$this->makeBrand(['ko' => '나이키', 'en' => 'Nike'], 'nike', 'https://www.nike.com');
DB::enableQueryLog();
$this->repository->getAll(['search' => '나이키']);
$log = DB::getQueryLog();
DB::disableQueryLog();
$sql = collect($log)->pluck('query')->implode(' | ');
$this->assertStringContainsString(
'match(`name`) against',
strtolower($sql),
'이름에 대한 FULLTEXT 조건이 쿼리에 없습니다.'
);
$this->assertMatchesRegularExpression(
'/against\(\? in boolean mode\)\s+or\s+`slug`\s+like\s+\?\s+or\s+`website`\s+like\s+\?/i',
strtolower($sql),
'이름·slug·website 가 OR 로 묶이지 않았습니다 — 좁히는 AND 로 걸리면 이름만 일치하는 브랜드가 전부 사라집니다.'
);
}
public function test_search_finds_brand_by_slug(): void
{
// Given: 이름은 한글, slug 는 영문
$puma = $this->makeBrand(['ko' => '퓨마', 'en' => 'Puma'], 'puma-korea', 'https://www.puma.com');
// When: slug 조각으로 검색
$result = $this->repository->getAll(['search' => 'puma-korea']);
// Then: slug 가 맞았으므로 나와야 한다
$this->assertCount(1, $result, 'slug 가 일치하는 브랜드가 검색되지 않았습니다.');
$this->assertSame($puma->id, $result->first()->id);
}
public function test_search_finds_brand_by_website(): void
{
// Given: 이름·slug 와 무관한 도메인
$zara = $this->makeBrand(['ko' => '자라', 'en' => 'ZARA'], 'zara', 'https://shop.inditex-group.com');
// When: 도메인 조각으로 검색
$result = $this->repository->getAll(['search' => 'inditex-group']);
// Then: website 가 맞았으므로 나와야 한다
$this->assertCount(1, $result, 'website 가 일치하는 브랜드가 검색되지 않았습니다.');
$this->assertSame($zara->id, $result->first()->id);
}
public function test_search_excludes_unrelated_brands(): void
{
// Given: 서로 겹치지 않는 두 브랜드
$this->makeBrand(['ko' => '나이키', 'en' => 'Nike'], 'nike', 'https://www.nike.com');
$this->makeBrand(['ko' => '아디다스', 'en' => 'Adidas'], 'adidas', 'https://www.adidas.com');
// When: 한쪽만 가리키는 키워드로 검색
$result = $this->repository->getAll(['search' => 'adidas']);
// Then: 나머지는 섞이지 않는다
$this->assertCount(1, $result);
$this->assertSame('adidas', $result->first()->slug);
}
public function test_search_respects_active_filter(): void
{
// Given: 같은 키워드를 가진 활성/비활성 브랜드
$active = $this->makeBrand(['ko' => '나이키', 'en' => 'Nike'], 'nike-korea', null);
$inactive = $this->makeBrand(['ko' => '나이키 키즈', 'en' => 'Nike Kids'], 'nike-kids', null);
$inactive->update(['is_active' => false]);
// When: 활성만 요청
$result = $this->repository->getAll(['search' => 'nike-korea', 'is_active' => true]);
// Then: 검색과 필터가 함께 적용된다
$this->assertCount(1, $result);
$this->assertSame($active->id, $result->first()->id);
}
public function test_search_keeps_active_filter_and_keyword_grouped(): void
{
// Given: 비활성 브랜드가 키워드를 담고 있다
$this->makeBrand(['ko' => '나이키', 'en' => 'Nike'], 'nike-korea', null)
->update(['is_active' => false]);
// When: 활성만 요청
$result = $this->repository->getAll(['search' => 'nike-korea', 'is_active' => true]);
// Then: OR 그룹이 괄호로 묶여야 활성 조건이 무력화되지 않는다
$this->assertCount(0, $result, 'is_active 조건이 OR 로 흡수돼 비활성 브랜드가 새어 나왔습니다.');
}
}
@@ -0,0 +1,31 @@
feature: 관리자 주문 목록 컨텍스트 왕복
description: |
관리자 주문 목록과 그에 딸린 주문 상세는 하나의 "목록 클러스터" 다. 이 안에서의 이동은 URL 목록
상태(page / per_page / 검색 / 상태 필터 / 기간)를 손실 없이 이어받아야 한다 (공개 이슈 #75).
운영 흐름상 이 도메인이 가장 아프다 — 필터를 여러 개 걸어 두고 주문을 하나씩 열어 확인하는데,
복귀할 때마다 1페이지 무필터로 되돌아가면 걸어 둔 조건을 매번 다시 만들어야 한다.
반대로 **초기화 버튼과 프리셋 적용은 병합하지 않는다**. 프리셋은 조건 세트를 통째로 갈아끼우는
동작이라 병합하면 직전 프리셋의 기간·상태가 남아 엉뚱한 결과가 나온다. 이 구분은 액션 노드의
`audit:allow layout-list-context-navigate-merge-query` 주석으로 코드에 기록돼 있고,
룰이 "주석은 병합하지 않겠다는데 코드는 mergeQuery: true" 인 자기모순을 검출한다.
axes:
# 목록 클러스터 안에서 발생하는 이동 leg
leg: [back] # 주문 상세 → 목록
effects:
- list_return_preserves_query # 복귀 이동이 URL 목록 상태를 그대로 복원
test_files:
- modules/_bundled/sirsoft-ecommerce/tests/Playwright/specs/admin/order-admin-list-context-round-trip.spec.ts
- modules/_bundled/sirsoft-ecommerce/resources/js/__tests__/layouts/admin-list-context-round-trip.test.ts
- .claude/scripts/audit/__tests__/layout-list-context-navigate-merge-query.test.cjs
validation:
note: |
진입 leg(목록 행 → 상세)와 필터/프리셋/초기화의 병합 여부는 레이아웃 테스트가 실 JSON 의 액션
params 로 전수 고정한다. 브라우저 spec 은 진입이 만들어 내는 URL 상태를 재현한 뒤 복귀 leg 를
실측한다. 재발 차단은 audit 룰 `layout-list-context-navigate-merge-query` (error) 가 담당한다.
@@ -18,6 +18,7 @@
### Fixed
- 관리자 페이지 목록에서 상세나 수정 화면에 다녀오면 보고 있던 페이지와 검색 조건이 사라지고 1페이지로 되돌아가던 문제를 수정했습니다. (#75 @jiwonpapa 님께서 제보해주셨습니다.)
- 페이지 활동 로그에서 "제목"·"내용" 변경 항목의 이름이 비어 보이던 문제를 수정했습니다.
- 다른 페이지의 주소로 특정 페이지의 이전 버전 내용을 열람할 수 있던 문제를 수정했습니다.
- 다른 페이지에 속한 버전으로 복원을 시도하면 "복원에 실패했습니다" 라는 서버 오류가 나던 문제를 수정했습니다. 이제 열람과 동일하게 "찾을 수 없음" 으로 안내합니다.
@@ -0,0 +1,212 @@
/**
* @file admin-list-context-round-trip.test.ts
* @description 관리자 페이지 목록 컨텍스트 왕복 시 URL 목록 상태 보존 회귀 (#75)
*
* 결함: 페이지 목록(`/admin/pages`) 에서 상세·수정 폼으로 들어갔다 돌아오면 navigate 가
* `mergeQuery` 없이 실행되어 page/검색 필터가 URL 에서 사라지고 1페이지로 되돌아갔다.
*
* 검증 방식 2단:
* 1. 실 레이아웃 JSON 전수 분석 — 클러스터 내 navigate 가 모두 `mergeQuery: true` 인지
* 2. 실 액션을 엔진에 태워 실행(`triggerAction`) — 선언이 실제 목적지 URL 로 이어지는지
* 선언만 검사하면 "JSON 에 리터럴이 적혀 있다" 까지만 고정되고 병합 결과는 미검증으로 남는다.
*
* @scenario leg=row_click|detail_return|form_cancel
* @effects navigation_preserves_list_query
*
* @vitest-environment jsdom
*/
import { describe, it, expect, afterEach } from 'vitest';
import fs from 'fs';
import path from 'path';
import {
createLayoutTest,
createMockComponentRegistryWithBasics,
} from '@core/template-engine/__tests__/utils/layoutTestUtils';
const LAYOUTS_ROOT = path.resolve(__dirname, '../../../layouts/admin');
/** 이 확장이 소유한 페이지네이션 목록 라우트 */
const LIST_ROUTES = ['/admin/pages'];
/** 목록 클러스터에 속하는 레이아웃 파일 */
const CLUSTER_FILES = ['admin_page_list.json', 'admin_page_detail.json', 'admin_page_form.json'];
type NavAction = {
handler: string;
comment?: string;
params: { path?: string; mergeQuery?: unknown; query?: unknown };
};
/**
* JSON 트리에서 navigate/replaceUrl 액션을 모두 수집합니다.
*
* @param node 순회 시작 노드
* @returns 액션 목록
*/
function collectNavActions(node: unknown): NavAction[] {
const out: NavAction[] = [];
const walk = (n: unknown): void => {
if (Array.isArray(n)) {
n.forEach(walk);
return;
}
if (!n || typeof n !== 'object') return;
const obj = n as Record<string, unknown>;
if (
(obj.handler === 'navigate' || obj.handler === 'replaceUrl') &&
obj.params &&
typeof obj.params === 'object'
) {
out.push(obj as unknown as NavAction);
}
Object.values(obj).forEach(walk);
};
walk(node);
return out;
}
/**
* 목적지 경로를 비교용 표준형(`{{expr}}` → `*`)으로 바꿉니다.
*
* @param raw 원본 경로
* @returns 표준형 경로 (판정 불가 시 null)
*/
function normalizePath(raw: unknown): string | null {
if (typeof raw !== 'string' || raw === '') return null;
const p = raw.replace(/\{\{[^}]*\}\}/g, '*').split('?')[0].replace(/\/+$/, '');
return p.startsWith('/') ? p : null;
}
/**
* 경로가 목록 라우트와 같은 클러스터인지 판정합니다.
*
* @param dest 표준형 목적지
* @param list 표준형 목록 라우트
* @returns 같은 클러스터 여부
*/
function inFamily(dest: string, list: string): boolean {
return dest === list || dest.startsWith(`${list}/`);
}
/**
* 레이아웃 파일을 읽어 파싱합니다.
*
* @param rel 레이아웃 루트 기준 상대 경로
* @returns 파싱된 JSON
*/
function readLayout(rel: string): unknown {
return JSON.parse(fs.readFileSync(path.join(LAYOUTS_ROOT, rel), 'utf8'));
}
describe('#75 관리자 페이지 목록 컨텍스트 왕복 — mergeQuery 전수', () => {
it.each(CLUSTER_FILES)('%s 의 클러스터 내 navigate 는 모두 mergeQuery: true', (rel) => {
const offenders = collectNavActions(readLayout(rel))
.filter((a) => {
if (typeof a.comment === 'string' && a.comment.includes('audit:allow')) return false;
const dest = normalizePath(a.params.path);
if (!dest) return false;
if (!LIST_ROUTES.some((l) => inFamily(dest, l))) return false;
return a.params.mergeQuery !== true;
})
.map((a) => `${a.params.path} (mergeQuery=${JSON.stringify(a.params.mergeQuery)})`);
expect(offenders, `목록 상태를 떨구는 navigate: \n ${offenders.join('\n ')}`).toEqual([]);
});
it("페이지 상세의 '목록' 버튼이 목록 상태를 복원한다", () => {
const backs = collectNavActions(readLayout('admin_page_detail.json')).filter(
(a) => a.params.path === '/admin/pages'
);
expect(backs.length).toBeGreaterThan(0);
backs.forEach((a) => expect(a.params.mergeQuery).toBe(true));
});
});
// ---------------------------------------------------------------------------
// 실행 검증 — 실 액션을 엔진에 태워 목적지 URL 을 확인한다
// ---------------------------------------------------------------------------
/**
* 실 JSON 액션을 현재 URL 상태에서 실행하고 목적지를 돌려줍니다.
*
* @param action 실 레이아웃 JSON 에서 뽑은 navigate 액션
* @returns navigate 목적지 경로
*/
async function runNav(action: NavAction): Promise<string> {
const utils = createLayoutTest(
{
version: '1.0.0',
layout_name: 'nav_action_probe',
data_sources: [],
components: [{ type: 'basic', name: 'Div', props: { 'data-testid': 'probe' } }],
} as never,
{ componentRegistry: createMockComponentRegistryWithBasics() as never, locale: 'ko' }
);
await utils.render();
await utils.triggerAction({ type: 'click', ...action } as never);
const dest = utils.getNavigationHistory()[0];
utils.cleanup();
return dest;
}
/**
* 목적지 URL 의 쿼리스트링을 파싱합니다.
*
* @param dest navigate 목적지
* @returns URLSearchParams
*/
function queryOf(dest: string): URLSearchParams {
return new URLSearchParams(dest.includes('?') ? dest.slice(dest.indexOf('?')) : '');
}
/**
* 실 JSON 에서 목적지 경로가 일치하는 navigate 액션을 찾습니다.
*
* @param json 레이아웃 JSON
* @param destPath 목적지 경로 (원문 그대로)
* @returns 액션
*/
function findNavAction(json: unknown, destPath: string): NavAction {
const action = collectNavActions(json).find((a) => a.params.path === destPath);
expect(action, `navigate 액션(${destPath})을 실 JSON 에서 찾지 못함`).toBeTruthy();
return action as NavAction;
}
describe('#75 관리자 페이지 목록 컨텍스트 왕복 — 실행 결과 URL', () => {
afterEach(() => {
window.history.replaceState({}, '', '/');
});
it('목록 행 클릭이 목록 상태를 상세 URL 로 나른다', async () => {
window.history.replaceState({}, '', '/admin/pages?page=3&per_page=2&sort_by=title');
const q = queryOf(await runNav(findNavAction(readLayout('admin_page_list.json'), '/admin/pages/{{$args[1].id}}')));
expect(q.get('page')).toBe('3');
expect(q.get('per_page')).toBe('2');
expect(q.get('sort_by')).toBe('title');
});
it("상세의 '목록' 버튼이 상세 URL 의 목록 상태를 목록으로 복귀시킨다", async () => {
window.history.replaceState({}, '', '/admin/pages/7?page=3&per_page=2&sort_by=title');
const q = queryOf(await runNav(findNavAction(readLayout('admin_page_detail.json'), '/admin/pages')));
expect(q.get('page')).toBe('3');
expect(q.get('per_page')).toBe('2');
expect(q.get('sort_by')).toBe('title');
});
it('상세 → 수정 이동에서도 목록 상태가 이어진다', async () => {
window.history.replaceState({}, '', '/admin/pages/7?page=3&per_page=2');
const q = queryOf(
await runNav(findNavAction(readLayout('admin_page_detail.json'), '/admin/pages/{{route?.id}}/edit'))
);
expect(q.get('page')).toBe('3');
expect(q.get('per_page')).toBe('2');
});
});
@@ -158,7 +158,9 @@
{
"handler": "navigate",
"params": {
"path": "/admin/pages"
"path": "/admin/pages",
"mergeQuery": true,
"query": {}
}
}
],
@@ -655,7 +657,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/pages"
"path": "/admin/pages",
"mergeQuery": true,
"query": {}
}
}
],
@@ -691,7 +695,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/pages/{{route?.id}}/edit"
"path": "/admin/pages/{{route?.id}}/edit",
"mergeQuery": true,
"query": {}
}
}
],
@@ -963,7 +963,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "{{route?.id ? '/admin/pages/' + route.id : '/admin/pages'}}"
"path": "{{route?.id ? '/admin/pages/' + route.id : '/admin/pages'}}",
"mergeQuery": true,
"query": {}
}
}
],
@@ -1058,7 +1060,9 @@
{
"handler": "navigate",
"params": {
"path": "/admin/pages/{{route?.id ?? response.data.id}}"
"path": "/admin/pages/{{route?.id ?? response.data.id}}",
"mergeQuery": true,
"query": {}
}
}
],
@@ -111,7 +111,8 @@
"handler": "navigate",
"params": {
"path": "/admin/pages",
"mergeQuery": false
"mergeQuery": true,
"query": {}
}
}
],
@@ -139,7 +140,9 @@
"type": "click",
"handler": "navigate",
"params": {
"path": "/admin/pages/create"
"path": "/admin/pages/create",
"mergeQuery": true,
"query": {}
}
}
],
@@ -828,13 +831,17 @@
"view": {
"handler": "navigate",
"params": {
"path": "/admin/pages/{{$args[1].id}}"
"path": "/admin/pages/{{$args[1].id}}",
"mergeQuery": true,
"query": {}
}
},
"edit": {
"handler": "navigate",
"params": {
"path": "/admin/pages/{{$args[1].id}}/edit"
"path": "/admin/pages/{{$args[1].id}}/edit",
"mergeQuery": true,
"query": {}
}
},
"delete": {
@@ -968,7 +975,7 @@
"params": {
"path": "/admin/pages",
"mergeQuery": true,
"query": []
"query": {}
}
},
{
@@ -1129,7 +1136,7 @@
"params": {
"path": "/admin/pages",
"mergeQuery": true,
"query": []
"query": {}
}
},
{
@@ -0,0 +1,106 @@
/**
* 관리자 페이지 목록 컨텍스트 왕복 — 목록 상태가 상세·폼을 거쳐도 살아남는지 (공개 이슈 #75).
*
* 결함: 목록 → 상세 → 목록, 목록 → 등록/수정 폼 → 취소 경로에 `mergeQuery` 가 빠져 있어 표시 개수·
* 필터 같은 목록 상태가 이동 한 번에 사라졌다. 취소 버튼은 목적지가 삼항 표현식이라 정적 검사에서도
* 오래 빠져 있던 자리다.
*
* 표시 개수(`per_page`)를 표식으로 쓴다 — 시드 건수와 무관하게 항상 URL 에 실리는 목록 상태다.
*
* 커버 범위: 이 spec 은 **복귀 leg**(상세 → 목록, 폼 취소 → 목록)를 브라우저 수준에서 실측한다.
* 진입 leg(목록 행 → 상세)는 행 끝 ⋯ 메뉴가 포털로 렌더되어 로케이터가 불안정하므로,
* `resources/js/__tests__/layouts/admin-list-context-round-trip.test.ts` 가 실 JSON 의 액션 params 로
* 고정하고 audit 룰이 재발을 차단한다. 복귀 leg 는 진입으로 만들어진 URL 상태를 그대로 재현해 검증한다.
*
* @scenario page-admin-list-context-round-trip
* @axes leg=back leg=cancel
* @effects list_return_preserves_query
*/
import { test, expect, authenticatePage } from '../../fixtures/page-auth';
const LIST_URL = '/admin/pages';
const LIST_STATE = 'per_page=10';
/**
* 현재 URL 의 쿼리 파라미터를 돌려줍니다.
*
* @param url 페이지 URL
* @returns 쿼리 파라미터
*/
function queryOf(url: string): URLSearchParams {
return new URL(url).searchParams;
}
/**
* 목록의 첫 페이지 id 를 조회합니다.
*
* 브라우저 컨텍스트에서 조회해 화면과 같은 토큰·권한을 그대로 쓴다.
*
* @param page Playwright 페이지
* @returns 페이지 id
*/
async function firstPageId(page: import('@playwright/test').Page): Promise<number> {
const id = await page.evaluate(async () => {
const res = await fetch('/api/modules/sirsoft-page/admin/pages?per_page=1', {
headers: {
Authorization: `Bearer ${localStorage.getItem('auth_token')}`,
Accept: 'application/json',
},
});
const json = await res.json();
const rows = json?.data?.data ?? json?.data ?? [];
return Array.isArray(rows) && rows.length > 0 ? rows[0].id : null;
});
expect(id, '페이지 시드가 없어 왕복을 검증할 수 없습니다.').not.toBeNull();
return id as number;
}
test.describe('관리자 페이지 목록 컨텍스트 왕복 (#75)', () => {
// @scenario leg=back
// @effects list_return_preserves_query
test('상세에서 목록으로 돌아오면 목록 상태가 복원된다', async ({ page, pageManageToken }) => {
await authenticatePage(page, pageManageToken);
await page.goto(`${LIST_URL}?${LIST_STATE}`);
await page.waitForLoadState('networkidle', { timeout: 30_000 });
const id = await firstPageId(page);
// 목록에서 상세로 들어간 직후와 동일한 URL 상태 (진입 leg 가 mergeQuery 로 만들어 주는 형태)
await page.goto(`${LIST_URL}/${id}?${LIST_STATE}`);
await page.waitForLoadState('networkidle', { timeout: 30_000 });
await page.locator('#header_back_button').click();
await page.waitForURL(/\/admin\/pages\?/, { timeout: 30_000 });
expect(queryOf(page.url()).get('per_page')).toBe('10');
});
// @scenario leg=cancel
// @effects list_return_preserves_query
test('등록 폼에서 취소하면 목록 상태가 유지된 채 목록으로 돌아온다', async ({ page, pageManageToken }) => {
await authenticatePage(page, pageManageToken);
await page.goto(`${LIST_URL}/create?${LIST_STATE}`);
await page.waitForLoadState('networkidle', { timeout: 30_000 });
await page.locator('#footer_cancel_button').click();
await page.waitForURL(/\/admin\/pages\?/, { timeout: 30_000 });
expect(queryOf(page.url()).get('per_page')).toBe('10');
});
// @scenario leg=cancel
// @effects list_return_preserves_query
test('수정 폼에서 취소하면 그 페이지 상세로 돌아오며 목록 상태가 살아 있다', async ({ page, pageManageToken }) => {
await authenticatePage(page, pageManageToken);
await page.goto(`${LIST_URL}?${LIST_STATE}`);
await page.waitForLoadState('networkidle', { timeout: 30_000 });
const id = await firstPageId(page);
await page.goto(`${LIST_URL}/${id}/edit?${LIST_STATE}`);
await page.waitForLoadState('networkidle', { timeout: 30_000 });
await page.locator('#footer_cancel_button').click();
await page.waitForURL(new RegExp(`/admin/pages/${id}\\?`), { timeout: 30_000 });
expect(queryOf(page.url()).get('per_page')).toBe('10');
});
});
@@ -0,0 +1,29 @@
feature: 관리자 페이지 목록 컨텍스트 왕복
description: |
관리자 페이지 목록과 그에 딸린 상세·등록/수정 폼은 하나의 "목록 클러스터" 다. 이 안에서의 이동은
URL 목록 상태(page / per_page / 정렬 / 필터)를 손실 없이 이어받아야 한다 (공개 이슈 #75).
이 모듈에서 특히 오래 남아 있던 자리는 **폼 취소 leg** 이다. 저장 leg 는 목적지가 고정 경로라
일찍 교정됐지만, 취소 버튼은 목적지가 삼항 표현식(`route?.id ? '/admin/pages/' + id : '/admin/pages'`)
이라 정적 검사에서 판정 자체가 포기돼 "저장하면 유지 / 취소하면 리셋" 비대칭이 남았다.
audit 룰이 표현식 안의 문자열 리터럴로 클러스터를 판정하도록 승격되면서 검출 대상이 됐다.
axes:
# 목록 클러스터 안에서 발생하는 이동 leg
leg: [back, cancel] # 상세→목록 / 폼 취소→직전 화면
effects:
- list_return_preserves_query # 복귀 이동이 URL 목록 상태를 그대로 복원
test_files:
- modules/_bundled/sirsoft-page/tests/Playwright/specs/admin/page-admin-list-context-round-trip.spec.ts
- modules/_bundled/sirsoft-page/resources/js/__tests__/layouts/admin-list-context-round-trip.test.ts
- .claude/scripts/audit/__tests__/layout-list-context-navigate-merge-query.test.cjs
validation:
note: |
진입 leg(목록 행 → 상세)는 행 끝 액션 메뉴가 포털로 렌더돼 브라우저 로케이터가 불안정하므로
레이아웃 테스트가 실 JSON 의 액션 params 로 고정한다. 브라우저 spec 은 진입이 만들어 내는 URL 상태를
그대로 재현한 뒤 복귀 leg 를 실측한다. 재발 차단은 audit 룰
`layout-list-context-navigate-merge-query` (error) 가 담당한다.