feat(grid): support selecting multiple fields for sorting

This commit is contained in:
HE WENJUN authored and GitHub committed 2026-10-01 03:11:16 +08:00
1 parent c840206b25
commit a1e2d39ed3
37 files changed
+2033 -48

No files matched your search

@@ -1241,6 +1241,29 @@ describe("useDataGridActions", () => {
expect(tab.resultSortMode).toBe("database");
});
it("executes a column sort through the effective ORDER BY channel without exposing the structured part in the input", async () => {
const tab = tableDataTab({
resultPageLimit: 7,
tableMeta: {
schema: "public",
tableName: "users",
tableType: "TABLE",
columns: [
{ name: "sort_value", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
{ name: "created_at", data_type: "timestamp", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
],
primaryKeys: [],
},
});
mocks.buildTableSelectSql.mockResolvedValueOnce("SELECT sorted");
const actions = useDataGridActions(computed(() => tab));
await actions.onSort(tab.id, "sort_value", 0, "asc", undefined, "database", '"sort_value" ASC, "created_at" DESC');
expect(mocks.buildTableSelectSql).toHaveBeenCalledWith(expect.objectContaining({ orderBy: '"sort_value" ASC, "created_at" DESC', limit: 7, offset: 0 }));
expect(tab.orderByInput).toBe('"sort_value" ASC');
});
it("clears paginated table sorting by querying the first page without the generated order", async () => {
const tab = tableDataTab({
resultSortColumn: "sort_value",
@@ -0,0 +1,154 @@
import { nextTick, ref } from "vue";
import { beforeEach, describe, expect, it } from "vitest";
import { buildDataGridStructuredOrderBy, clearDataGridSortBuilderMemoryCache, combineDataGridOrderByInputs, moveDataGridStructuredSortRule, useDataGridSortBuilder, type DataGridStructuredSortRule } from "@/composables/useDataGridSortBuilder";
function idFactory() {
let index = 0;
return () => `sort-${++index}`;
}
beforeEach(clearDataGridSortBuilderMemoryCache);
describe("structured data-grid ORDER BY", () => {
it("combines manual and structured sorting without changing either input", () => {
const manual = "LOWER(name) ASC";
const structured = '"id" DESC';
expect(combineDataGridOrderByInputs(manual, structured)).toBe('LOWER(name) ASC, "id" DESC');
expect(manual).toBe("LOWER(name) ASC");
expect(structured).toBe('"id" DESC');
expect(combineDataGridOrderByInputs("", structured)).toBe(structured);
expect(combineDataGridOrderByInputs("", "")).toBeUndefined();
});
it("builds enabled rules in priority order, allows duplicate fields, and rejects incomplete active rules", () => {
const rules: DataGridStructuredSortRule[] = [
{ id: "a", columnName: "created at", direction: "desc" },
{ id: "b", columnName: "ignored", direction: "asc", disabled: true },
{ id: "c", columnName: "name", direction: "asc" },
];
expect(buildDataGridStructuredOrderBy(rules, (column) => `"${column}"`)).toBe('"created at" DESC, "name" ASC');
expect(buildDataGridStructuredOrderBy([...rules, { id: "d", columnName: "", direction: "asc" }], (column) => column)).toBeUndefined();
expect(buildDataGridStructuredOrderBy([...rules, { id: "d", columnName: "name", direction: "desc" }], (column) => column)).toBe("created at DESC, name ASC, name DESC");
expect(buildDataGridStructuredOrderBy([], (column) => column)).toBe("");
});
it("allows adding more sort rules than the number of available fields", () => {
const builder = useDataGridSortBuilder({ columns: ["name"], cacheKey: "tab-1", scopeKey: "scope-1", createId: idFactory() });
builder.setOpen(true);
builder.updateRule(builder.rules.value[0]!.id, { columnName: "name" });
builder.addRule();
builder.updateRule(builder.rules.value[1]!.id, { columnName: "name", direction: "desc" });
expect(builder.rules.value).toEqual([
{ id: "sort-1", columnName: "name", direction: "asc" },
{ id: "sort-2", columnName: "name", direction: "desc" },
]);
});
it("moves rules without mutating the source array", () => {
const rules: DataGridStructuredSortRule[] = [
{ id: "a", columnName: "a", direction: "asc" },
{ id: "b", columnName: "b", direction: "desc" },
];
const moved = moveDataGridStructuredSortRule(rules, "b", 0);
expect(moved.map((rule) => rule.id)).toEqual(["b", "a"]);
expect(rules.map((rule) => rule.id)).toEqual(["a", "b"]);
});
});
describe("useDataGridSortBuilder", () => {
it("keeps disabled draft rules when the same tab is remounted", async () => {
const columns = ref(["id", "name"]);
const first = useDataGridSortBuilder({ columns, cacheKey: "tab-1", scopeKey: "scope-1", createId: idFactory() });
first.setOpen(true);
first.updateRule(first.rules.value[0]!.id, { columnName: "id" });
first.addRule();
first.updateRule(first.rules.value[1]!.id, { columnName: "name", direction: "desc", disabled: true });
first.markApplied('"id" ASC');
await nextTick();
const second = useDataGridSortBuilder({ columns, cacheKey: "tab-1", scopeKey: "scope-1", createId: idFactory() });
second.setOpen(true);
expect(second.rules.value).toHaveLength(2);
expect(second.rules.value[1]).toMatchObject({ columnName: "name", direction: "desc", disabled: true });
expect(second.appliedOrderByInput.value).toBe('"id" ASC');
});
it("isolates and restores rules for each cache and scope pair", async () => {
const scopeKey = ref("scope-1");
const builder = useDataGridSortBuilder({ columns: ["id", "name"], cacheKey: "tab-1", scopeKey, createId: idFactory() });
builder.setOpen(true);
builder.updateRule(builder.rules.value[0]!.id, { columnName: "id" });
builder.markApplied('"id" ASC');
await nextTick();
scopeKey.value = "scope-2";
await nextTick();
builder.updateRule(builder.rules.value[0]!.id, { columnName: "name", direction: "desc", disabled: true });
builder.markApplied("");
await nextTick();
scopeKey.value = "scope-1";
await nextTick();
expect(builder.rules.value).toEqual([{ id: "sort-1", columnName: "id", direction: "asc" }]);
expect(builder.appliedOrderByInput.value).toBe('"id" ASC');
scopeKey.value = "scope-2";
await nextTick();
expect(builder.rules.value).toEqual([{ id: "sort-2", columnName: "name", direction: "desc", disabled: true }]);
expect(builder.appliedOrderByInput.value).toBe("");
});
it("resets only the draft without clearing the applied structured sort", () => {
const builder = useDataGridSortBuilder({ columns: ["id", "name"], cacheKey: "tab-1", scopeKey: "scope-1", createId: idFactory() });
builder.setOpen(true);
builder.updateRule(builder.rules.value[0]!.id, { columnName: "id", direction: "desc" });
builder.addRule();
builder.updateRule(builder.rules.value[1]!.id, { columnName: "name", direction: "desc" });
builder.markApplied('"id" DESC, "name" DESC');
builder.reset();
expect(builder.rules.value).toEqual([{ id: "sort-3", columnName: "", direction: "asc" }]);
expect(builder.appliedOrderByInput.value).toBe('"id" DESC, "name" DESC');
});
it("clears draft and applied structured sorting together", () => {
const builder = useDataGridSortBuilder({ columns: ["id", "name"], cacheKey: "tab-1", scopeKey: "scope-1", createId: idFactory() });
builder.setOpen(true);
builder.updateRule(builder.rules.value[0]!.id, { columnName: "id" });
builder.markApplied('"id" ASC');
builder.clear();
expect(builder.rules.value).toEqual([{ id: "sort-2", columnName: "", direction: "asc" }]);
expect(builder.activeRuleCount.value).toBe(0);
expect(builder.appliedOrderByInput.value).toBe("");
});
it("updates the badge count from configured active rules before applying", () => {
const builder = useDataGridSortBuilder({ columns: ["id", "name"], cacheKey: "tab-1", scopeKey: "scope-1", createId: idFactory() });
builder.setOpen(true);
expect(builder.activeRuleCount.value).toBe(0);
builder.updateRule(builder.rules.value[0]!.id, { columnName: "id" });
expect(builder.activeRuleCount.value).toBe(1);
builder.addRule();
expect(builder.activeRuleCount.value).toBe(1);
builder.updateRule(builder.rules.value[1]!.id, { columnName: "name", direction: "desc" });
expect(builder.activeRuleCount.value).toBe(2);
builder.updateRule(builder.rules.value[0]!.id, { disabled: true });
expect(builder.activeRuleCount.value).toBe(1);
builder.enableOnlyRule(builder.rules.value[0]!.id);
expect(builder.rules.value.map((rule) => !!rule.disabled)).toEqual([false, true]);
expect(builder.activeRuleCount.value).toBe(1);
});
});
@@ -627,7 +627,7 @@ export function useDataGridActions(activeTab: ComputedRef<QueryTab | undefined>)
});
}
async function onSort(tabId: string | undefined, column: string, columnIndex: number, direction: "asc" | "desc" | null, whereInput?: string, mode: DataGridSortMode = "database") {
async function onSort(tabId: string | undefined, column: string, columnIndex: number, direction: "asc" | "desc" | null, whereInput?: string, mode: DataGridSortMode = "database", effectiveOrderBy?: string) {
const tab = resolveActionTab(tabId);
if (!tab) return;
tab.resultSortColumn = direction ? column : undefined;
@@ -649,10 +649,11 @@ export function useDataGridActions(activeTab: ComputedRef<QueryTab | undefined>)
tab.whereInput = whereInput ?? "";
const config = connectionStore.getConfig(tab.connectionId);
const quotedColumn = quoteIdent(tab, column);
const orderBy = direction ? `${config?.db_type === "neo4j" ? `n.${quotedColumn}` : quotedColumn} ${direction.toUpperCase()}` : undefined;
const headerOrderBy = direction ? `${config?.db_type === "neo4j" ? `n.${quotedColumn}` : quotedColumn} ${direction.toUpperCase()}` : undefined;
const orderBy = effectiveOrderBy === undefined ? headerOrderBy : effectiveOrderBy.trim() || undefined;
const limit = tableDataPageLimit(tab);
const pagination = { limit, offset: 0 };
tab.orderByInput = orderBy;
tab.orderByInput = headerOrderBy;
const sql = await buildTableSql(tab, { orderBy, whereInput, limit, offset: pagination.offset });
queryStore.updateSql(tab.id, sql);
await queryStore.executeTabSql(tab.id, sql, {
@@ -0,0 +1,163 @@
import { computed, ref, toValue, watch, type MaybeRefOrGetter } from "vue";
import { uuid } from "@/lib/common/utils";
import type { DataGridSortDirection } from "@/lib/dataGrid/dataGridSort";
export type DataGridStructuredSortRule = {
id: string;
columnName: string;
direction: DataGridSortDirection;
disabled?: boolean;
};
type DataGridSortBuilderCacheEntry = {
appliedOrderBy: string;
rules: DataGridStructuredSortRule[];
};
type UseDataGridSortBuilderOptions = {
columns: MaybeRefOrGetter<readonly string[]>;
cacheKey: MaybeRefOrGetter<string>;
scopeKey: MaybeRefOrGetter<string>;
createId?: () => string;
};
const SORT_BUILDER_CACHE_MAX_ENTRIES = 128;
const sortBuilderCache = new Map<string, DataGridSortBuilderCacheEntry>();
function cloneRules(rules: readonly DataGridStructuredSortRule[]): DataGridStructuredSortRule[] {
return rules.map((rule) => ({ ...rule }));
}
function normalizedOrderBy(value: string | undefined): string {
return value?.trim() ?? "";
}
export function combineDataGridOrderByInputs(manualOrderBy: string | undefined, structuredOrderBy: string | undefined): string | undefined {
return [normalizedOrderBy(manualOrderBy), normalizedOrderBy(structuredOrderBy)].filter(Boolean).join(", ") || undefined;
}
export function buildDataGridStructuredOrderBy(rules: readonly DataGridStructuredSortRule[], quoteColumn: (columnName: string) => string): string | undefined {
const activeRules = rules.filter((rule) => !rule.disabled);
if (activeRules.some((rule) => !rule.columnName)) return undefined;
return activeRules.map((rule) => `${quoteColumn(rule.columnName)} ${rule.direction.toUpperCase()}`).join(", ");
}
export function moveDataGridStructuredSortRule(rules: readonly DataGridStructuredSortRule[], ruleId: string, targetIndex: number): DataGridStructuredSortRule[] {
const sourceIndex = rules.findIndex((rule) => rule.id === ruleId);
if (sourceIndex < 0 || rules.length < 2) return cloneRules(rules);
const nextIndex = Math.min(rules.length - 1, Math.max(0, Math.trunc(targetIndex)));
if (sourceIndex === nextIndex) return cloneRules(rules);
const nextRules = cloneRules(rules);
const [rule] = nextRules.splice(sourceIndex, 1);
nextRules.splice(nextIndex, 0, rule!);
return nextRules;
}
export function useDataGridSortBuilder(options: UseDataGridSortBuilderOptions) {
const rules = ref<DataGridStructuredSortRule[]>([]);
const open = ref(false);
const appliedOrderByInput = ref("");
const activeRuleCount = computed(() => rules.value.filter((rule) => !rule.disabled && !!rule.columnName).length);
function defaultRule(): DataGridStructuredSortRule {
return { id: options.createId?.() ?? uuid(), columnName: "", direction: "asc" };
}
function entryKey(): string | undefined {
const cacheKey = toValue(options.cacheKey);
if (!cacheKey) return undefined;
return JSON.stringify({ cacheKey, scopeKey: toValue(options.scopeKey) });
}
function persist() {
const key = entryKey();
if (!key) return;
sortBuilderCache.delete(key);
sortBuilderCache.set(key, { appliedOrderBy: appliedOrderByInput.value, rules: cloneRules(rules.value) });
while (sortBuilderCache.size > SORT_BUILDER_CACHE_MAX_ENTRIES) {
const oldest = sortBuilderCache.keys().next().value;
if (oldest === undefined) break;
sortBuilderCache.delete(oldest);
}
}
function restore() {
const key = entryKey();
const cached = key ? sortBuilderCache.get(key) : undefined;
if (cached) {
rules.value = cloneRules(cached.rules);
appliedOrderByInput.value = cached.appliedOrderBy;
if (open.value && !rules.value.length && toValue(options.columns).length) rules.value = [defaultRule()];
return;
}
rules.value = open.value && toValue(options.columns).length ? [defaultRule()] : [];
appliedOrderByInput.value = "";
persist();
}
function setOpen(value: boolean) {
if (value && !rules.value.length && toValue(options.columns).length) rules.value = [defaultRule()];
open.value = value;
}
function addRule() {
if (!toValue(options.columns).length) return;
rules.value = [...rules.value, defaultRule()];
}
function removeRule(id: string) {
rules.value = rules.value.filter((rule) => rule.id !== id);
}
function updateRule(id: string, patch: Partial<DataGridStructuredSortRule>) {
rules.value = rules.value.map((rule) => (rule.id === id ? { ...rule, ...patch } : rule));
}
function moveRule(id: string, targetIndex: number) {
rules.value = moveDataGridStructuredSortRule(rules.value, id, targetIndex);
}
function enableOnlyRule(id: string) {
if (!rules.value.some((rule) => rule.id === id)) return;
rules.value = rules.value.map((rule) => ({ ...rule, disabled: rule.id !== id }));
}
function reset() {
rules.value = toValue(options.columns).length ? [defaultRule()] : [];
}
function clear() {
appliedOrderByInput.value = "";
reset();
persist();
}
function markApplied(orderBy: string) {
appliedOrderByInput.value = normalizedOrderBy(orderBy);
persist();
}
watch(rules, persist, { deep: true });
watch([() => toValue(options.cacheKey), () => toValue(options.scopeKey)], restore, { immediate: true });
return {
rules,
open,
appliedOrderByInput,
activeRuleCount,
setOpen,
addRule,
removeRule,
updateRule,
moveRule,
enableOnlyRule,
reset,
clear,
markApplied,
restore,
};
}
export function clearDataGridSortBuilderMemoryCache() {
sortBuilderCache.clear();
}
@@ -169,6 +169,7 @@ export function useSidebarDataOpenRuntime() {
tab.schema = tableSchema;
tab.whereInput = undefined;
tab.orderByInput = undefined;
tab.structuredOrderByInput = undefined;
tab.previewSql = undefined;
tab.resultSortColumn = undefined;
tab.resultSortColumnIndex = undefined;