feat(xugu): organize package members and preserve body access

This commit is contained in:
Elias authored and GitHub committed 2026-08-12 10:59:37 +08:00
1 parent e8fae013bd
commit 275b4d5831
9 files changed
+412 -49

No files matched your search

@@ -198,8 +198,12 @@ describe("connectionStore metadata loading", () => {
match_mode: "prefix",
});
expect(packageNode.isExpanded).toBe(true);
expect(packageNode.children?.map((child) => child.label)).toEqual(["process_item(p_id IN INT)", "process_item(p_code IN VARCHAR)", "item_count"]);
expect(packageNode.children?.every((child) => child.parentName === "business_api")).toBe(true);
expect(packageNode.children?.map((child) => [child.type, child.label, child.objectCount])).toEqual([
["group-procedures", "tree.procedures", 2],
["group-functions", "tree.functions", 1],
]);
expect(packageNode.children?.flatMap((group) => group.children ?? []).map((child) => child.label)).toEqual(["process_item(p_id IN INT)", "process_item(p_code IN VARCHAR)", "item_count"]);
expect(packageNode.children?.flatMap((group) => group.children ?? []).every((child) => child.parentName === "business_api")).toBe(true);
}, 15000);
it("loads Xugu object type members through the scoped completion endpoint", async () => {
@@ -1675,6 +1679,110 @@ describe("connectionStore metadata loading", () => {
expect(storedProcedureGroup?.children?.map((node) => node.label)).toEqual(["p_0999"]);
});
it("merges Xugu package body metadata when it arrives on the next page", async () => {
const packageSpec: ObjectInfo = {
name: "business_api",
object_type: "PACKAGE",
schema: "app_schema",
valid: true,
comment: null,
created_at: null,
updated_at: null,
parent_schema: null,
parent_name: null,
};
const packageBody: ObjectInfo = {
...packageSpec,
object_type: "PACKAGE_BODY",
valid: false,
};
const listObjects = vi.fn().mockResolvedValueOnce([packageSpec, packageBody]).mockResolvedValueOnce([packageBody]);
vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
vi.doMock("@/lib/backend/api", () => ({
checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
listObjects,
loadSchemaCache: vi.fn().mockResolvedValue(null),
saveSchemaCache: vi.fn().mockResolvedValue(undefined),
saveConnections: vi.fn().mockResolvedValue(undefined),
saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
}));
const { useConnectionStore } = await import("@/stores/connectionStore");
const { useSettingsStore } = await import("@/stores/settingsStore");
const store = useConnectionStore();
const settingsStore = useSettingsStore();
settingsStore.editorSettings.sidebarObjectDisplay = "grouped";
settingsStore.desktopSettings.sidebar_table_page_size = 1;
const connection = xuguConnection();
const packageGroup: TreeNode = {
id: "xugu-1:app_db:app_schema:__packages",
label: "tree.packages",
type: "group-packages",
connectionId: connection.id,
database: "app_db",
schema: "app_schema",
isExpanded: false,
children: [],
};
store.connections = [connection];
store.connectedIds.add(connection.id);
store.treeNodes = [
{
id: connection.id,
label: connection.name,
type: "connection",
connectionId: connection.id,
isExpanded: true,
children: [
{
id: "xugu-1:app_db",
label: "app_db",
type: "database",
connectionId: connection.id,
database: "app_db",
isExpanded: true,
children: [
{
id: "xugu-1:app_db:app_schema",
label: "app_schema",
type: "schema",
connectionId: connection.id,
database: "app_db",
schema: "app_schema",
isExpanded: true,
children: [packageGroup],
},
],
},
],
},
];
await store.loadObjectGroupChildren(packageGroup);
const packageNode = packageGroup.children?.[0];
expect(packageNode).toEqual(expect.objectContaining({ type: "package", label: "business_api", xuguPackageBodyAvailable: undefined, valid: true }));
const packageNodeId = packageNode?.id;
const loadMoreNode = packageGroup.children?.at(-1);
expect(loadMoreNode?.type).toBe("load-more");
await store.loadMoreObjectGroupChildren(loadMoreNode!);
expect(packageGroup.children).toHaveLength(1);
expect(packageGroup.children?.[0]?.id).toBe(packageNodeId);
expect(packageGroup.children?.[0]).toEqual(
expect.objectContaining({
type: "package",
label: "business_api",
xuguPackageBodyAvailable: true,
xuguPackageBodyValid: false,
valid: false,
}),
);
});
it("reloads a collapsed database after a forced connection database refresh", async () => {
const listDatabases = vi
.fn()
+16 -6
View File
@@ -1605,16 +1605,17 @@ export const useConnectionStore = defineStore("connection", () => {
}
function objectGroupChildrenFromObjects(options: { node: TreeNode; parentNodeId: string; effectiveSchema?: string; objectTypes: DatabaseObjectTreeKind[]; objects: ObjectInfo[] }): TreeNode[] {
const databaseType = options.node.connectionId ? effectiveDatabaseTypeForConnection(getConfig(options.node.connectionId)) : undefined;
const grouped = buildGroupedObjectTreeNodes({
nodeId: options.parentNodeId,
connectionId: options.node.connectionId || "",
database: options.node.database || "",
schema: options.effectiveSchema,
objects: options.objects.filter((object) => options.objectTypes.includes(normalizedObjectTreeKind(object.object_type))),
databaseType,
});
const refreshedGroup = grouped.find((group) => group.type === options.node.type);
const children = refreshedGroup?.children ?? [];
const databaseType = options.node.connectionId ? effectiveDatabaseTypeForConnection(getConfig(options.node.connectionId)) : undefined;
return supportsPackageMemberExpansion(databaseType) ? markPackageNodesExpandable(children) : children;
}
@@ -1644,12 +1645,20 @@ export const useConnectionStore = defineStore("connection", () => {
const tableChildren = pageChildren.filter((child) => child.type === "table");
const nonTableChildren = pageChildren.filter((child) => child.type !== "table");
let merged = tableChildren.length ? mergeTableTreePageChildren(currentChildren, tableChildren, connectionId, database) : [...currentChildren];
const existing = new Set(merged.map(treeNodeObjectIdentity));
const existing = new Map(merged.map((node) => [treeNodeObjectIdentity(node), node]));
for (const child of nonTableChildren) {
const key = treeNodeObjectIdentity(child);
if (existing.has(key)) continue;
const existingNode = existing.get(key);
if (existingNode) {
if (child.type === "package" && child.xuguPackageBodyAvailable === true) {
existingNode.xuguPackageBodyAvailable = true;
existingNode.xuguPackageBodyValid = child.xuguPackageBodyValid;
existingNode.valid = existingNode.valid === false || child.valid === false ? false : (existingNode.valid ?? child.valid ?? null);
}
continue;
}
merged.push(child);
existing.add(key);
existing.set(key, child);
}
const config = parent.connectionId ? getConfig(parent.connectionId) : undefined;
return sortSidebarTreeChildrenForParent(
@@ -1872,14 +1881,15 @@ export const useConnectionStore = defineStore("connection", () => {
);
const supplementalObjects = filterSimpleSidebarSupplementalObjects(objects);
if (supplementalObjects.length === 0) return;
const databaseType = effectiveDatabaseTypeForConnection(getConfig(options.connectionId));
let supplementalChildren = buildSimpleObjectTreeNodes({
nodeId: options.nodeId,
connectionId: options.connectionId,
database: options.database,
schema: options.effectiveSchema,
objects: supplementalObjects,
databaseType,
});
const databaseType = effectiveDatabaseTypeForConnection(getConfig(options.connectionId));
if (supportsPackageMemberExpansion(databaseType)) {
supplementalChildren = markPackageNodesExpandable(supplementalChildren);
}
@@ -5708,7 +5718,7 @@ export const useConnectionStore = defineStore("connection", () => {
});
const targetNode = treeNodeLoadTarget(load);
if (!targetNode) return;
setChildren(targetNode, buildPackageMemberNodes(targetNode, response.candidates));
setChildren(targetNode, buildPackageMemberNodes(targetNode, response.candidates, databaseType));
targetNode.isExpanded = true;
},
options,