tiny.smg.storage.context

1const std = @import("std");2const sql = @import("sql");3const sys = @import("sys");4const smg = @import("../root.zig");5const storage = smg.storage;6const database = storage.database;7const store = storage.store;8const sync = storage.sync;910const graph_mod = smg.graph;11const model = smg.model;12const name_mod = smg.name;13const view = smg.view;1415pub const NameResolution = union(enum) {16    resolved: []const u8,17    missing: []const []const u8,18    ambiguous: []const []const u8,19};2021pub const NodeContext = struct {22    node: model.Node,23    incoming: []const model.Edge,24    outgoing: []const model.Edge,25    path: []const []const u8,26};2728const EdgeContext = struct {29    incoming: []const model.Edge,30    outgoing: []const model.Edge,31    path: []const []const u8,32};3334pub fn resolveNodeName(allocator: std.mem.Allocator, root: []const u8, raw: []const u8, limits: smg.Limits) !NameResolution {35    var opened = try store.openRead(allocator, root, limits.storage);36    defer opened.close();37    return try resolveNodeNameFromReader(allocator, root, &opened.reader, raw, limits.suggestions);38}3940pub fn resolveNodeNameFromReader(41    allocator: std.mem.Allocator,42    root: []const u8,43    reader: *database.Reader,44    raw: []const u8,45    limits: smg.SuggestionLimits,46) !NameResolution {47    var handle = try reader.catalog.openRelation(reader.allocator, storage.rows.nodes_relation);48    defer handle.deinit();49    const slot = indexSlot(&handle, storage.rows.node_name_index) orelse50        return error.StorageIndexMissing;51    if (try exactNodeName(allocator, reader.allocator, &handle, slot, raw)) |exact| {52        return .{ .resolved = exact };53    }54    const translated = try name_mod.dottedFromPath(allocator, raw);55    defer if (translated) |name| allocator.free(name);56    var translated_exact = if (translated) |name|57        try exactNodeName(allocator, reader.allocator, &handle, slot, name)58    else59        null;60    defer if (translated_exact) |name| allocator.free(name);6162    var candidates = try CandidateNames.init(63        allocator,64        raw,65        translated,66        translated_exact == null,67        limits,68    );69    defer candidates.deinit();70    var projection_ready = true;71    storage.names.scan(allocator, root, reader.head, &candidates) catch |err| switch (err) {72        error.OutOfMemory => return err,73        else => projection_ready = false,74    };75    if (!projection_ready) {76        const replacement = try CandidateNames.init(77            allocator,78            raw,79            translated,80            translated_exact == null,81            limits,82        );83        candidates.deinit();84        candidates = replacement;85        try scanIndexedNames(reader.allocator, &handle, slot, &candidates);86    }87    return try candidates.take(&translated_exact);88}8990fn scanIndexedNames(91    allocator: std.mem.Allocator,92    handle: anytype,93    slot: usize,94    candidates: *CandidateNames,95) !void {96    var scan: sql.IndexScan = undefined;97    try handle.relation.indexScan(&scan, allocator, slot, null, null);98    defer scan.deinit();99    var values: [1]sql.row.Value = undefined;100    var key_scratch: [sql.page.size]u8 = undefined;101    while (try scan.next()) |entry| {102        const name = try storage.names.indexedName(&values, &key_scratch, entry.key);103        try candidates.visit(name);104    }105}106107fn exactNodeName(108    allocator: std.mem.Allocator,109    scratch: std.mem.Allocator,110    handle: anytype,111    slot: usize,112    name: []const u8,113) !?[]const u8 {114    var lookup: sql.IndexScan = undefined;115    try handle.relation.lookup(&lookup, scratch, slot, &.{.{ .text = name }});116    defer lookup.deinit();117    const entry = (try lookup.next()) orelse return null;118    var values: [1]sql.row.Value = undefined;119    var key_scratch: [sql.page.size]u8 = undefined;120    const indexed_name = try storage.names.indexedName(&values, &key_scratch, entry.key);121    return try allocator.dupe(u8, indexed_name);122}123124fn nodeByName(allocator: std.mem.Allocator, scratch: std.mem.Allocator, handle: anytype, name: []const u8) !?model.Node {125    const rowid = (try firstIndexedRowid(scratch, handle, storage.rows.node_name_index, name)) orelse return null;126    const bytes = (try handle.relation.get(allocator, rowid)) orelse return error.StorageIndexCorrupt;127    defer allocator.free(bytes);128    return (try storage.rows.decodeNodeRow(allocator, rowid, bytes)).node;129}130131fn firstIndexedRowid(scratch: std.mem.Allocator, handle: anytype, index_name: []const u8, value: []const u8) !?i64 {132    const slot = indexSlot(handle, index_name) orelse return error.StorageIndexMissing;133    var lookup: sql.IndexScan = undefined;134    try handle.relation.lookup(&lookup, scratch, slot, &.{.{ .text = value }});135    defer lookup.deinit();136    const entry = (try lookup.next()) orelse return null;137    return entry.rowid;138}139140fn indexSlot(handle: anytype, name: []const u8) ?usize {141    for (handle.index_definitions, 0..) |definition, slot| {142        if (std.mem.eql(u8, definition.name, name)) return slot;143    }144    return null;145}146147fn freeNames(allocator: std.mem.Allocator, names: []const []const u8) void {148    for (names) |name| allocator.free(name);149    if (names.len != 0) allocator.free(names);150}151152const CandidateNames = struct {153    allocator: std.mem.Allocator,154    raw: []const u8,155    fallback_query: []const u8,156    translated: bool,157    include_fallback: bool,158    limits: smg.SuggestionLimits,159    suffixes: OwnedNames = .{},160    fallback_suffixes: OwnedNames = .{},161    subsequences: OwnedNames = .{},162    suggestions: Suggestions,163164    fn init(165        allocator: std.mem.Allocator,166        raw: []const u8,167        translated: ?[]const u8,168        include_fallback: bool,169        limits: smg.SuggestionLimits,170    ) !CandidateNames {171        return .{172            .allocator = allocator,173            .raw = raw,174            .fallback_query = translated orelse raw,175            .translated = translated != null,176            .include_fallback = include_fallback,177            .limits = limits,178            .suggestions = try Suggestions.init(allocator, raw, limits),179        };180    }181182    pub fn visit(self: *CandidateNames, name: []const u8) std.mem.Allocator.Error!void {183        if (name_mod.matchesSuffix(name, self.raw)) {184            try self.suffixes.append(self.allocator, name, null);185        }186        if (!self.include_fallback) return;187        if (self.translated and name_mod.matchesSuffix(name, self.fallback_query)) {188            try self.fallback_suffixes.append(189                self.allocator,190                name,191                self.limits.fallback_match_count,192            );193        }194        if (name_mod.matchesSubsequence(name, self.fallback_query)) {195            try self.subsequences.append(196                self.allocator,197                name,198                self.limits.fallback_match_count,199            );200        }201        if (!std.mem.eql(u8, name, self.raw)) {202            try self.suggestions.consider(self.allocator, name);203        }204    }205206    fn take(207        self: *CandidateNames,208        translated_exact: *?[]const u8,209    ) !NameResolution {210        if (self.suffixes.items.items.len != 0) {211            return try self.suffixes.takeResolution(self.allocator);212        }213        if (translated_exact.*) |name| {214            translated_exact.* = null;215            return .{ .resolved = name };216        }217        if (self.fallback_suffixes.items.items.len != 0) {218            return try self.fallback_suffixes.takeResolution(self.allocator);219        }220        if (self.subsequences.items.items.len != 0) {221            return try self.subsequences.takeResolution(self.allocator);222        }223        return .{ .missing = try self.suggestions.take(self.allocator) };224    }225226    fn deinit(self: *CandidateNames) void {227        self.suffixes.deinit(self.allocator);228        self.fallback_suffixes.deinit(self.allocator);229        self.subsequences.deinit(self.allocator);230        self.suggestions.deinit(self.allocator);231        self.* = undefined;232    }233};234235const OwnedNames = struct {236    items: std.ArrayList([]const u8) = .empty,237    overflowed: bool = false,238239    fn append(240        self: *OwnedNames,241        allocator: std.mem.Allocator,242        name: []const u8,243        limit: ?usize,244    ) !void {245        if (self.overflowed) return;246        if (limit) |maximum| {247            if (self.items.items.len == maximum) {248                self.clear(allocator);249                self.overflowed = true;250                return;251            }252        }253        const owned = try allocator.dupe(u8, name);254        errdefer allocator.free(owned);255        try self.items.append(allocator, owned);256    }257258    fn takeResolution(259        self: *OwnedNames,260        allocator: std.mem.Allocator,261    ) !NameResolution {262        std.debug.assert(self.items.items.len != 0);263        std.mem.sort([]const u8, self.items.items, {}, stringLess);264        if (self.items.items.len == 1) {265            const name = self.items.items[0];266            self.items.deinit(allocator);267            self.items = .empty;268            return .{ .resolved = name };269        }270        const names = try self.items.toOwnedSlice(allocator);271        self.items = .empty;272        return .{ .ambiguous = names };273    }274275    fn clear(self: *OwnedNames, allocator: std.mem.Allocator) void {276        for (self.items.items) |name| allocator.free(name);277        self.items.clearRetainingCapacity();278    }279280    fn deinit(self: *OwnedNames, allocator: std.mem.Allocator) void {281        self.clear(allocator);282        self.items.deinit(allocator);283        self.* = .{};284    }285};286287const SuggestedName = struct {288    name: []const u8,289    rank: view.SuggestionRank,290};291292const Suggestions = struct {293    query: ?view.SuggestionQuery,294    items: []SuggestedName,295    count: usize = 0,296297    fn init(allocator: std.mem.Allocator, raw: []const u8, limits: smg.SuggestionLimits) !Suggestions {298        const items = try allocator.alloc(SuggestedName, limits.displayed_name_count);299        errdefer allocator.free(items);300        return .{301            .query = try view.SuggestionQuery.init(allocator, raw, limits),302            .items = items,303        };304    }305306    fn consider(307        self: *Suggestions,308        allocator: std.mem.Allocator,309        name: []const u8,310    ) !void {311        const query = if (self.query) |*query| query else return;312        const rank = query.rank(name) orelse return;313        const candidate = SuggestedName{ .name = name, .rank = rank };314        if (self.count == self.items.len and315            !suggestedNameLess({}, candidate, self.items[self.count - 1]))316        {317            return;318        }319        const owned = try allocator.dupe(u8, name);320        if (self.count == self.items.len) {321            allocator.free(self.items[self.count - 1].name);322            self.items[self.count - 1] = .{ .name = owned, .rank = rank };323        } else {324            self.items[self.count] = .{ .name = owned, .rank = rank };325            self.count += 1;326        }327        std.mem.sort(SuggestedName, self.items[0..self.count], {}, suggestedNameLess);328    }329330    fn take(self: *Suggestions, allocator: std.mem.Allocator) ![]const []const u8 {331        if (self.count == 0) return &.{};332        const names = try allocator.alloc([]const u8, self.count);333        for (self.items[0..self.count], 0..) |entry, index| names[index] = entry.name;334        self.count = 0;335        return names;336    }337338    fn deinit(self: *Suggestions, allocator: std.mem.Allocator) void {339        for (self.items[0..self.count]) |entry| allocator.free(entry.name);340        if (self.query) |*query| query.deinit();341        allocator.free(self.items);342        self.* = undefined;343    }344};345346fn suggestedNameLess(_: void, a: SuggestedName, b: SuggestedName) bool {347    return view.suggestionLessThan(a.name, a.rank, b.name, b.rank);348}349350pub fn load(allocator: std.mem.Allocator, root: []const u8, name: []const u8, include_edges: bool, limits: smg.StorageLimits) !NodeContext {351    var opened = try store.openRead(allocator, root, limits);352    defer opened.close();353    return try loadFromReader(allocator, &opened.reader, name, include_edges);354}355356pub fn loadFromReader(allocator: std.mem.Allocator, reader: *database.Reader, name: []const u8, include_edges: bool) !NodeContext {357    var node_handle = try reader.catalog.openRelation(reader.allocator, storage.rows.nodes_relation);358    defer node_handle.deinit();359    var loaded_node = (try nodeByName(allocator, reader.allocator, &node_handle, name)) orelse return error.NodeNotFound;360    errdefer model.deinitNode(&loaded_node, allocator);361    if (!include_edges) return .{362        .node = loaded_node,363        .incoming = &.{},364        .outgoing = &.{},365        .path = &.{},366    };367368    const edges = try loadEdges(allocator, reader, name);369    return .{370        .node = loaded_node,371        .incoming = edges.incoming,372        .outgoing = edges.outgoing,373        .path = edges.path,374    };375}376377pub fn loadNodes(allocator: std.mem.Allocator, root: []const u8, names: []const []const u8, limits: smg.StorageLimits) ![]model.Node {378    var opened = try store.openRead(allocator, root, limits);379    defer opened.close();380    return try loadNodesFromReader(allocator, &opened.reader, names);381}382383pub fn loadNodesFromReader(allocator: std.mem.Allocator, reader: *database.Reader, names: []const []const u8) ![]model.Node {384    var handle = try reader.catalog.openRelation(reader.allocator, storage.rows.nodes_relation);385    defer handle.deinit();386    var loaded: std.ArrayList(model.Node) = .empty;387    errdefer {388        for (loaded.items) |*node| model.deinitNode(node, allocator);389        loaded.deinit(allocator);390    }391    for (names) |name| {392        if (findNode(loaded.items, name) != null) continue;393        if (try nodeByName(allocator, reader.allocator, &handle, name)) |node| try loaded.append(allocator, node);394    }395    return try loaded.toOwnedSlice(allocator);396}397398fn findNode(loaded: []const model.Node, name: []const u8) ?model.Node {399    for (loaded) |node| {400        if (std.mem.eql(u8, node.name, name)) return node;401    }402    return null;403}404405fn loadEdges(allocator: std.mem.Allocator, reader: *database.Reader, name: []const u8) !EdgeContext {406    var handle = try reader.catalog.openRelation(reader.allocator, storage.rows.edges_relation);407    defer handle.deinit();408    const incoming = try edgesByIndex(allocator, reader.allocator, &handle, storage.rows.edge_target_index, name);409    const outgoing = try edgesByIndex(allocator, reader.allocator, &handle, storage.rows.edge_source_index, name);410    std.mem.sort(model.Edge, incoming, {}, storedIncomingLess);411    std.mem.sort(model.Edge, outgoing, {}, storedOutgoingLess);412    return .{413        .incoming = incoming,414        .outgoing = outgoing,415        .path = try storedContainmentPath(allocator, reader.allocator, &handle, name),416    };417}418419fn stringLess(_: void, a: []const u8, b: []const u8) bool {420    return std.mem.lessThan(u8, a, b);421}422423fn storedIncomingLess(_: void, a: model.Edge, b: model.Edge) bool {424    const rel = std.mem.order(u8, a.rel, b.rel);425    if (rel != .eq) return rel == .lt;426    return std.mem.lessThan(u8, a.source, b.source);427}428429fn storedOutgoingLess(_: void, a: model.Edge, b: model.Edge) bool {430    const rel = std.mem.order(u8, a.rel, b.rel);431    if (rel != .eq) return rel == .lt;432    return std.mem.lessThan(u8, a.target, b.target);433}434435fn edgesByIndex(allocator: std.mem.Allocator, scratch: std.mem.Allocator, handle: anytype, index_name: []const u8, value: []const u8) ![]model.Edge {436    const slot = indexSlot(handle, index_name) orelse return error.StorageIndexMissing;437    var lookup: sql.IndexScan = undefined;438    try handle.relation.lookup(&lookup, scratch, slot, &.{.{ .text = value }});439    defer lookup.deinit();440    var edges: std.ArrayList(model.Edge) = .empty;441    errdefer {442        for (edges.items) |*edge| model.deinitEdge(edge, allocator);443        edges.deinit(allocator);444    }445    while (try lookup.next()) |entry| {446        const bytes = (try handle.relation.get(allocator, entry.rowid)) orelse return error.StorageIndexCorrupt;447        const decoded = storage.rows.decodeEdgeRow(allocator, entry.rowid, bytes) catch |err| {448            allocator.free(bytes);449            return err;450        };451        allocator.free(bytes);452        edges.append(allocator, decoded.edge) catch |err| {453            var edge = decoded.edge;454            model.deinitEdge(&edge, allocator);455            return err;456        };457    }458    return try edges.toOwnedSlice(allocator);459}460461fn parentForTarget(allocator: std.mem.Allocator, scratch: std.mem.Allocator, handle: anytype, target: []const u8) !?[]const u8 {462    const slot = indexSlot(handle, storage.rows.edge_target_index) orelse return error.StorageIndexMissing;463    var lookup: sql.IndexScan = undefined;464    try handle.relation.lookup(&lookup, scratch, slot, &.{.{ .text = target }});465    defer lookup.deinit();466    var best: ?[]const u8 = null;467    errdefer if (best) |name| allocator.free(name);468    while (try lookup.next()) |entry| {469        const bytes = (try handle.relation.get(allocator, entry.rowid)) orelse return error.StorageIndexCorrupt;470        const relation = storage.rows.edgeRelView(bytes) catch |err| {471            allocator.free(bytes);472            return err;473        };474        if (!std.mem.eql(u8, relation, model.RelType.contains)) {475            allocator.free(bytes);476            continue;477        }478        const source = storage.rows.edgeSourceView(bytes) catch |err| {479            allocator.free(bytes);480            return err;481        };482        if (best == null or std.mem.lessThan(u8, source, best.?)) {483            const owned = try allocator.dupe(u8, source);484            if (best) |previous| allocator.free(previous);485            best = owned;486        }487        allocator.free(bytes);488    }489    return best;490}491492fn containsName(names: []const []const u8, target: []const u8) bool {493    for (names) |name| {494        if (std.mem.eql(u8, name, target)) return true;495    }496    return false;497}498499fn storedContainmentPath(allocator: std.mem.Allocator, scratch: std.mem.Allocator, handle: anytype, name: []const u8) ![]const []const u8 {500    var reversed: std.ArrayList([]const u8) = .empty;501    errdefer {502        for (reversed.items) |entry| allocator.free(entry);503        reversed.deinit(allocator);504    }505    try reversed.append(allocator, try allocator.dupe(u8, name));506    var current = name;507    while (try parentForTarget(allocator, scratch, handle, current)) |parent| {508        if (containsName(reversed.items, parent)) {509            allocator.free(parent);510            break;511        }512        try reversed.append(allocator, parent);513        current = parent;514    }515    std.mem.reverse([]const u8, reversed.items);516    return try reversed.toOwnedSlice(allocator);517}518519test "resolve node name finds exact suffix ambiguous and missing matches" {520    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);521    defer arena.deinit();522    const allocator = arena.allocator();523    const root = try testRoot(allocator, 0);524    defer sys.fs.deleteTree(root) catch {};525    try initStore(allocator, root);526    var stored = graph_mod.init(allocator);527    for ([_][]const u8{ "app", "app.helper", "app.main", "lib.main", "lib.pkg.src.core.merge" }) |name| try graph_mod.addNode(&stored, .{ .name = name, .type = model.NodeType.module });528    try saveGraph(allocator, stored, root);529530    const exact = try resolveNodeName(allocator, root, "app.main", smg.default_limits);531    try std.testing.expectEqualStrings("app.main", exact.resolved);532    const suffix = try resolveNodeName(allocator, root, "helper", smg.default_limits);533    try std.testing.expectEqualStrings("app.helper", suffix.resolved);534    const missing = try resolveNodeName(allocator, root, "absent", smg.default_limits);535    try std.testing.expectEqual(@as(usize, 0), missing.missing.len);536    const typo = try resolveNodeName(allocator, root, "app.mian", smg.default_limits);537    try std.testing.expect(typo.missing.len >= 1);538    try std.testing.expectEqualStrings("app.main", typo.missing[0]);539    const ambiguous = try resolveNodeName(allocator, root, "main", smg.default_limits);540    try std.testing.expectEqual(@as(usize, 2), ambiguous.ambiguous.len);541    try std.testing.expectEqualStrings("app.main", ambiguous.ambiguous[0]);542    try std.testing.expectEqualStrings("lib.main", ambiguous.ambiguous[1]);543    const path = try resolveNodeName(allocator, root, "lib/pkg/src/core/merge.zig", smg.default_limits);544    try std.testing.expectEqualStrings("lib.pkg.src.core.merge", path.resolved);545    const subsequence = try resolveNodeName(allocator, root, "pkg.core.merge", smg.default_limits);546    try std.testing.expectEqualStrings("lib.pkg.src.core.merge", subsequence.resolved);547    const path_missing = try resolveNodeName(allocator, root, "pkg/main.zig", smg.default_limits);548    try std.testing.expect(path_missing.missing.len >= 2);549    try std.testing.expectEqualStrings("app.main", path_missing.missing[0]);550}551552const NameCount = struct {553    count: usize = 0,554555    pub fn visit(self: *NameCount, _: []const u8) std.mem.Allocator.Error!void {556        self.count += 1;557    }558};559560test "name projection preserves index fallback resolutions" {561    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);562    defer arena.deinit();563    const allocator = arena.allocator();564    const root = try testRoot(allocator, 4);565    defer sys.fs.deleteTree(root) catch {};566    try initStore(allocator, root);567    var stored = graph_mod.init(allocator);568    for ([_][]const u8{569        "app",570        "app.helper",571        "app.main",572        "lib.main",573        "lib.pkg.src.core.merge",574    }) |name| {575        try graph_mod.addNode(576            &stored,577            .{ .name = name, .type = model.NodeType.module },578        );579    }580    try saveGraph(allocator, stored, root);581    try writeNameProjection(allocator, root);582    var opened = try store.openRead(allocator, root, smg.default_limits.storage);583    defer opened.close();584    try std.testing.expect(try storage.names.matchesHead(585        allocator,586        root,587        opened.reader.head,588    ));589    var counted = NameCount{};590    try storage.names.scan(allocator, root, opened.reader.head, &counted);591    try std.testing.expectEqual(@as(usize, 5), counted.count);592    try expectProjectionMatchesFallback(allocator, root, &opened.reader);593}594595fn expectProjectionMatchesFallback(596    allocator: std.mem.Allocator,597    root: []const u8,598    reader: *database.Reader,599) !void {600    const queries = [_][]const u8{601        "app.main",602        "helper",603        "absent",604        "app.mian",605        "main",606        "lib/pkg/src/core/merge.zig",607        "pkg.core.merge",608    };609    var projected: [queries.len]NameResolution = undefined;610    for (queries, 0..) |query, index| {611        projected[index] = try resolveNodeNameFromReader(612            allocator,613            root,614            reader,615            query,616            smg.default_limits.suggestions,617        );618    }619    const projection_path = try std.fs.path.join(620        allocator,621        &.{ root, storage.paths.smg_dir_name, storage.names.file_name },622    );623    const hidden_path = try std.fmt.allocPrint(624        allocator,625        "{s}.hidden",626        .{projection_path},627    );628    try sys.fs.rename(projection_path, hidden_path);629    var hidden = true;630    defer if (hidden) sys.fs.rename(hidden_path, projection_path) catch {};631    for (queries, projected) |query, expected| {632        const fallback = try resolveNodeNameFromReader(633            allocator,634            root,635            reader,636            query,637            smg.default_limits.suggestions,638        );639        try expectNameResolutionEqual(expected, fallback);640    }641    try sys.fs.rename(hidden_path, projection_path);642    hidden = false;643}644645fn expectNameResolutionEqual(expected: NameResolution, actual: NameResolution) !void {646    try std.testing.expectEqual(647        std.meta.activeTag(expected),648        std.meta.activeTag(actual),649    );650    switch (expected) {651        .resolved => |name| try std.testing.expectEqualStrings(name, actual.resolved),652        .missing => |names| try expectNameSlicesEqual(names, actual.missing),653        .ambiguous => |names| try expectNameSlicesEqual(names, actual.ambiguous),654    }655}656657fn expectNameSlicesEqual(expected: []const []const u8, actual: []const []const u8) !void {658    try std.testing.expectEqual(expected.len, actual.len);659    for (expected, actual) |expected_name, actual_name| {660        try std.testing.expectEqualStrings(expected_name, actual_name);661    }662}663664test "streamed suggestions preserve batch ranking" {665    const allocator = std.testing.allocator;666    const names = [_][]const u8{667        "zeta.mark_status",668        "epsilon.mark_status",669        "delta.mark_status",670        "gamma.mark_status",671        "beta.mark_status",672        "alpha.mark_status",673        "eta.mark_status",674    };675    const expected = try view.suggest(676        allocator,677        &names,678        "markstatus",679        smg.default_limits.suggestions.displayed_name_count,680        smg.default_limits.suggestions,681    );682    defer allocator.free(expected);683    var streamed = try Suggestions.init(allocator, "markstatus", smg.default_limits.suggestions);684    defer streamed.deinit(allocator);685    for (names) |name| try streamed.consider(allocator, name);686    const actual = try streamed.take(allocator);687    defer freeNames(allocator, actual);688    try std.testing.expectEqual(expected.len, actual.len);689    for (expected, actual) |expected_name, actual_name| {690        try std.testing.expectEqualStrings(expected_name, actual_name);691    }692}693694fn deinitNameResolution(allocator: std.mem.Allocator, resolution: NameResolution) void {695    switch (resolution) {696        .resolved => |name| allocator.free(name),697        .missing, .ambiguous => |names| freeNames(allocator, names),698    }699}700701fn checkResolveFallbackAllocationFailures(702    allocator: std.mem.Allocator,703    root: []const u8,704    reader: *database.Reader,705) !void {706    const resolution = try resolveNodeNameFromReader(707        allocator,708        root,709        reader,710        "app.mian",711        smg.default_limits.suggestions,712    );713    defer deinitNameResolution(allocator, resolution);714    try std.testing.expectEqualStrings("app.main", resolution.missing[0]);715}716717test "resolve node name cleans every fallback allocation failure" {718    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);719    defer arena.deinit();720    const allocator = arena.allocator();721    const root = try testRoot(allocator, 2);722    defer sys.fs.deleteTree(root) catch {};723    try initStore(allocator, root);724    var stored = graph_mod.init(allocator);725    try graph_mod.addNode(726        &stored,727        .{ .name = "app.main", .type = model.NodeType.module },728    );729    try saveGraph(allocator, stored, root);730    var opened = try store.openRead(allocator, root, smg.default_limits.storage);731    defer opened.close();732733    try std.testing.checkAllAllocationFailures(734        std.testing.allocator,735        checkResolveFallbackAllocationFailures,736        .{ root, &opened.reader },737    );738}739740test "load node context returns shallow edges and containment path" {741    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);742    defer arena.deinit();743    const allocator = arena.allocator();744    const root = try testRoot(allocator, 1);745    defer sys.fs.deleteTree(root) catch {};746    try initStore(allocator, root);747    var stored = graph_mod.init(allocator);748    try graph_mod.addNode(&stored, .{ .name = "app", .type = model.NodeType.module });749    try graph_mod.addNode(&stored, .{ .name = "app.main", .type = model.NodeType.function, .file = "src/app.zig", .line = 7 });750    try graph_mod.addNode(&stored, .{ .name = "app.helper", .type = model.NodeType.function });751    try graph_mod.addNode(&stored, .{ .name = "lib.util", .type = model.NodeType.function });752    try graph_mod.addEdge(&stored, .{ .source = "app", .target = "app.main", .rel = model.RelType.contains });753    try graph_mod.addEdge(&stored, .{ .source = "lib.util", .target = "app.main", .rel = model.RelType.calls });754    try graph_mod.addEdge(&stored, .{ .source = "app.main", .target = "app.helper", .rel = model.RelType.imports });755    try saveGraph(allocator, stored, root);756757    const shallow = try load(allocator, root, "app.main", false, smg.default_limits.storage);758    try std.testing.expectEqualStrings("app.main", shallow.node.name);759    try std.testing.expectEqual(@as(usize, 0), shallow.incoming.len);760    try std.testing.expectEqual(@as(usize, 0), shallow.outgoing.len);761    try std.testing.expectEqual(@as(usize, 0), shallow.path.len);762763    const loaded = try load(allocator, root, "app.main", true, smg.default_limits.storage);764    try std.testing.expectEqualStrings("app.main", loaded.node.name);765    try std.testing.expectEqualStrings("src/app.zig", loaded.node.file.?);766    try std.testing.expectEqual(@as(?i64, 7), loaded.node.line);767    try std.testing.expectEqual(@as(usize, 2), loaded.incoming.len);768    try std.testing.expectEqualStrings(model.RelType.calls, loaded.incoming[0].rel);769    try std.testing.expectEqualStrings(model.RelType.contains, loaded.incoming[1].rel);770    try std.testing.expectEqual(@as(usize, 1), loaded.outgoing.len);771    try std.testing.expectEqualStrings(model.RelType.imports, loaded.outgoing[0].rel);772    try std.testing.expectEqual(@as(usize, 2), loaded.path.len);773    try std.testing.expectEqualStrings("app", loaded.path[0]);774    try std.testing.expectEqualStrings("app.main", loaded.path[1]);775776    try std.testing.expectError(error.NodeNotFound, load(allocator, root, "absent", true, smg.default_limits.storage));777}778779fn initStore(allocator: std.mem.Allocator, root: []const u8) !void {780    try sys.fs.createDirPath(root);781    var opened = try store.open(allocator, root, smg.default_limits.storage);782    opened.close();783}784785fn saveGraph(allocator: std.mem.Allocator, graph: graph_mod.Graph, root: []const u8) !void {786    var opened = try store.open(allocator, root, smg.default_limits.storage);787    defer opened.close();788    try sync.replaceGraph(allocator, &opened.database, graph);789}790791fn writeNameProjection(allocator: std.mem.Allocator, root: []const u8) !void {792    var opened = try store.open(allocator, root, smg.default_limits.storage);793    defer opened.close();794    const head = (try opened.database.connection.checkout()).head;795    try storage.names.writeForHead(allocator, root, &opened.database, head);796}797798fn testRoot(allocator: std.mem.Allocator, offset: i64) ![]const u8 {799    return try std.fmt.allocPrint(allocator, "/tmp/smg-storage-context-test-{x}", .{@as(u64, @intCast(@max(0, sys.time.realMilliTimestamp() + offset)))});800}

1pub const context = @import("context.zig");