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

@@ -32,15 +32,25 @@ describe("package member tree", () => {
{ name: "lookup", kind: "function", signature: null, data_type: "VARCHAR" },
{ name: "ignored_table", kind: "table" },
];
const result = buildPackageMemberNodes(packageNode(), candidates);
const result = buildPackageMemberNodes(packageNode(), candidates, "xugu");
expect(result.map((node) => [node.type, node.label])).toEqual([
["procedure", "calculate(p_value IN INT)"],
["procedure", "calculate(p_value IN VARCHAR)"],
["function", "lookup"],
expect(result.map((node) => [node.type, node.label, node.objectCount])).toEqual([
["group-procedures", "tree.procedures", 2],
["group-functions", "tree.functions", 1],
]);
expect(result.every((node) => node.parentName === "business_api" && node.parentSchema === "app_schema" && node.parentType === "package" && node.valid === false)).toBe(true);
expect(new Set(result.map((node) => node.id)).size).toBe(3);
expect(result[0]?.children?.map((node) => node.label)).toEqual(["calculate(p_value IN INT)", "calculate(p_value IN VARCHAR)"]);
expect(result[1]?.children?.map((node) => node.label)).toEqual(["lookup"]);
expect(result.flatMap((node) => node.children ?? []).every((node) => node.parentName === "business_api" && node.parentSchema === "app_schema" && node.parentType === "package" && node.valid === false)).toBe(true);
expect(new Set(result.flatMap((node) => node.children ?? []).map((node) => node.id)).size).toBe(3);
});
it("keeps package body source metadata on the package without adding a duplicate body node", () => {
const node = { ...packageNode(), xuguPackageBodyAvailable: true, xuguPackageBodyValid: false };
const result = buildPackageMemberNodes(node, [{ name: "calculate", kind: "procedure", signature: null }], "xugu");
expect(result.map((child) => [child.type, child.label])).toEqual([["group-procedures", "tree.procedures"]]);
expect(result[0]?.children).toHaveLength(1);
expect(result.some((child) => child.type === "package-body")).toBe(false);
});
it("deduplicates exact duplicate metadata without merging case-distinct members", () => {
@@ -50,8 +60,24 @@ describe("package member tree", () => {
{ name: "MIXEDCASE", kind: "function", signature: "p INT" },
{ name: "", kind: "procedure" },
];
const result = buildPackageMemberNodes(packageNode(), candidates);
const result = buildPackageMemberNodes(packageNode(), candidates, "xugu");
expect(result.map((node) => node.objectName)).toEqual(["MixedCase", "MIXEDCASE"]);
expect(result.flatMap((node) => node.children ?? []).map((node) => node.objectName)).toEqual(["MixedCase", "MIXEDCASE"]);
});
it("keeps non-Xugu package members flat", () => {
const result = buildPackageMemberNodes(
packageNode(),
[
{ name: "calculate", kind: "procedure", signature: null },
{ name: "lookup", kind: "function", signature: null },
],
"oracle",
);
expect(result.map((node) => [node.type, node.label])).toEqual([
["procedure", "calculate"],
["function", "lookup"],
]);
});
});
@@ -80,6 +80,23 @@ describe("treeNodeClick", () => {
});
});
it("routes the package body action to the owning package source", () => {
expect(
objectSourceTargetForTreeNode({
id: "pkg:body",
label: "business_api",
type: "package-body",
objectName: "business_api",
schema: "app_schema",
}),
).toEqual({
name: "business_api",
schema: "app_schema",
objectType: "PACKAGE_BODY",
signature: undefined,
});
});
it("keeps standalone routine source routing unchanged", () => {
expect(objectSourceTargetForTreeNode({ id: "proc", label: "standalone_proc", type: "procedure", schema: "app" })).toEqual({
name: "standalone_proc",
+70
View File
@@ -117,6 +117,76 @@ describe("PostgreSQL custom type metadata", () => {
});
describe("programmable database objects", () => {
it("coalesces Xugu package specification and body into one top-level node", () => {
const objects: ObjectInfo[] = [
{ name: "DBX_UI_PKG", object_type: "PACKAGE", schema: "APP", valid: true },
{ name: "DBX_UI_PKG", object_type: "PACKAGE_BODY", schema: "APP", valid: false },
];
const nodes = buildSimpleObjectTreeNodes({ ...context, schema: "APP", objects, databaseType: "xugu" });
expect(nodes).toHaveLength(1);
expect(nodes[0]).toEqual(
expect.objectContaining({
type: "package",
objectName: "DBX_UI_PKG",
valid: false,
xuguPackageBodyAvailable: true,
xuguPackageBodyValid: false,
}),
);
});
it("keeps the package body as metadata for the expandable Xugu package node", () => {
const objects: ObjectInfo[] = [
{ name: "DBX_UI_PKG", object_type: "PACKAGE", schema: "APP", valid: true },
{ name: "DBX_UI_PKG", object_type: "PACKAGE_BODY", schema: "APP", valid: true },
];
const groups = buildGroupedObjectTreeNodes({ ...context, schema: "APP", objects, databaseType: "xugu" });
const packageGroup = groups.find((node) => node.type === "group-packages");
expect(packageGroup?.objectCount).toBe(1);
expect(packageGroup?.children).toEqual([expect.objectContaining({ type: "package", objectName: "DBX_UI_PKG" })]);
});
it("keeps a body-only Xugu metadata response visible as a package", () => {
const nodes = buildSimpleObjectTreeNodes({
...context,
schema: "APP",
objects: [{ name: "BODY_ONLY_PKG", object_type: "PACKAGE_BODY", schema: "APP", valid: true }],
databaseType: "xugu",
});
expect(nodes).toEqual([
expect.objectContaining({
type: "package",
objectName: "BODY_ONLY_PKG",
xuguPackageBodyAvailable: true,
xuguPackageBodyValid: true,
}),
]);
});
it("does not advertise a body child for a specification-only Xugu package", () => {
const nodes = buildSimpleObjectTreeNodes({
...context,
schema: "APP",
objects: [{ name: "SPEC_ONLY_PKG", object_type: "PACKAGE", schema: "APP", valid: true }],
databaseType: "xugu",
});
expect(nodes[0]).toEqual(expect.objectContaining({ type: "package", xuguPackageBodyAvailable: undefined }));
});
it("does not merge package and package body for other databases", () => {
const objects: ObjectInfo[] = [
{ name: "DBX_UI_PKG", object_type: "PACKAGE", schema: "APP" },
{ name: "DBX_UI_PKG", object_type: "PACKAGE_BODY", schema: "APP" },
];
const nodes = buildSimpleObjectTreeNodes({ ...context, schema: "APP", objects, databaseType: "oracle" });
expect(nodes.map((node) => node.type)).toEqual(["package", "package-body"]);
});
it("keeps Xugu trigger/type nodes distinct and preserves an invalid status", () => {
const objects: ObjectInfo[] = [
{ name: "TRG_AUDIT", object_type: "TRIGGER", schema: "APP", valid: false },
+57 -22
View File
@@ -1,14 +1,53 @@
import type { CompletionAssistantCandidate, TreeNode } from "@/types/database";
import type { CompletionAssistantCandidate, DatabaseType, TreeNode, TreeNodeType } from "@/types/database";
export function markPackageNodesExpandable(nodes: TreeNode[]): TreeNode[] {
return nodes.map((node) => (node.type === "package" ? { ...node, children: node.children ?? [] } : node));
}
export function buildPackageMemberNodes(packageNode: TreeNode, candidates: readonly CompletionAssistantCandidate[]): TreeNode[] {
const parentName = packageNode.objectName || packageNode.label;
const parentSchema = packageNode.schema;
function packageMemberGroup(packageNode: TreeNode, type: "procedure" | "function", children: TreeNode[]): TreeNode {
const isProcedureGroup = type === "procedure";
const groupType: TreeNodeType = isProcedureGroup ? "group-procedures" : "group-functions";
return {
id: `${packageNode.id}:members:${type}s`,
label: isProcedureGroup ? "tree.procedures" : "tree.functions",
type: groupType,
objectName: packageNode.objectName || packageNode.label,
parentName: packageNode.objectName || packageNode.label,
parentSchema: packageNode.schema,
parentType: "package",
connectionId: packageNode.connectionId,
database: packageNode.database,
schema: packageNode.schema,
objectCount: children.length,
isExpanded: false,
children,
};
}
function packageMemberNode(packageNode: TreeNode, kind: "procedure" | "function", name: string, signature: string): TreeNode {
return {
id: `${packageNode.id}:member:${kind}:${name}:${signature}`,
label: signature ? `${name}(${signature})` : name,
type: kind,
objectName: name,
signature: signature || undefined,
parentName: packageNode.objectName || packageNode.label,
parentSchema: packageNode.schema,
parentType: "package",
valid: packageNode.valid,
connectionId: packageNode.connectionId,
database: packageNode.database,
schema: packageNode.schema,
isExpanded: false,
children: undefined,
};
}
export function buildPackageMemberNodes(packageNode: TreeNode, candidates: readonly CompletionAssistantCandidate[], databaseType?: DatabaseType): TreeNode[] {
const seen = new Set<string>();
const children: TreeNode[] = [];
const members: TreeNode[] = [];
const procedures: TreeNode[] = [];
const functions: TreeNode[] = [];
for (const candidate of candidates) {
if (candidate.kind !== "procedure" && candidate.kind !== "function") continue;
@@ -18,23 +57,19 @@ export function buildPackageMemberNodes(packageNode: TreeNode, candidates: reado
const key = `${candidate.kind}\0${name}\0${signature}`;
if (seen.has(key)) continue;
seen.add(key);
children.push({
id: `${packageNode.id}:member:${candidate.kind}:${name}:${signature}`,
label: signature ? `${name}(${signature})` : name,
type: candidate.kind,
objectName: name,
signature: signature || undefined,
parentName,
parentSchema,
parentType: "package",
valid: packageNode.valid,
connectionId: packageNode.connectionId,
database: packageNode.database,
schema: parentSchema,
isExpanded: false,
children: undefined,
});
const member = packageMemberNode(packageNode, candidate.kind, name, signature);
members.push(member);
if (candidate.kind === "procedure") procedures.push(member);
else functions.push(member);
}
return children;
// Xugu presents package specifications and bodies as one logical package.
// Keep the richer member folders scoped to Xugu so Oracle and other package
// providers retain their existing flat member tree.
if (databaseType !== "xugu") return members;
const groups: TreeNode[] = [];
if (procedures.length > 0) groups.push(packageMemberGroup(packageNode, "procedure", procedures));
if (functions.length > 0) groups.push(packageMemberGroup(packageNode, "function", functions));
return groups;
}
+86 -5
View File
@@ -1,4 +1,4 @@
import type { ObjectInfo, TableInfo, TreeNode, TreeNodeType } from "@/types/database";
import type { DatabaseType, ObjectInfo, TableInfo, TreeNode, TreeNodeType } from "@/types/database";
import { normalizeSidebarObjectKind, type SidebarObjectKind } from "@/lib/database/databaseObjectCapabilities";
const databaseObjectNameCollator = new Intl.Collator(undefined, { numeric: true, sensitivity: "base" });
@@ -543,12 +543,89 @@ function buildObjectTreeEntries({ nodeId, connectionId, database, schema, object
return buildPartitionTree(entries, connectionId, database);
}
export function buildSimpleObjectTreeNodes({ nodeId, connectionId, database, schema, objects }: { nodeId: string; connectionId: string; database: string; schema?: string; objects: ObjectInfo[] }): TreeNode[] {
type XuguPackageObjectInfo = ObjectInfo & {
xugu_package_body_available?: boolean | null;
xugu_package_body_valid?: boolean | null;
};
function packageObjectIdentity(schema: string | undefined, name: string): string {
return `${schema || ""}\0${name}`;
}
/**
* Xugu exposes a package specification and body as two rows in ALL_PACKAGES,
* while they are one logical package in the schema tree. Keep the two source
* kinds available through metadata on the specification node, but coalesce
* their visible tree entry only for Xugu connections.
*/
function coalesceXuguPackageObjects(objects: readonly ObjectInfo[], databaseType?: DatabaseType): ObjectInfo[] {
if (databaseType !== "xugu") return [...objects];
const packageBodies = new Map<string, ObjectInfo>();
for (const object of objects) {
if (normalizeObjectType(object.object_type) !== "PACKAGE_BODY") continue;
const schema = object.schema ? normalizeDatabaseObjectName(object.schema) : undefined;
const name = normalizeDatabaseObjectName(object.name);
if (name) packageBodies.set(packageObjectIdentity(schema, name), object);
}
const result: ObjectInfo[] = [];
const emittedPackages = new Set<string>();
for (const object of objects) {
const type = normalizeObjectType(object.object_type);
const schema = object.schema ? normalizeDatabaseObjectName(object.schema) : undefined;
const name = normalizeDatabaseObjectName(object.name);
if (!name) continue;
if (type === "PACKAGE_BODY") {
const key = packageObjectIdentity(schema, name);
if (emittedPackages.has(key)) continue;
// A restricted metadata response may contain only PACKAGE_BODY. Keep it
// visible as a package so the body source is not silently lost.
if (!objects.some((candidate) => normalizeObjectType(candidate.object_type) === "PACKAGE" && packageObjectIdentity(candidate.schema ? normalizeDatabaseObjectName(candidate.schema) : undefined, normalizeDatabaseObjectName(candidate.name)) === key)) {
result.push({
...object,
object_type: "PACKAGE",
schema,
name,
valid: object.valid,
xugu_package_body_available: true,
xugu_package_body_valid: object.valid,
});
emittedPackages.add(key);
}
continue;
}
if (type !== "PACKAGE") {
result.push({ ...object, schema, name });
continue;
}
const key = packageObjectIdentity(schema, name);
if (emittedPackages.has(key)) continue;
const body = packageBodies.get(key);
const bodyValid = body?.valid ?? null;
result.push({
...object,
schema,
name,
valid: object.valid === false || body?.valid === false ? false : (object.valid ?? body?.valid ?? null),
xugu_package_body_available: !!body,
xugu_package_body_valid: bodyValid,
} satisfies XuguPackageObjectInfo);
emittedPackages.add(key);
}
return result;
}
export function buildSimpleObjectTreeNodes({ nodeId, connectionId, database, schema, objects, databaseType }: { nodeId: string; connectionId: string; database: string; schema?: string; objects: ObjectInfo[]; databaseType?: DatabaseType }): TreeNode[] {
const seen = new Set<string>();
const tableEntries: TableTreeEntry[] = [];
const objectNodes: TreeNode[] = [];
for (const obj of objects) {
for (const obj of coalesceXuguPackageObjects(objects, databaseType)) {
const objectType = normalizeObjectType(obj.object_type);
if (!["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "TRIGGER", "SEQUENCE", "SYNONYM", "PACKAGE", "PACKAGE_BODY", "TYPE", "TYPE_BODY"].includes(objectType)) {
continue;
@@ -591,6 +668,8 @@ export function buildSimpleObjectTreeNodes({ nodeId, connectionId, database, sch
valid: obj.valid ?? undefined,
meta: objectType === "TRIGGER" ? (obj.trigger ?? undefined) : undefined,
xuguTypeMembersExpandable: objectType === "TYPE" && obj.xugu_type_members_expandable === true,
xuguPackageBodyAvailable: objectType === "PACKAGE" && obj.xugu_package_body_available === true ? true : undefined,
xuguPackageBodyValid: objectType === "PACKAGE" && obj.xugu_package_body_available === true ? (obj.xugu_package_body_valid ?? null) : undefined,
connectionId,
database,
schema: childSchema,
@@ -718,10 +797,10 @@ export function objectTypesForGroupNode(type: TreeNodeType): DatabaseObjectTreeK
return groupDefs.find((def) => def.nodeType === type)?.objectTypes ?? null;
}
export function buildGroupedObjectTreeNodes({ nodeId, connectionId, database, schema, objects }: { nodeId: string; connectionId: string; database: string; schema?: string; objects: ObjectInfo[] }): TreeNode[] {
export function buildGroupedObjectTreeNodes({ nodeId, connectionId, database, schema, objects, databaseType }: { nodeId: string; connectionId: string; database: string; schema?: string; objects: ObjectInfo[]; databaseType?: DatabaseType }): TreeNode[] {
const buckets = new Map<string, ObjectInfo[]>();
const seen = new Set<string>();
for (const obj of objects) {
for (const obj of coalesceXuguPackageObjects(objects, databaseType)) {
const name = normalizeDatabaseObjectName(obj.name);
if (!name) continue;
const t = normalizeObjectType(obj.object_type);
@@ -768,6 +847,8 @@ export function buildGroupedObjectTreeNodes({ nodeId, connectionId, database, sc
valid: obj.valid ?? undefined,
meta: objectType === "TRIGGER" ? (obj.trigger ?? undefined) : undefined,
xuguTypeMembersExpandable: objectType === "TYPE" && obj.xugu_type_members_expandable === true,
xuguPackageBodyAvailable: objectType === "PACKAGE" && obj.xugu_package_body_available === true ? true : undefined,
xuguPackageBodyValid: objectType === "PACKAGE" && obj.xugu_package_body_available === true ? (obj.xugu_package_body_valid ?? null) : undefined,
connectionId,
database,
schema: childSchema,