Extract graph resource ordering

Author: sabino

PLAN.md

@@ -569,7 +569,7 @@ Exit criteria:
 
 - M0 is complete as the Zig `0.16.0` runtime scaffold.
 - M1 has started on stacked branches with native Zig artifact-first parser slices.
-- M1A has started with behavior-preserving `src/project/types.zig`, `src/project/selector.zig`, `src/project/manifest.zig`, `src/project/util.zig`, `src/project/config.zig`, `src/project/fs.zig`, `src/project/jinja.zig`, `src/project/resolve.zig`, and `src/project/parse.zig` extractions. `src/project/manifest.zig` owns selected-resource JSON and partial `manifest.json` writing with native tests for selected JSON shape, JSON escaping, exposure dependency ordering, disabled-resource filtering, and graph-map output. `src/project/util.zig` owns shared display, membership, append-dedup, string sorting, and narrow YAML scalar/list helpers. `src/project/config.zig` owns `dbt_project.yml` loading, project path/docs config parsing, and applying parsed project path/docs configs to graph nodes. `src/project/fs.zig` owns deterministic resource file discovery, Linux directory traversal helpers, and resource path/name helpers. `src/project/jinja.zig` owns lexical Jinja call, parenthesis, quoted string, and literal argument helpers while graph-aware scanning remains in `src/project.zig`. `src/project/resolve.zig` owns graph lookup/count helpers, duplicate resource validation, low-level ref/source resolution helpers, and dependency-map mutation for refs, sources, and known macro dependencies. `src/project/parse.zig` owns narrow parser scalar helpers for YAML booleans, JSON-compatible scalar classification, generic-test YAML item names, generic-test definition construction/cloning, and generic-test identity/name/hash helpers with native tests. `src/project.zig` remains the public parser/list facade and still owns most loader, resource parser, scanner, and resolver orchestration code until follow-up extractions move those pieces behind focused internal modules.
+- M1A has started with behavior-preserving `src/project/types.zig`, `src/project/selector.zig`, `src/project/manifest.zig`, `src/project/util.zig`, `src/project/config.zig`, `src/project/fs.zig`, `src/project/jinja.zig`, `src/project/resolve.zig`, and `src/project/parse.zig` extractions. `src/project/manifest.zig` owns selected-resource JSON and partial `manifest.json` writing with native tests for selected JSON shape, JSON escaping, exposure dependency ordering, disabled-resource filtering, and graph-map output. `src/project/util.zig` owns shared display, membership, append-dedup, string sorting, and narrow YAML scalar/list helpers. `src/project/config.zig` owns `dbt_project.yml` loading, project path/docs config parsing, and applying parsed project path/docs configs to graph nodes. `src/project/fs.zig` owns deterministic resource file discovery, Linux directory traversal helpers, and resource path/name helpers. `src/project/jinja.zig` owns lexical Jinja call, parenthesis, quoted string, and literal argument helpers while graph-aware scanning remains in `src/project.zig`. `src/project/resolve.zig` owns graph lookup/count helpers, canonical graph resource ordering, duplicate resource validation, low-level ref/source resolution helpers, and dependency-map mutation for refs, sources, and known macro dependencies. `src/project/parse.zig` owns narrow parser scalar helpers for YAML booleans, JSON-compatible scalar classification, generic-test YAML item names, generic-test definition construction/cloning, and generic-test identity/name/hash helpers with native tests. `src/project.zig` remains the public parser/list facade and still owns most loader, resource parser, scanner, and resolver orchestration code until follow-up extractions move those pieces behind focused internal modules.
 - `dxt parse` now targets the supported Tier 0 subset: project name/model paths/seed paths/macro paths, project and package model path configs for literal `+materialized`, `+tags`, and model/seed `+docs.node_color`, root-project model config overrides for installed packages, SQL model discovery, CSV seed discovery, installed package SQL model and CSV seed discovery from `dbt_packages`, source discovery, installed package source discovery, exposure discovery, installed package exposure discovery, project macro discovery, installed package macro discovery from `dbt_packages`, macro property YAML for project macro descriptions and arguments, project and package docs block discovery, literal `ref` to models or seeds, two-argument package refs, package-local refs in installed package models and exposures, unique installed-package fallback for unqualified refs, literal `source`, package-local sources in installed package models, unique installed-package fallback for unqualified sources, literal `doc` in project and package descriptions, inline `config(materialized=..., tags=...)`, known project/package-qualified/package-local macro call dependencies, narrow project and package YAML model properties for scalar descriptions, simple columns, tags, materialization, disabled SQL models, dbt-shaped `unique`, `not_null`, `accepted_values`, and `relationships` generic test nodes, model/test `refs` and `sources` artifact fields, dependency maps, and deterministic partial `manifest.json`. The manifest includes the v12 top-level maps needed by the M1 artifact shape and is covered by a pinned local dbt Manifest v12 schema slice. YAML generic test arguments are currently supported for scalar values plus inline and block lists required by public Jaffle Shop DuckDB-style tests.
 - `dxt ls` now lists dbt-selectable resources from the same parser graph with stable text/JSON output and basic name/FQN wildcards, tag wildcards, slash-aware `path:` wildcards, exact `package:`/`package:this`, `source:` wildcards including package-qualified source selectors, `exposure:` wildcards, `resource_type:`, `test_type:generic`, config materialization, comma intersection, whitespace union, multi-argument selector lists, repeated selector flags, leading/trailing `+` graph expansion, and exact exclude filters; macros are emitted in artifacts but not exposed as `ls` resources.
 - Synthetic fixtures cover one model, model refs, seed refs, source refs, exposure refs to models and sources, combined source/model YAML, inline config/tag selection, config materialization selection, comma-intersection selection, YAML model properties and columns, emitted `unique`, `not_null`, `accepted_values`, and `relationships` generic test nodes, project macro artifacts and macro properties, configured `macro-paths` replacing the default macro directory, installed package macros with package-qualified calls and package-local macro calls, installed package models, seeds, sources, docs, exposures, package YAML model properties, root package config overrides, and package-qualified/package-local refs/sources, macro calls recorded in model and macro `depends_on.macros`, docs blocks with literal `doc` descriptions, disabled models, disabled ref diagnostics, unmatched model-property warnings, duplicate model and docs diagnostics, unsupported dynamic ref/doc diagnostics, missing doc diagnostics, malformed docs block diagnostics, unresolved package macro diagnostics, and unsupported unknown macro-call diagnostics.

