pub const std = @import("std"); const ParseFromValueError = std.json.ParseFromValueError; /// Handle json fields that can have different Zig types depending on the message. /// Each union field should have a unique Zig type. /// /// Example json: /// /// ```json /// [ /// { "question": "How old are you ?", "answer": 5 }, /// { "question": "Count to three.", "answer": [1, 2, 3] }, /// ] /// ``` /// /// Corresponding Zig code: /// /// ```zig /// const Answer = union { /// number: i32, /// numbers: []const i32, /// /// const Helpers = stdx.json.UnionHelpers(@This()); /// pub const jsonParse = Helpers.jsonParse; /// pub const jsonParseFromValue = Helpers.jsonParseFromValue; /// pub const jsonStringify = Helpers.jsonStringify; /// }; /// /// const Message = struct { /// question: []const u8; /// answer: Answer; /// } /// ``` pub fn UnionHelpers(comptime T: type) type { return struct { pub fn jsonParse(allocator: std.mem.Allocator, source: anytype, options: std.json.ParseOptions) std.json.ParseError(@TypeOf(source.*))!T { return jsonParseFromValue( allocator, try std.json.innerParse(std.json.Value, allocator, source, options), options, ); } pub fn jsonParseFromValue(allocator: std.mem.Allocator, source: std.json.Value, options: std.json.ParseOptions) ParseFromValueError!T { inline for (comptime std.meta.fieldNames(T), comptime std.meta.fieldTypes(T)) |field_name, Field| { switch (Field) { bool => if (source == .bool) return @unionInit(T, field_name, source.bool), []const u8 => switch (source) { .string, .number_string => |v| { const dupe = try allocator.dupe(u8, v); return @unionInit(T, field_name, dupe); }, else => {}, }, else => switch (@typeInfo(Field)) { .int => if (source == .integer) return @unionInit(T, field_name, @intCast(source.integer)), .float => if (source == .float) return @unionInit(T, field_name, @floatCast(source.float)), .@"struct" => if (source == .object) return @unionInit(T, field_name, try std.json.innerParseFromValue(Field, allocator, source, options)), inline else => switch (source) { .number_string, .array => return @unionInit(T, field_name, try std.json.innerParseFromValue(Field, allocator, source, options)), else => {}, }, }, } } return error.UnknownField; } pub fn jsonStringify(self: T, jw: anytype) !void { return switch (self) { inline else => |v| jw.write(v), }; } }; } /// Deprecated: prefer importing `stdx.json.UnionHelpers` method into your union. /// This will remove the nesting required by `stdx.json.Union`. pub fn Union(comptime T: type) type { return struct { const Self = @This(); value: T, const Helpers = UnionHelpers(T); pub fn jsonParse(allocator: std.mem.Allocator, source: anytype, options: std.json.ParseOptions) std.json.ParseError(@TypeOf(source.*))!Self { return .{ .value = try Helpers.jsonParse(allocator, source, options) }; } pub fn jsonParseFromValue(allocator: std.mem.Allocator, source: std.json.Value, options: std.json.ParseOptions) ParseFromValueError!Self { return .{ .value = try Helpers.jsonParseFromValue(allocator, source, options) }; } pub fn jsonStringify(self: Self, jw: anytype) !void { return try Helpers.jsonStringify(self.value, jw); } }; } /// Handle json fields that can have different Zig types depending on another field in the same message. /// This is translated to a Zig tagged union. /// /// Example json: /// /// ```json /// [ /// { "type": "faq", "question": "How old are you ?", "answer": 5 }, /// { "type": "address", "city": "NYC", "zipcode": "49130"}, /// ] /// ``` /// /// Corresponding Zig struct: /// /// ```zig /// const Entry = union { /// faq: struct { question: []const u8, answer: u32 }, /// address: struct { city: []const u8, zipcode: []const u8 }, /// /// const Helpers = stdx.json.TaggedUnionHelpers(@This(), "type"); /// pub const jsonParse = Helpers.jsonParse; /// pub const jsonParseFromValue = Helpers.jsonParseFromValue; /// pub const jsonStringify = Helpers.jsonStringify; /// }; /// /// const Message = []const Entry; /// ``` pub fn TaggedUnionHelpers(comptime T: type, comptime tag_name: [:0]const u8) type { comptime { if (@typeInfo(T) != .@"union") { @compileError("TaggedUnion expects a union type, found " ++ @typeName(T)); } for (std.meta.fieldNames(T), std.meta.fieldTypes(T)) |field_name, Field| { if (@typeInfo(Field) != .@"struct") { @compileError("TaggedUnion member '" ++ field_name ++ "' must be a struct, found " ++ @typeName(Field)); } } } return struct { pub fn jsonParse(allocator: std.mem.Allocator, source: anytype, options: std.json.ParseOptions) std.json.ParseError(@TypeOf(source.*))!T { return jsonParseFromValue( allocator, try std.json.innerParse(std.json.Value, allocator, source, options), options, ); } pub fn jsonParseFromValue(allocator: std.mem.Allocator, source: std.json.Value, options: std.json.ParseOptions) ParseFromValueError!T { errdefer std.log.warn("failed to parse: {} as {s}", .{ source, @typeName(T) }); if (source != .object) return error.UnexpectedToken; var o = source.object; const tag = (o.fetchSwapRemove(tag_name) orelse return error.MissingField).value; if (tag != .string) return error.LengthMismatch; inline for (comptime std.meta.fieldNames(T), comptime std.meta.fieldTypes(T)) |field_name, Field| { if (std.mem.eql(u8, field_name, tag.string)) { const inner: Field = std.json.parseFromValueLeaky(Field, allocator, .{ .object = o }, options) catch |err| { std.log.warn("failed to interpret {s} as a {s}: {}", .{ tag.string, @typeName(Field), err }); return err; }; return @unionInit(T, field_name, inner); } } return error.InvalidEnumTag; } pub fn jsonStringify(self: T, jw: anytype) !void { try jw.beginObject(); switch (self) { inline else => |v, tag| { // emit a field containing the enum tag. try jw.objectField(tag_name); try jw.write(@tagName(tag)); switch (@typeInfo(@TypeOf(v))) { .@"struct" => inline for (comptime std.meta.fieldNames(@TypeOf(v))) |name| { try jw.objectField(name); try jw.write(@field(v, name)); }, else => unreachable, // Would have failed with comptime check. } }, } try jw.endObject(); } }; } /// Deprecated: prefer importing `stdx.json.TaggedUnionHelpers` method into your union. /// This will remove the nesting required by `stdx.json.TaggedUnion`. pub fn TaggedUnion(comptime T: type, comptime tag_name: [:0]const u8) type { return struct { const Self = @This(); value: T, const Helpers = TaggedUnionHelpers(T, tag_name); pub fn jsonParse(allocator: std.mem.Allocator, source: anytype, options: std.json.ParseOptions) std.json.ParseError(@TypeOf(source.*))!Self { return .{ .value = try Helpers.jsonParse(allocator, source, options) }; } pub fn jsonParseFromValue(allocator: std.mem.Allocator, source: std.json.Value, options: std.json.ParseOptions) ParseFromValueError!Self { return .{ .value = try Helpers.jsonParseFromValue(allocator, source, options) }; } pub fn jsonStringify(self: Self, jw: anytype) !void { return try Helpers.jsonStringify(self.value, jw); } }; } pub fn NeverNull(comptime T: type, comptime default_value: T) type { return struct { const Self = @This(); value: T = default_value, pub fn jsonParse(allocator: std.mem.Allocator, source: anytype, options: std.json.ParseOptions) !Self { return .{ .value = (try std.json.innerParse(?T, allocator, source, options)) orelse default_value }; } pub fn jsonParseFromValue(allocator: std.mem.Allocator, source: std.json.Value, options: std.json.ParseOptions) !Self { return .{ .value = (try std.json.innerParseFromValue(?T, allocator, source, options)) orelse default_value }; } pub fn jsonStringify(self: Self, jw: anytype) !void { try jw.write(self.value); } }; } pub fn fillDefaultStructValues(comptime T: type, r: *T) !void { const info = @typeInfo(T).@"struct"; inline for (info.field_names, info.field_types, info.field_attrs) |field_name, Field, attrs| { if (attrs.defaultValue(Field)) |default| { if (@field(r, field_name) == null) { @field(r, field_name) = default; } } } } test "union" { const Answer = union(enum) { number: i32, numbers: []const i32, flag: bool, ratio: f64, text: []const u8, const Helpers = UnionHelpers(@This()); pub const jsonParse = Helpers.jsonParse; pub const jsonParseFromValue = Helpers.jsonParseFromValue; pub const jsonStringify = Helpers.jsonStringify; }; const Message = struct { question: []const u8, answer: Answer, }; var arena = std.heap.ArenaAllocator.init(std.testing.allocator); defer arena.deinit(); const allocator = arena.allocator(); const number_case = "{\"question\":\"How old are you?\",\"answer\":5}"; const parsed_number = try std.json.parseFromSliceLeaky(Message, allocator, number_case, .{}); try std.testing.expectEqualStrings("How old are you?", parsed_number.question); try std.testing.expectEqual(@as(i32, 5), parsed_number.answer.number); try std.testing.expectFmt(number_case, "{f}", .{std.json.fmt(parsed_number, .{})}); const numbers_case = "{\"question\":\"Count to three.\",\"answer\":[1,2,3]}"; const parsed_numbers = try std.json.parseFromSliceLeaky(Message, allocator, numbers_case, .{}); try std.testing.expectEqual(@as(usize, 3), parsed_numbers.answer.numbers.len); try std.testing.expectEqual(@as(i32, 1), parsed_numbers.answer.numbers[0]); try std.testing.expectEqual(@as(i32, 2), parsed_numbers.answer.numbers[1]); try std.testing.expectEqual(@as(i32, 3), parsed_numbers.answer.numbers[2]); try std.testing.expectFmt(numbers_case, "{f}", .{std.json.fmt(parsed_numbers, .{})}); const flag_case = "{\"question\":\"Are you ready?\",\"answer\":true}"; const parsed_flag = try std.json.parseFromSliceLeaky(Message, allocator, flag_case, .{}); try std.testing.expectEqual(true, parsed_flag.answer.flag); try std.testing.expectFmt(flag_case, "{f}", .{std.json.fmt(parsed_flag, .{})}); const ratio_case = "{\"question\":\"What is pi?\",\"answer\":3.5}"; const parsed_ratio = try std.json.parseFromSliceLeaky(Message, allocator, ratio_case, .{}); try std.testing.expectEqual(@as(f64, 3.5), parsed_ratio.answer.ratio); try std.testing.expectFmt(ratio_case, "{f}", .{std.json.fmt(parsed_ratio, .{})}); const text_case = "{\"question\":\"Your name?\",\"answer\":\"zml\"}"; const parsed_text = try std.json.parseFromSliceLeaky(Message, allocator, text_case, .{}); try std.testing.expectEqualStrings("zml", parsed_text.answer.text); try std.testing.expectFmt(text_case, "{f}", .{std.json.fmt(parsed_text, .{})}); const null_value = try std.json.parseFromSliceLeaky(std.json.Value, allocator, "null", .{}); try std.testing.expectError(error.UnknownField, Answer.jsonParseFromValue(allocator, null_value, .{})); } test "strings in union can be freed" { const Answer = union(enum) { string: []const u8, number: u32, const Helpers = UnionHelpers(@This()); pub const jsonParse = Helpers.jsonParse; pub const jsonParseFromValue = Helpers.jsonParseFromValue; pub const jsonStringify = Helpers.jsonStringify; }; const Struct = struct { answer1: Answer, answer2: Answer, }; const struct_json = \\{"answer1":"I'm 29","answer2": 1e29} ; var parsed_value = try std.json.parseFromSlice(std.json.Value, std.testing.allocator, struct_json, .{ .parse_numbers = false }); defer parsed_value.deinit(); const parsed = try std.json.parseFromValueLeaky(Struct, std.testing.allocator, parsed_value.value, .{}); try std.testing.expect(parsed.answer1 == .string); try std.testing.expectEqualStrings("I'm 29", parsed.answer1.string); std.testing.allocator.free(parsed.answer1.string); try std.testing.expect(parsed.answer2 == .string); try std.testing.expectEqualStrings("1e29", parsed.answer2.string); std.testing.allocator.free(parsed.answer2.string); } test "tagged union" { const Message = union(enum) { faq: struct { question: []const u8, answer: u32, }, address: struct { city: []const u8, zipcode: []const u8, }, const Helpers = TaggedUnionHelpers(@This(), "type"); pub const jsonParse = Helpers.jsonParse; pub const jsonParseFromValue = Helpers.jsonParseFromValue; pub const jsonStringify = Helpers.jsonStringify; }; var arena = std.heap.ArenaAllocator.init(std.testing.allocator); defer arena.deinit(); const allocator = arena.allocator(); const faq_case = "{\"type\":\"faq\",\"question\":\"How old are you?\",\"answer\":5}"; const parsed_faq = try std.json.parseFromSliceLeaky(Message, allocator, faq_case, .{}); try std.testing.expectEqualStrings("How old are you?", parsed_faq.faq.question); try std.testing.expectEqual(@as(u32, 5), parsed_faq.faq.answer); try std.testing.expectFmt(faq_case, "{f}", .{std.json.fmt(parsed_faq, .{})}); const address_case = "{\"type\":\"address\",\"city\":\"NYC\",\"zipcode\":\"49130\"}"; const parsed_address = try std.json.parseFromSliceLeaky(Message, allocator, address_case, .{}); try std.testing.expectEqualStrings("NYC", parsed_address.address.city); try std.testing.expectEqualStrings("49130", parsed_address.address.zipcode); try std.testing.expectFmt(address_case, "{f}", .{std.json.fmt(parsed_address, .{})}); } test "never null" { var arena = std.heap.ArenaAllocator.init(std.testing.allocator); defer arena.deinit(); const allocator = arena.allocator(); const non_null = try std.json.parseFromSliceLeaky(NeverNull(i32, 10), allocator, "3", .{}); try std.testing.expectEqual(@as(i32, 3), non_null.value); try std.testing.expectFmt("3", "{f}", .{std.json.fmt(non_null, .{})}); const was_null = try std.json.parseFromSliceLeaky(NeverNull(i32, 10), allocator, "null", .{}); try std.testing.expectEqual(@as(i32, 10), was_null.value); try std.testing.expectFmt("10", "{f}", .{std.json.fmt(was_null, .{})}); }