@svadmin/core 0.69.3 → 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/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@svadmin/core",
3
- "version": "0.69.3",
3
+ "version": "0.70.0",
4
4
  "author": "zuohuadong",
5
5
  "repository": {
6
6
  "type": "git",
@@ -59,6 +59,10 @@
59
59
  "types": "./src/defined-options.ts",
60
60
  "default": "./src/defined-options.ts"
61
61
  },
62
+ "./provider-filters": {
63
+ "types": "./src/provider-filter-capabilities.ts",
64
+ "default": "./src/provider-filter-capabilities.ts"
65
+ },
62
66
  "./resource-contract": {
63
67
  "types": "./src/resource-contract.ts",
64
68
  "default": "./src/resource-contract.ts"
@@ -0,0 +1,77 @@
1
+ import type { Filter } from './types';
2
+
3
+ function textHit(value: string, expected: string, mode: 'includes' | 'starts' | 'ends', sensitive: boolean): boolean {
4
+ const left = sensitive ? value : value.toLowerCase();
5
+ const right = sensitive ? expected : expected.toLowerCase();
6
+ if (mode === 'includes') return left.includes(right);
7
+ if (mode === 'starts') return left.startsWith(right);
8
+ return left.endsWith(right);
9
+ }
10
+
11
+ function textOperator(
12
+ value: unknown,
13
+ expected: unknown,
14
+ mode: 'includes' | 'starts' | 'ends',
15
+ sensitive: boolean,
16
+ negate: boolean,
17
+ ): boolean {
18
+ if (typeof value !== 'string' || typeof expected !== 'string') return false;
19
+ const hit = textHit(value, expected, mode, sensitive);
20
+ return negate ? !hit : hit;
21
+ }
22
+
23
+ /** 客户端表格筛选。带 s 的字符串运算符区分大小写,不带 s 的不区分。 */
24
+ export function matchClientFilter(item: Record<string, unknown>, filter: Filter): boolean {
25
+ if (!('field' in filter)) {
26
+ if (filter.operator === 'and') return filter.value.every((child) => matchClientFilter(item, child));
27
+ if (filter.operator === 'or') return filter.value.length === 0 || filter.value.some((child) => matchClientFilter(item, child));
28
+ return true;
29
+ }
30
+ const value = item[filter.field];
31
+ const expected = filter.value;
32
+ switch (filter.operator) {
33
+ case 'null': return value == null;
34
+ case 'nnull': return value != null;
35
+ default: break;
36
+ }
37
+ if (expected == null || expected === '') return true;
38
+ switch (filter.operator) {
39
+ case 'eq': return value == expected;
40
+ case 'ne': return value != expected;
41
+ case 'eqs': return Object.is(value, expected);
42
+ case 'nes': return !Object.is(value, expected);
43
+ case 'lt': return typeof value === 'number' && typeof expected === 'number' && value < expected;
44
+ case 'gt': return typeof value === 'number' && typeof expected === 'number' && value > expected;
45
+ case 'lte': return typeof value === 'number' && typeof expected === 'number' && value <= expected;
46
+ case 'gte': return typeof value === 'number' && typeof expected === 'number' && value >= expected;
47
+ case 'in': return !Array.isArray(expected) || expected.length === 0 || expected.includes(value);
48
+ case 'nin': return !Array.isArray(expected) || expected.length === 0 || !expected.includes(value);
49
+ case 'ina': return Array.isArray(value) && Array.isArray(expected) && expected.every((entry) => value.includes(entry));
50
+ case 'nina': return Array.isArray(value) && Array.isArray(expected) && expected.some((entry) => !value.includes(entry));
51
+ case 'contains': return textOperator(value, expected, 'includes', false, false);
52
+ case 'ncontains': return textOperator(value, expected, 'includes', false, true);
53
+ case 'containss': return textOperator(value, expected, 'includes', true, false);
54
+ case 'ncontainss': return textOperator(value, expected, 'includes', true, true);
55
+ case 'startswith': return textOperator(value, expected, 'starts', false, false);
56
+ case 'nstartswith': return textOperator(value, expected, 'starts', false, true);
57
+ case 'startswiths': return textOperator(value, expected, 'starts', true, false);
58
+ case 'nstartswiths': return textOperator(value, expected, 'starts', true, true);
59
+ case 'endswith': return textOperator(value, expected, 'ends', false, false);
60
+ case 'nendswith': return textOperator(value, expected, 'ends', false, true);
61
+ case 'endswiths': return textOperator(value, expected, 'ends', true, false);
62
+ case 'nendswiths': return textOperator(value, expected, 'ends', true, true);
63
+ case 'between': {
64
+ if (!Array.isArray(expected) || expected.length !== 2) return true;
65
+ const [min, max] = expected;
66
+ return typeof value === 'number' && typeof min === 'number' && typeof max === 'number'
67
+ && value >= min && value <= max;
68
+ }
69
+ case 'nbetween': {
70
+ if (!Array.isArray(expected) || expected.length !== 2) return true;
71
+ const [min, max] = expected;
72
+ return typeof value === 'number' && typeof min === 'number' && typeof max === 'number'
73
+ && (value < min || value > max);
74
+ }
75
+ default: return true;
76
+ }
77
+ }
@@ -28,20 +28,26 @@ export function resolveEditableTableQuery(
28
28
  url?: {
29
29
  page?: number;
30
30
  pageSize?: number;
31
+ sorters?: Sort[];
31
32
  sortField?: string;
32
33
  sortOrder?: 'asc' | 'desc';
33
34
  filters?: Filter[];
34
35
  },
35
36
  ): Pick<EditableTableQuery, 'pagination' | 'sorters' | 'filters'> {
36
37
  const synced = options.syncWithLocation === true;
38
+ const syncedSorters = url?.sorters?.length
39
+ ? url.sorters
40
+ : url?.sortField
41
+ ? [{ field: url.sortField, order: url.sortOrder ?? 'asc' }]
42
+ : undefined;
37
43
  return {
38
44
  pagination: {
39
45
  ...options.pagination,
40
46
  current: synced ? url?.page ?? options.pagination?.current ?? 1 : options.pagination?.current ?? 1,
41
47
  pageSize: synced ? url?.pageSize ?? options.pagination?.pageSize ?? 50 : options.pagination?.pageSize ?? 50,
42
48
  },
43
- ...(synced && url?.sortField
44
- ? { sorters: [{ field: url.sortField, order: url.sortOrder ?? 'asc' }] }
49
+ ...(synced && syncedSorters
50
+ ? { sorters: syncedSorters }
45
51
  : options.sorters ? { sorters: options.sorters } : {}),
46
52
  ...((synced ? url?.filters ?? options.filters : options.filters) ? {
47
53
  filters: synced ? url?.filters ?? options.filters : options.filters,
@@ -49,6 +55,22 @@ export function resolveEditableTableQuery(
49
55
  };
50
56
  }
51
57
 
58
+ function assertBatchReceipt(ids: readonly (string | number)[], records: readonly Record<string, unknown>[]): void {
59
+ const expected = new Set(ids.map((id) => String(id)));
60
+ if (expected.size !== ids.length || records.length !== ids.length) {
61
+ throw new Error('Batch update response did not match the requested records');
62
+ }
63
+ const seen = new Set<string>();
64
+ for (const record of records) {
65
+ const id = record['id'];
66
+ const key = typeof id === 'string' || typeof id === 'number' ? String(id) : '';
67
+ if (!key || !expected.has(key) || seen.has(key)) {
68
+ throw new Error('Batch update response did not match the requested records');
69
+ }
70
+ seen.add(key);
71
+ }
72
+ }
73
+
52
74
  function retryAttempts(retry: boolean | number | undefined): number {
53
75
  if (retry === true) return 4;
54
76
  if (typeof retry === 'number' && Number.isInteger(retry) && retry > 0 && retry <= 10) return retry + 1;
@@ -282,7 +304,10 @@ export function createEditableTableController(
282
304
  try {
283
305
  if (provider.updateMany) {
284
306
  const result = await provider.updateMany({ resource: contract.name, ids, variables });
285
- for (const record of result.data) parseContractRecord(contract, record);
307
+ const records = Array.isArray(result?.data) ? result.data : undefined;
308
+ if (!records) throw new Error('Batch update response did not match the requested records');
309
+ const parsed = records.map((record) => parseContractRecord(contract, record));
310
+ assertBatchReceipt(ids, parsed);
286
311
  } else {
287
312
  for (const id of ids) {
288
313
  const result = await provider.update({ resource: contract.name, id, variables });
package/src/index.ts CHANGED
@@ -18,9 +18,7 @@ export {
18
18
  createProviderBundle,
19
19
  createTenantCacheKey,
20
20
  defaultTenantAdapter,
21
- appendTenantCacheKey,
22
21
  isTenantCacheKey,
23
- queryKeyMatchesTenant,
24
22
  resolveTenantProviderMeta,
25
23
  withProviderMeta,
26
24
  withTenantDataProvider,
@@ -226,6 +224,13 @@ export { checkError } from './hook-utils.svelte';
226
224
  export type { NotificationConfig, OvertimeOptions, OvertimeResult, LiveSubscriptionParams } from './hook-utils.svelte';
227
225
 
228
226
  export { CRUD_FIELD_OPERATORS, DeleteManyPartialError, HttpError, UndoError, isCrudFieldOperator } from './types';
227
+ export {
228
+ FILTER_PROVIDER_IDS,
229
+ PROVIDER_FILTER_CAPABILITIES,
230
+ assertFiltersExecutable,
231
+ providerSupportsOperator,
232
+ } from './provider-filter-capabilities';
233
+ export type { FilterProviderId, ProviderFilterCapability } from './provider-filter-capabilities';
229
234
  export { withResourceSchemas } from './resource-schemas';
230
235
  export type { ResourceSchemas, ResourceSchemaMap, InferSchemaResourceMap, InferSchemaInputMap } from './resource-schemas';
231
236
  export type {
@@ -10,6 +10,7 @@ import { createOvertimeTracker, createLiveSubscription, type NotificationConfig,
10
10
  type LiveSubscriptionParams } from './hook-utils.svelte';
11
11
  import { HttpError, type BaseRecord, type GetListResult, type Pagination, type Sort, type Filter, type KnownResources } from './types';
12
12
  import { decodeBaseRecord, decodeListResult, rejectProviderResponse, type RecordDecoder } from './record-decoder';
13
+ import { listQuerySettings, type ResourceQueryOptions } from './query-options';
13
14
  import { captureQueryProvider, snapshotListParams } from './query-snapshot';
14
15
  import type { LiveMode, LiveEvent } from './live.svelte';
15
16
  import type { QueryKey } from './query-keys';
@@ -19,14 +20,19 @@ import {
19
20
  createQuerySession, createQueryResultView, pendingQueryResult, querySessionError, supersededQuerySession,
20
21
  } from './query-session.svelte';
21
22
 
22
- export interface UseInfiniteListOptions extends ContractOptions {
23
+ export type InfinitePages<T extends BaseRecord> = InfiniteData<GetListResult<T>, number>;
24
+
25
+ export interface UseInfiniteListOptions<
26
+ TData extends BaseRecord = BaseRecord,
27
+ TSelected = InfinitePages<TData>,
28
+ > extends ContractOptions {
23
29
  resource?: KnownResources;
24
30
  pagination?: Pagination;
25
31
  sorters?: Sort[];
26
32
  filters?: Filter[];
27
33
  meta?: Record<string, unknown>;
28
34
  dataProviderName?: string;
29
- queryOptions?: { staleTime?: number; enabled?: boolean };
35
+ queryOptions?: ResourceQueryOptions<InfinitePages<TData>, TSelected>;
30
36
  successNotification?: NotificationConfig;
31
37
  errorNotification?: NotificationConfig;
32
38
  liveMode?: LiveMode;
@@ -44,7 +50,7 @@ const flagsSchema = Type.Object({
44
50
  isFetchPreviousPageError: Type.Boolean(), isFetchingPreviousPage: Type.Boolean(),
45
51
  }, { additionalProperties: false });
46
52
 
47
- type Pages<T extends BaseRecord> = InfiniteData<GetListResult<T>, number>;
53
+ type Pages<T extends BaseRecord> = InfinitePages<T>;
48
54
  type InfiniteOutcome<T> =
49
55
  | { status: 'pending'; data: undefined; error: null; isPending: true; isError: false; isSuccess: false;
50
56
  isLoading: boolean; isLoadingError: false; isRefetchError: false; isPlaceholderData: false;
@@ -63,12 +69,12 @@ type InfiniteOutcome<T> =
63
69
  ));
64
70
 
65
71
  /** The installed observer retains data on paging errors without setting isRefetchError. */
66
- export type InfiniteListResult<T extends BaseRecord> =
67
- Omit<InfiniteQueryObserverBaseResult<Pages<T>, unknown>, keyof InfiniteOutcome<Pages<T>> | 'refetch' | 'fetchNextPage' | 'fetchPreviousPage'>
68
- & InfiniteOutcome<Pages<T>> & {
69
- refetch: (settings?: RefetchOptions) => Promise<InfiniteListResult<T>>;
70
- fetchNextPage: (settings?: FetchNextPageOptions) => Promise<InfiniteListResult<T>>;
71
- fetchPreviousPage: (settings?: FetchPreviousPageOptions) => Promise<InfiniteListResult<T>>;
72
+ export type InfiniteListResult<T extends BaseRecord, TData = Pages<T>> =
73
+ Omit<InfiniteQueryObserverBaseResult<TData, unknown>, keyof InfiniteOutcome<TData> | 'refetch' | 'fetchNextPage' | 'fetchPreviousPage'>
74
+ & InfiniteOutcome<TData> & {
75
+ refetch: (settings?: RefetchOptions) => Promise<InfiniteListResult<T, TData>>;
76
+ fetchNextPage: (settings?: FetchNextPageOptions) => Promise<InfiniteListResult<T, TData>>;
77
+ fetchPreviousPage: (settings?: FetchPreviousPageOptions) => Promise<InfiniteListResult<T, TData>>;
72
78
  };
73
79
 
74
80
  export function decodeInfiniteResult<T extends BaseRecord>(input: unknown, decode: RecordDecoder<T>): InfiniteData<GetListResult<T>, number> {
@@ -88,15 +94,16 @@ export function useInfiniteList(options: UseInfiniteListOptions = {}) {
88
94
  return createInfiniteListQuery(options, () => decodeBaseRecord);
89
95
  }
90
96
 
91
- export function createInfiniteListQuery<TData extends BaseRecord>(
92
- options: UseInfiniteListOptions, getDecoder: () => RecordDecoder<TData>,
97
+ export function createInfiniteListQuery<TData extends BaseRecord, TSelected = Pages<TData>>(
98
+ options: UseInfiniteListOptions<TData, TSelected>, getDecoder: () => RecordDecoder<TData>,
93
99
  ) {
94
100
  const context = captureContractContext(options);
95
101
  const parsed = useParsed();
96
102
  const adminOptions = getAdminOptions();
97
103
  type Data = Pages<TData>;
98
- type Result = InfiniteListResult<TData>;
104
+ type Result = InfiniteListResult<TData, TSelected>;
99
105
  const session = createQuerySession(context, () => {
106
+ const querySettings = listQuerySettings(options.queryOptions);
100
107
  const resource = options.resource ?? parsed.resource ?? '';
101
108
  const captured = captureQueryProvider(context, {
102
109
  resource, ...definedOptions({ dataProviderName: options.dataProviderName, contract: options.contract, meta: options.meta }),
@@ -110,8 +117,16 @@ export function createInfiniteListQuery<TData extends BaseRecord>(
110
117
  return {
111
118
  resource, captured, params, decode: getDecoder(),
112
119
  queryKey: context.queryKeys(resource, options.dataProviderName).data.infiniteList(resource, { ...params, source: captured.source }),
113
- enabled: options.queryOptions?.enabled ?? true,
114
- staleTime: options.queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
120
+ enabled: querySettings.enabled,
121
+ staleTime: querySettings.staleTime ?? adminOptions.reactQuery?.staleTime,
122
+ gcTime: querySettings.gcTime ?? adminOptions.reactQuery?.gcTime,
123
+ refetchOnWindowFocus: querySettings.refetchOnWindowFocus ?? adminOptions.reactQuery?.refetchOnWindowFocus,
124
+ retry: querySettings.retry,
125
+ retryDelay: querySettings.retryDelay,
126
+ refetchInterval: querySettings.refetchInterval,
127
+ refetchIntervalInBackground: querySettings.refetchIntervalInBackground,
128
+ placeholderData: querySettings.placeholderData as Data | ((previousData: Data | undefined) => Data | undefined) | undefined,
129
+ select: options.queryOptions?.select,
115
130
  successNotification: options.successNotification, errorNotification: options.errorNotification,
116
131
  };
117
132
  });
@@ -142,7 +157,16 @@ export function createInfiniteListQuery<TData extends BaseRecord>(
142
157
  }
143
158
  },
144
159
  enabled: origin.enabled && origin.auth.available,
145
- ...definedOptions({ staleTime: origin.staleTime }),
160
+ ...definedOptions({
161
+ staleTime: origin.staleTime,
162
+ gcTime: origin.gcTime,
163
+ refetchOnWindowFocus: origin.refetchOnWindowFocus,
164
+ retry: origin.retry,
165
+ retryDelay: origin.retryDelay,
166
+ refetchInterval: origin.refetchInterval,
167
+ refetchIntervalInBackground: origin.refetchIntervalInBackground,
168
+ placeholderData: origin.placeholderData,
169
+ }),
146
170
  };
147
171
  });
148
172
 
@@ -184,15 +208,19 @@ export function createInfiniteListQuery<TData extends BaseRecord>(
184
208
  if (!checkExact(flagsSchema, flags)) return rejectProviderResponse();
185
209
  const failureReason = result.failureReason === null ? null : querySessionError(result.failureReason);
186
210
  const rawData: unknown = result.data;
211
+ const projectData = (value: unknown): TSelected => {
212
+ const pages = decodeInfiniteResult(value, origin.decode);
213
+ return origin.select ? origin.select(pages) : pages as TSelected;
214
+ };
187
215
  if (result.status === 'success') {
188
- const data = decodeInfiniteResult(rawData, origin.decode);
216
+ const data = projectData(rawData);
189
217
  if (!session.current(origin)) return pending(operations);
190
218
  return { ...result, ...flags, ...operations, data, failureReason, isFetchNextPageError: false, isFetchPreviousPageError: false };
191
219
  }
192
220
  if (result.status === 'error') {
193
221
  const base = { ...result, ...flags, ...operations, error: querySessionError(result.error), failureReason };
194
222
  if (rawData === undefined) return { ...base, data: undefined, isLoadingError: true, isRefetchError: false };
195
- const data = decodeInfiniteResult(rawData, origin.decode);
223
+ const data = projectData(rawData);
196
224
  if (!session.current(origin)) return pending(operations);
197
225
  if (flags.isFetchNextPageError) return {
198
226
  ...base, data, isLoadingError: false, isRefetchError: false, isFetchNextPageError: true, isFetchPreviousPageError: false,
@@ -127,31 +127,6 @@ export function isTenantCacheKey(value: unknown): value is TenantCacheKey {
127
127
  );
128
128
  }
129
129
 
130
- /**
131
- * @deprecated 0.36 — Query Key v2 replaces positional tenant cache-key appending.
132
- * Use `keys({ tenant })` instead. Removed in 0.39.
133
- */
134
- export function appendTenantCacheKey(
135
- queryKey: readonly unknown[],
136
- tenantCacheKey: TenantCacheKey|undefined,
137
- ): readonly unknown[] {
138
- return tenantCacheKey? [...queryKey,tenantCacheKey]:queryKey;
139
- }
140
-
141
- /**
142
- * @deprecated 0.36 — Query Key v2 replaces positional tenant cache-key matching.
143
- * Use `queryKeyMatches(queryKey, { tenant })` instead. Removed in 0.39.
144
- */
145
- export function queryKeyMatchesTenant(
146
- queryKey: readonly unknown[],
147
- tenantCacheKey: TenantCacheKey|undefined,
148
- ): boolean {
149
- const candidate=queryKey.at(-1);
150
- const keyTenant=isTenantCacheKey(candidate)? candidate:undefined;
151
- if(!tenantCacheKey) return keyTenant===undefined;
152
- return keyTenant?.__svadminTenant===tenantCacheKey.__svadminTenant;
153
- }
154
-
155
130
  export interface ProviderMetaInput {
156
131
  readonly resource?: string;
157
132
  readonly meta?: Record<string,unknown>;
@@ -0,0 +1,111 @@
1
+ import { isCrudFieldOperator, type CrudOperator, type Filter, CRUD_FIELD_OPERATORS } from './types';
2
+
3
+ /**
4
+ * 各一手数据源实际执行的筛选协议。
5
+ * 未声明的运算符或逻辑组合必须失败关闭,不能改写成相等或丢掉条件组。
6
+ */
7
+ export const FILTER_PROVIDER_IDS = [
8
+ 'pocketbase',
9
+ 'directus',
10
+ 'sanity',
11
+ 'elysia',
12
+ 'supabase-table',
13
+ 'scaffold-memory',
14
+ ] as const;
15
+
16
+ export type FilterProviderId = (typeof FILTER_PROVIDER_IDS)[number];
17
+
18
+ export interface ProviderFilterCapability {
19
+ id: FilterProviderId;
20
+ /** 语义等价、会被真正下推的字段运算符。 */
21
+ operators: readonly CrudOperator[];
22
+ /** 是否执行嵌套 and/or。key 只是条件组身份,不是查询谓词。 */
23
+ logical: boolean;
24
+ }
25
+
26
+ function operators(values: readonly CrudOperator[]): readonly CrudOperator[] {
27
+ return values;
28
+ }
29
+
30
+ export const PROVIDER_FILTER_CAPABILITIES: Record<FilterProviderId, ProviderFilterCapability> = {
31
+ pocketbase: {
32
+ id: 'pocketbase',
33
+ logical: true,
34
+ operators: operators([
35
+ 'eq', 'ne', 'lt', 'gt', 'lte', 'gte',
36
+ 'contains', 'ncontains', 'startswith', 'nstartswith', 'endswith', 'nendswith',
37
+ 'in', 'nin', 'null', 'nnull', 'between', 'nbetween',
38
+ ]),
39
+ },
40
+ directus: {
41
+ id: 'directus',
42
+ logical: true,
43
+ operators: operators([
44
+ 'eq', 'ne', 'lt', 'gt', 'lte', 'gte',
45
+ 'contains', 'ncontains', 'containss', 'ncontainss',
46
+ 'startswith', 'nstartswith', 'startswiths', 'nstartswiths',
47
+ 'endswith', 'nendswith', 'endswiths', 'nendswiths',
48
+ 'in', 'nin', 'null', 'nnull', 'between', 'nbetween',
49
+ ]),
50
+ },
51
+ sanity: {
52
+ id: 'sanity',
53
+ logical: true,
54
+ operators: operators([
55
+ 'eq', 'ne', 'lt', 'gt', 'lte', 'gte',
56
+ 'contains', 'ncontains', 'startswith', 'endswith',
57
+ 'in', 'nin', 'null', 'nnull', 'between', 'nbetween',
58
+ ]),
59
+ },
60
+ elysia: {
61
+ id: 'elysia',
62
+ logical: true,
63
+ operators: CRUD_FIELD_OPERATORS,
64
+ },
65
+ 'supabase-table': {
66
+ id: 'supabase-table',
67
+ logical: false,
68
+ operators: operators(['eq']),
69
+ },
70
+ 'scaffold-memory': {
71
+ id: 'scaffold-memory',
72
+ logical: true,
73
+ operators: operators(['eq', 'ne', 'contains', 'in', 'null', 'nnull']),
74
+ },
75
+ };
76
+
77
+ const supportedOperators = new Map<FilterProviderId, ReadonlySet<string>>(
78
+ FILTER_PROVIDER_IDS.map((id) => [id, new Set(PROVIDER_FILTER_CAPABILITIES[id].operators)]),
79
+ );
80
+
81
+ export function providerSupportsOperator(provider: FilterProviderId, operator: CrudOperator): boolean {
82
+ return supportedOperators.get(provider)?.has(operator) ?? false;
83
+ }
84
+
85
+ function visitFilter(provider: FilterProviderId, filter: Filter, depth: number, seen: Set<object>): void {
86
+ const capability = PROVIDER_FILTER_CAPABILITIES[provider];
87
+ const allowed = supportedOperators.get(provider);
88
+ if (!capability || !allowed) throw new Error(`Unknown filter provider: ${provider}`);
89
+ if (depth > 32) throw new Error(`Unsupported ${provider} filter: nesting is too deep`);
90
+ if (typeof filter !== 'object' || filter === null || seen.has(filter)) {
91
+ throw new Error(`Unsupported ${provider} filter: expected an object`);
92
+ }
93
+ seen.add(filter);
94
+ if ('field' in filter) {
95
+ if (!isCrudFieldOperator(filter.operator) || !allowed.has(filter.operator)) {
96
+ throw new Error(`Unsupported ${provider} filter operator: ${String(filter.operator)}`);
97
+ }
98
+ return;
99
+ }
100
+ if (!capability.logical || (filter.operator !== 'and' && filter.operator !== 'or') || !Array.isArray(filter.value)) {
101
+ throw new Error(`Unsupported ${provider} logical operator: ${String(filter.operator)}`);
102
+ }
103
+ for (const child of filter.value) visitFilter(provider, child, depth + 1, seen);
104
+ }
105
+
106
+ /** 在翻译之前拒绝能力矩阵之外的运算符和逻辑组合。 */
107
+ export function assertFiltersExecutable(provider: FilterProviderId, filters: readonly Filter[] | undefined): void {
108
+ if (!FILTER_PROVIDER_IDS.includes(provider)) throw new Error(`Unknown filter provider: ${String(provider)}`);
109
+ const seen = new Set<object>();
110
+ for (const filter of filters ?? []) visitFilter(provider, filter, 0, seen);
111
+ }