src/project.zig

@@ -86,6 +86,7 @@ const rejectDuplicateModels = project_resolve.rejectDuplicateModels;
 const rejectDuplicateSeeds = project_resolve.rejectDuplicateSeeds;
 const resolveDependencies = project_resolve.resolveDependencies;
 const resolveRefDependency = project_resolve.resolveRefDependency;
+const sortGraphResources = project_resolve.sortGraphResources;
 
 pub fn parse(runtime: Runtime, options: Options, stdout: *Io.Writer, stderr: *Io.Writer) !void {
     var graph = try loadGraph(runtime, options.project_dir);
@@ -200,12 +201,7 @@ fn loadGraph(runtime: Runtime, project_dir: []const u8) !Graph {
     try applyMacroProperties(&graph);
     try applyModelProperties(&graph, config.name);
     try materializeGenericTests(&graph);
-    sortNodes(graph.nodes.items);
-    sortTests(graph.tests.items);
-    sortSources(graph.sources.items);
-    sortExposures(graph.exposures.items);
-    sortDocs(graph.docs.items);
-    sortMacros(graph.macros.items);
+    sortGraphResources(&graph);
     try rejectDuplicateModels(&graph);
     try rejectDuplicateSeeds(&graph);
     try rejectDuplicateDocs(&graph);
@@ -1430,38 +1426,6 @@ fn sortGenericTestDefs(tests: []GenericTestDef) void {
     }.lessThan);
 }
 
