fix: load runtime config and escape --from-json output

Author: DonPrus

src/config.zig

@@ -0,0 +1,52 @@
+const std = @import("std");
+
+pub const Config = struct {
+    port: u16 = 7700,
+    db: []const u8 = "nulltickets.db",
+};
+
+/// Load runtime config from JSON file. Missing file means defaults.
+/// The caller should provide an arena allocator since returned slices may point
+/// to parser-owned allocations.
+pub fn loadFromFile(allocator: std.mem.Allocator, path: []const u8) !Config {
+    const file = std.fs.cwd().openFile(path, .{}) catch |err| {
+        if (err == error.FileNotFound) return Config{};
+        return err;
+    };
+    defer file.close();
+
+    const contents = try file.readToEndAlloc(allocator, 1024 * 1024);
+    const parsed = try std.json.parseFromSlice(Config, allocator, contents, .{ .ignore_unknown_fields = true });
+    return parsed.value;
+}
+
+test "loadFromFile returns defaults when missing" {
+    const cfg = try loadFromFile(std.testing.allocator, "nonexistent-config-file-12345.json");
+    try std.testing.expectEqual(@as(u16, 7700), cfg.port);
+    try std.testing.expectEqualStrings("nulltickets.db", cfg.db);
+}
+
+test "loadFromFile reads config values" {
+    var tmp = std.testing.tmpDir(.{});
+    defer tmp.cleanup();
+
+    try tmp.dir.writeFile(.{
+        .sub_path = "config.json",
+        .data =
+        \\{
+        \\  "port": 7788,
+        \\  "db": "tickets.db"
+        \\}
+        ,
+    });
+
+    const cfg_path = try tmp.dir.realpathAlloc(std.testing.allocator, "config.json");
+    defer std.testing.allocator.free(cfg_path);
+
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+
+    const cfg = try loadFromFile(arena.allocator(), cfg_path);
+    try std.testing.expectEqual(@as(u16, 7788), cfg.port);
+    try std.testing.expectEqualStrings("tickets.db", cfg.db);
+}

src/from_json.zig

@@ -12,14 +12,16 @@ pub fn run(allocator: std.mem.Allocator, json_str: []const u8) !void {
     };
     defer parsed.deinit();
 
-    var buf: std.ArrayList(u8) = .{};
-    defer buf.deinit(allocator);
-    const w = buf.writer(allocator);
-    try std.fmt.format(w, "{{\n  \"port\": {d},\n  \"db\": \"{s}\"\n}}\n", .{ parsed.value.port, parsed.value.db_path });
+    const config_json = try std.json.Stringify.valueAlloc(allocator, .{
+        .port = parsed.value.port,
+        .db = parsed.value.db_path,
+    }, .{ .whitespace = .indent_2 });
+    defer allocator.free(config_json);
 
     const file = try std.fs.cwd().createFile("config.json", .{});
     defer file.close();
-    try file.writeAll(buf.items);
+    try file.writeAll(config_json);
+    try file.writeAll("\n");
 
     const stdout = std.fs.File.stdout();
     try stdout.writeAll("{\"status\":\"ok\"}\n");

src/main.zig

@@ -1,6 +1,7 @@
 const std = @import("std");
 const Store = @import("store.zig").Store;
 const api = @import("api.zig");
+const config = @import("config.zig");
 
 const version = "0.1.0";
 
@@ -35,27 +36,49 @@ pub fn main() !void {
     defer args2.deinit();
     _ = args2.next(); // skip program name
 
-    var port: u16 = 7700;
-    var db_path: [:0]const u8 = "nulltickets.db";
+    var port_override: ?u16 = null;
+    var db_override: ?[:0]const u8 = null;
+    var config_path: []const u8 = "config.json";
 
     while (args2.next()) |arg| {
         if (std.mem.eql(u8, arg, "--port")) {
             if (args2.next()) |val| {
-                port = std.fmt.parseInt(u16, val, 10) catch {
+                port_override = std.fmt.parseInt(u16, val, 10) catch {
                     std.debug.print("invalid port: {s}\n", .{val});
                     return;
                 };
             }
         } else if (std.mem.eql(u8, arg, "--db")) {
             if (args2.next()) |val| {
-                db_path = val;
+                db_override = val;
+            }
+        } else if (std.mem.eql(u8, arg, "--config")) {
+            if (args2.next()) |val| {
+                config_path = val;
             }
         } else if (std.mem.eql(u8, arg, "--version")) {
             std.debug.print("nulltickets v{s}\n", .{version});
             return;
         }
     }
 
+    var cfg_arena = std.heap.ArenaAllocator.init(allocator);
+    defer cfg_arena.deinit();
+    const cfg = config.loadFromFile(cfg_arena.allocator(), config_path) catch |err| {
+        std.debug.print("failed to load config from {s}: {}\n", .{ config_path, err });
+        return;
+    };
+
+    const port = port_override orelse cfg.port;
+    const db_path: [:0]const u8 = db_override orelse blk: {
+        const db_z = cfg_arena.allocator().allocSentinel(u8, cfg.db.len, 0) catch {
+            std.debug.print("out of memory\n", .{});
+            return;
+        };
+        @memcpy(db_z, cfg.db);
+        break :blk db_z;
+    };
+
     std.debug.print("nulltickets v{s}\n", .{version});
     std.debug.print("opening database: {s}\n", .{db_path});