@svadmin/core 0.69.2 → 0.70.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/src/url-sync.ts CHANGED
@@ -1,31 +1,45 @@
1
- import type { Filter } from './types';
1
+ import type { Filter, LogicalFilter, Sort } from './types';
2
+ import { isCrudFieldOperator } from './types';
2
3
  import { captureAdminContext } from './context.svelte';
3
4
  import type { AdminContextAccessor } from './context.svelte';
4
5
  import { getAdminOptions } from './options.svelte';
5
6
 
6
- const CRUD_OPERATORS = new Set([
7
- 'eq', 'ne', 'lt', 'gt', 'lte', 'gte',
8
- 'contains', 'ncontains', 'startswith', 'endswith',
9
- 'in', 'nin', 'null', 'nnull', 'between', 'nbetween',
10
- ]);
11
-
12
7
  function isRecord(value: unknown): value is Record<string, unknown> {
13
8
  return typeof value === 'object' && value !== null && !Array.isArray(value);
14
9
  }
15
10
 
16
- function isFilter(value: unknown, depth: number, budget: { remaining: number }): value is Filter {
17
- if (depth > 20 || budget.remaining-- <= 0 || !isRecord(value)) return false;
11
+ function readFilterKey(value: Record<string, unknown>): string | undefined | null {
12
+ if (!('key' in value)) return undefined;
13
+ const key = value['key'];
14
+ if (typeof key !== 'string' || key.length < 1 || key.length > 128) return null;
15
+ return key;
16
+ }
17
+
18
+ /** 重新构造过滤器,只保留协议字段,避免把 URL 里的多余属性写回路由状态。 */
19
+ function readFilter(value: unknown, depth: number, budget: { remaining: number }): Filter | undefined {
20
+ if (depth > 20 || budget.remaining-- <= 0 || !isRecord(value)) return undefined;
18
21
 
19
22
  if (typeof value['field'] === 'string') {
20
- return value['field'].trim().length > 0
21
- && typeof value['operator'] === 'string'
22
- && CRUD_OPERATORS.has(value['operator'])
23
- && 'value' in value;
23
+ if (value['field'].trim().length === 0 || !isCrudFieldOperator(value['operator']) || !('value' in value)) {
24
+ return undefined;
25
+ }
26
+ return { field: value['field'], operator: value['operator'], value: value['value'] };
24
27
  }
25
28
 
26
- return (value['operator'] === 'and' || value['operator'] === 'or')
27
- && Array.isArray(value['value'])
28
- && value['value'].every((entry) => isFilter(entry, depth + 1, budget));
29
+ if ((value['operator'] !== 'and' && value['operator'] !== 'or') || !Array.isArray(value['value'])) {
30
+ return undefined;
31
+ }
32
+ const key = readFilterKey(value);
33
+ if (key === null) return undefined;
34
+ const children: Filter[] = [];
35
+ for (const entry of value['value']) {
36
+ const child = readFilter(entry, depth + 1, budget);
37
+ if (!child) return undefined;
38
+ children.push(child);
39
+ }
40
+ const filter: LogicalFilter = { operator: value['operator'], value: children };
41
+ if (key !== undefined) filter.key = key;
42
+ return filter;
29
43
  }
30
44
 
31
45
  function parseFilters(value: string): Filter[] | undefined {
@@ -33,7 +47,34 @@ function parseFilters(value: string): Filter[] | undefined {
33
47
  const parsed: unknown = JSON.parse(value);
34
48
  if (!Array.isArray(parsed)) return undefined;
35
49
  const budget = { remaining: 200 };
36
- return parsed.every((entry) => isFilter(entry, 0, budget)) ? parsed : undefined;
50
+ const filters: Filter[] = [];
51
+ for (const entry of parsed) {
52
+ const filter = readFilter(entry, 0, budget);
53
+ if (!filter) return undefined;
54
+ filters.push(filter);
55
+ }
56
+ return filters;
57
+ } catch {
58
+ return undefined;
59
+ }
60
+ }
61
+
62
+ const MAX_SORTERS = 16;
63
+
64
+ function parseSorters(value: string): Sort[] | undefined {
65
+ try {
66
+ const parsed: unknown = JSON.parse(value);
67
+ if (!Array.isArray(parsed) || parsed.length === 0 || parsed.length > MAX_SORTERS) return undefined;
68
+ const sorters: Sort[] = [];
69
+ for (const entry of parsed) {
70
+ if (!isRecord(entry) || Object.keys(entry).some((key) => key !== 'field' && key !== 'order')) return undefined;
71
+ const field = entry['field'];
72
+ const order = entry['order'];
73
+ if (typeof field !== 'string' || field.trim().length === 0 || field.length > 256) return undefined;
74
+ if (order !== 'asc' && order !== 'desc') return undefined;
75
+ sorters.push({ field, order });
76
+ }
77
+ return sorters;
37
78
  } catch {
38
79
  return undefined;
39
80
  }
@@ -53,13 +94,21 @@ export function sanitizeListQueryParams(params: Record<string, string>): Record<
53
94
  const result: Record<string, string> = {};
54
95
  const page = positiveIntegerParam(params['page'], 1_000_000);
55
96
  const pageSize = positiveIntegerParam(params['pageSize'], 1_000);
97
+ const sorters = params['sorters'] ? parseSorters(params['sorters']) : undefined;
56
98
  const sort = params['sort']?.trim();
57
99
  const search = params['q'];
58
100
  const filters = params['filters'] ? parseFilters(params['filters']) : undefined;
59
101
 
60
102
  if (page) result['page'] = page;
61
103
  if (pageSize) result['pageSize'] = pageSize;
62
- if (sort && sort.length <= 256) {
104
+ if (sorters?.length) {
105
+ const first = sorters[0];
106
+ if (first) {
107
+ result['sorters'] = JSON.stringify(sorters);
108
+ result['sort'] = first.field;
109
+ result['order'] = first.order;
110
+ }
111
+ } else if (sort && sort.length <= 256) {
63
112
  result['sort'] = sort;
64
113
  if (params['order'] === 'asc' || params['order'] === 'desc') result['order'] = params['order'];
65
114
  }
@@ -85,6 +134,7 @@ export function appendListQueryFromPath(path: string, currentPath: string): stri
85
134
  export interface URLState {
86
135
  page?: number;
87
136
  pageSize?: number;
137
+ sorters?: Sort[];
88
138
  sortField?: string;
89
139
  sortOrder?: 'asc' | 'desc';
90
140
  search?: string;
@@ -106,11 +156,24 @@ export function readURLState(adminContext: AdminContextAccessor = captureAdminCo
106
156
  const pageSize = params['pageSize'];
107
157
  if (pageSize) { const n = parseInt(pageSize, 10); if (!isNaN(n) && n > 0) state.pageSize = n; }
108
158
 
109
- const sortField = params['sort'];
110
- if (sortField) state.sortField = sortField;
111
-
112
- const sortOrder = params['order'];
113
- if (sortOrder === 'asc' || sortOrder === 'desc') state.sortOrder = sortOrder;
159
+ const sorters = params['sorters'] ? parseSorters(params['sorters']) : undefined;
160
+ if (sorters?.length) {
161
+ const first = sorters[0];
162
+ state.sorters = sorters;
163
+ if (first) {
164
+ state.sortField = first.field;
165
+ state.sortOrder = first.order;
166
+ }
167
+ } else {
168
+ const sortField = params['sort'];
169
+ const sortOrder = params['order'];
170
+ if (sortField) {
171
+ state.sortField = sortField;
172
+ const order = sortOrder === 'desc' ? 'desc' : 'asc';
173
+ state.sorters = [{ field: sortField, order }];
174
+ }
175
+ if (sortOrder === 'asc' || sortOrder === 'desc') state.sortOrder = sortOrder;
176
+ }
114
177
 
115
178
  const search = params['q'];
116
179
  if (search) state.search = search;
@@ -150,14 +213,28 @@ export function writeURLState(
150
213
  else delete params['pageSize'];
151
214
  }
152
215
 
153
- if ('sortField' in state) {
154
- if (state.sortField) params['sort'] = state.sortField;
155
- else delete params['sort'];
156
- }
216
+ if ('sorters' in state) {
217
+ const sorters = state.sorters ?? [];
218
+ const first = sorters[0];
219
+ if (sorters.length > 0 && first) {
220
+ params['sorters'] = JSON.stringify(sorters);
221
+ params['sort'] = first.field;
222
+ params['order'] = first.order;
223
+ } else {
224
+ delete params['sorters'];
225
+ delete params['sort'];
226
+ delete params['order'];
227
+ }
228
+ } else {
229
+ if ('sortField' in state) {
230
+ if (state.sortField) params['sort'] = state.sortField;
231
+ else delete params['sort'];
232
+ }
157
233
 
158
- if ('sortOrder' in state) {
159
- if (state.sortOrder) params['order'] = state.sortOrder;
160
- else delete params['order'];
234
+ if ('sortOrder' in state) {
235
+ if (state.sortOrder) params['order'] = state.sortOrder;
236
+ else delete params['order'];
237
+ }
161
238
  }
162
239
 
163
240
  if ('search' in state) {
@@ -3,8 +3,7 @@ import { useParsed } from './useParsed.svelte';
3
3
  import { captureAdminContext } from './context.svelte';
4
4
  import { getAdminOptions } from './options.svelte';
5
5
  import { t } from './i18n.svelte';
6
- import type { BaseRecord,HttpError,Filter,KnownResources,ResourceDefinition } from './types';
7
- import { useList } from './query-hooks.svelte';
6
+ import type { BaseRecord,ResourceDefinition } from './types';
8
7
  import { toast } from './toast.svelte';
9
8
  import { createSelectQuery as useSelectImpl, type UseSelectOptions } from './select-query.svelte';
10
9
  import { decodeBaseRecord } from './record-decoder';
@@ -171,23 +170,6 @@ export function useBreadcrumb() {
171
170
  return { get items() { return items; } };
172
171
  }
173
172
 
174
- // ─── useRelation ───────────────────────────────────────────
175
-
176
- export interface UseRelationOptions<_TData extends BaseRecord=BaseRecord,_TError=HttpError> {
177
- resource: KnownResources;
178
- id?: string|number;
179
- pagination?: { current?: number; pageSize?: number };
180
- sorters?: { field: string; order: 'asc'|'desc' }[];
181
- filters?: Filter[];
182
- queryOptions?: { enabled?: boolean; staleTime?: number };
183
- }
184
-
185
- export function useRelation(options: UseRelationOptions) {
186
- return useList({
187
- ...options
188
- });
189
- }
190
-
191
173
  // ─── useNotification ────────────────────────────────────────
192
174
  export function useNotification() {
193
175
  const adminContext=captureAdminContext();