fix: pass openssl lib name

build.zig

@@ -16,7 +16,11 @@ pub fn build(b: *std.Build) !void {
 
     b.installArtifact(lib);
 
-    const pg_dep = b.dependency("pg", .{ .target = target, .optimize = optimize });
+    const pg_dep = b.dependency("pg", .{
+        .target = target,
+        .optimize = optimize,
+        .openssl_lib_name = "ssl",
+    });
     const jetcommon_dep = b.dependency("jetcommon", .{ .target = target, .optimize = optimize });
     const jetcommon_module = jetcommon_dep.module("jetcommon");
 

src/jetquery/Migrate.zig

@@ -228,7 +228,8 @@ test "migrate" {
 
     const new_defaults_query = test_repo.Query(.DefaultsTest)
         .select(.{ .id, .name, .count });
-    try std.testing.expectError(error.PG, test_repo.execute(new_defaults_query));
+    const new_defaults_result = test_repo.execute(new_defaults_query);
+    try std.testing.expect(new_defaults_result == error.PG);
 
     // Human-cats query should still work after first rollback
     var human_cats_result = try test_repo.execute(human_cats_query);
@@ -245,15 +246,16 @@ test "migrate" {
     try migrate.rollback();
 
     // After rolling back cats, human table should still exist but can't join to cats
-    try std.testing.expectError(error.PG, test_repo.execute(human_cats_query));
+    const human_cats_result2 = test_repo.execute(human_cats_query);
+    try std.testing.expect(human_cats_result2 == error.PG);
 
     // Rollback the create_humans migration
     try migrate.rollback();
 
     // After rolling back humans, human table should no longer exist
     {
         const humans = test_repo.Query(.Human).all(&test_repo);
-        try std.testing.expectError(error.PG, humans);
+        try std.testing.expect(humans == error.PG);
     }
 }
 

src/jetquery/Repo.zig

@@ -1374,8 +1374,8 @@ test "aggregate count() with HAVING" {
 test "missing config options" {
     try resetDatabase();
 
-    const repo = Repo(.postgresql, struct {}).init(std.testing.allocator, .{ .adapter = .{} });
-    try std.testing.expectError(error.JetQueryConfigError, repo);
+    const result = Repo(.postgresql, struct {}).init(std.testing.allocator, .{ .adapter = .{} });
+    try std.testing.expect(result == error.JetQueryConfigError);
 }
 
 test "transactions" {
@@ -1469,10 +1469,8 @@ test "alterTable" {
 
     try repo.createTable("cats", &.{}, .{});
 
-    try std.testing.expectError(
-        error.PG,
-        repo.Query(.Cat).select(.{ .name, .paws }).all(&repo),
-    );
+    const result1 = repo.Query(.Cat).select(.{ .name, .paws }).all(&repo);
+    try std.testing.expect(result1 == error.PG);
 
     try repo.alterTable("cats", .{
         .columns = .{
@@ -1486,26 +1484,20 @@ test "alterTable" {
     const cats = try repo.Query(.Cat).select(.{ .name, .paws }).all(&repo);
     try std.testing.expect(cats.len == 0); // Empty table but valid select columns.
 
-    try std.testing.expectError(
-        error.PG,
-        repo.Query(.Dog).select(.{ .name, .paws }).all(&repo),
-    );
+    const result2 = repo.Query(.Dog).select(.{ .name, .paws }).all(&repo);
+    try std.testing.expect(result2 == error.PG);
 
     try repo.alterTable("cats", .{ .rename = "dogs" });
 
-    try std.testing.expectError(
-        error.PG,
-        repo.Query(.Cat).select(.{ .name, .paws }).all(&repo),
-    );
+    const result3 = repo.Query(.Cat).select(.{ .name, .paws }).all(&repo);
+    try std.testing.expect(result3 == error.PG);
 
     const dogs = try repo.Query(.Dog).select(.{ .name, .paws }).all(&repo);
     try std.testing.expect(dogs.len == 0); // Empty table but valid select columns.
 
     try repo.alterTable("dogs", .{ .columns = .{ .drop = &.{"paws"} } });
-    try std.testing.expectError(
-        error.PG,
-        repo.Query(.Dog).select(.{ .name, .paws }).all(&repo),
-    );
+    const result4 = repo.Query(.Dog).select(.{ .name, .paws }).all(&repo);
+    try std.testing.expect(result4 == error.PG);
 
     try repo.alterTable(
         "dogs",

src/jetquery/events.zig

@@ -55,10 +55,9 @@ pub fn defaultCallback(event: Event) !void {
             var writer: std.Io.Writer = .fixed(&duration_buf);
             try writer.printDurationSigned(duration);
         }
-        const formatted_duration = if (event.duration) |_|
-            try std.fmt.bufPrint(&buf, " [{s}]", .{duration_buf})
-        else
-            "";
+        const formatted_duration = if (event.duration) |_| blk: {
+            break :blk std.fmt.bufPrint(&buf, " [{s}]", .{duration_buf}) catch "";
+        } else "";
         std.debug.print("{s}{s}{s}{s}{s}", .{
             event.message orelse "",
             if (event.message) |_| "\n" else "",

src/jetquery/reflection/util.zig

@@ -70,17 +70,13 @@ pub fn zigEscape(
     comptime context: enum { id, string },
     input: []const u8,
 ) ![]const u8 {
-    var writer: std.Io.Writer.Allocating = .init(allocator);
-    defer writer.deinit();
+    var buf = ArrayListManaged(u8).init(allocator);
+    const writer = buf.writer();
+    const formatter = switch (context) {
+        .id => std.zig.fmtId(input),
+        .string => std.zig.fmtString(input),
+    };
 
-    switch (context) {
-        .id => {
-            var formatter = std.zig.fmtId(input);
-            try formatter.format(&writer.writer);
-        },
-        .string => {
-            try std.zig.stringEscape(input, &writer.writer);
-        },
-    }
-    return writer.toOwnedSlice();
+    try writer.print("{any}", .{formatter});
+    return try buf.toOwnedSlice();
 }

src/jetquery/sql/Where.zig

@@ -660,9 +660,7 @@ fn nodeTree(
                 var t: type = OG;
 
                 for (path[0 .. path.len - 1]) |c| {
-                    const field_enum = std.meta.FieldEnum(t);
-                    const name_cast = std.enums.nameCast(field_enum, c);
-                    t = @FieldType(t, @tagName(name_cast));
+                    t = @FieldType(t, c);
                 }
                 const value: t = undefined;
                 const condition = @field(value, path[path.len - 1]);