feat(grid): support selecting multiple fields for sorting
This commit is contained in:
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;
|
||||
|
||||
Reference in new issue
Block a user