@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/package.json +6 -2
- package/src/client-filter.ts +77 -0
- package/src/crud-operator-schema.ts +20 -0
- package/src/editable-table.svelte.ts +90 -0
- package/src/editable-table.ts +339 -0
- package/src/index.ts +15 -5
- package/src/inferencer-contract.ts +114 -0
- package/src/inferencer.ts +219 -42
- package/src/infinite-query.svelte.ts +45 -17
- package/src/provider-bundle.ts +0 -25
- package/src/provider-filter-capabilities.ts +111 -0
- package/src/query-hooks.svelte.ts +78 -37
- package/src/query-options.ts +79 -0
- package/src/query-snapshot.ts +3 -4
- package/src/resource-contract.ts +6 -3
- package/src/resource-schemas.ts +3 -6
- package/src/router-provider.ts +11 -0
- package/src/routing-hooks.svelte.ts +84 -3
- package/src/select-options.ts +49 -3
- package/src/select-query.svelte.ts +67 -16
- package/src/session-query.svelte.ts +6 -1
- package/src/strict-hooks.svelte.ts +53 -20
- package/src/table-hooks.svelte.ts +22 -60
- package/src/table-state.svelte.ts +4 -3
- package/src/types.ts +22 -7
- package/src/url-sync.ts +107 -30
- package/src/utility-hooks.svelte.ts +1 -19
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@svadmin/core",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.70.0",
|
|
4
4
|
"author": "zuohuadong",
|
|
5
5
|
"repository": {
|
|
6
6
|
"type": "git",
|
|
@@ -14,7 +14,7 @@
|
|
|
14
14
|
"@testing-library/dom": "^10.4.1",
|
|
15
15
|
"@testing-library/svelte": "^5.4.2",
|
|
16
16
|
"@testing-library/user-event": "^14.6.6",
|
|
17
|
-
"@types/bun": "^1.4.
|
|
17
|
+
"@types/bun": "^1.4.4",
|
|
18
18
|
"@types/jsdom": "^30.0.0",
|
|
19
19
|
"exceljs": "4.4.0",
|
|
20
20
|
"happy-dom": "^21.0.4",
|
|
@@ -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
|
+
}
|
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
import { Type, type Static } from 'typebox';
|
|
2
|
+
import type { CrudOperator } from './types';
|
|
3
|
+
|
|
4
|
+
/** 与 CRUD_FIELD_OPERATORS 保持同一组字面量,供查询快照和资源 schema 共用。 */
|
|
5
|
+
export const crudFieldOperatorSchema = Type.Union([
|
|
6
|
+
Type.Literal('eq'), Type.Literal('ne'), Type.Literal('eqs'), Type.Literal('nes'),
|
|
7
|
+
Type.Literal('lt'), Type.Literal('gt'), Type.Literal('lte'), Type.Literal('gte'),
|
|
8
|
+
Type.Literal('in'), Type.Literal('nin'), Type.Literal('ina'), Type.Literal('nina'),
|
|
9
|
+
Type.Literal('contains'), Type.Literal('ncontains'), Type.Literal('containss'), Type.Literal('ncontainss'),
|
|
10
|
+
Type.Literal('startswith'), Type.Literal('nstartswith'), Type.Literal('startswiths'), Type.Literal('nstartswiths'),
|
|
11
|
+
Type.Literal('endswith'), Type.Literal('nendswith'), Type.Literal('endswiths'), Type.Literal('nendswiths'),
|
|
12
|
+
Type.Literal('null'), Type.Literal('nnull'),
|
|
13
|
+
Type.Literal('between'), Type.Literal('nbetween'),
|
|
14
|
+
]);
|
|
15
|
+
|
|
16
|
+
type OperatorParity = Static<typeof crudFieldOperatorSchema> extends CrudOperator
|
|
17
|
+
? CrudOperator extends Static<typeof crudFieldOperatorSchema> ? true : never
|
|
18
|
+
: never;
|
|
19
|
+
const operatorParity: OperatorParity = true;
|
|
20
|
+
void operatorParity;
|
|
@@ -0,0 +1,90 @@
|
|
|
1
|
+
import { captureAdminContext } from './context.svelte';
|
|
2
|
+
import { getAdminOptions } from './options.svelte';
|
|
3
|
+
import { createEditableTableController, resolveEditableTableQuery, type EditableTableQuery } from './editable-table';
|
|
4
|
+
import { readURLState } from './url-sync';
|
|
5
|
+
import type { DataProvider, Filter, Pagination, Sort } from './types';
|
|
6
|
+
import type { ResourceContract } from './resource-contract';
|
|
7
|
+
|
|
8
|
+
export interface UseEditableTableOptions {
|
|
9
|
+
resource: ResourceContract;
|
|
10
|
+
dataProviderName?: string;
|
|
11
|
+
provider?: DataProvider;
|
|
12
|
+
pagination?: Pagination;
|
|
13
|
+
sorters?: Sort[];
|
|
14
|
+
filters?: Filter[];
|
|
15
|
+
syncWithLocation?: boolean;
|
|
16
|
+
/**
|
|
17
|
+
* enabled 与 retry 会作用到这次加载。
|
|
18
|
+
* refetchInterval、select、placeholderData 仍由 useList / useTable 提供,这里的加载是命令式的。
|
|
19
|
+
*/
|
|
20
|
+
queryOptions?: { enabled?: boolean; retry?: EditableTableQuery['retry'] };
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
/**
|
|
24
|
+
* Refine-like editable table hook.
|
|
25
|
+
* The returned `editor` object is the prop EditableTable understands.
|
|
26
|
+
*/
|
|
27
|
+
export function useEditableTable(options: UseEditableTableOptions) {
|
|
28
|
+
const provider = options.provider ?? captureAdminContext().getDataProvider(options.dataProviderName);
|
|
29
|
+
const syncWithLocation = options.syncWithLocation ?? getAdminOptions().syncWithLocation ?? false;
|
|
30
|
+
const url = syncWithLocation && typeof window !== 'undefined' ? readURLState() : undefined;
|
|
31
|
+
const controller = createEditableTableController(options.resource, provider, {
|
|
32
|
+
...resolveEditableTableQuery({ ...options, syncWithLocation }, url),
|
|
33
|
+
...(options.queryOptions?.retry === undefined ? {} : { retry: options.queryOptions.retry }),
|
|
34
|
+
});
|
|
35
|
+
let version = $state(0);
|
|
36
|
+
|
|
37
|
+
$effect(() => {
|
|
38
|
+
if (options.queryOptions?.enabled === false) return;
|
|
39
|
+
void controller.load().then(() => {
|
|
40
|
+
version += 1;
|
|
41
|
+
}, () => {
|
|
42
|
+
version += 1;
|
|
43
|
+
});
|
|
44
|
+
});
|
|
45
|
+
|
|
46
|
+
function bump(): void {
|
|
47
|
+
version += 1;
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
return {
|
|
51
|
+
get snapshot() {
|
|
52
|
+
void version;
|
|
53
|
+
return controller.snapshot();
|
|
54
|
+
},
|
|
55
|
+
get editor() {
|
|
56
|
+
void version;
|
|
57
|
+
const current = controller.snapshot();
|
|
58
|
+
return {
|
|
59
|
+
rows: current.rows,
|
|
60
|
+
errors: current.errors,
|
|
61
|
+
saving: current.saving,
|
|
62
|
+
failure: current.failure,
|
|
63
|
+
onCell: (rowIndex: number, key: string, value: unknown) => {
|
|
64
|
+
controller.setCell(rowIndex, key, value);
|
|
65
|
+
bump();
|
|
66
|
+
},
|
|
67
|
+
onSubmit: async () => {
|
|
68
|
+
await controller.submit();
|
|
69
|
+
bump();
|
|
70
|
+
},
|
|
71
|
+
onRetry: async () => {
|
|
72
|
+
await controller.retry();
|
|
73
|
+
bump();
|
|
74
|
+
},
|
|
75
|
+
onAdd: () => {
|
|
76
|
+
controller.addRow();
|
|
77
|
+
bump();
|
|
78
|
+
},
|
|
79
|
+
onDelete: (rowIndex: number) => {
|
|
80
|
+
controller.deleteRow(rowIndex);
|
|
81
|
+
bump();
|
|
82
|
+
},
|
|
83
|
+
};
|
|
84
|
+
},
|
|
85
|
+
submitBatch: async (patch: Record<string, unknown>) => {
|
|
86
|
+
await controller.submitBatch(patch);
|
|
87
|
+
bump();
|
|
88
|
+
},
|
|
89
|
+
};
|
|
90
|
+
}
|
|
@@ -0,0 +1,339 @@
|
|
|
1
|
+
import type { DataProvider, Filter, Pagination, Sort } from './types';
|
|
2
|
+
import { HttpError } from './types';
|
|
3
|
+
import { definedOptions } from './defined-options';
|
|
4
|
+
import {
|
|
5
|
+
getContractFormFields,
|
|
6
|
+
parseContractCreateInput,
|
|
7
|
+
parseContractRecord,
|
|
8
|
+
parseContractUpdateInput,
|
|
9
|
+
type ResourceContract,
|
|
10
|
+
} from './resource-contract';
|
|
11
|
+
|
|
12
|
+
export interface EditableTableQuery {
|
|
13
|
+
pagination?: Pagination;
|
|
14
|
+
sorters?: Sort[];
|
|
15
|
+
filters?: Filter[];
|
|
16
|
+
meta?: Record<string, unknown>;
|
|
17
|
+
/** false 只请求一次;数字表示失败后的额外重试次数,与 TanStack Query 的 retry 一致。 */
|
|
18
|
+
retry?: boolean | number;
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
export function resolveEditableTableQuery(
|
|
22
|
+
options: {
|
|
23
|
+
pagination?: Pagination;
|
|
24
|
+
sorters?: Sort[];
|
|
25
|
+
filters?: Filter[];
|
|
26
|
+
syncWithLocation?: boolean;
|
|
27
|
+
},
|
|
28
|
+
url?: {
|
|
29
|
+
page?: number;
|
|
30
|
+
pageSize?: number;
|
|
31
|
+
sorters?: Sort[];
|
|
32
|
+
sortField?: string;
|
|
33
|
+
sortOrder?: 'asc' | 'desc';
|
|
34
|
+
filters?: Filter[];
|
|
35
|
+
},
|
|
36
|
+
): Pick<EditableTableQuery, 'pagination' | 'sorters' | 'filters'> {
|
|
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;
|
|
43
|
+
return {
|
|
44
|
+
pagination: {
|
|
45
|
+
...options.pagination,
|
|
46
|
+
current: synced ? url?.page ?? options.pagination?.current ?? 1 : options.pagination?.current ?? 1,
|
|
47
|
+
pageSize: synced ? url?.pageSize ?? options.pagination?.pageSize ?? 50 : options.pagination?.pageSize ?? 50,
|
|
48
|
+
},
|
|
49
|
+
...(synced && syncedSorters
|
|
50
|
+
? { sorters: syncedSorters }
|
|
51
|
+
: options.sorters ? { sorters: options.sorters } : {}),
|
|
52
|
+
...((synced ? url?.filters ?? options.filters : options.filters) ? {
|
|
53
|
+
filters: synced ? url?.filters ?? options.filters : options.filters,
|
|
54
|
+
} : {}),
|
|
55
|
+
};
|
|
56
|
+
}
|
|
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
|
+
|
|
74
|
+
function retryAttempts(retry: boolean | number | undefined): number {
|
|
75
|
+
if (retry === true) return 4;
|
|
76
|
+
if (typeof retry === 'number' && Number.isInteger(retry) && retry > 0 && retry <= 10) return retry + 1;
|
|
77
|
+
return 1;
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
export interface EditableTableSnapshot {
|
|
81
|
+
rows: Record<string, unknown>[];
|
|
82
|
+
errors: Record<string, string>;
|
|
83
|
+
saving: boolean;
|
|
84
|
+
failure: string | null;
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
interface EditableRow {
|
|
88
|
+
key: string;
|
|
89
|
+
id?: string | number;
|
|
90
|
+
draft: boolean;
|
|
91
|
+
values: Record<string, unknown>;
|
|
92
|
+
original: Record<string, unknown>;
|
|
93
|
+
error: string | null;
|
|
94
|
+
failed: boolean;
|
|
95
|
+
dirty: boolean;
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
let nextKey = 0;
|
|
99
|
+
|
|
100
|
+
function pick(fields: readonly string[], values: Record<string, unknown>): Record<string, unknown> {
|
|
101
|
+
const result: Record<string, unknown> = {};
|
|
102
|
+
for (const field of fields) {
|
|
103
|
+
if (Object.hasOwn(values, field)) result[field] = values[field];
|
|
104
|
+
}
|
|
105
|
+
return result;
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
/**
|
|
109
|
+
* Headless editable-table contract: form values, schema validation,
|
|
110
|
+
* per-row submit, failure recovery, and batch update.
|
|
111
|
+
*/
|
|
112
|
+
export function createEditableTableController(
|
|
113
|
+
contract: ResourceContract,
|
|
114
|
+
provider: DataProvider,
|
|
115
|
+
query: EditableTableQuery = {},
|
|
116
|
+
) {
|
|
117
|
+
let rows: EditableRow[] = [];
|
|
118
|
+
let saving = false;
|
|
119
|
+
let failure: string | null = null;
|
|
120
|
+
|
|
121
|
+
function snapshot(): EditableTableSnapshot {
|
|
122
|
+
const errors: Record<string, string> = {};
|
|
123
|
+
for (const row of rows) {
|
|
124
|
+
if (row.error) errors[row.key] = row.error;
|
|
125
|
+
}
|
|
126
|
+
return {
|
|
127
|
+
rows: rows.map((row) => ({ ...row.values, id: row.id ?? row.key })),
|
|
128
|
+
errors,
|
|
129
|
+
saving,
|
|
130
|
+
failure,
|
|
131
|
+
};
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
async function readRows(): Promise<void> {
|
|
135
|
+
const result = await provider.getList({
|
|
136
|
+
resource: contract.name,
|
|
137
|
+
...definedOptions({
|
|
138
|
+
pagination: query.pagination ?? { current: 1, pageSize: 50 },
|
|
139
|
+
sorters: query.sorters,
|
|
140
|
+
filters: query.filters,
|
|
141
|
+
meta: query.meta,
|
|
142
|
+
}),
|
|
143
|
+
});
|
|
144
|
+
const records = result.data.map((record) => parseContractRecord(contract, record));
|
|
145
|
+
rows = records.map((record) => {
|
|
146
|
+
const rawId = record['id'];
|
|
147
|
+
const id = typeof rawId === 'string' || typeof rawId === 'number' ? rawId : undefined;
|
|
148
|
+
const values = { ...record };
|
|
149
|
+
return {
|
|
150
|
+
key: id === undefined ? `row_${++nextKey}` : String(id),
|
|
151
|
+
...(id === undefined ? {} : { id }),
|
|
152
|
+
draft: false,
|
|
153
|
+
values,
|
|
154
|
+
original: { ...values },
|
|
155
|
+
error: null,
|
|
156
|
+
failed: false,
|
|
157
|
+
dirty: false,
|
|
158
|
+
};
|
|
159
|
+
});
|
|
160
|
+
failure = null;
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
async function load(): Promise<void> {
|
|
164
|
+
const attempts = retryAttempts(query.retry);
|
|
165
|
+
let last: unknown;
|
|
166
|
+
for (let attempt = 0; attempt < attempts; attempt += 1) {
|
|
167
|
+
try {
|
|
168
|
+
await readRows();
|
|
169
|
+
return;
|
|
170
|
+
} catch (error) {
|
|
171
|
+
last = error;
|
|
172
|
+
if (error instanceof HttpError && error.code === 'INVALID_PROVIDER_RESPONSE') break;
|
|
173
|
+
}
|
|
174
|
+
}
|
|
175
|
+
failure = 'Could not load rows';
|
|
176
|
+
throw last;
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
function setCell(rowIndex: number, key: string, value: unknown): void {
|
|
180
|
+
const row = rows[rowIndex];
|
|
181
|
+
if (!row || key === 'id') return;
|
|
182
|
+
row.values = { ...row.values, [key]: value };
|
|
183
|
+
row.dirty = true;
|
|
184
|
+
row.error = null;
|
|
185
|
+
row.failed = false;
|
|
186
|
+
failure = null;
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
function addRow(): void {
|
|
190
|
+
const key = `row_${++nextKey}`;
|
|
191
|
+
const values: Record<string, unknown> = {};
|
|
192
|
+
for (const field of getContractFormFields(contract, 'create')) values[field] = '';
|
|
193
|
+
rows = [...rows, {
|
|
194
|
+
key,
|
|
195
|
+
draft: true,
|
|
196
|
+
values,
|
|
197
|
+
original: { ...values },
|
|
198
|
+
error: null,
|
|
199
|
+
failed: false,
|
|
200
|
+
dirty: true,
|
|
201
|
+
}];
|
|
202
|
+
}
|
|
203
|
+
|
|
204
|
+
function deleteRow(rowIndex: number): void {
|
|
205
|
+
const row = rows[rowIndex];
|
|
206
|
+
if (!row) return;
|
|
207
|
+
rows = rows.filter((candidate) => candidate !== row);
|
|
208
|
+
}
|
|
209
|
+
|
|
210
|
+
function validateRow(row: EditableRow): boolean {
|
|
211
|
+
try {
|
|
212
|
+
if (row.draft) {
|
|
213
|
+
parseContractCreateInput(contract, pick(getContractFormFields(contract, 'create'), row.values));
|
|
214
|
+
} else {
|
|
215
|
+
parseContractUpdateInput(contract, pick(getContractFormFields(contract, 'edit'), row.values));
|
|
216
|
+
}
|
|
217
|
+
row.error = null;
|
|
218
|
+
return true;
|
|
219
|
+
} catch {
|
|
220
|
+
row.error = row.draft ? 'Invalid create input' : 'Invalid update input';
|
|
221
|
+
return false;
|
|
222
|
+
}
|
|
223
|
+
}
|
|
224
|
+
|
|
225
|
+
async function persist(row: EditableRow): Promise<void> {
|
|
226
|
+
if (row.draft) {
|
|
227
|
+
const variables = parseContractCreateInput(contract, pick(getContractFormFields(contract, 'create'), row.values));
|
|
228
|
+
const result = await provider.create({ resource: contract.name, variables });
|
|
229
|
+
const created = parseContractRecord(contract, result.data);
|
|
230
|
+
const id = typeof created['id'] === 'string' || typeof created['id'] === 'number' ? created['id'] : undefined;
|
|
231
|
+
row.draft = false;
|
|
232
|
+
row.dirty = false;
|
|
233
|
+
row.failed = false;
|
|
234
|
+
row.error = null;
|
|
235
|
+
if (id !== undefined) {
|
|
236
|
+
row.id = id;
|
|
237
|
+
row.key = String(id);
|
|
238
|
+
}
|
|
239
|
+
row.values = { ...row.values, ...created };
|
|
240
|
+
row.original = { ...row.values };
|
|
241
|
+
return;
|
|
242
|
+
}
|
|
243
|
+
if (row.id === undefined) return;
|
|
244
|
+
const variables = parseContractUpdateInput(contract, pick(getContractFormFields(contract, 'edit'), row.values));
|
|
245
|
+
const result = await provider.update({ resource: contract.name, id: row.id, variables });
|
|
246
|
+
const saved = parseContractRecord(contract, result.data);
|
|
247
|
+
row.dirty = false;
|
|
248
|
+
row.failed = false;
|
|
249
|
+
row.error = null;
|
|
250
|
+
row.values = { ...row.values, ...saved };
|
|
251
|
+
row.original = { ...row.values };
|
|
252
|
+
}
|
|
253
|
+
|
|
254
|
+
async function exclusive(work: () => Promise<void>): Promise<void> {
|
|
255
|
+
if (saving) return;
|
|
256
|
+
saving = true;
|
|
257
|
+
try {
|
|
258
|
+
await work();
|
|
259
|
+
} finally {
|
|
260
|
+
saving = false;
|
|
261
|
+
}
|
|
262
|
+
}
|
|
263
|
+
|
|
264
|
+
async function submitTargets(targets: readonly EditableRow[]): Promise<void> {
|
|
265
|
+
failure = null;
|
|
266
|
+
let failed = 0;
|
|
267
|
+
for (const row of targets) {
|
|
268
|
+
if (!validateRow(row)) {
|
|
269
|
+
row.failed = true;
|
|
270
|
+
failed += 1;
|
|
271
|
+
continue;
|
|
272
|
+
}
|
|
273
|
+
try {
|
|
274
|
+
await persist(row);
|
|
275
|
+
} catch {
|
|
276
|
+
row.failed = true;
|
|
277
|
+
row.error = 'Save failed';
|
|
278
|
+
failed += 1;
|
|
279
|
+
}
|
|
280
|
+
}
|
|
281
|
+
failure = failed > 0 ? `${failed} row(s) were not saved` : null;
|
|
282
|
+
}
|
|
283
|
+
|
|
284
|
+
async function submit(): Promise<void> {
|
|
285
|
+
await exclusive(() => submitTargets(rows.filter((row) => row.draft || row.dirty || row.failed)));
|
|
286
|
+
}
|
|
287
|
+
|
|
288
|
+
async function retry(): Promise<void> {
|
|
289
|
+
await exclusive(() => submitTargets(rows.filter((row) => row.failed)));
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
async function submitBatch(patch: Record<string, unknown>): Promise<void> {
|
|
293
|
+
let variables: unknown;
|
|
294
|
+
try {
|
|
295
|
+
variables = parseContractUpdateInput(contract, patch);
|
|
296
|
+
} catch {
|
|
297
|
+
failure = 'Invalid update input';
|
|
298
|
+
return;
|
|
299
|
+
}
|
|
300
|
+
const targets = rows.filter((row) => !row.draft && row.id !== undefined);
|
|
301
|
+
const ids = targets.flatMap((row) => row.id === undefined ? [] : [row.id]);
|
|
302
|
+
await exclusive(async () => {
|
|
303
|
+
failure = null;
|
|
304
|
+
try {
|
|
305
|
+
if (provider.updateMany) {
|
|
306
|
+
const result = await provider.updateMany({ resource: contract.name, ids, variables });
|
|
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);
|
|
311
|
+
} else {
|
|
312
|
+
for (const id of ids) {
|
|
313
|
+
const result = await provider.update({ resource: contract.name, id, variables });
|
|
314
|
+
parseContractRecord(contract, result.data);
|
|
315
|
+
}
|
|
316
|
+
}
|
|
317
|
+
for (const row of targets) {
|
|
318
|
+
row.values = { ...row.values, ...patch };
|
|
319
|
+
row.original = { ...row.values };
|
|
320
|
+
row.dirty = false;
|
|
321
|
+
row.failed = false;
|
|
322
|
+
row.error = null;
|
|
323
|
+
}
|
|
324
|
+
} catch {
|
|
325
|
+
for (const row of targets) {
|
|
326
|
+
row.failed = true;
|
|
327
|
+
row.error = 'Save failed';
|
|
328
|
+
row.values = { ...row.values, ...patch };
|
|
329
|
+
row.dirty = true;
|
|
330
|
+
}
|
|
331
|
+
failure = `${targets.length} row(s) were not saved`;
|
|
332
|
+
}
|
|
333
|
+
});
|
|
334
|
+
}
|
|
335
|
+
|
|
336
|
+
return { snapshot, load, setCell, addRow, deleteRow, submit, retry, submitBatch };
|
|
337
|
+
}
|
|
338
|
+
|
|
339
|
+
export type EditableTableController = ReturnType<typeof createEditableTableController>;
|
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,
|
|
@@ -55,7 +53,8 @@ export {
|
|
|
55
53
|
useApiUrl,
|
|
56
54
|
useNavigation, useGo, useBack,
|
|
57
55
|
useGetToPath, useLink,
|
|
58
|
-
|
|
56
|
+
useMutationMode, useWarnAboutChange, useSyncWithLocation, useMeta,
|
|
57
|
+
useResource, useResourceParams, useKeys,
|
|
59
58
|
useModal, useDrawer,
|
|
60
59
|
useOvertime, useLoadingOvertime,
|
|
61
60
|
useTitle,
|
|
@@ -64,10 +63,13 @@ export {
|
|
|
64
63
|
resetSidebarCollapsed,
|
|
65
64
|
} from './hooks.svelte';
|
|
66
65
|
export {
|
|
67
|
-
useList, useOne, useShow, useMany, useInfiniteList, useSelect, useTable,
|
|
66
|
+
useList, useSimpleList, useOne, useShow, useMany, useInfiniteList, useSelect, useTable,
|
|
68
67
|
useCreate, useUpdate, useDelete, useCreateMany, useUpdateMany, useDeleteMany, useForm,
|
|
69
68
|
useInvalidate,
|
|
70
69
|
} from './strict-hooks.svelte';
|
|
70
|
+
export { useEditableTable } from './editable-table.svelte';
|
|
71
|
+
export { createEditableTableController } from './editable-table';
|
|
72
|
+
export type { EditableTableSnapshot } from './editable-table';
|
|
71
73
|
export { defineResource, getContractFormFields, withContractProjection } from './resource-contract';
|
|
72
74
|
export {
|
|
73
75
|
defineAdminConfig,
|
|
@@ -221,7 +223,14 @@ export type { AdminOptions, TextTransformers, OvertimeConfig } from './options.s
|
|
|
221
223
|
export { checkError } from './hook-utils.svelte';
|
|
222
224
|
export type { NotificationConfig, OvertimeOptions, OvertimeResult, LiveSubscriptionParams } from './hook-utils.svelte';
|
|
223
225
|
|
|
224
|
-
export { DeleteManyPartialError, HttpError, UndoError } from './types';
|
|
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';
|
|
225
234
|
export { withResourceSchemas } from './resource-schemas';
|
|
226
235
|
export type { ResourceSchemas, ResourceSchemaMap, InferSchemaResourceMap, InferSchemaInputMap } from './resource-schemas';
|
|
227
236
|
export type {
|
|
@@ -319,6 +328,7 @@ export {
|
|
|
319
328
|
generateEditPageCode,
|
|
320
329
|
generateShowPageCode,
|
|
321
330
|
generateResourceCode,
|
|
331
|
+
generateResourceContractCode,
|
|
322
332
|
generateComponentCode,
|
|
323
333
|
generateResourceBundle,
|
|
324
334
|
} from './inferencer';
|