-fn sortNodes(nodes: []Node) void {
-    std.mem.sort(Node, nodes, {}, struct {
-        fn lessThan(_: void, a: Node, b: Node) bool {
-            return std.mem.lessThan(u8, a.unique_id, b.unique_id);
-        }
-    }.lessThan);
-}
-
-fn sortTests(tests: []GenericTestNode) void {
-    std.mem.sort(GenericTestNode, tests, {}, struct {
-        fn lessThan(_: void, a: GenericTestNode, b: GenericTestNode) bool {
-            return std.mem.lessThan(u8, a.unique_id, b.unique_id);
-        }
-    }.lessThan);
-}
-
-fn sortSources(sources: []SourceDef) void {
-    std.mem.sort(SourceDef, sources, {}, struct {
-        fn lessThan(_: void, a: SourceDef, b: SourceDef) bool {
-            return std.mem.lessThan(u8, a.unique_id, b.unique_id);
-        }
-    }.lessThan);
-}
-
-fn sortExposures(exposures: []ExposureDef) void {
-    std.mem.sort(ExposureDef, exposures, {}, struct {
-        fn lessThan(_: void, a: ExposureDef, b: ExposureDef) bool {
-            return std.mem.lessThan(u8, a.unique_id, b.unique_id);
-        }
-    }.lessThan);
-}
-
 fn sortMetaEntries(entries: []MetaEntry) void {
     std.mem.sort(MetaEntry, entries, {}, struct {
         fn lessThan(_: void, a: MetaEntry, b: MetaEntry) bool {
@@ -1470,22 +1434,6 @@ fn sortMetaEntries(entries: []MetaEntry) void {
     }.lessThan);
 }
 
-fn sortDocs(docs: []DocBlock) void {
-    std.mem.sort(DocBlock, docs, {}, struct {
-        fn lessThan(_: void, a: DocBlock, b: DocBlock) bool {
-            return std.mem.lessThan(u8, a.unique_id, b.unique_id);
-        }
-    }.lessThan);
-}
-
-fn sortMacros(macros: []MacroDef) void {
-    std.mem.sort(MacroDef, macros, {}, struct {
-        fn lessThan(_: void, a: MacroDef, b: MacroDef) bool {
-            return std.mem.lessThan(u8, a.unique_id, b.unique_id);
-        }
-    }.lessThan);
-}
-
 fn sortColumns(columns: []ColumnDef) void {
     std.mem.sort(ColumnDef, columns, {}, struct {
         fn lessThan(_: void, a: ColumnDef, b: ColumnDef) bool {

src/project/resolve.zig

@@ -3,9 +3,14 @@ const types = @import("types.zig");
 const util = @import("util.zig");
 
 const DocBlock = types.DocBlock;
+const ExposureDef = types.ExposureDef;
+const GenericTestNode = types.GenericTestNode;
 const Graph = types.Graph;
+const MacroDef = types.MacroDef;
+const Node = types.Node;
 const RefDep = types.RefDep;
 const SourceDep = types.SourceDep;
+const SourceDef = types.SourceDef;
 
 const appendUnique = util.appendUnique;
 const sortStrings = util.sortStrings;
@@ -141,6 +146,15 @@ pub fn resolveDependencies(graph: *Graph) !void {
     }
 }
 
+pub fn sortGraphResources(graph: *Graph) void {
+    sortNodes(graph.nodes.items);
+    sortTests(graph.tests.items);
+    sortSources(graph.sources.items);
+    sortExposures(graph.exposures.items);
+    sortDocs(graph.docs.items);
+    sortMacros(graph.macros.items);
+}
+
 pub fn rejectDuplicateModels(graph: *const Graph) !void {
     var i: usize = 0;
     while (i < graph.nodes.items.len) : (i += 1) {
@@ -253,6 +267,54 @@ fn resolveRefInPackage(graph: *const Graph, package: []const u8, name: []const u
     return null;
 }
 
+fn sortNodes(nodes: []Node) void {
+    std.mem.sort(Node, nodes, {}, struct {
+        fn lessThan(_: void, a: Node, b: Node) bool {
+            return std.mem.lessThan(u8, a.unique_id, b.unique_id);
+        }
+    }.lessThan);
+}
+
+fn sortTests(tests: []GenericTestNode) void {
+    std.mem.sort(GenericTestNode, tests, {}, struct {
+        fn lessThan(_: void, a: GenericTestNode, b: GenericTestNode) bool {
+            return std.mem.lessThan(u8, a.unique_id, b.unique_id);
+        }
+    }.lessThan);
+}
+
+fn sortSources(sources: []SourceDef) void {
+    std.mem.sort(SourceDef, sources, {}, struct {
+        fn lessThan(_: void, a: SourceDef, b: SourceDef) bool {
+            return std.mem.lessThan(u8, a.unique_id, b.unique_id);
+        }
+    }.lessThan);
+}
+
+fn sortExposures(exposures: []ExposureDef) void {
+    std.mem.sort(ExposureDef, exposures, {}, struct {
+        fn lessThan(_: void, a: ExposureDef, b: ExposureDef) bool {
+            return std.mem.lessThan(u8, a.unique_id, b.unique_id);
+        }
+    }.lessThan);
+}
+
+fn sortDocs(docs: []DocBlock) void {
+    std.mem.sort(DocBlock, docs, {}, struct {
+        fn lessThan(_: void, a: DocBlock, b: DocBlock) bool {
+            return std.mem.lessThan(u8, a.unique_id, b.unique_id);
+        }
+    }.lessThan);
+}
+
+fn sortMacros(macros: []MacroDef) void {
+    std.mem.sort(MacroDef, macros, {}, struct {
+        fn lessThan(_: void, a: MacroDef, b: MacroDef) bool {
+            return std.mem.lessThan(u8, a.unique_id, b.unique_id);
+        }
+    }.lessThan);
+}
+
 fn findProjectMacroIdByName(graph: *const Graph, name: []const u8) ?[]const u8 {
     return findMacroIdByPackageAndName(graph, graph.project_name, name);
 }
@@ -467,3 +529,58 @@ test "dependency resolution rejects unresolved macro dependencies" {
 
     try std.testing.expectError(error.UnresolvedMacro, resolveDependencies(&graph));
 }
+
+test "graph resource sorting preserves deterministic unique id order" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    var graph = Graph{ .allocator = arena.allocator(), .project_name = "demo" };
+    defer graph.deinit();
+
+    try appendNode(&graph, "model", "demo", "model.demo.z_orders", "z_orders", true);
+    try appendNode(&graph, "model", "demo", "model.demo.a_customers", "a_customers", true);
+    try graph.tests.append(graph.allocator, .{
+        .package_name = "demo",
+        .unique_id = "test.demo.z_test.2222222222",
+        .name = "z_test",
+        .alias = "z_test",
+        .path = "",
+        .original_file_path = "",
+        .raw_code = "",
+        .test_name = "unique",
+        .attached_node = "model.demo.z_orders",
+    });
+    try graph.tests.append(graph.allocator, .{
+        .package_name = "demo",
+        .unique_id = "test.demo.a_test.1111111111",
+        .name = "a_test",
+        .alias = "a_test",
+        .path = "",
+        .original_file_path = "",
+        .raw_code = "",
+        .test_name = "not_null",
+        .attached_node = "model.demo.a_customers",
+    });
+    try appendSource(&graph, "demo", "raw", "z_orders");
+    try appendSource(&graph, "demo", "raw", "a_customers");
+    try graph.exposures.append(graph.allocator, .{ .package_name = "demo", .unique_id = "exposure.demo.z_dashboard", .name = "z_dashboard", .path = "", .original_file_path = "" });
+    try graph.exposures.append(graph.allocator, .{ .package_name = "demo", .unique_id = "exposure.demo.a_dashboard", .name = "a_dashboard", .path = "", .original_file_path = "" });
+    try graph.docs.append(graph.allocator, .{ .package_name = "demo", .unique_id = "doc.demo.z_doc", .name = "z_doc", .path = "", .original_file_path = "", .block_contents = "" });
+    try graph.docs.append(graph.allocator, .{ .package_name = "demo", .unique_id = "doc.demo.a_doc", .name = "a_doc", .path = "", .original_file_path = "", .block_contents = "" });
+    try appendMacro(&graph, "demo", "z_macro");
+    try appendMacro(&graph, "demo", "a_macro");
+
+    sortGraphResources(&graph);
+
+    try std.testing.expectEqualStrings("model.demo.a_customers", graph.nodes.items[0].unique_id);
+    try std.testing.expectEqualStrings("model.demo.z_orders", graph.nodes.items[1].unique_id);
+    try std.testing.expectEqualStrings("test.demo.a_test.1111111111", graph.tests.items[0].unique_id);
+    try std.testing.expectEqualStrings("test.demo.z_test.2222222222", graph.tests.items[1].unique_id);
+    try std.testing.expectEqualStrings("source.demo.raw.a_customers", graph.sources.items[0].unique_id);
+    try std.testing.expectEqualStrings("source.demo.raw.z_orders", graph.sources.items[1].unique_id);
+    try std.testing.expectEqualStrings("exposure.demo.a_dashboard", graph.exposures.items[0].unique_id);
+    try std.testing.expectEqualStrings("exposure.demo.z_dashboard", graph.exposures.items[1].unique_id);
+    try std.testing.expectEqualStrings("doc.demo.a_doc", graph.docs.items[0].unique_id);
+    try std.testing.expectEqualStrings("doc.demo.z_doc", graph.docs.items[1].unique_id);
+    try std.testing.expectEqualStrings("macro.demo.a_macro", graph.macros.items[0].unique_id);
+    try std.testing.expectEqualStrings("macro.demo.z_macro", graph.macros.items[1].unique_id);
+}