feat: add response header support

Author: nilslice

src/http.zig

@@ -1,5 +1,46 @@
 const std = @import("std");
 const Memory = @import("Memory.zig");
+const extism = @import("ffi.zig");
+
+pub const Headers = struct {
+    allocator: std.mem.Allocator,
+    raw: []const u8,
+    internal: std.json.ArrayHashMap([]const u8),
+
+    /// Get a value (if it exists) from the Headers map at the provided name.
+    /// NOTE: this may be a multi-value header, and will be a comma-separated list.
+    pub fn get(self: Headers, name: []const u8) ?std.http.Header {
+        const val = self.internal.map.get(name);
+        if (val) |v| {
+            return std.http.Header{
+                .name = name,
+                .value = v,
+            };
+        } else {
+            return null;
+        }
+    }
+
+    /// Access the internal data to iterate over or mutate as needed.
+    pub fn internal(self: Headers) std.json.ArrayHashMap([]const u8) {
+        return self.internal;
+    }
+
+    /// Check if the Headers is empty.
+    pub fn isEmpty(self: Headers) bool {
+        return self.internal.map.entries.len == 0;
+    }
+
+    /// Check if a header exists in the Headers.
+    pub fn contains(self: Headers, key: []const u8) bool {
+        return self.internal.map.contains(key);
+    }
+
+    pub fn deinit(self: *Headers) void {
+        self.allocator.free(self.raw);
+        self.internal.deinit(self.allocator);
+    }
+};
 
 pub const HttpResponse = struct {
     memory: Memory,
@@ -23,11 +64,19 @@ pub const HttpResponse = struct {
         return self.status;
     }
 
-    pub fn headers(self: HttpResponse, allocator: std.mem.Allocator) !std.StringArrayHashMap([]u8) {
-        const buf = try allocator.alloc(u8, @intCast(self.responseHeaders.length));
-        self.responseHeaders.load(buf);
-        const out = try std.json.parseFromSlice(std.StringArrayHashMap([]u8), allocator, buf, .{ .allocate = .alloc_always, .ignore_unknown_fields = true });
-        return out.value;
+    /// IMPORTANT: it's the caller's responsibility to `deinit` the Headers if returned.
+    pub fn headers(self: HttpResponse, allocator: std.mem.Allocator) !Headers {
+        const data = try self.responseHeaders.loadAlloc(allocator);
+        errdefer allocator.free(data);
+
+        const j = try std.json.parseFromSlice(std.json.ArrayHashMap([]const u8), allocator, data, .{ .allocate = .alloc_always, .ignore_unknown_fields = true });
+        defer j.deinit();
+
+        return Headers{
+            .allocator = allocator,
+            .raw = data,
+            .internal = j.value,
+        };
     }
 };
 

src/main.zig

@@ -227,7 +227,7 @@ pub const Plugin = struct {
         const status: u16 = @intCast(extism.http_status_code());
 
         const headersOffset = extism.http_headers();
-        const headersLength = extism.length(offset);
+        const headersLength = extism.length_unsafe(headersOffset);
         const headersMem = Memory.init(headersOffset, headersLength);
 
         const mem = Memory.init(offset, length);