25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
feat(neo4j): visualize and edit graph query results
Hand Sonic7ca34d76a9d0
diff --git a/agents/drivers/neo4j-go/README.md b/agents/drivers/neo4j-go/README.mdindex 0cd7a85430..0c6e429b37 100644--- a/agents/drivers/neo4j-go/README.md+++ b/agents/drivers/neo4j-go/README.md@@ -23,7 +23,7 @@ This module replaces the Neo4j JDBC Agent with the official Neo4j Go Driver.- Node labels use `CALL db.labels()`.- Properties use `db.schema.nodeTypeProperties()` with a sampled-node fallback.- Index uniqueness is derived from `SHOW INDEXES ... owningConstraint`, which is compatible with Neo4j 5.x.-- Query row values retain the previous Agent behavior: scalar and graph values are returned as displayable strings, while null remains null.+- Scalar query values remain displayable strings and null remains null. Graph values carry a versioned envelope with the original display text, typed identities and properties for the shared graph result view.## Validationdiff --git a/agents/drivers/neo4j-go/driver.go b/agents/drivers/neo4j-go/driver.goindex 7189bfb7b6..41d7f42da6 100644--- a/agents/drivers/neo4j-go/driver.go+++ b/agents/drivers/neo4j-go/driver.go@@ -60,19 +60,13 @@ func openVerifiedRuntime(params connectParams) (*connectionRuntime, error) {_ = driver.Close(context.Background())return nil, err}- return &connectionRuntime{driver: driver, params: params, legacySingleDatabase: usesLegacySingleDatabase(ctx, driver)}, nil-}--// usesLegacySingleDatabase reports whether the server negotiated Bolt 3 or-// older. Those servers only expose the default database, and the driver refuses-// to select a database name for them, so sessions must not send one. Probe-// failures keep the modern behavior.-func usesLegacySingleDatabase(ctx context.Context, driver neo4j.Driver) bool {- info, err := driver.GetServerInfo(ctx)- if err != nil {- return false+ runtime := &connectionRuntime{driver: driver, params: params}+ if info, err := driver.GetServerInfo(ctx); err == nil {+ // Older Bolt versions supply numeric IDs in the element-ID fields.+ runtime.legacySingleDatabase = info.ProtocolVersion().Major < 4+ runtime.legacyGraphIDs = info.ProtocolVersion().Major < 5}- return info.ProtocolVersion().Major < 4+ return runtime, nil}func openDriver(params connectParams) (neo4j.Driver, error) {diff --git a/agents/drivers/neo4j-go/graph.go b/agents/drivers/neo4j-go/graph.gonew file mode 100644index 0000000000..e81a7fc1e6--- /dev/null+++ b/agents/drivers/neo4j-go/graph.go@@ -0,0 +1,207 @@+package main++import (+ "encoding/json"+ "reflect"+ "sort"+ "strconv"+ "strings"++ neo4j "github.com/neo4j/neo4j-go-driver/v6/neo4j"+)++type graphVID struct {+ Type string `json:"type"`+ Value string `json:"value"`+}++type graphProperty struct {+ Owner string `json:"owner"`+ Name string `json:"name"`+ Type string `json:"type"`+ Value any `json:"value"`+}++type graphNode struct {+ ID string `json:"id"`+ VID graphVID `json:"vid"`+ Labels []string `json:"labels"`+ Properties []graphProperty `json:"properties"`+}++type graphEdge struct {+ ID string `json:"id"`+ VID graphVID `json:"vid"`+ Source string `json:"source"`+ Target string `json:"target"`+ SourceVID graphVID `json:"sourceVid"`+ TargetVID graphVID `json:"targetVid"`+ Type string `json:"type"`+ Properties []graphProperty `json:"properties"`+}++type graphCell struct {+ *nodeCell+ Marker string `json:"__dbx_graph_cell"`+ Kind string `json:"kind"`+ Display any `json:"display"`+ Nodes []graphNode `json:"nodes"`+ Edges []graphEdge `json:"edges"`+ DisplayParts []any `json:"displayParts,omitempty"`+}++func normalizeGraphQueryValue(value any, legacyIDs bool) any {+ display := normalizeQueryValue(value)+ cell := &graphCell{Marker: "neo4j-v1", Kind: strings.ToLower(neo4jTypeName(value)), Display: display, Nodes: []graphNode{}, Edges: []graphEdge{}}+ if node, ok := value.(neo4j.Node); ok {+ tableCell := normalizeNodeCell(node)+ cell.nodeCell = &tableCell+ cell.Kind = "vertex"+ }+ if _, ok := value.(neo4j.Relationship); ok {+ cell.Kind = "edge"+ }+ appendGraphValue(value, cell, legacyIDs)+ if len(cell.Nodes) == 0 && len(cell.Edges) == 0 {+ return display+ }+ if cell.Kind != "vertex" && cell.Kind != "edge" {+ appendGraphDisplay(value, &cell.DisplayParts, legacyIDs)+ }+ return cell+}++// Keep scalar JSON tokens intact while retaining references to editable entities.+func appendDisplayText(parts *[]any, text string) {+ if len(*parts) > 0 {+ if previous, ok := (*parts)[len(*parts)-1].(string); ok && len(previous)+len(text) <= 4096 {+ (*parts)[len(*parts)-1] = previous + text+ return+ }+ }+ *parts = append(*parts, text)+}++func appendGraphDisplay(value any, parts *[]any, legacyIDs bool) {+ switch typed := value.(type) {+ case neo4j.Node:+ *parts = append(*parts, map[string]string{"nodeId": graphIdentity("vertex", graphVIDFor(typed.ElementId, typed.Id, legacyIDs))})+ case neo4j.Relationship:+ *parts = append(*parts, map[string]string{"edgeId": graphIdentity("edge", graphVIDFor(typed.ElementId, typed.Id, legacyIDs))})+ case neo4j.Path:+ appendDisplayText(parts, `{"nodes":`)+ appendGraphDisplay(typed.Nodes, parts, legacyIDs)+ appendDisplayText(parts, `,"relationships":`)+ appendGraphDisplay(typed.Relationships, parts, legacyIDs)+ appendDisplayText(parts, "}")+ case map[string]any:+ keys := make([]string, 0, len(typed))+ for key := range typed {+ keys = append(keys, key)+ }+ sort.Strings(keys)+ appendDisplayText(parts, "{")+ for index, key := range keys {+ if index > 0 {+ appendDisplayText(parts, ",")+ }+ appendDisplayText(parts, formatJSONValue(key)+":")+ appendGraphDisplay(typed[key], parts, legacyIDs)+ }+ appendDisplayText(parts, "}")+ default:+ value := reflect.ValueOf(value)+ if value.IsValid() && (value.Kind() == reflect.Slice || value.Kind() == reflect.Array) {+ appendDisplayText(parts, "[")+ for i := 0; i < value.Len(); i++ {+ if i > 0 {+ appendDisplayText(parts, ",")+ }+ appendGraphDisplay(value.Index(i).Interface(), parts, legacyIDs)+ }+ appendDisplayText(parts, "]")+ } else {+ appendDisplayText(parts, formatJSONValue(typed))+ }+ }+}++func graphVIDFor(elementID string, legacyID int64, legacyIDs bool) graphVID {+ if legacyIDs {+ return graphVID{Type: "neo4j-id", Value: strconv.FormatInt(legacyID, 10)}+ }+ return graphVID{Type: "neo4j-element-id", Value: elementID}+}++func graphIdentity(kind string, vid graphVID) string {+ encoded, _ := json.Marshal([]string{kind, vid.Type, vid.Value})+ return string(encoded)+}++func graphPlaceholder(elementID string, legacyID int64, legacyIDs bool) graphNode {+ vid := graphVIDFor(elementID, legacyID, legacyIDs)+ return graphNode{ID: graphIdentity("vertex", vid), VID: vid, Labels: []string{}, Properties: []graphProperty{}}+}++func graphProperties(properties map[string]any) []graphProperty {+ result := make([]graphProperty, 0, len(properties))+ for name, value := range properties {+ property := graphProperty{Name: name, Type: neo4jTypeName(value), Value: normalizeQueryValue(value)}+ switch typed := value.(type) {+ case string:+ property.Type = "string"+ case bool:+ property.Type, property.Value = "bool", typed+ case int, int64:+ property.Type = "int"+ case float64:+ property.Type = "float"+ case []byte:+ property.Value = formatJSONValue(typed)+ }+ result = append(result, property)+ }+ sort.Slice(result, func(i, j int) bool { return result[i].Name < result[j].Name })+ return result+}++func appendGraphValue(value any, cell *graphCell, legacyIDs bool) {+ switch typed := value.(type) {+ case neo4j.Node:+ node := graphPlaceholder(typed.ElementId, typed.Id, legacyIDs)+ node.Labels = append(node.Labels, typed.Labels...)+ node.Properties = graphProperties(typed.Props)+ cell.Nodes = append(cell.Nodes, node)+ case neo4j.Relationship:+ source := graphPlaceholder(typed.StartElementId, typed.StartId, legacyIDs)+ target := graphPlaceholder(typed.EndElementId, typed.EndId, legacyIDs)+ vid := graphVIDFor(typed.ElementId, typed.Id, legacyIDs)+ cell.Nodes = append(cell.Nodes, source, target)+ cell.Edges = append(cell.Edges, graphEdge{ID: graphIdentity("edge", vid), VID: vid, Source: source.ID, Target: target.ID, SourceVID: source.VID, TargetVID: target.VID, Type: typed.Type, Properties: graphProperties(typed.Props)})+ case neo4j.Path:+ for _, node := range typed.Nodes {+ appendGraphValue(node, cell, legacyIDs)+ }+ for _, edge := range typed.Relationships {+ appendGraphValue(edge, cell, legacyIDs)+ }+ case map[string]any:+ keys := make([]string, 0, len(typed))+ for key := range typed {+ keys = append(keys, key)+ }+ sort.Strings(keys)+ for _, key := range keys {+ appendGraphValue(typed[key], cell, legacyIDs)+ }+ case []byte:+ return+ default:+ value := reflect.ValueOf(value)+ if value.IsValid() && (value.Kind() == reflect.Slice || value.Kind() == reflect.Array) {+ for i := 0; i < value.Len(); i++ {+ appendGraphValue(value.Index(i).Interface(), cell, legacyIDs)+ }+ }+ }+}diff --git a/agents/drivers/neo4j-go/graph_test.go b/agents/drivers/neo4j-go/graph_test.gonew file mode 100644index 0000000000..026aee064a--- /dev/null+++ b/agents/drivers/neo4j-go/graph_test.go@@ -0,0 +1,67 @@+package main++import (+ "encoding/json"+ "reflect"+ "strings"+ "testing"++ neo4j "github.com/neo4j/neo4j-go-driver/v6/neo4j"+)++func TestGraphRecordPreservesScalarDisplayAndExactIdentity(t *testing.T) {+ node := neo4j.Node{Id: 9007199254740993, ElementId: "4:test:1", Labels: []string{"Person", "Employee"}, Props: map[string]any{"name": "Sample A", "count": int64(9007199254740993), "enabled": true}}+ for _, legacy := range []bool{false, true} {+ row := normalizeRecord(&neo4j.Record{Values: []any{node, int64(42), nil, true}}, 4, legacy)+ cell, ok := row[0].(*graphCell)+ if !ok || cell.Marker != "neo4j-v1" || cell.Kind != "vertex" || cell.Display != formatNode(node) {+ t.Fatalf("invalid graph cell: %#v", row[0])+ }+ if !reflect.DeepEqual(row[1:], []any{"42", nil, "true"}) {+ t.Fatalf("scalar results changed: %#v", row[1:])+ }+ vid := cell.Nodes[0].VID+ if legacy && (vid.Type != "neo4j-id" || vid.Value != "9007199254740993") || !legacy && (vid.Type != "neo4j-element-id" || vid.Value != "4:test:1") {+ t.Fatalf("identity lost: %#v", vid)+ }+ encoded, err := json.Marshal(cell)+ if err != nil || !strings.Contains(string(encoded), `"value":"9007199254740993"`) || !strings.Contains(string(encoded), `"value":true`) {+ t.Fatalf("property types or precision lost: %s, %v", encoded, err)+ }+ }+}++func TestGraphPathsPreserveDirectionParallelEdgesAndSelfLoops(t *testing.T) {+ a := neo4j.Node{ElementId: "a", Labels: []string{"Person"}}+ b := neo4j.Node{ElementId: "b"}+ reverse := neo4j.Relationship{ElementId: "r1", StartElementId: "b", EndElementId: "a", Type: "KNOWS"}+ parallel := reverse+ parallel.ElementId = "r2"+ loop := neo4j.Relationship{ElementId: "a", StartElementId: "a", EndElementId: "a", Type: "SELF"}+ path := neo4j.Path{Nodes: []neo4j.Node{a, b}, Relationships: []neo4j.Relationship{reverse, parallel, loop}}+ cell := normalizeGraphQueryValue(map[string]any{"paths": []any{path}}, false).(*graphCell)+ if len(cell.DisplayParts) == 0 {+ t.Fatal("nested graph display references were lost")+ }+ if len(cell.Edges) != 3 || cell.Edges[0].Source != graphPlaceholder("b", 0, false).ID || cell.Edges[0].Target != graphPlaceholder("a", 0, false).ID {+ t.Fatalf("relationship direction lost: %#v", cell.Edges)+ }+ if cell.Edges[0].ID == cell.Edges[1].ID || cell.Edges[2].ID == cell.Nodes[0].ID || cell.Edges[2].Source != cell.Edges[2].Target {+ t.Fatal("parallel relationships, node IDs or self-loops collided")+ }+ if got := normalizeGraphQueryValue([]any{int64(1), "text"}, false); got != `[1,"text"]` {+ t.Fatalf("scalar collection changed: %#v", got)+ }+}++func TestGraphBinaryPropertyRetainsItsJSONRepresentation(t *testing.T) {+ for _, bytes := range [][]byte{{}, {0, 34, 92, 128, 255}, []byte(`{"looks":"like JSON"}`)} {+ node := neo4j.Node{ElementId: "binary", Labels: []string{"Sample"}, Props: map[string]any{"bytes": bytes, "name": "before"}}+ cell := normalizeGraphQueryValue(node, false).(*graphCell)+ property := cell.Nodes[0].Properties[0]+ value, ok := property.Value.(string)+ if !ok || !json.Valid([]byte(value)) || value != formatJSONValue(bytes) {+ t.Fatalf("binary property cannot be reconstructed: %#v, want %s", property, formatJSONValue(bytes))+ }+ }+}diff --git a/agents/drivers/neo4j-go/main.go b/agents/drivers/neo4j-go/main.goindex 35abec3232..793ace7393 100644--- a/agents/drivers/neo4j-go/main.go+++ b/agents/drivers/neo4j-go/main.go@@ -97,6 +97,7 @@ type connectionRuntime struct {// legacySingleDatabase is set for servers that negotiated Bolt 3 or older:// they have a single default database and reject session database selection.legacySingleDatabase bool+ legacyGraphIDs boolreferences intclosed boolmu sync.Mutexdiff --git a/agents/drivers/neo4j-go/node_result_test.go b/agents/drivers/neo4j-go/node_result_test.goindex 5a607efd76..fc204c6de0 100644--- a/agents/drivers/neo4j-go/node_result_test.go+++ b/agents/drivers/neo4j-go/node_result_test.go@@ -13,8 +13,8 @@ func TestNodeResultKeepsSourceWidthAndExactPropertyValues(t *testing.T) {node := neo4j.Node{Labels: []string{"Person"}, Props: map[string]any{"name": "Ada", "age": int64(9007199254740993), "active": true, "scores": []any{int64(1), int64(2)},}}- row := normalizeRecord(&neo4j.Record{Values: []any{node, int64(7), nil}}, 3)- cell, ok := row[0].(nodeCell)+ row := normalizeRecord(&neo4j.Record{Values: []any{node, int64(7), nil}}, 3, false)+ cell, ok := row[0].(*graphCell)if !ok || len(row) != 3 || row[1] != "7" || row[2] != nil {t.Fatalf("unexpected record: %#v", row)}@@ -24,11 +24,11 @@ func TestNodeResultKeepsSourceWidthAndExactPropertyValues(t *testing.T) {{Name: "name", Type: "String", Value: "Ada"},{Name: "scores", Type: "List", Value: "[1,2]"},}- if cell.Marker != "v1" || cell.Display != formatNode(node) || !reflect.DeepEqual(cell.Properties, want) {+ if cell.nodeCell == nil || cell.nodeCell.Marker != "v1" || cell.Display != formatNode(node) || !reflect.DeepEqual(cell.nodeCell.Properties, want) {t.Fatalf("unexpected node cell: %#v", cell)}encoded, err := json.Marshal(row)- if err != nil || !strings.Contains(string(encoded), `"value":"9007199254740993"`) {+ if err != nil || !strings.Contains(string(encoded), `"value":"9007199254740993"`) || !strings.Contains(string(encoded), `"__dbx_neo4j_node":"v1"`) || !strings.Contains(string(encoded), `"__dbx_graph_cell":"neo4j-v1"`) {t.Fatalf("inexact wire value: %s, err=%v", encoded, err)}}@@ -42,9 +42,16 @@ func TestEmptyNodeAndNonNodeValues(t *testing.T) {for _, value := range []any{nil, "(:Person {\"name\":\"literal\"})", true, int64(42),neo4j.Relationship{Type: "KNOWS"}, neo4j.Path{Nodes: []neo4j.Node{node}},[]any{node}, map[string]any{"node": node}} {- row := normalizeRecord(&neo4j.Record{Values: []any{value}}, 1)- if !reflect.DeepEqual(row[0], normalizeQueryValue(value)) {- t.Fatalf("non-node result changed for %T: %#v", value, row)+ row := normalizeRecord(&neo4j.Record{Values: []any{value}}, 1, false)+ display := row[0]+ if cell, ok := display.(*graphCell); ok {+ if cell.nodeCell != nil {+ t.Fatalf("non-node result has node table metadata for %T: %#v", value, cell)+ }+ display = cell.Display+ }+ if !reflect.DeepEqual(display, normalizeQueryValue(value)) {+ t.Fatalf("non-node display changed for %T: %#v", value, row)}}}diff --git a/agents/drivers/neo4j-go/query.go b/agents/drivers/neo4j-go/query.goindex 240a745f24..0e70eac3d5 100644--- a/agents/drivers/neo4j-go/query.go+++ b/agents/drivers/neo4j-go/query.go@@ -29,7 +29,7 @@ func (s *server) executeQuery(options queryOptions) (queryResult, error) {return queryResult{}, err}maxRows := effectiveMaxRows(options.MaxRows)- rows, columns, columnTypes, truncated, err := readResultPage(ctx, result, maxRows)+ rows, columns, columnTypes, truncated, err := readResultPage(ctx, result, maxRows, s.runtime.legacyGraphIDs)if err != nil {return queryResult{}, err}@@ -64,7 +64,7 @@ func (s *server) executeQueryPage(options queryOptions, pageSize int) (queryPages.endOperation(cancel)return queryPageResult{}, err}- rows, columns, columnTypes, hasMore, err := readResultPage(ctx, result, pageSize)+ rows, columns, columnTypes, hasMore, err := readResultPage(ctx, result, pageSize, s.runtime.legacyGraphIDs)if err != nil {_ = session.Close(ctx)s.endOperation(cancel)@@ -103,7 +103,7 @@ func (s *server) fetchQueryPage(id string, pageSize int) (queryPageResult, errorif pageSize > query.remaining {pageSize = query.remaining}- rows, _, _, hasMore, err := readResultPage(query.ctx, query.result, pageSize)+ rows, _, _, hasMore, err := readResultPage(query.ctx, query.result, pageSize, s.runtime.legacyGraphIDs)if err != nil {s.closeQuerySession(id)return queryPageResult{}, err@@ -202,7 +202,7 @@ func (s *server) executeBatch(params map[string]json.RawMessage) (queryResult, ereturn emptyQueryResult(time.Since(started)), nil}-func readResultPage(ctx context.Context, result neo4j.Result, limit int) ([][]any, []string, []string, bool, error) {+func readResultPage(ctx context.Context, result neo4j.Result, limit int, legacyGraphIDs bool) ([][]any, []string, []string, bool, error) {if limit < 0 {limit = 0}@@ -222,7 +222,7 @@ func readResultPage(ctx context.Context, result neo4j.Result, limit int) ([][]an} else {refineColumnTypes(columnTypes, record)}- rows = append(rows, normalizeRecord(record, len(columns)))+ rows = append(rows, normalizeRecord(record, len(columns), legacyGraphIDs))}if err := result.Err(); err != nil {return nil, nil, nil, false, err@@ -237,17 +237,13 @@ func readResultPage(ctx context.Context, result neo4j.Result, limit int) ([][]anreturn rows, columns, columnTypes, hasMore, nil}-func normalizeRecord(record *neo4j.Record, width int) []any {+func normalizeRecord(record *neo4j.Record, width int, legacyGraphIDs bool) []any {row := make([]any, width)if record == nil {return row}for index := 0; index < width && index < len(record.Values); index++ {- if node, ok := record.Values[index].(neo4j.Node); ok {- row[index] = normalizeNodeCell(node)- } else {- row[index] = normalizeQueryValue(record.Values[index])- }+ row[index] = normalizeGraphQueryValue(record.Values[index], legacyGraphIDs)}return row}diff --git a/apps/desktop/src/components/layout/ContentArea.vue b/apps/desktop/src/components/layout/ContentArea.vueindex 85dfc189ad..c49b5dda07 100644--- a/apps/desktop/src/components/layout/ContentArea.vue+++ b/apps/desktop/src/components/layout/ContentArea.vue@@ -6,8 +6,8 @@ import { canReloadUnavailableDataTab, restoredDataTabReloadFilters } from "@/libimport { defaultViewForResult } from "@/lib/query/queryResultDefaultView";import { extractNeo4jNodeCells, projectNeo4jNodeResult } from "@/lib/neo4j/neo4jNodeResult";import { useNeo4jNodeTableResult } from "@/composables/useNeo4jNodeTableResult";-import { extractGraphCells, type GraphEdge, type GraphNode, type GraphProperty, type GraphResult } from "@/lib/graph/graphResult";-import { applyGraphPropertyToResult, buildNebulaGraphExpand, buildNebulaGraphPropertyUpdate, graphPropertyFromUpdateResult, graphPropertyMatchesValue } from "@/lib/graph/nebulaGraph";+import { extractGraphCells, graphPropertyFromUpdateResult, type GraphEdge, type GraphNode, type GraphProperty, type GraphResult } from "@/lib/graph/graphResult";+import { graphAdapterForDatabase } from "@/lib/graph/graphAdapters";import { queryResultMessages } from "@/lib/query/queryResultMessages";import { isQueryExecutionErrorResult } from "@/lib/query/queryResultError";import { hasQueryOutput as tabHasQueryOutput } from "@/lib/query/queryOutput";@@ -643,6 +643,7 @@ async function fetchGridResultForExport(onProgress?: (info: { rowsExported: numbconst result = await queryStore.fetchTabResultForExport(props.activeTab.id, onProgress);if (!result || !isNeo4j) return result;extractNeo4jNodeCells(result);+ extractGraphCells(result);return projectNeo4jNodeResult(result);}const activeResultSql = computed(() => resultSqlForGrid(props.activeTab));@@ -745,7 +746,8 @@ const redisConsoleResults = computed(() => (props.activeTab.results?.length ? prconst canShowRedisConsoleOutput = computed(() => activeEffectiveDatabaseType.value === "redis" && (props.activeTab.isExecuting || redisConsoleResults.value.some((result) => result.execution_error === true || typeof result.redis_console_output === "string")));const redisResultViewMode = computed<RedisResultViewMode>(() => (activeEffectiveDatabaseType.value === "redis" ? (props.activeTab.uiState?.redisResultViewMode ?? "grid") : "grid"));const canShowResultOutput = computed(() => hasTabularResult.value || props.activeTab.isExecuting);-const canShowGraphOutput = computed(() => activeEffectiveDatabaseType.value === "nebula" && !!props.activeTab.result?.graph_data?.nodes.length);+const activeGraphAdapter = computed(() => graphAdapterForDatabase(activeEffectiveDatabaseType.value));+const canShowGraphOutput = computed(() => !!activeGraphAdapter.value && !!props.activeTab.result?.graph_data?.nodes.length);const canShowExplainOutput = computed(() => !!props.activeTab.explainPlan || !!props.activeTab.explainError || !!props.activeTab.explainTableResult || !!props.activeTab.explainTableError || props.activeTab.isExplaining === true);// A batch can attach server messages to more than one statement result (for// example a `DO $$ RAISE NOTICE $$` block followed by a SELECT). The messages@@ -761,9 +763,10 @@ const canShowMessagesOutput = computed(() => resultMessageCount.value > 0);const showStandaloneResultToolbar = computed(() => activeElasticsearchJsonResponse.value || props.activeOutputView !== "result" || (redisResultViewMode.value === "console" && canShowRedisConsoleOutput.value) || !props.activeTab.result || !hasTabularResult.value);const standaloneResultToolbarCompact = computed(() => isDataGridToolbarCompact(standaloneResultToolbarWidth.value, standaloneResultToolbarViewportWidth.value));-async function saveNebulaGraphProperty(entity: GraphNode | GraphEdge, property: GraphProperty, value: string | boolean): Promise<GraphProperty | undefined> {+async function saveGraphProperty(entity: GraphNode | GraphEdge, property: GraphProperty, value: string | boolean): Promise<GraphProperty | undefined> {const connection = activeResultConnection.value;- if (activeEffectiveDatabaseType.value !== "nebula" || connectionIsEffectivelyReadOnly(connection)) throw new Error(t("graph.unavailable"));+ const adapter = activeGraphAdapter.value;+ if (!adapter || connectionIsEffectivelyReadOnly(connection)) throw new Error(t("graph.unavailable"));const tab = props.activeTab;const result = tab.result;const connectionId = activeResultConnectionId.value;@@ -772,7 +775,7 @@ async function saveNebulaGraphProperty(entity: GraphNode | GraphEdge, property:const generation = tab.resultViewGeneration;const sourceKey = graphViewKey.value;const isCurrent = () => props.activeTab === tab && graphViewKey.value === sourceKey && (generation !== undefined ? !!tab.result?.graph_data : tab.result === result);- const statement = buildNebulaGraphPropertyUpdate(entity, property, value);+ const statement = adapter.buildPropertyUpdate(entity, property, value);const production = productionContextForDatabase(connection, database);if (production.active) {const confirmed = await productionSafetyStore.requestConfirmation({ sql: statement, connectionName: connection?.name, database, productionDatabases: production.databases, source: t("graph.title") });@@ -786,20 +789,21 @@ async function saveNebulaGraphProperty(entity: GraphNode | GraphEdge, property:if (response.rows.length === 0) throw new Error(t("graph.conflict"));const updated = graphPropertyFromUpdateResult(response, property);// A failed WHEN condition may still yield the stored value.- if (!graphPropertyMatchesValue(updated, value)) throw new Error(t("graph.conflict"));- applyGraphPropertyToResult(tab.result!, entity, property, updated);+ if (!adapter.matchesPropertyValue(updated, value)) throw new Error(t("graph.conflict"));+ adapter.applyPropertyUpdate(tab.result!, entity, property, updated);return updated;}-async function expandNebulaGraphNode(node: GraphNode): Promise<GraphResult | undefined> {+async function expandGraphNode(node: GraphNode): Promise<GraphResult | undefined> {+ const adapter = activeGraphAdapter.value;const tab = props.activeTab;const result = tab.result;const connectionId = activeResultConnectionId.value;const database = activeResultDatabase.value;const generation = tab.resultViewGeneration;const sourceKey = graphViewKey.value;- if (activeEffectiveDatabaseType.value !== "nebula" || !connectionId || !database) return undefined;- const response = await api.executeQuery(connectionId, database, buildNebulaGraphExpand(node), undefined, undefined, { maxRows: 200 });+ if (!adapter || !connectionId || !database) return undefined;+ const response = await api.executeQuery(connectionId, database, adapter.buildExpand(node), undefined, undefined, { maxRows: 200 });if (props.activeTab !== tab || graphViewKey.value !== sourceKey || (generation === undefined && tab.result !== result)) return undefined;if (response.execution_error) throw new Error(response.error?.detail ?? t("graph.unavailable"));return extractGraphCells(response).graph_data;@@ -2472,8 +2476,8 @@ defineExpose({:rows="activeTab.result.rows":columns="activeTab.result.columns":read-only="connectionIsEffectivelyReadOnly(activeResultConnection)"- :save-property="saveNebulaGraphProperty"- :expand-node="expandNebulaGraphNode"+ :save-property="saveGraphProperty"+ :expand-node="expandGraphNode"/><div v-else-if="activeOutputView === 'summary'" class="flex flex-1 min-h-0 min-w-0 overflow-auto bg-background">diff --git a/apps/desktop/src/components/layout/__tests__/ContentArea.graphActions.spec.ts b/apps/desktop/src/components/layout/__tests__/ContentArea.graphActions.spec.tsindex be181f69ae..638c950046 100644--- a/apps/desktop/src/components/layout/__tests__/ContentArea.graphActions.spec.ts+++ b/apps/desktop/src/components/layout/__tests__/ContentArea.graphActions.spec.ts@@ -32,8 +32,9 @@ import { useConnectionStore } from "@/stores/connectionStore";import { useQueryStore } from "@/stores/queryStore";import { useProductionSafetyStore } from "@/stores/productionSafetyStore";+let databaseType: "nebula" | "neo4j" = "nebula";function node(): GraphNode {- return { id: "shared", vid: { type: "string", value: "shared" }, labels: ["Person"], properties: [{ owner: "Person", name: "age", type: "int", value: "20" }] };+ return { id: "shared", vid: { type: databaseType === "nebula" ? "string" : "neo4j-element-id", value: "shared" }, labels: ["Person"], properties: [{ owner: databaseType === "nebula" ? "Person" : "", name: "age", type: "int", value: "20" }] };}function result(count = 1): QueryResult {@@ -69,7 +70,7 @@ async function mountContentArea(production = false) {const pinia = createPinia();setActivePinia(pinia);const connectionStore = useConnectionStore();- connectionStore.connections = ["a", "b"].map((id): ConnectionConfig => ({ id, name: `Synthetic ${id}`, db_type: "nebula", driver_profile: "nebula-v3", host: "localhost", port: 9669, username: "", password: "", is_production: production }));+ connectionStore.connections = ["a", "b"].map((id): ConnectionConfig => ({ id, name: `Synthetic ${id}`, db_type: databaseType, driver_profile: databaseType === "nebula" ? "nebula-v3" : "neo4j", host: "localhost", port: 9669, username: "", password: "", is_production: production }));const queryStore = useQueryStore();queryStore.tabs = ["a", "b"].map((id): QueryTab => ({ id, title: id, connectionId: id, database: `space_${id}`, mode: "query", sql: "MATCH (v) RETURN v", isExecuting: false, isCancelling: false, isExplaining: false, resultViewGeneration: `generation-${id}`, result: result(id === "a" ? 1 : 2) }));const state = reactive({ activeTab: queryStore.tabs[0] });@@ -118,12 +119,15 @@ afterEach(() => {}});-describe("ContentArea graph actions", () => {+describe.each(["nebula", "neo4j"] as const)("ContentArea %s graph actions", (type) => {+ beforeEach(() => {+ databaseType = type;+ });it("rejects a conditional update that returns a different stored value", async () => {const execute = vi.spyOn(api, "executeQuery").mockResolvedValue(response("21"));const { state } = await mountContentArea();await expect(save(graphViews[0])).rejects.toThrow("graph.conflict");- expect(execute).toHaveBeenCalledWith("a", "space_a", expect.stringContaining("WHEN `age` == 20"), undefined, undefined, { maxRows: 1 });+ expect(execute).toHaveBeenCalledWith("a", "space_a", expect.stringContaining(type === "nebula" ? "WHEN `age` == 20" : "WITH n WHERE n.`age` = 20"), undefined, undefined, { maxRows: 1 });expect(state.activeTab.result!.graph_data!.nodes[0].properties[0].value).toBe("20");expect(state.activeTab.result!.rows[0][0]).toBe("original");});@@ -133,7 +137,7 @@ describe("ContentArea graph actions", () => {const { state } = await mountContentArea();await expect(save(graphViews[0])).resolves.toEqual(expect.objectContaining({ value: "22" }));expect(state.activeTab.result!.graph_data!.nodes[0].properties[0].value).toBe("22");- expect(state.activeTab.result!.rows[0][0]).toContain("age: 22");+ expect(state.activeTab.result!.rows[0][0]).toContain(type === "nebula" ? "age: 22" : '"age":22');});it("discards an expansion when switching to a tab with a superset of the same IDs", async () => {@@ -197,6 +201,21 @@ describe("ContentArea graph actions", () => {await flush();pending.resolve(response("22"));await expect(saved).resolves.toEqual(expect.objectContaining({ value: "22" }));- expect(state.activeTab.result!.rows.every((row) => String(row[0]).includes("age: 22"))).toBe(true);+ expect(state.activeTab.result!.rows.every((row) => String(row[0]).includes(type === "nebula" ? "age: 22" : '"age":22'))).toBe(true);+ });++ it("uses the adapter's precision when validating a saved float", async () => {+ vi.spyOn(api, "executeQuery").mockResolvedValue(response("3.1500000948905659"));+ const { state } = await mountContentArea();+ const property = state.activeTab.result!.graph_data!.nodes[0].properties[0];+ property.type = "float";+ property.value = "3.14";+ const saved = save(graphViews[0], "3.15");+ if (type === "nebula") {+ await expect(saved).resolves.toEqual(expect.objectContaining({ value: "3.1500000948905659" }));+ } else {+ await expect(saved).rejects.toThrow("graph.conflict");+ expect(property.value).toBe("3.14");+ }});});diff --git a/apps/desktop/src/lib/graph/graphAdapters.ts b/apps/desktop/src/lib/graph/graphAdapters.tsnew file mode 100644index 0000000000..48bd1529db--- /dev/null+++ b/apps/desktop/src/lib/graph/graphAdapters.ts@@ -0,0 +1,20 @@+import type { DatabaseType, QueryResult } from "@/types/database";+import { graphPropertyMatchesValue, type GraphEdge, type GraphNode, type GraphProperty } from "./graphResult";+import { applyGraphPropertyToResult, buildNebulaGraphExpand, buildNebulaGraphPropertyUpdate, graphPropertyMatchesValue as nebulaPropertyMatchesValue } from "./nebulaGraph";+import { applyNeo4jGraphPropertyToResult, buildNeo4jGraphExpand, buildNeo4jGraphPropertyUpdate } from "./neo4jGraph";++interface GraphAdapter {+ buildPropertyUpdate: (entity: GraphNode | GraphEdge, property: GraphProperty, value: string | boolean) => string;+ buildExpand: (node: GraphNode) => string;+ applyPropertyUpdate: (result: QueryResult, entity: GraphNode | GraphEdge, property: GraphProperty, updated: GraphProperty) => void;+ matchesPropertyValue: (property: GraphProperty, value: string | boolean) => boolean;+}++const adapters: Partial<Record<DatabaseType, GraphAdapter>> = {+ nebula: { buildPropertyUpdate: buildNebulaGraphPropertyUpdate, buildExpand: buildNebulaGraphExpand, applyPropertyUpdate: applyGraphPropertyToResult, matchesPropertyValue: nebulaPropertyMatchesValue },+ neo4j: { buildPropertyUpdate: buildNeo4jGraphPropertyUpdate, buildExpand: buildNeo4jGraphExpand, applyPropertyUpdate: applyNeo4jGraphPropertyToResult, matchesPropertyValue: graphPropertyMatchesValue },+};++export function graphAdapterForDatabase(type: DatabaseType | undefined): GraphAdapter | undefined {+ return type ? adapters[type] : undefined;+}diff --git a/apps/desktop/src/lib/graph/graphResult.ts b/apps/desktop/src/lib/graph/graphResult.tsindex 36ca2d1822..f908a486b1 100644--- a/apps/desktop/src/lib/graph/graphResult.ts+++ b/apps/desktop/src/lib/graph/graphResult.ts@@ -21,6 +21,7 @@ export interface GraphNode {export interface GraphEdge {id: string;+ vid?: GraphVid;source: string;target: string;sourceVid?: GraphVid;@@ -48,7 +49,7 @@ export interface GraphResult {}interface GraphCellEnvelope {- __dbx_graph_cell: "nebula-v1";+ __dbx_graph_cell: "nebula-v1" | "neo4j-v1";kind: string;display: string;nodes: GraphNode[];@@ -56,10 +57,10 @@ interface GraphCellEnvelope {displayParts?: GraphDisplayPart[];}-function graphCellEnvelope(value: unknown): value is GraphCellEnvelope {+export function isGraphCellEnvelope(value: unknown): value is GraphCellEnvelope {if (!value || typeof value !== "object" || Array.isArray(value)) return false;const cell = value as Partial<GraphCellEnvelope>;- return cell.__dbx_graph_cell === "nebula-v1" && typeof cell.display === "string" && typeof cell.kind === "string" && Array.isArray(cell.nodes) && Array.isArray(cell.edges);+ return (cell.__dbx_graph_cell === "nebula-v1" || cell.__dbx_graph_cell === "neo4j-v1") && typeof cell.display === "string" && typeof cell.kind === "string" && Array.isArray(cell.nodes) && Array.isArray(cell.edges);}function mergeProperties(left: GraphProperty[], right: GraphProperty[]): GraphProperty[] {@@ -117,7 +118,7 @@ export function extractGraphCells(result: QueryResult): QueryResult {const cells: GraphCellRef[] = [];result.rows.forEach((row, rowIndex) => {row.forEach((value, columnIndex) => {- if (!graphCellEnvelope(value)) return;+ if (!isGraphCellEnvelope(value)) return;rows ??= result.rows.map((original) => [...original]);rows[rowIndex][columnIndex] = value.display;for (const node of value.nodes) {@@ -132,6 +133,28 @@ export function extractGraphCells(result: QueryResult): QueryResult {return result;}+export function graphPropertyFromUpdateResult(result: QueryResult, property: GraphProperty): GraphProperty {+ if (result.execution_error) throw new Error(result.error?.detail ?? "Graph property update failed");+ const value = result.rows[0]?.[0];+ if (result.rows.length !== 1 || value === null || value === undefined) throw new Error("The graph property was not updated");+ if (property.type === "int" && typeof value === "number" && !Number.isSafeInteger(value)) throw new Error("Inexact returned graph integer");+ if (property.type === "bool") {+ if (value !== true && value !== false && value !== "true" && value !== "false") throw new Error("Invalid boolean property returned by the database");+ return { ...property, value: value === true || value === "true" };+ }+ return { ...property, value: String(value) };+}++export function graphPropertyMatchesValue(property: GraphProperty, value: string | boolean): boolean {+ if (property.type === "int" && typeof property.value === "string" && typeof value === "string") {+ return /^-?\d+$/u.test(property.value) && /^-?\d+$/u.test(value) && BigInt(property.value) === BigInt(value);+ }+ if (property.type === "float" && typeof property.value === "string" && typeof value === "string") {+ return property.value.trim() !== "" && value.trim() !== "" && Number.isFinite(Number(property.value)) && Number(property.value) === Number(value);+ }+ return property.value === value;+}+export function updateGraphResultProperty(result: QueryResult, entity: GraphNode | GraphEdge, property: GraphProperty, updated: GraphProperty, formatNode: (node: GraphNode) => string, formatEdge: (edge: GraphEdge) => string, formatCell?: (cell: GraphCellRef) => string | undefined): void {const graph = result.graph_data;if (!graph) return;diff --git a/apps/desktop/src/lib/graph/neo4jGraph.spec.ts b/apps/desktop/src/lib/graph/neo4jGraph.spec.tsnew file mode 100644index 0000000000..dd967a17ca--- /dev/null+++ b/apps/desktop/src/lib/graph/neo4jGraph.spec.ts@@ -0,0 +1,84 @@+import { describe, expect, it } from "vitest";+import { applyNeo4jGraphPropertyToResult, buildNeo4jGraphExpand, buildNeo4jGraphPropertyUpdate } from "./neo4jGraph";+import { extractGraphCells, graphPropertyFromUpdateResult, type GraphEdge, type GraphNode } from "./graphResult";+import { graphAdapterForDatabase } from "./graphAdapters";+import type { QueryResult } from "@/types/database";++const node: GraphNode = { id: "n", vid: { type: "neo4j-element-id", value: "4:sample:1" }, labels: ["Person"], properties: [{ owner: "", name: "age", type: "int", value: "9007199254740993" }] };+const edge: GraphEdge = { id: "r", vid: { type: "neo4j-element-id", value: "5:sample:1" }, source: "n", target: "m", sourceVid: node.vid, targetVid: { type: "neo4j-element-id", value: "4:sample:2" }, type: "KNOWS", properties: [{ owner: "", name: "active", type: "bool", value: true }] };++describe("Neo4j graph adapter", () => {+ it("retains double precision while Nebula uses its single-precision comparison", () => {+ const returned = { owner: "", name: "weight", type: "float", value: "3.1500000948905659" };+ expect(graphAdapterForDatabase("nebula")!.matchesPropertyValue(returned, "3.15")).toBe(true);+ expect(graphAdapterForDatabase("neo4j")!.matchesPropertyValue(returned, "3.15")).toBe(false);+ expect(graphAdapterForDatabase("neo4j")!.matchesPropertyValue({ ...returned, value: "3.15000010" }, "3.15000011")).toBe(false);+ expect(graphAdapterForDatabase("neo4j")!.matchesPropertyValue({ ...returned, value: "3.15" }, "3.15")).toBe(true);+ });+ it("keeps legacy byte text from corrupting JSON when another property is edited", () => {+ const binaryNode: GraphNode = {+ ...node,+ properties: [+ { owner: "", name: "bytes", type: "List", value: '\u0000binary"\\text' },+ { owner: "", name: "name", type: "string", value: "before" },+ ],+ };+ const result = extractGraphCells({ columns: ["nested"], rows: [[{ __dbx_graph_cell: "neo4j-v1", kind: "map", display: "before", nodes: [binaryNode], edges: [], displayParts: ['{"node":', { nodeId: "n" }, "}"] }]] as unknown as QueryResult["rows"], affected_rows: 0, execution_time_ms: 0 });+ applyNeo4jGraphPropertyToResult(result, binaryNode, binaryNode.properties[1], { ...binaryNode.properties[1], value: "after" });+ expect(JSON.parse(String(result.rows[0][0])).node.properties).toEqual({ bytes: '\u0000binary"\\text', name: "after" });+ });++ it("preserves a normalized byte array and exact integer tokens after editing", () => {+ const binaryNode: GraphNode = {+ ...node,+ properties: [+ { owner: "", name: "bytes", type: "List", value: '["0","34","255"]' },+ { owner: "", name: "age", type: "int", value: "9007199254740993" },+ ],+ };+ const result = extractGraphCells({ columns: ["n"], rows: [[{ __dbx_graph_cell: "neo4j-v1", kind: "vertex", display: "before", nodes: [binaryNode], edges: [] }]] as unknown as QueryResult["rows"], affected_rows: 0, execution_time_ms: 0 });+ applyNeo4jGraphPropertyToResult(result, binaryNode, binaryNode.properties[1], { ...binaryNode.properties[1], value: "9007199254740994" });+ expect(result.rows[0][0]).toContain('"bytes":["0","34","255"]');+ expect(result.rows[0][0]).toContain('"age":9007199254740994');+ });+ it("updates nested graph references without parsing or rounding scalar JSON tokens", () => {+ const result = extractGraphCells({+ columns: ["nested"],+ rows: [[{ __dbx_graph_cell: "neo4j-v1", kind: "map", display: "before", nodes: [structuredClone(node)], edges: [structuredClone(edge)], displayParts: ['{"count":9007199254740997,"node":', { nodeId: "n" }, ',"edge":', { edgeId: "r" }, "}"] }]] as unknown as QueryResult["rows"],+ affected_rows: 0,+ execution_time_ms: 0,+ });+ applyNeo4jGraphPropertyToResult(result, node, node.properties[0], { ...node.properties[0], value: "9007199254740994" });+ expect(result.rows[0][0]).toContain('"count":9007199254740997');+ expect(result.rows[0][0]).toContain('"age":9007199254740994');+ applyNeo4jGraphPropertyToResult(result, edge, edge.properties[0], { ...edge.properties[0], value: false });+ expect(result.rows[0][0]).toContain('"active":false');+ });+ it("uses modern or legacy identities and preserves integer precision", () => {+ const statement = buildNeo4jGraphPropertyUpdate(node, node.properties[0], "9007199254740994");+ expect(statement).toContain('elementId(n) = "4:sample:1"');+ expect(statement).toContain("SET n.`age` = n.`age` WITH n WHERE n.`age` = 9007199254740993 SET n.`age` = 9007199254740994");+ expect(buildNeo4jGraphExpand({ ...node, vid: { type: "neo4j-id", value: "9007199254740993" } })).toBe("MATCH (n) WHERE id(n) = 9007199254740993 OPTIONAL MATCH (n)-[r]-(m) RETURN n, r, m LIMIT 200");+ expect(buildNeo4jGraphPropertyUpdate(edge, edge.properties[0], false)).toContain('elementId(r) = "5:sample:1" AND elementId(s) = "4:sample:1" AND elementId(t) = "4:sample:2"');+ });++ it("quotes user values and identifiers, rejects invalid numbers, and preserves float types", () => {+ const property = { owner: "", name: "odd`key", type: "string", value: "before" };+ expect(buildNeo4jGraphPropertyUpdate(node, property, 'after"\\\n')).toContain('SET n.`odd``key` = "after\\\"\\\\\\n"');+ expect(buildNeo4jGraphPropertyUpdate(node, { ...property, name: "weight", type: "float", value: "1.5" }, "2")).toContain('SET n.`weight` = toFloat("2")');+ for (const value of ["1; DELETE n", "9223372036854775808", "1.5"]) expect(() => buildNeo4jGraphPropertyUpdate(node, node.properties[0], value)).toThrow();+ expect(() => buildNeo4jGraphExpand({ ...node, vid: undefined })).toThrow();+ });++ it("keeps scalar results unchanged and refreshes direct graph cells after updates", () => {+ const result = extractGraphCells({ columns: ["n", "count"], rows: [[{ __dbx_graph_cell: "neo4j-v1", kind: "vertex", display: "before", nodes: [structuredClone(node)], edges: [] }, "12"]] as unknown as QueryResult["rows"], affected_rows: 0, execution_time_ms: 0 });+ expect(result.rows).toEqual([["before", "12"]]);+ const updated = graphPropertyFromUpdateResult({ columns: ["dbx_value"], rows: [["9007199254740994"]], affected_rows: 0, execution_time_ms: 0 }, node.properties[0]);+ applyNeo4jGraphPropertyToResult(result, node, node.properties[0], updated);+ expect(result.rows[0][0]).toBe('(:Person {"age":9007199254740994})');+ expect(result.graph_data?.nodes[0].properties[0].value).toBe("9007199254740994");+ expect(graphAdapterForDatabase("neo4j")?.buildExpand).toBe(buildNeo4jGraphExpand);+ expect(graphAdapterForDatabase("nebula")).toBeDefined();+ expect(graphAdapterForDatabase("mysql")).toBeUndefined();+ });+});diff --git a/apps/desktop/src/lib/graph/neo4jGraph.ts b/apps/desktop/src/lib/graph/neo4jGraph.tsnew file mode 100644index 0000000000..2a04e41254--- /dev/null+++ b/apps/desktop/src/lib/graph/neo4jGraph.ts@@ -0,0 +1,99 @@+import { updateGraphResultProperty, type GraphEdge, type GraphNode, type GraphProperty, type GraphVid } from "./graphResult";+import type { QueryResult } from "@/types/database";++function quoteIdentifier(value: string): string {+ if (!value || [...value].some((char) => (char.codePointAt(0) ?? 0) < 32)) throw new Error("Invalid Neo4j identifier");+ return `\`${value.replaceAll("\\", "\\\\").replaceAll("`", "``")}\``;+}++function integer(value: string | boolean): string {+ if (typeof value !== "string" || !/^-?(?:0|[1-9]\d*)$/u.test(value)) throw new Error("Invalid Neo4j integer");+ const number = BigInt(value);+ if (number < -9223372036854775808n || number > 9223372036854775807n) throw new Error("Neo4j integer is outside the signed 64-bit range");+ return value;+}++function identity(variable: string, vid: GraphVid | undefined): string {+ if (vid?.type === "neo4j-id") return `id(${variable}) = ${integer(vid.value)}`;+ if (vid?.type === "neo4j-element-id" && vid.value) return `elementId(${variable}) = ${JSON.stringify(vid.value)}`;+ throw new Error("Missing Neo4j entity identity");+}++function propertyValue(type: string, value: string | boolean | null): string {+ if (type === "string" && typeof value === "string") return JSON.stringify(value);+ if (type === "bool" && typeof value === "boolean") return value ? "true" : "false";+ if (type === "int" && value !== null) return integer(value);+ if (type === "float" && typeof value === "string" && /^-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/u.test(value) && Number.isFinite(Number(value))) return `toFloat(${JSON.stringify(value)})`;+ throw new Error("Invalid value for this Neo4j property type");+}++export function buildNeo4jGraphPropertyUpdate(entity: GraphNode | GraphEdge, property: GraphProperty, value: string | boolean): string {+ if (property.owner) throw new Error("Neo4j properties do not have a Tag owner");+ const node = "labels" in entity;+ const variable = node ? "n" : "r";+ const pattern = node ? `(n${entity.labels.map((label) => `:${quoteIdentifier(label)}`).join("")})` : `(s)-[r:${quoteIdentifier(entity.type)}]->(t)`;+ const predicates = [identity(variable, entity.vid)];+ if (!node) predicates.push(identity("s", entity.sourceVid), identity("t", entity.targetVid));+ const target = `${variable}.${quoteIdentifier(property.name)}`;+ // The dependent SET acquires the write lock before checking the saved value.+ return `MATCH ${pattern} WHERE ${predicates.join(" AND ")} SET ${target} = ${target} WITH ${variable} WHERE ${target} = ${propertyValue(property.type, property.value)} SET ${target} = ${propertyValue(property.type, value)} RETURN ${target} AS dbx_value`;+}++export function buildNeo4jGraphExpand(node: GraphNode): string {+ return `MATCH (n) WHERE ${identity("n", node.vid)} OPTIONAL MATCH (n)-[r]-(m) RETURN n, r, m LIMIT 200`;+}++function propertiesJSON(properties: GraphProperty[]): string {+ const values = [...properties]+ .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))+ .map((property) => {+ const value = property.value;+ let literal = JSON.stringify(value);+ if (typeof value === "string" && ["int", "float", "List", "Map"].includes(property.type)) {+ try {+ const parsed: unknown = JSON.parse(value);+ if ((["int", "float"].includes(property.type) && typeof parsed === "number" && Number.isFinite(parsed)) || (property.type === "List" && Array.isArray(parsed)) || (property.type === "Map" && parsed !== null && typeof parsed === "object" && !Array.isArray(parsed))) literal = value;+ } catch {+ // Older Agents may label raw byte text as List; quote it as text.+ }+ }+ return `${JSON.stringify(property.name)}:${literal}`;+ });+ return `{${values.join(",")}}`;+}++export function applyNeo4jGraphPropertyToResult(result: QueryResult, entity: GraphNode | GraphEdge, property: GraphProperty, updated: GraphProperty): void {+ const nodes = new Map(result.graph_data?.nodes.map((node) => [node.id, node]));+ const edges = new Map(result.graph_data?.edges.map((edge) => [edge.id, edge]));+ const propertiesDisplay = (properties: GraphProperty[]) => (properties.length ? ` ${propertiesJSON(properties)}` : "");+ updateGraphResultProperty(+ result,+ entity,+ property,+ updated,+ (node) => `(${node.labels.length ? `:${node.labels.join(":")}` : ""}${propertiesDisplay(node.properties)})`,+ (edge) => `[:${edge.type}${propertiesDisplay(edge.properties)}]`,+ (cell) => {+ if (!cell.displayParts) return undefined;+ const parts: string[] = [];+ for (const part of cell.displayParts) {+ if (typeof part === "string") parts.push(part);+ else if ("nodeId" in part) {+ const node = nodes.get(part.nodeId);+ if (!node?.vid) return undefined;+ parts.push(`{"elementId":${JSON.stringify(node.vid.value)},"labels":${JSON.stringify(node.labels)},"properties":${propertiesJSON(node.properties)}}`);+ } else {+ const edge = edges.get(part.edgeId);+ if (!edge?.vid || !edge.sourceVid || !edge.targetVid) return undefined;+ parts.push(`{"elementId":${JSON.stringify(edge.vid.value)},"endElementId":${JSON.stringify(edge.targetVid.value)},"properties":${propertiesJSON(edge.properties)},"startElementId":${JSON.stringify(edge.sourceVid.value)},"type":${JSON.stringify(edge.type)}}`);+ }+ }+ return parts.join("");+ },+ );+ if (!("labels" in entity) || !result.neo4j_node_cells?.length) return;+ const affected = new Set(result.graph_data?.cells.filter((cell) => cell.kind === "vertex" && cell.nodeIds.includes(entity.id)).map((cell) => `${cell.row}:${cell.column}`));+ result.neo4j_node_cells = result.neo4j_node_cells.map((cell) =>+ affected.has(`${cell.row_index}:${cell.column_index}`) ? { ...cell, properties: cell.properties.map((candidate) => (candidate.name === property.name ? { ...candidate, value: updated.value === null ? null : String(updated.value) } : candidate)) } : cell,+ );+}diff --git a/apps/desktop/src/lib/graph/neo4jGraphResult.spec.ts b/apps/desktop/src/lib/graph/neo4jGraphResult.spec.tsnew file mode 100644index 0000000000..80b6c61562--- /dev/null+++ b/apps/desktop/src/lib/graph/neo4jGraphResult.spec.ts@@ -0,0 +1,138 @@+import { computed, effectScope, ref } from "vue";+import { describe, expect, it } from "vitest";+import { useNeo4jNodeTableResult } from "@/composables/useNeo4jNodeTableResult";+import { extractNeo4jNodeCells, projectNeo4jNodeResult } from "@/lib/neo4j/neo4jNodeResult";+import { appendQueryResultSegment } from "@/stores/queryStore";+import type { QueryResult } from "@/types/database";+import { extractGraphCells, type GraphNode, type GraphProperty } from "./graphResult";+import { applyNeo4jGraphPropertyToResult } from "./neo4jGraph";++function vertex(id: string, name: string, age = "9007199254740993") {+ const node: GraphNode = {+ id,+ vid: { type: "neo4j-element-id", value: id },+ labels: ["Person"],+ properties: [+ { owner: "", name: "name", type: "string", value: name },+ { owner: "", name: "age", type: "int", value: age },+ { owner: "", name: "active", type: "bool", value: true },+ ],+ };+ return {+ __dbx_graph_cell: "neo4j-v1",+ __dbx_neo4j_node: "v1",+ kind: "vertex",+ display: `(:Person {name: "${name}"})`,+ nodes: [node],+ edges: [],+ properties: [+ { name: "name", type: "String", value: name },+ { name: "age", type: "Integer", value: age },+ { name: "active", type: "Boolean", value: "true" },+ ],+ };+}++function page(rows: unknown[][]): QueryResult {+ return { columns: ["p", "score"], rows: rows as QueryResult["rows"], affected_rows: 0, execution_time_ms: 1 };+}++function normalize(result: QueryResult): QueryResult {+ extractNeo4jNodeCells(result);+ return extractGraphCells(result);+}++describe("Neo4j graph and node-table compatibility", () => {+ it("retains both wire contracts, exact properties, scalar columns, and idempotent extraction", () => {+ const cell = vertex("qa-a", "QA Alice");+ const result = page([[cell, "7"]]);+ extractNeo4jNodeCells(result);+ extractNeo4jNodeCells(result);+ expect(result.neo4j_node_cells).toHaveLength(1);+ expect(result.rows[0]?.[0]).toEqual(cell);+ extractGraphCells(result);+ normalize(result);+ expect(result.graph_data?.nodes).toHaveLength(1);+ expect(result.graph_data?.cells).toHaveLength(1);+ const projected = projectNeo4jNodeResult(result);+ expect(projected.columns).toEqual(["p", "score", "p.name", "p.age", "p.active"]);+ expect(projected.rows).toEqual([[cell.display, "7", "QA Alice", "9007199254740993", "true"]]);+ expect(projected.hidden_column_indexes).toEqual([0]);+ expect(result.columns).toEqual(["p", "score"]);+ expect(result.rows).toEqual([[cell.display, "7"]]);+ });++ it("keeps both metadata streams aligned across raw cursor pages and clips both at the cap", () => {+ const first = normalize(page([[vertex("qa-a", "QA Alice"), "1"]]));+ const combined = appendQueryResultSegment(+ first,+ page([+ [vertex("qa-b", "QA Bob"), "2"],+ [vertex("qa-omitted", "QA Omitted"), "3"],+ ]),+ 2,+ );+ expect(combined.rows).toHaveLength(2);+ expect(combined.graph_data?.cells.map((cell) => cell.row)).toEqual([0, 1]);+ expect(combined.graph_data?.nodes.map((node) => node.id)).toEqual(["qa-a", "qa-b"]);+ expect(combined.neo4j_node_cells?.map((cell) => cell.row_index)).toEqual([0, 1]);+ expect(projectNeo4jNodeResult(combined).rows.map((row) => row[2])).toEqual(["QA Alice", "QA Bob"]);+ expect(appendQueryResultSegment(first, page([[vertex("qa-b", "QA Bob"), "2"]]), 1).neo4j_node_cells).toHaveLength(1);+ });++ it("updates all matching aliases in the graph, reactive node grid and export, without touching other nodes", () => {+ const scope = effectScope();+ const source = ref(+ normalize(+ page([+ [vertex("qa-a", "QA Alice"), "1"],+ [vertex("qa-a", "QA Alice"), "2"],+ [vertex("qa-b", "QA Bob", "42"), "3"],+ ]),+ ),+ );+ const table = scope.run(() =>+ useNeo4jNodeTableResult(+ computed(() => source.value),+ computed(() => "qa-result"),+ ),+ )!;+ expect(table.result.value?.rows.map((row) => row[2])).toEqual(["QA Alice", "QA Alice", "QA Bob"]);+ const node = source.value.graph_data!.nodes[0]!;+ for (const [name, value] of [+ ["name", "QA Updated"],+ ["age", "9007199254740994"],+ ["active", false],+ ] as const) {+ const property = node.properties.find((property) => property.name === name)!;+ applyNeo4jGraphPropertyToResult(source.value, node, property, { ...property, value } as GraphProperty);+ }+ expect(table.result.value?.rows.map((row) => row.slice(2))).toEqual([+ ["QA Updated", "9007199254740994", "false"],+ ["QA Updated", "9007199254740994", "false"],+ ["QA Bob", "42", "true"],+ ]);+ expect(projectNeo4jNodeResult(source.value).rows).toEqual(table.result.value?.rows);+ table.setSort("p.age", 3, "asc");+ expect(table.result.value?.rows[0]?.[2]).toBe("QA Bob");+ expect(source.value.graph_data?.nodes[0]?.properties.find((property) => property.name === "age")?.value).toBe("9007199254740994");+ expect(source.value.graph_data?.cells.map((cell) => cell.row)).toEqual([0, 1, 2]);+ scope.stop();+ });++ it("normalizes old node envelopes and malformed optional graph metadata without leaving object cells", () => {+ const cell = vertex("qa-a", "QA Alice");+ const result = normalize(+ page([+ [{ ...cell, nodes: null }, "1"],+ [{ __dbx_neo4j_node: "v1", display: "(:Person)", properties: [] }, "2"],+ ]),+ );+ expect(result.rows).toEqual([+ [cell.display, "1"],+ ["(:Person)", "2"],+ ]);+ expect(result.neo4j_node_cells).toHaveLength(2);+ expect(result.graph_data).toBeUndefined();+ });+});diff --git a/apps/desktop/src/lib/neo4j/neo4jNodeResult.ts b/apps/desktop/src/lib/neo4j/neo4jNodeResult.tsindex 976a72598e..a6f0bcb04b 100644--- a/apps/desktop/src/lib/neo4j/neo4jNodeResult.ts+++ b/apps/desktop/src/lib/neo4j/neo4jNodeResult.ts@@ -1,4 +1,5 @@import type { QueryResult } from "@/types/database";+import { isGraphCellEnvelope } from "@/lib/graph/graphResult";type CellValue = QueryResult["rows"][number][number];@@ -35,20 +36,21 @@ function nodeEnvelope(value: unknown): { display: string; properties: Neo4jNodeP/** Normalize typed wire cells once, keeping primitive rows and original columns. */export function extractNeo4jNodeCells(result: QueryResult): void {let rows: QueryResult["rows"] | undefined;- let cells: Neo4jNodeCell[] | undefined;+ let cells: Map<string, Neo4jNodeCell> | undefined;result.rows.forEach((row, row_index) => {row.forEach((value, column_index) => {if (column_index >= result.columns.length) return;const cell = nodeEnvelope(value);if (!cell) return;rows ??= result.rows.map((row) => [...row]);- cells ??= [...(result.neo4j_node_cells ?? [])];- rows[row_index]![column_index] = cell.display;- cells.push({ row_index, column_index, properties: cell.properties });+ cells ??= new Map((result.neo4j_node_cells ?? []).map((cell) => [`${cell.row_index}:${cell.column_index}`, cell]));+ // Graph extraction still needs the typed envelope after table metadata extraction.+ rows[row_index]![column_index] = isGraphCellEnvelope(value) ? value : cell.display;+ cells.set(`${row_index}:${column_index}`, { row_index, column_index, properties: cell.properties });});});if (rows) result.rows = rows;- if (cells) result.neo4j_node_cells = cells;+ if (cells) result.neo4j_node_cells = [...cells.values()];}export function appendNeo4jNodeCells(previous: QueryResult, segment: QueryResult, appendedRowCount: number): Neo4jNodeCell[] | undefined {diff --git a/apps/desktop/src/lib/sql/cypherReadOnly.spec.ts b/apps/desktop/src/lib/sql/cypherReadOnly.spec.tsnew file mode 100644index 0000000000..a101960686--- /dev/null+++ b/apps/desktop/src/lib/sql/cypherReadOnly.spec.ts@@ -0,0 +1,40 @@+import { describe, expect, it } from "vitest";+import { classifySqlRisk } from "./sqlRisk";++describe("Neo4j read-only query safety", () => {+ it.each(["SHOW DATABASES", "EXPLAIN MATCH (n) RETURN n"])("preserves read-only metadata and plans: %s", (sql) => expect(classifySqlRisk(sql, { dialect: "neo4j" }).risk).toBe("read"));+ it.each(["MATCH (n)-->(m) RETURN n,m", "MATCH (n) WHERE elementId(n) = '4:id:1' OPTIONAL MATCH (n)-[r]-(m) RETURN n,r,m LIMIT 200", "// SET is a comment\nMATCH (n:`DELETE`) WHERE n.name = 'CREATE; SET' RETURN n", "UNWIND [1,2] AS x RETURN x; RETURN 1", "/* comment */ WITH 1 AS x RETURN x"])(+ "allows pure Cypher reads: %s",+ (sql) => expect(classifySqlRisk(sql, { dialect: "neo4j" }).risk).toBe("read"),+ );++ it.each([+ "MATCH (n)-->(m) SET n.x = 1 RETURN n",+ "MATCH (n) RETURN n /* outer /* inner */ UNION MATCH (m) SET m.x=1 RETURN m /* */",+ "MATCH (n) RETURN n; CREATE (m)",+ "MATCH (n) WITH n DETACH DELETE n RETURN 1",+ "MATCH (n) CALL { WITH n SET n.x = 1 } RETURN n",+ "WITH 1 AS x CALL apoc.cypher.run('CREATE (n)', {}) YIELD value RETURN value",+ "MATCH (n) FOREACH (x IN [1] | SET n.x = x) RETURN n",+ "INSERT (n) RETURN n",+ "SHOW TRANSACTIONS YIELD transactionId TERMINATE TRANSACTIONS transactionId",+ "RETURN 'unterminated",+ "RETURN 1 /*",+ "",+ "// read",+ "MATCH (n) RETURN 'escaped\\' quote' SET n.x = 1 RETURN n",+ ])("blocks writes, calls and incomplete input: %s", (sql) => expect(classifySqlRisk(sql, { dialect: "neo4j" }).risk).not.toBe("read"));++ it("does not enable MATCH for SQL dialects", () => expect(classifySqlRisk("MATCH (n) RETURN n", { dialect: "mysql" }).risk).not.toBe("read"));++ it.each(["WITH {set: 1, delete: 2} AS m RETURN m.set, m.delete", "MATCH (n:SET) WHERE n.remove = $delete RETURN n", "MATCH (n) RETURN n./* property */set"])("allows keyword-named identifiers: %s", (sql) => expect(classifySqlRisk(sql, { dialect: "neo4j" }).risk).toBe("read"));++ it.each([+ String.raw`MATCH (n) \u0053ET n.p = 1 RETURN n`,+ String.raw`MATCH (n) // hidden\u000ASET n.p = 1 RETURN n`,+ String.raw`MATCH (n) RETURN n.\u0060name\u0060 SET n.p = 1 RETURN n`,+ "WITH {set: 1} AS m MATCH (n) SET n.p = m.set RETURN n",+ "MATCH (n:SET) DELETE n RETURN 1",+ "MATCH (n) RETURN n.set; CALL dbms.killQuery('q')",+ ])("does not hide writes behind escapes or identifier names: %s", (sql) => expect(classifySqlRisk(sql, { dialect: "neo4j" }).risk).not.toBe("read"));+});diff --git a/apps/desktop/src/lib/sql/cypherReadOnly.ts b/apps/desktop/src/lib/sql/cypherReadOnly.tsnew file mode 100644index 0000000000..891ca74053--- /dev/null+++ b/apps/desktop/src/lib/sql/cypherReadOnly.ts@@ -0,0 +1,63 @@+const UNSAFE_WORDS = new Set(["CREATE", "INSERT", "MERGE", "SET", "REMOVE", "DELETE", "DETACH", "DROP", "ALTER", "RENAME", "GRANT", "REVOKE", "DENY", "CALL", "FOREACH", "LOAD", "START", "STOP", "TERMINATE"]);++// Keep parity with dbx-sql-core/cypher_read_only.rs. `--` must remain an edge.+export function isProvenReadOnlyCypher(source: string): boolean {+ // Neo4j expands Unicode escapes before lexing, including inside comments.+ if (source.includes("\\u")) return false;+ const statements: string[][] = [[]];+ let index = 0;+ while (index < source.length) {+ const char = source[index];+ const next = source[index + 1];+ if (char === "/" && next === "/") {+ index += 2;+ while (index < source.length && !["\n", "\r"].includes(source[index])) index++;+ } else if (char === "/" && next === "*") {+ index += 2;+ let depth = 1;+ while (index < source.length && depth > 0) {+ if (source[index] === "/" && source[index + 1] === "*") {+ return false;+ } else if (source[index] === "*" && source[index + 1] === "/") {+ depth--;+ index += 2;+ } else index++;+ }+ if (depth !== 0) return false;+ } else if (char === "'" || char === '"' || char === "`") {+ index++;+ let closed = false;+ while (index < source.length) {+ if (source[index] === "\\") index += 2;+ else if (source[index] === char) {+ index++;+ if (source[index] === char) index++;+ else {+ closed = true;+ break;+ }+ } else index++;+ }+ if (!closed) return false;+ statements[statements.length - 1].push("<quoted>");+ } else if (char === ";") {+ statements.push([]);+ index++;+ } else if (/[A-Za-z_]/.test(char)) {+ const start = index++;+ while (index < source.length && /[\p{L}\p{N}_]/u.test(source[index])) index++;+ statements[statements.length - 1].push(source.slice(start, index).toUpperCase());+ } else {+ if ([".", ":", "$"].includes(char)) statements[statements.length - 1].push(char);+ else if (!/\s/u.test(char)) statements[statements.length - 1].push("<symbol>");+ index++;+ }+ }+ const nonempty = statements.filter((words) => words.length);+ return (+ nonempty.length > 0 &&+ nonempty.every(+ (words) => ["MATCH", "OPTIONAL", "RETURN", "WITH", "UNWIND", "SHOW", "EXPLAIN", "PROFILE"].includes(words[0]) && (words[0] === "SHOW" || words.includes("RETURN")) && !words.some((word, index) => UNSAFE_WORDS.has(word) && ![".", ":", "$"].includes(words[index - 1]) && words[index + 1] !== ":"),+ )+ );+}diff --git a/apps/desktop/src/lib/sql/sqlRisk.ts b/apps/desktop/src/lib/sql/sqlRisk.tsindex 82e298fdfb..2095120d18 100644--- a/apps/desktop/src/lib/sql/sqlRisk.ts+++ b/apps/desktop/src/lib/sql/sqlRisk.ts@@ -3,6 +3,7 @@ import { classifySolrRequestRisk, classifySolrSourceRisk } from "@/lib/solr/solrimport { classifyCouchDbRequestRisk, classifyCouchDbSourceRisk, type CouchDbRequestRisk } from "@/lib/couchdb/couchdbRequestRisk";import { mongoAggregateWriteStage, splitMongoCommandRanges, type MongoCommand } from "@/lib/mongo/mongoShellCommand";import { isCouchDbDatabaseType, isElasticsearchCompatibleDatabaseType, isSolrDatabaseType, type DatabaseType } from "@/types/database";+import { isProvenReadOnlyCypher } from "./cypherReadOnly";export type SqlRiskLevel = "read" | "write" | "ddl" | "transaction" | "unknown";@@ -70,6 +71,10 @@ export function splitSqlStatementsForSafety(sql: string, dialect?: DatabaseType}export function classifySqlRisk(sql: string, options: SqlRiskOptions = {}): SqlRiskAssessment {+ if (options.dialect === "neo4j") {+ const assessment: SqlRiskStatementAssessment = { risk: isProvenReadOnlyCypher(sql) ? "read" : "unknown", firstKeyword: "cypher" };+ return { ...assessment, statements: [assessment] };+ }const mongoStatements = mongoShellStatements(sql, options.dialect);if (mongoStatements) {const highest = highestRiskStatement(mongoStatements);@@ -88,6 +93,7 @@ export function classifySqlRisk(sql: string, options: SqlRiskOptions = {}): SqlR}export function classifySqlStatementRisk(sql: string, options: SqlRiskOptions = {}): SqlRiskStatementAssessment {+ if (options.dialect === "neo4j") return { risk: isProvenReadOnlyCypher(sql) ? "read" : "unknown", firstKeyword: "cypher" };const mongoStatements = mongoShellStatements(sql, options.dialect);if (mongoStatements) return highestRiskStatement(mongoStatements);diff --git a/crates/dbx-core/src/data/query_result_export.rs b/crates/dbx-core/src/data/query_result_export.rsindex e0d80e94ce..f20200164c 100644--- a/crates/dbx-core/src/data/query_result_export.rs+++ b/crates/dbx-core/src/data/query_result_export.rs@@ -1105,6 +1105,8 @@ async fn export_query_result_core_inner(let row_count = result.rows.len();if request.database_type == DatabaseType::Nebula {crate::text_export::normalize_nebula_export_rows(&mut result.rows);+ } else if request.database_type == DatabaseType::Neo4j {+ crate::text_export::normalize_neo4j_export_rows(&mut result.rows);}let formatted_rows = crate::temporal_format::format_temporal_export_rows_with_string_types_cow(&result.rows,diff --git a/crates/dbx-formats/src/text_export.rs b/crates/dbx-formats/src/text_export.rsindex 99055dbe89..0c7924da2b 100644--- a/crates/dbx-formats/src/text_export.rs+++ b/crates/dbx-formats/src/text_export.rs@@ -26,6 +26,22 @@ pub fn normalize_nebula_export_rows(rows: &mut [Vec<Value>]) {}}+pub fn normalize_neo4j_export_rows(rows: &mut [Vec<Value>]) {+ for value in rows.iter_mut().flatten() {+ let graph_cell = value.get("__dbx_graph_cell").and_then(Value::as_str) == Some("neo4j-v1")+ && value.get("kind").is_some_and(Value::is_string)+ && value.get("nodes").is_some_and(Value::is_array)+ && value.get("edges").is_some_and(Value::is_array);+ let node_cell = value.get("__dbx_neo4j_node").and_then(Value::as_str) == Some("v1")+ && value.get("properties").is_some_and(Value::is_array);+ if graph_cell || node_cell {+ if let Some(display) = value.get("display").and_then(Value::as_str) {+ *value = Value::String(display.to_owned());+ }+ }+ }+}+pub fn format_json(data: &QueryResultTextExportData) -> Result<String, String> {let rows = data.rows@@ -442,7 +458,10 @@ fn chrono_local_now() -> String {mod tests {use serde_json::{json, Value};- use super::{format_html, format_json, format_markdown, normalize_nebula_export_rows, QueryResultTextExportData};+ use super::{+ format_html, format_json, format_markdown, normalize_nebula_export_rows, normalize_neo4j_export_rows,+ QueryResultTextExportData,+ };#[test]fn nebula_exports_use_display_cells_without_leaking_graph_metadata() {@@ -492,6 +511,62 @@ mod tests {assert_eq!(rows[0][4], original[0][4]);}+ #[test]+ fn neo4j_exports_use_display_cells_without_leaking_graph_metadata() {+ let displays = [+ ("vertex", "(:Person {\"count\":9007199254740993})"),+ ("edge", "[:KNOWS]"),+ ("path", "{\"nodes\":[],\"relationships\":[]}"),+ ("map", "{\"count\":9007199254740993,\"node\":{\"labels\":[\"Person\"]}}"),+ ];+ let mut rows = displays+ .iter()+ .map(|(kind, display)| {+ vec![+ json!({+ "__dbx_graph_cell": "neo4j-v1", "kind": kind, "display": display,+ "nodes": [], "edges": [], "displayParts": ["internal metadata"]+ }),+ json!(false),+ Value::Null,+ ]+ })+ .collect::<Vec<_>>();+ rows.push(vec![+ json!({"__dbx_neo4j_node":"v1", "display":"(:Legacy)", "properties": []}),+ json!(7),+ json!("plain"),+ ]);+ normalize_neo4j_export_rows(&mut rows);+ for (index, (_, display)) in displays.iter().enumerate() {+ assert_eq!(rows[index], vec![json!(display), json!(false), Value::Null]);+ }+ assert_eq!(rows[4], vec![json!("(:Legacy)"), json!(7), json!("plain")]);+ let data = QueryResultTextExportData {+ title: None,+ columns: vec!["entity".into(), "value".into(), "note".into()],+ rows,+ };+ let exported: Value = serde_json::from_str(&format_json(&data).unwrap()).unwrap();+ assert_eq!(exported[0]["entity"], json!(displays[0].1));+ assert_eq!(exported[1]["entity"], json!("[:KNOWS]"));+ assert!(!format_markdown(&data).contains("__dbx_graph_cell"));+ }++ #[test]+ fn neo4j_export_normalization_preserves_ordinary_and_unknown_objects() {+ let mut rows = vec![vec![+ json!({"display":"ordinary", "properties":[]}),+ json!({"__dbx_graph_cell":"nebula-v1", "kind":"vertex", "display":"nebula", "nodes":[], "edges":[]}),+ json!({"__dbx_graph_cell":"neo4j-v2", "kind":"vertex", "display":"future", "nodes":[], "edges":[]}),+ json!({"__dbx_graph_cell":"neo4j-v1", "kind":"vertex", "display":42, "nodes":[], "edges":[]}),+ json!({"__dbx_graph_cell":"neo4j-v1", "kind":"vertex", "display":"malformed", "nodes":null, "edges":[]}),+ ]];+ let original = rows.clone();+ normalize_neo4j_export_rows(&mut rows);+ assert_eq!(rows, original);+ }+#[test]fn formats_json_rows_as_objects() {let out = format_json(&QueryResultTextExportData {diff --git a/crates/dbx-sql-core/src/cypher_read_only.rs b/crates/dbx-sql-core/src/cypher_read_only.rsnew file mode 100644index 0000000000..61221e8fb9--- /dev/null+++ b/crates/dbx-sql-core/src/cypher_read_only.rs@@ -0,0 +1,168 @@+const UNSAFE_WORDS: &[&str] = &[+ "CREATE",+ "INSERT",+ "MERGE",+ "SET",+ "REMOVE",+ "DELETE",+ "DETACH",+ "DROP",+ "ALTER",+ "RENAME",+ "GRANT",+ "REVOKE",+ "DENY",+ "CALL",+ "FOREACH",+ "LOAD",+ "START",+ "STOP",+ "TERMINATE",+];++// Cypher's `--` is a relationship, not a SQL line comment. Keep this scanner+// separate so trailing writes cannot disappear during SQL comment stripping.+pub(crate) fn is_proven_read_only_cypher(source: &str) -> bool {+ // Neo4j expands Unicode escapes before lexing, including inside comments.+ if source.contains("\\u") {+ return false;+ }+ let chars: Vec<char> = source.chars().collect();+ let mut index = 0;+ let mut statements = vec![Vec::<String>::new()];+ while index < chars.len() {+ let ch = chars[index];+ let next = chars.get(index + 1).copied();+ if ch == '/' && next == Some('/') {+ index += 2;+ while index < chars.len() && !matches!(chars[index], '\n' | '\r') {+ index += 1;+ }+ } else if ch == '/' && next == Some('*') {+ index += 2;+ let mut depth = 1;+ while index < chars.len() && depth > 0 {+ match (chars[index], chars.get(index + 1)) {+ ('/', Some('*')) => {+ return false;+ }+ ('*', Some('/')) => {+ depth -= 1;+ index += 2;+ }+ _ => index += 1,+ }+ }+ if depth != 0 {+ return false;+ }+ } else if matches!(ch, '\'' | '"' | '`') {+ index += 1;+ let mut closed = false;+ while index < chars.len() {+ if chars[index] == '\\' {+ index += 2;+ } else if chars[index] == ch {+ index += 1;+ if chars.get(index) == Some(&ch) {+ index += 1;+ } else {+ closed = true;+ break;+ }+ } else {+ index += 1;+ }+ }+ if !closed {+ return false;+ }+ statements.last_mut().unwrap().push("<quoted>".into());+ } else if ch == ';' {+ statements.push(Vec::new());+ index += 1;+ } else if ch.is_ascii_alphabetic() || ch == '_' {+ let start = index;+ index += 1;+ while index < chars.len() && (chars[index].is_alphanumeric() || chars[index] == '_') {+ index += 1;+ }+ statements.last_mut().unwrap().push(chars[start..index].iter().collect::<String>().to_ascii_uppercase());+ } else {+ if matches!(ch, '.' | ':' | '$') {+ statements.last_mut().unwrap().push(ch.to_string());+ } else if !ch.is_whitespace() {+ statements.last_mut().unwrap().push("<symbol>".into());+ }+ index += 1;+ }+ }+ let statements: Vec<_> = statements.iter().filter(|words| !words.is_empty()).collect();+ !statements.is_empty()+ && statements.iter().all(|words| {+ matches!(+ words.first().map(String::as_str),+ Some("MATCH" | "OPTIONAL" | "RETURN" | "WITH" | "UNWIND" | "SHOW" | "EXPLAIN" | "PROFILE")+ ) && (words[0] == "SHOW" || words.iter().any(|word| word == "RETURN"))+ && !words.iter().enumerate().any(|(index, word)| {+ UNSAFE_WORDS.contains(&word.as_str())+ && !matches!(+ index.checked_sub(1).and_then(|previous| words.get(previous)).map(String::as_str),+ Some("." | ":" | "$")+ )+ && words.get(index + 1).map(String::as_str) != Some(":")+ })+ })+}++#[cfg(test)]+mod tests {+ use crate::{models::connection::DatabaseType, query_execution_sql::check_read_only};++ #[test]+ fn cypher_reads_are_allowed_only_for_neo4j() {+ for source in [+ "MATCH (n)-->(m) RETURN n,m",+ "MATCH (n) WHERE elementId(n) = '4:id:1' OPTIONAL MATCH (n)-[r]-(m) RETURN n,r,m LIMIT 200",+ "// SET is a comment\nMATCH (n:`DELETE`) WHERE n.name = 'CREATE; SET' RETURN n",+ "UNWIND [1,2] AS x RETURN x; RETURN 1",+ "SHOW DATABASES",+ "EXPLAIN MATCH (n) RETURN n",+ "/* comment */ WITH 1 AS x RETURN x",+ "WITH {set: 1, delete: 2} AS m RETURN m.set, m.delete",+ "MATCH (n:SET) WHERE n.remove = $delete RETURN n",+ "MATCH (n) RETURN n./* property */set",+ ] {+ assert!(check_read_only(source, "test", DatabaseType::Neo4j).is_ok(), "{source}");+ }+ assert!(check_read_only("MATCH (n) RETURN n", "test", DatabaseType::Mysql).is_err());+ }++ #[test]+ fn cypher_writes_procedures_and_incomplete_input_are_blocked() {+ for source in [+ "MATCH (n)-->(m) SET n.x = 1 RETURN n",+ "MATCH (n) RETURN n /* outer /* inner */ UNION MATCH (m) SET m.x=1 RETURN m /* */",+ "MATCH (n) RETURN n; CREATE (m)",+ "MATCH (n) WITH n DETACH DELETE n RETURN 1",+ "MATCH (n) CALL { WITH n SET n.x = 1 } RETURN n",+ "WITH 1 AS x CALL apoc.cypher.run('CREATE (n)', {}) YIELD value RETURN value",+ "MATCH (n) FOREACH (x IN [1] | SET n.x = x) RETURN n",+ "INSERT (n) RETURN n",+ "SHOW TRANSACTIONS YIELD transactionId TERMINATE TRANSACTIONS transactionId",+ "RETURN 'unterminated",+ "RETURN 1 /*",+ "",+ "// read",+ "MATCH (n) RETURN 'escaped\\' quote' SET n.x = 1 RETURN n",+ r"MATCH (n) \u0053ET n.p = 1 RETURN n",+ r"MATCH (n) // hidden\u000ASET n.p = 1 RETURN n",+ r"MATCH (n) RETURN n.\u0060name\u0060 SET n.p = 1 RETURN n",+ "WITH {set: 1} AS m MATCH (n) SET n.p = m.set RETURN n",+ "MATCH (n:SET) DELETE n RETURN 1",+ "MATCH (n) RETURN n.set; CALL dbms.killQuery('q')",+ ] {+ assert!(check_read_only(source, "test", DatabaseType::Neo4j).is_err(), "{source}");+ }+ }+}diff --git a/crates/dbx-sql-core/src/lib.rs b/crates/dbx-sql-core/src/lib.rsindex 0dab086d72..027049fae1 100644--- a/crates/dbx-sql-core/src/lib.rs+++ b/crates/dbx-sql-core/src/lib.rs@@ -2,6 +2,8 @@pub use dbx_types::{database_manifest, models, types};+mod cypher_read_only;+pub mod dml_preview_sql;pub mod mysql_ddl_normalize;pub mod mysql_event_sql;diff --git a/crates/dbx-sql-core/src/query_execution_sql.rs b/crates/dbx-sql-core/src/query_execution_sql.rsindex fbcab26d4f..0c386aa8af 100644--- a/crates/dbx-sql-core/src/query_execution_sql.rs+++ b/crates/dbx-sql-core/src/query_execution_sql.rs@@ -427,6 +427,9 @@ pub fn is_write_sql(sql: &str) -> bool {/// executable comments and file exports, plus PostgreSQL-family/SQL Server/// `SELECT ... INTO` table creation.pub fn is_write_sql_for_database(sql: &str, database_type: DatabaseType) -> bool {+ if database_type == DatabaseType::Neo4j {+ return !crate::cypher_read_only::is_proven_read_only_cypher(sql);+ }// VictoriaMetrics execution is hard-wired to the read-only query API; MetricsQL// does not use SQL verbs and must not be rejected by SQL write classification.if database_type == DatabaseType::VictoriaMetrics {diff --git a/docs/screenshots/neo4j-graph-result.png b/docs/screenshots/neo4j-graph-result.pngnew file mode 100644index 0000000000..411442864fBinary files /dev/null and b/docs/screenshots/neo4j-graph-result.png differ