yuzucchii/discord.zig
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

finished nuking that thing

Browse Source
This commit is contained in:
ajpd 2025-04-11 18:49:20 -05:00
parent f74c1479bd
commit b56b7062cf
10 changed files with 254 additions and 1604 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/errors.zig
View File

@ -29,5 +29,5 @@ pub const DiscordError = struct {
};
pub fn Result(comptime T: type) type {
return @import("json.zig").OwnedEither(DiscordError, T);
return @import("json-helper.zig").OwnedEither(DiscordError, T);
}

47
src/http.zig
View File

@ -18,7 +18,8 @@ const std = @import("std");
const mem = std.mem;
const http = std.http;
const json = std.json;
const zjson = @import("json.zig");
const json_helpers = @import("json-helper.zig");
pub const Result = @import("errors.zig").Result;
pub const DiscordError = @import("errors.zig").DiscordError;
@ -100,16 +101,16 @@ pub const FetchReq = struct {
pub fn get(self: *FetchReq, comptime T: type, path: []const u8) !Result(T) {
const result = try self.makeRequest(.GET, path, null);
if (result.status != .ok)
return try zjson.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
const output = try zjson.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
const output = try json_helpers.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return output;
}
pub fn delete(self: *FetchReq, path: []const u8) !Result(void) {
const result = try self.makeRequest(.DELETE, path, null);
if (result.status != .no_content)
return try zjson.tryParse(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.tryParse(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
return .ok({});
}
@ -124,9 +125,9 @@ pub const FetchReq = struct {
const result = try self.makeRequest(.PATCH, path, try string.toOwnedSlice());
if (result.status != .ok)
return try zjson.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try zjson.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
}
pub fn patch2(self: *FetchReq, path: []const u8, object: anytype) !void {
@ -139,7 +140,7 @@ pub const FetchReq = struct {
const result = try self.makeRequest(.PATCH, path, try string.toOwnedSlice());
if (result.status != .no_content)
return try zjson.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
return .ok({});
}
@ -154,9 +155,9 @@ pub const FetchReq = struct {
const result = try self.makeRequest(.PUT, path, try string.toOwnedSlice());
if (result.status != .ok)
return try zjson.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try zjson.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
}
pub fn put2(self: *FetchReq, comptime T: type, path: []const u8, object: anytype) !Result(T) {
@ -169,16 +170,16 @@ pub const FetchReq = struct {
const result = try self.makeRequest(.PUT, path, try string.toOwnedSlice());
if (result.status == .no_content)
return try zjson.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try zjson.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
}
pub fn put3(self: *FetchReq, path: []const u8) !Result(void) {
const result = try self.makeRequest(.PUT, path, null);
if (result.status != .no_content)
return try zjson.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
return .ok({});
}
@ -187,9 +188,9 @@ pub const FetchReq = struct {
const result = try self.makeRequest(.PUT, path, null);
if (result.status != .ok)
return try zjson.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try zjson.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
}
pub fn put5(self: *FetchReq, path: []const u8, object: anytype) !Result(void) {
@ -202,7 +203,7 @@ pub const FetchReq = struct {
const result = try self.makeRequest(.PUT, path, try self.body.toOwnedSlice());
if (result.status != .no_content)
return try zjson.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
return .ok({});
}
@ -217,18 +218,18 @@ pub const FetchReq = struct {
const result = try self.makeRequest(.POST, path, try string.toOwnedSlice());
if (result.status != .ok)
return try zjson.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try zjson.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
}
pub fn post2(self: *FetchReq, comptime T: type, path: []const u8) !Result(T) {
const result = try self.makeRequest(.POST, path, null);
if (result.status != .ok)
return try zjson.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try zjson.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
}
pub fn post3(
@ -247,9 +248,9 @@ pub const FetchReq = struct {
const result = try self.makeRequestWithFiles(.POST, path, try string.toOwnedSlice(), files);
if (result.status != .ok)
return try zjson.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try zjson.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
}
pub fn post4(self: *FetchReq, path: []const u8, object: anytype) !Result(void) {
@ -262,7 +263,7 @@ pub const FetchReq = struct {
const result = try self.makeRequest(.POST, path, try string.toOwnedSlice());
if (result.status != .no_content)
return try zjson.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
return .ok({});
}
@ -271,7 +272,7 @@ pub const FetchReq = struct {
const result = try self.makeRequest(.POST, path, null);
if (result.status != .no_content)
return try zjson.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
return try json_helpers.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
return .ok({});
}

163
src/json-helper.zig
View File

@ -15,6 +15,7 @@
//! PERFORMANCE OF THIS SOFTWARE.
const std = @import("std");
const json = std.json;
/// a hashmap for key value pairs
/// where every key is an int
@ -43,32 +44,25 @@ pub fn AssociativeArray(comptime E: type, comptime V: type) type {
return struct {
map: std.EnumMap(E, V),
pub fn jsonParse(allocator: std.mem.Allocator, src: []const u8) !@This() {
const scanner = std.json.Scanner.initCompleteInput(allocator, src);
defer scanner.deinit();
pub fn jsonParse(allocator: std.mem.Allocator, src: anytype, _: json.ParseOptions) !@This() {
var map: std.EnumMap(E, V) = .{};
if (try scanner.next() != .object_begin)
return error.InvalidJson;
while (true) {
switch (try scanner.peekNextTokenType()) {
.object_end => break,
.string => {}, // might be a key
else => return error.UnexpectedToken,
}
const key = try std.json.innerParse(E, allocator, &scanner, .{
.max_value_len = 0x100
});
const val = try std.json.innerParse(V, allocator, &scanner, .{
const value = try std.json.innerParse(std.json.Value, allocator, src, .{
.max_value_len = 0x100
});
if (map.contains(key))
return error.DuplicateKey;
var iterator = value.object.iterator();
map.put(key, val);
while (iterator.next()) |it| {
const k = it.key_ptr.*;
const v = it.value_ptr.*;
// eg: enum(u8) would be @"enum".tag_type where tag_type is a u8
const int = std.fmt.parseInt(@typeInfo(E).@"enum".tag_type, k, 10) catch unreachable;
const val = try std.json.parseFromValueLeaky(V, allocator, v, .{.max_value_len = 0x100});
map.put(@enumFromInt(int), val);
}
return .{.map = map};
@ -94,38 +88,26 @@ pub fn DiscriminatedUnion(comptime U: type, comptime key: []const u8) type {
return struct {
t: U,
pub fn jsonParse(allocator: std.mem.Allocator, src: []const u8) !@This() {
const scanner = std.json.Scanner.initCompleteInput(allocator, src);
defer scanner.deinit();
if (try scanner.next() != .object_begin)
return error.CouldntMatchAgainstNonObjectType;
pub fn jsonParse(allocator: std.mem.Allocator, src: anytype, _: json.ParseOptions) !@This() {
// extract next value, which should be an object
// and should have a key "type" or whichever key might be
const value = try std.json.innerParse(std.json.Value, allocator, &scanner, .{
const value = try std.json.innerParse(std.json.Value, allocator, src, .{
.max_value_len = 0x100
});
if (value != .object)
return error.CouldntMatchAgainstNonObjectType;
const discriminator = value.object.get(key) orelse
@panic("couldn't find property " ++ key ++ "in raw object");
var u: U = undefined;
if (discriminator != .integer)
return error.CouldntMatchAgainstNonIntegerType;
const tag: @typeInfo(E).@"enum".tag_type = @intCast(discriminator.integer);
inline for (@typeInfo(E).@"enum".fields) |field| {
if (field.value == tag) {
const T = comptime std.meta.fields(U)[field.value].type;
comptime std.debug.assert(@hasField(T, key));
u = @unionInit(U, field.name, try std.json.innerParse(T, allocator, &scanner, .{.max_value_len = 0x100}));
u = @unionInit(U, field.name, try std.json.innerParse(T, allocator, src, .{.max_value_len = 0x100}));
}
}
@ -138,18 +120,11 @@ pub fn DiscriminatedUnion(comptime U: type, comptime key: []const u8) type {
pub fn Record(comptime T: type) type {
return struct {
map: std.StringHashMapUnmanaged(T),
pub fn jsonParse(allocator: std.mem.Allocator, src: []const u8) !@This() {
const scanner = std.json.Scanner.initCompleteInput(allocator, src);
defer scanner.deinit();
const value = try std.json.innerParse(std.json.Value, allocator, &scanner, .{
pub fn jsonParse(allocator: std.mem.Allocator, src: anytype, _: json.ParseOptions) !@This() {
const value = try std.json.innerParse(std.json.Value, allocator, src, .{
.max_value_len = 0x100
});
if (value != .object)
return error.CouldntMatchAgainstNonObjectType;
errdefer value.object.deinit();
var iterator = value.object.iterator();
@ -170,3 +145,103 @@ pub fn Record(comptime T: type) type {
};
}
/// Either a b = Left a | Right b
pub fn Either(comptime L: type, comptime R: type) type {
return union(enum) {
left: L,
right: R,
/// always returns .right
pub fn unwrap(self: @This()) R {
// discord.zig specifics
if (@hasField(L, "code") and @hasField(L, "message") and self == .left)
std.debug.panic("Error: {d}, {s}\n", .{ self.left.code, self.left.message });
// for other libraries, it'll do this
if (self == .left)
std.debug.panic("Error: {any}\n", .{self.left});
return self.right;
}
pub fn is(self: @This(), tag: std.meta.Tag(@This())) bool {
return self == tag;
}
};
}
/// meant to handle a `std.json.Value` and handling the deinitialization thereof
pub fn Owned(comptime T: type) type {
return struct {
arena: *std.heap.ArenaAllocator,
value: T,
pub fn deinit(self: @This()) void {
const allocator = self.arena.child_allocator;
self.arena.deinit();
allocator.destroy(self.arena);
}
};
}
/// same as `Owned` but instead it handles 2 different values, generally `.right` is the correct one and `left` the error type
pub fn OwnedEither(comptime L: type, comptime R: type) type {
return struct {
value: Either(L, R),
arena: *std.heap.ArenaAllocator,
pub fn ok(ok_value: R) @This() {
return .{ .value = ok_value };
}
pub fn err(err_value: L) @This() {
return .{ .value = err_value };
}
pub fn deinit(self: @This()) void {
const allocator = self.arena.child_allocator;
self.arena.deinit();
allocator.destroy(self.arena);
}
};
}
/// same as `std.json.parseFromSlice`
pub fn parseRight(comptime L: type, comptime R: type, child_allocator: std.mem.Allocator, data: []const u8) json.ParseError(json.Scanner)!OwnedEither(L, R) {
var owned: OwnedEither(L, R) = .{
.arena = try child_allocator.create(std.heap.ArenaAllocator),
.value = undefined,
};
owned.arena.* = .init(child_allocator);
const allocator = owned.arena.allocator();
const value = try json.parseFromSliceLeaky(json.Value, allocator, data, .{
.max_value_len = 0x100,
});
owned.value = .{ .right = try json.parseFromValueLeaky(R, allocator, value, .{.max_value_len = 0x100}) };
errdefer owned.arena.deinit();
return owned;
}
/// same as `std.json.parseFromSlice`
pub fn parseLeft(comptime L: type, comptime R: type, child_allocator: std.mem.Allocator, data: []const u8) json.ParseError(json.Scanner)!OwnedEither(L, R) {
var owned: OwnedEither(L, R) = .{
.arena = try child_allocator.create(std.heap.ArenaAllocator),
.value = undefined,
};
owned.arena.* = .init(child_allocator);
const allocator = owned.arena.allocator();
const value = try json.parseFromSliceLeaky(json.Value, allocator, data, .{
.max_value_len = 0x100,
});
owned.value = .{ .left = try json.parseFromValueLeaky(L, allocator, value, .{.max_value_len = 0x100}) };
errdefer owned.arena.deinit();
return owned;
}

1419
src/json.zig
View File

File diff suppressed because it is too large Load Diff

140
src/shard.zig
View File

@ -26,7 +26,7 @@ const http = std.http;
// todo use this to read compressed messages
const zlib = @import("zlib");
const zjson = @import("json.zig");
const json = @import("std").json;
const Result = @import("errors.zig").Result;
const Self = @This();
@ -215,7 +215,7 @@ pub fn deinit(self: *Self) void {
self.client.deinit();
}
const ReadMessageError = mem.Allocator.Error || zlib.Error || zjson.ParserError;
const ReadMessageError = mem.Allocator.Error || zlib.Error || json.ParseError(json.Scanner);
/// listens for messages
fn readMessage(self: *Self, _: anytype) !void {
@ -250,7 +250,7 @@ fn readMessage(self: *Self, _: anytype) !void {
// maybe use threads and call it instead from there
if (payload.t) |name| {
self.sequence.store(payload.s orelse 0, .monotonic);
try self.handleEvent(name, decompressed); // we use zjson thereonwards
try self.handleEvent(name, decompressed);
}
},
.Hello => {
@ -398,389 +398,389 @@ pub fn send(self: *Self, _: bool, data: anytype) SendError!void {
pub fn handleEvent(self: *Self, name: []const u8, payload: []const u8) !void {
if (mem.eql(u8, name, "READY")) if (self.handler.ready) |event| {
const ready = try zjson.parse(GatewayPayload(Types.Ready), self.allocator, payload);
const ready = try json.parseFromSlice(GatewayPayload(Types.Ready), self.allocator, payload, .{.max_value_len=0x100});
try event(self, ready.value.d.?);
};
if (mem.eql(u8, name, "APPLICATION_COMMAND_PERMISSIONS_UPDATE")) if (self.handler.application_command_permissions_update) |event| {
const acp = try zjson.parse(GatewayPayload(Types.ApplicationCommandPermissions), self.allocator, payload);
const acp = try json.parseFromSlice(GatewayPayload(Types.ApplicationCommandPermissions), self.allocator, payload, .{.max_value_len=0x100});
try event(self, acp.value.d.?);
};
if (mem.eql(u8, name, "CHANNEL_CREATE")) if (self.handler.channel_create) |event| {
const chan = try zjson.parse(GatewayPayload(Types.Channel), self.allocator, payload);
const chan = try json.parseFromSlice(GatewayPayload(Types.Channel), self.allocator, payload, .{.max_value_len=0x100});
try event(self, chan.value.d.?);
};
if (mem.eql(u8, name, "CHANNEL_UPDATE")) if (self.handler.channel_update) |event| {
const chan = try zjson.parse(GatewayPayload(Types.Channel), self.allocator, payload);
const chan = try json.parseFromSlice(GatewayPayload(Types.Channel), self.allocator, payload, .{.max_value_len=0x100});
try event(self, chan.value.d.?);
};
if (mem.eql(u8, name, "CHANNEL_DELETE")) if (self.handler.channel_delete) |event| {
const chan = try zjson.parse(GatewayPayload(Types.Channel), self.allocator, payload);
const chan = try json.parseFromSlice(GatewayPayload(Types.Channel), self.allocator, payload, .{.max_value_len=0x100});
try event(self, chan.value.d.?);
};
if (mem.eql(u8, name, "CHANNEL_PINS_UPDATE")) if (self.handler.channel_pins_update) |event| {
const chan_pins_update = try zjson.parse(GatewayPayload(Types.ChannelPinsUpdate), self.allocator, payload);
const chan_pins_update = try json.parseFromSlice(GatewayPayload(Types.ChannelPinsUpdate), self.allocator, payload, .{.max_value_len=0x100});
try event(self, chan_pins_update.value.d.?);
};
if (mem.eql(u8, name, "ENTITLEMENT_CREATE")) if (self.handler.entitlement_create) |event| {
const entitlement = try zjson.parse(GatewayPayload(Types.Entitlement), self.allocator, payload);
const entitlement = try json.parseFromSlice(GatewayPayload(Types.Entitlement), self.allocator, payload, .{.max_value_len=0x100});
try event(self, entitlement.value.d.?);
};
if (mem.eql(u8, name, "ENTITLEMENT_UPDATE")) if (self.handler.entitlement_update) |event| {
const entitlement = try zjson.parse(GatewayPayload(Types.Entitlement), self.allocator, payload);
const entitlement = try json.parseFromSlice(GatewayPayload(Types.Entitlement), self.allocator, payload, .{.max_value_len=0x100});
try event(self, entitlement.value.d.?);
};
if (mem.eql(u8, name, "ENTITLEMENT_DELETE")) if (self.handler.entitlement_delete) |event| {
const entitlement = try zjson.parse(GatewayPayload(Types.Entitlement), self.allocator, payload);
const entitlement = try json.parseFromSlice(GatewayPayload(Types.Entitlement), self.allocator, payload, .{.max_value_len=0x100});
try event(self, entitlement.value.d.?);
};
if (mem.eql(u8, name, "INTEGRATION_CREATE")) if (self.handler.integration_create) |event| {
const guild_id = try zjson.parse(GatewayPayload(Types.IntegrationCreateUpdate), self.allocator, payload);
const guild_id = try json.parseFromSlice(GatewayPayload(Types.IntegrationCreateUpdate), self.allocator, payload, .{.max_value_len=0x100});
try event(self, guild_id.value.d.?);
};
if (mem.eql(u8, name, "INTEGRATION_UPDATE")) if (self.handler.integration_update) |event| {
const guild_id = try zjson.parse(GatewayPayload(Types.IntegrationCreateUpdate), self.allocator, payload);
const guild_id = try json.parseFromSlice(GatewayPayload(Types.IntegrationCreateUpdate), self.allocator, payload, .{.max_value_len=0x100});
try event(self, guild_id.value.d.?);
};
if (mem.eql(u8, name, "INTEGRATION_DELETE")) if (self.handler.integration_delete) |event| {
const data = try zjson.parse(GatewayPayload(Types.IntegrationDelete), self.allocator, payload);
const data = try json.parseFromSlice(GatewayPayload(Types.IntegrationDelete), self.allocator, payload, .{.max_value_len=0x100});
try event(self, data.value.d.?);
};
if (mem.eql(u8, name, "INTERACTION_CREATE")) if (self.handler.interaction_create) |event| {
const interaction = try zjson.parse(GatewayPayload(Types.MessageInteraction), self.allocator, payload);
const interaction = try json.parseFromSlice(GatewayPayload(Types.MessageInteraction), self.allocator, payload, .{.max_value_len=0x100});
try event(self, interaction.value.d.?);
};
if (mem.eql(u8, name, "INVITE_CREATE")) if (self.handler.invite_create) |event| {
const data = try zjson.parse(GatewayPayload(Types.InviteCreate), self.allocator, payload);
const data = try json.parseFromSlice(GatewayPayload(Types.InviteCreate), self.allocator, payload, .{.max_value_len=0x100});
try event(self, data.value.d.?);
};
if (mem.eql(u8, name, "INVITE_DELETE")) if (self.handler.invite_delete) |event| {
const data = try zjson.parse(GatewayPayload(Types.InviteDelete), self.allocator, payload);
const data = try json.parseFromSlice(GatewayPayload(Types.InviteDelete), self.allocator, payload, .{.max_value_len=0x100});
try event(self, data.value.d.?);
};
if (mem.eql(u8, name, "MESSAGE_CREATE")) if (self.handler.message_create) |event| {
const message = try zjson.parse(GatewayPayload(Types.Message), self.allocator, payload);
const message = try json.parseFromSlice(GatewayPayload(Types.Message), self.allocator, payload, .{.max_value_len=0x100});
try event(self, message.value.d.?);
};
if (mem.eql(u8, name, "MESSAGE_DELETE")) if (self.handler.message_delete) |event| {
const data = try zjson.parse(GatewayPayload(Types.MessageDelete), self.allocator, payload);
const data = try json.parseFromSlice(GatewayPayload(Types.MessageDelete), self.allocator, payload, .{.max_value_len=0x100});
try event(self, data.value.d.?);
};
if (mem.eql(u8, name, "MESSAGE_UPDATE")) if (self.handler.message_update) |event| {
const message = try zjson.parse(GatewayPayload(Types.Message), self.allocator, payload);
const message = try json.parseFromSlice(GatewayPayload(Types.Message), self.allocator, payload, .{.max_value_len=0x100});
try event(self, message.value.d.?);
};
if (mem.eql(u8, name, "MESSAGE_DELETE_BULK")) if (self.handler.message_delete_bulk) |event| {
const data = try zjson.parse(GatewayPayload(Types.MessageDeleteBulk), self.allocator, payload);
const data = try json.parseFromSlice(GatewayPayload(Types.MessageDeleteBulk), self.allocator, payload, .{.max_value_len=0x100});
try event(self, data.value.d.?);
};
if (mem.eql(u8, name, "MESSAGE_REACTION_ADD")) if (self.handler.message_reaction_add) |event| {
const reaction = try zjson.parse(GatewayPayload(Types.MessageReactionAdd), self.allocator, payload);
const reaction = try json.parseFromSlice(GatewayPayload(Types.MessageReactionAdd), self.allocator, payload, .{.max_value_len=0x100});
try event(self, reaction.value.d.?);
};
if (mem.eql(u8, name, "MESSAGE_REACTION_REMOVE")) if (self.handler.message_reaction_remove) |event| {
const reaction = try zjson.parse(GatewayPayload(Types.MessageReactionRemove), self.allocator, payload);
const reaction = try json.parseFromSlice(GatewayPayload(Types.MessageReactionRemove), self.allocator, payload, .{.max_value_len=0x100});
try event(self, reaction.value.d.?);
};
if (mem.eql(u8, name, "MESSAGE_REACTION_REMOVE_ALL")) if (self.handler.message_reaction_remove_all) |event| {
const data = try zjson.parse(GatewayPayload(Types.MessageReactionRemoveAll), self.allocator, payload);
const data = try json.parseFromSlice(GatewayPayload(Types.MessageReactionRemoveAll), self.allocator, payload, .{.max_value_len=0x100});
try event(self, data.value.d.?);
};
if (mem.eql(u8, name, "MESSAGE_REACTION_REMOVE_EMOJI")) if (self.handler.message_reaction_remove_emoji) |event| {
const emoji = try zjson.parse(GatewayPayload(Types.MessageReactionRemoveEmoji), self.allocator, payload);
const emoji = try json.parseFromSlice(GatewayPayload(Types.MessageReactionRemoveEmoji), self.allocator, payload, .{.max_value_len=0x100});
try event(self, emoji.value.d.?);
};
if (mem.eql(u8, name, "GUILD_CREATE")) {
const isAvailable =
try zjson.parse(GatewayPayload(struct { unavailable: ?bool }), self.allocator, payload);
try json.parseFromSlice(GatewayPayload(struct { unavailable: ?bool }), self.allocator, payload, .{.max_value_len=0x100});
if (isAvailable.value.d.?.unavailable == true) {
const guild = try zjson.parse(GatewayPayload(Types.Guild), self.allocator, payload);
const guild = try json.parseFromSlice(GatewayPayload(Types.Guild), self.allocator, payload, .{.max_value_len=0x100});
if (self.handler.guild_create) |event| try event(self, guild.value.d.?);
return;
}
const guild = try zjson.parse(GatewayPayload(Types.UnavailableGuild), self.allocator, payload);
const guild = try json.parseFromSlice(GatewayPayload(Types.UnavailableGuild), self.allocator, payload, .{.max_value_len=0x100});
if (self.handler.guild_create_unavailable) |event| try event(self, guild.value.d.?);
}
if (mem.eql(u8, name, "GUILD_UPDATE")) if (self.handler.guild_update) |event| {
const guild = try zjson.parse(GatewayPayload(Types.Guild), self.allocator, payload);
const guild = try json.parseFromSlice(GatewayPayload(Types.Guild), self.allocator, payload, .{.max_value_len=0x100});
try event(self, guild.value.d.?);
};
if (mem.eql(u8, name, "GUILD_DELETE")) if (self.handler.guild_delete) |event| {
const guild = try zjson.parse(GatewayPayload(Types.UnavailableGuild), self.allocator, payload);
const guild = try json.parseFromSlice(GatewayPayload(Types.UnavailableGuild), self.allocator, payload, .{.max_value_len=0x100});
try event(self, guild.value.d.?);
};
if (mem.eql(u8, name, "GUILD_SCHEDULED_EVENT_CREATE")) if (self.handler.guild_scheduled_event_create) |event| {
const s_event = try zjson.parse(GatewayPayload(Types.ScheduledEvent), self.allocator, payload);
const s_event = try json.parseFromSlice(GatewayPayload(Types.ScheduledEvent), self.allocator, payload, .{.max_value_len=0x100});
try event(self, s_event.value.d.?);
};
if (mem.eql(u8, name, "GUILD_SCHEDULED_EVENT_UPDATE")) if (self.handler.guild_scheduled_event_update) |event| {
const s_event = try zjson.parse(GatewayPayload(Types.ScheduledEvent), self.allocator, payload);
const s_event = try json.parseFromSlice(GatewayPayload(Types.ScheduledEvent), self.allocator, payload, .{.max_value_len=0x100});
try event(self, s_event.value.d.?);
};
if (mem.eql(u8, name, "GUILD_SCHEDULED_EVENT_DELETE")) if (self.handler.guild_scheduled_event_delete) |event| {
const s_event = try zjson.parse(GatewayPayload(Types.ScheduledEvent), self.allocator, payload);
const s_event = try json.parseFromSlice(GatewayPayload(Types.ScheduledEvent), self.allocator, payload, .{.max_value_len=0x100});
try event(self, s_event.value.d.?);
};
if (mem.eql(u8, name, "GUILD_SCHEDULED_EVENT_USER_ADD")) if (self.handler.guild_scheduled_event_user_add) |event| {
const data = try zjson.parse(GatewayPayload(Types.ScheduledEventUserAdd), self.allocator, payload);
const data = try json.parseFromSlice(GatewayPayload(Types.ScheduledEventUserAdd), self.allocator, payload, .{.max_value_len=0x100});
try event(self, data.value.d.?);
};
if (mem.eql(u8, name, "GUILD_SCHEDULED_EVENT_USER_REMOVE")) if (self.handler.guild_scheduled_event_user_remove) |event| {
const data = try zjson.parse(GatewayPayload(Types.ScheduledEventUserRemove), self.allocator, payload);
const data = try json.parseFromSlice(GatewayPayload(Types.ScheduledEventUserRemove), self.allocator, payload, .{.max_value_len=0x100});
try event(self, data.value.d.?);
};
if (mem.eql(u8, name, "GUILD_MEMBER_ADD")) if (self.handler.guild_member_add) |event| {
const guild_id = try zjson.parse(GatewayPayload(Types.GuildMemberAdd), self.allocator, payload);
const guild_id = try json.parseFromSlice(GatewayPayload(Types.GuildMemberAdd), self.allocator, payload, .{.max_value_len=0x100});
try event(self, guild_id.value.d.?);
};
if (mem.eql(u8, name, "GUILD_MEMBER_UPDATE")) if (self.handler.guild_member_update) |event| {
const fields = try zjson.parse(GatewayPayload(Types.GuildMemberUpdate), self.allocator, payload);
const fields = try json.parseFromSlice(GatewayPayload(Types.GuildMemberUpdate), self.allocator, payload, .{.max_value_len=0x100});
try event(self, fields.value.d.?);
};
if (mem.eql(u8, name, "GUILD_MEMBER_REMOVE")) if (self.handler.guild_member_remove) |event| {
const user = try zjson.parse(GatewayPayload(Types.GuildMemberRemove), self.allocator, payload);
const user = try json.parseFromSlice(GatewayPayload(Types.GuildMemberRemove), self.allocator, payload, .{.max_value_len=0x100});
try event(self, user.value.d.?);
};
if (mem.eql(u8, name, "GUILD_MEMBERS_CHUNK")) if (self.handler.guild_members_chunk) |event| {
const data = try zjson.parse(GatewayPayload(Types.GuildMembersChunk), self.allocator, payload);
const data = try json.parseFromSlice(GatewayPayload(Types.GuildMembersChunk), self.allocator, payload, .{.max_value_len=0x100});
try event(self, data.value.d.?);
};
if (mem.eql(u8, name, "GUILD_ROLE_CREATE")) if (self.handler.guild_role_create) |event| {
const role = try zjson.parse(GatewayPayload(Types.GuildRoleCreate), self.allocator, payload);
const role = try json.parseFromSlice(GatewayPayload(Types.GuildRoleCreate), self.allocator, payload, .{.max_value_len=0x100});
try event(self, role.value.d.?);
};
if (mem.eql(u8, name, "GUILD_ROLE_UPDATE")) if (self.handler.guild_role_update) |event| {
const role = try zjson.parse(GatewayPayload(Types.GuildRoleUpdate), self.allocator, payload);
const role = try json.parseFromSlice(GatewayPayload(Types.GuildRoleUpdate), self.allocator, payload, .{.max_value_len=0x100});
try event(self, role.value.d.?);
};
if (mem.eql(u8, name, "GUILD_ROLE_DELETE")) if (self.handler.guild_role_delete) |event| {
const role_id = try zjson.parse(GatewayPayload(Types.GuildRoleDelete), self.allocator, payload);
const role_id = try json.parseFromSlice(GatewayPayload(Types.GuildRoleDelete), self.allocator, payload, .{.max_value_len=0x100});
try event(self, role_id.value.d.?);
};
if (mem.eql(u8, name, "GUILD_DELETE")) if (self.handler.guild_delete) |event| {
const guild = try zjson.parse(GatewayPayload(Types.UnavailableGuild), self.allocator, payload);
const guild = try json.parseFromSlice(GatewayPayload(Types.UnavailableGuild), self.allocator, payload, .{.max_value_len=0x100});
try event(self, guild.value.d.?);
};
if (mem.eql(u8, name, "GUILD_BAN_ADD")) if (self.handler.guild_ban_add) |event| {
const gba = try zjson.parse(GatewayPayload(Types.GuildBanAddRemove), self.allocator, payload);
const gba = try json.parseFromSlice(GatewayPayload(Types.GuildBanAddRemove), self.allocator, payload, .{.max_value_len=0x100});
try event(self, gba.value.d.?);
};
if (mem.eql(u8, name, "GUILD_BAN_REMOVE")) if (self.handler.guild_ban_remove) |event| {
const gbr = try zjson.parse(GatewayPayload(Types.GuildBanAddRemove), self.allocator, payload);
const gbr = try json.parseFromSlice(GatewayPayload(Types.GuildBanAddRemove), self.allocator, payload, .{.max_value_len=0x100});
try event(self, gbr.value.d.?);
};
if (mem.eql(u8, name, "GUILD_EMOJIS_UPDATE")) if (self.handler.guild_emojis_update) |event| {
const emojis = try zjson.parse(GatewayPayload(Types.GuildEmojisUpdate), self.allocator, payload);
const emojis = try json.parseFromSlice(GatewayPayload(Types.GuildEmojisUpdate), self.allocator, payload, .{.max_value_len=0x100});
try event(self, emojis.value.d.?);
};
if (mem.eql(u8, name, "GUILD_STICKERS_UPDATE")) if (self.handler.guild_stickers_update) |event| {
const stickers = try zjson.parse(GatewayPayload(Types.GuildStickersUpdate), self.allocator, payload);
const stickers = try json.parseFromSlice(GatewayPayload(Types.GuildStickersUpdate), self.allocator, payload, .{.max_value_len=0x100});
try event(self, stickers.value.d.?);
};
if (mem.eql(u8, name, "GUILD_INTEGRATIONS_UPDATE")) if (self.handler.guild_integrations_update) |event| {
const guild_id = try zjson.parse(GatewayPayload(Types.GuildIntegrationsUpdate), self.allocator, payload);
const guild_id = try json.parseFromSlice(GatewayPayload(Types.GuildIntegrationsUpdate), self.allocator, payload, .{.max_value_len=0x100});
try event(self, guild_id.value.d.?);
};
if (mem.eql(u8, name, "THREAD_CREATE")) if (self.handler.thread_create) |event| {
const thread = try zjson.parse(GatewayPayload(Types.Channel), self.allocator, payload);
const thread = try json.parseFromSlice(GatewayPayload(Types.Channel), self.allocator, payload, .{.max_value_len=0x100});
try event(self, thread.value.d.?);
};
if (mem.eql(u8, name, "THREAD_UPDATE")) if (self.handler.thread_update) |event| {
const thread = try zjson.parse(GatewayPayload(Types.Channel), self.allocator, payload);
const thread = try json.parseFromSlice(GatewayPayload(Types.Channel), self.allocator, payload, .{.max_value_len=0x100});
try event(self, thread.value.d.?);
};
if (mem.eql(u8, name, "THREAD_DELETE")) if (self.handler.thread_delete) |event| {
const thread_data = try zjson.parse(GatewayPayload(Types.Partial(Types.Channel)), self.allocator, payload);
const thread_data = try json.parseFromSlice(GatewayPayload(Types.Partial(Types.Channel)), self.allocator, payload, .{.max_value_len=0x100});
try event(self, thread_data.value.d.?);
};
if (mem.eql(u8, name, "THREAD_LIST_SYNC")) if (self.handler.thread_list_sync) |event| {
const data = try zjson.parse(GatewayPayload(Types.ThreadListSync), self.allocator, payload);
const data = try json.parseFromSlice(GatewayPayload(Types.ThreadListSync), self.allocator, payload, .{.max_value_len=0x100});
try event(self, data.value.d.?);
};
if (mem.eql(u8, name, "THREAD_MEMBER_UPDATE")) if (self.handler.thread_member_update) |event| {
const guild_id = try zjson.parse(GatewayPayload(Types.ThreadMemberUpdate), self.allocator, payload);
const guild_id = try json.parseFromSlice(GatewayPayload(Types.ThreadMemberUpdate), self.allocator, payload, .{.max_value_len=0x100});
try event(self, guild_id.value.d.?);
};
if (mem.eql(u8, name, "THREAD_MEMBERS_UPDATE")) if (self.handler.thread_members_update) |event| {
const data = try zjson.parse(GatewayPayload(Types.ThreadMembersUpdate), self.allocator, payload);
const data = try json.parseFromSlice(GatewayPayload(Types.ThreadMembersUpdate), self.allocator, payload, .{.max_value_len=0x100});
try event(self, data.value.d.?);
};
if (mem.eql(u8, name, "TYPING_START")) if (self.handler.typing_start) |event| {
const data = try zjson.parse(GatewayPayload(Types.TypingStart), self.allocator, payload);
const data = try json.parseFromSlice(GatewayPayload(Types.TypingStart), self.allocator, payload, .{.max_value_len=0x100});
try event(self, data.value.d.?);
};
if (mem.eql(u8, name, "USER_UPDATE")) if (self.handler.user_update) |event| {
const user = try zjson.parse(GatewayPayload(Types.User), self.allocator, payload);
const user = try json.parseFromSlice(GatewayPayload(Types.User), self.allocator, payload, .{.max_value_len=0x100});
try event(self, user.value.d.?);
};
if (mem.eql(u8, name, "PRESENCE_UPDATE")) if (self.handler.presence_update) |event| {
const pu = try zjson.parse(GatewayPayload(Types.PresenceUpdate), self.allocator, payload);
const pu = try json.parseFromSlice(GatewayPayload(Types.PresenceUpdate), self.allocator, payload, .{.max_value_len=0x100});
try event(self, pu.value.d.?);
};
if (mem.eql(u8, name, "MESSSAGE_POLL_VOTE_ADD")) if (self.handler.message_poll_vote_add) |event| {
const data = try zjson.parse(GatewayPayload(Types.PollVoteAdd), self.allocator, payload);
const data = try json.parseFromSlice(GatewayPayload(Types.PollVoteAdd), self.allocator, payload, .{.max_value_len=0x100});
try event(self, data.value.d.?);
};
if (mem.eql(u8, name, "MESSSAGE_POLL_VOTE_REMOVE")) if (self.handler.message_poll_vote_remove) |event| {
const data = try zjson.parse(GatewayPayload(Types.PollVoteRemove), self.allocator, payload);
const data = try json.parseFromSlice(GatewayPayload(Types.PollVoteRemove), self.allocator, payload, .{.max_value_len=0x100});
try event(self, data.value.d.?);
};
if (mem.eql(u8, name, "WEBHOOKS_UPDATE")) if (self.handler.webhooks_update) |event| {
const fields = try zjson.parse(GatewayPayload(Types.WebhookUpdate), self.allocator, payload);
const fields = try json.parseFromSlice(GatewayPayload(Types.WebhookUpdate), self.allocator, payload, .{.max_value_len=0x100});
try event(self, fields.value.d.?);
};
if (mem.eql(u8, name, "STAGE_INSTANCE_CREATE")) if (self.handler.stage_instance_create) |event| {
const stage = try zjson.parse(GatewayPayload(Types.StageInstance), self.allocator, payload);
const stage = try json.parseFromSlice(GatewayPayload(Types.StageInstance), self.allocator, payload, .{.max_value_len=0x100});
try event(self, stage.value.d.?);
};
if (mem.eql(u8, name, "STAGE_INSTANCE_UPDATE")) if (self.handler.stage_instance_update) |event| {
const stage = try zjson.parse(GatewayPayload(Types.StageInstance), self.allocator, payload);
const stage = try json.parseFromSlice(GatewayPayload(Types.StageInstance), self.allocator, payload, .{.max_value_len=0x100});
try event(self, stage.value.d.?);
};
if (mem.eql(u8, name, "STAGE_INSTANCE_DELETE")) if (self.handler.stage_instance_delete) |event| {
const stage = try zjson.parse(GatewayPayload(Types.StageInstance), self.allocator, payload);
const stage = try json.parseFromSlice(GatewayPayload(Types.StageInstance), self.allocator, payload, .{.max_value_len=0x100});
try event(self, stage.value.d.?);
};
if (mem.eql(u8, name, "AUTO_MODERATION_RULE_CREATE")) if (self.handler.auto_moderation_rule_create) |event| {
const rule = try zjson.parse(GatewayPayload(Types.AutoModerationRule), self.allocator, payload);
const rule = try json.parseFromSlice(GatewayPayload(Types.AutoModerationRule), self.allocator, payload, .{.max_value_len=0x100});
try event(self, rule.value.d.?);
};
if (mem.eql(u8, name, "AUTO_MODERATION_RULE_UPDATE")) if (self.handler.auto_moderation_rule_update) |event| {
const rule = try zjson.parse(GatewayPayload(Types.AutoModerationRule), self.allocator, payload);
const rule = try json.parseFromSlice(GatewayPayload(Types.AutoModerationRule), self.allocator, payload, .{.max_value_len=0x100});
try event(self, rule.value.d.?);
};
if (mem.eql(u8, name, "AUTO_MODERATION_RULE_DELETE")) if (self.handler.auto_moderation_rule_delete) |event| {
const rule = try zjson.parse(GatewayPayload(Types.AutoModerationRule), self.allocator, payload);
const rule = try json.parseFromSlice(GatewayPayload(Types.AutoModerationRule), self.allocator, payload, .{.max_value_len=0x100});
try event(self, rule.value.d.?);
};
if (mem.eql(u8, name, "AUTO_MODERATION_ACTION_EXECUTION")) if (self.handler.auto_moderation_action_execution) |event| {
const ax = try zjson.parse(GatewayPayload(Types.AutoModerationActionExecution), self.allocator, payload);
const ax = try json.parseFromSlice(GatewayPayload(Types.AutoModerationActionExecution), self.allocator, payload, .{.max_value_len = 0x100});
try event(self, ax.value.d.?);
};
@ -790,7 +790,7 @@ pub fn handleEvent(self: *Self, name: []const u8, payload: []const u8) !void {
try anyEvent(self, payload);
}
pub const RequestFailedError = zjson.ParserError || MakeRequestError || error{FailedRequest};
pub const RequestFailedError = MakeRequestError || error{FailedRequest} || json.ParseError(json.Scanner);
// start http methods
@ -2709,7 +2709,7 @@ pub fn deleteTestEntitlement(self: *Self, application_id: Snowflake) RequestFail
}
/// Returns all SKUs for a given application.
pub fn fetchSkus(self: *Self, application_id: Snowflake) RequestFailedError!zjson.Owner([]Types.Sku) {
pub fn fetchSkus(self: *Self, application_id: Snowflake) RequestFailedError!Result([]Types.Sku) {
var buf: [256]u8 = undefined;
const path = try std.fmt.bufPrint(&buf, "/applications/{d}/skus", .{application_id.into()});

2
src/structures/application.zig
View File

@ -21,7 +21,7 @@ const Partial = @import("partial.zig").Partial;
const User = @import("user.zig").User;
const Team = @import("team.zig").Team;
const Guild = @import("guild.zig").Guild;
const AssociativeArray = @import("../json.zig").AssociativeArray;
const AssociativeArray = @import("../json-helper.zig").AssociativeArray;
/// https://discord.com/developers/docs/resources/application#application-object
pub const Application = struct {

67
src/structures/component.zig
View File

@ -5,7 +5,6 @@ const ButtonStyles = @import("shared.zig").ButtonStyles;
const ChannelTypes = @import("shared.zig").ChannelTypes;
const MessageComponentTypes = @import("shared.zig").MessageComponentTypes;
const zjson = @import("../json.zig");
const std = @import("std");
/// https://discord.com/developers/docs/interactions/message-components#buttons
@ -153,20 +152,20 @@ pub const SelectMenu = union(MessageComponentTypes) {
SelectMenuUsersAndRoles: SelectMenuUsersAndRoles,
SelectMenuChannels: SelectMenuChannels,
pub fn jsonParse(allocator: std.mem.Allocator, src: []const u8) !@This() {
pub fn jsonParse(allocator: std.mem.Allocator, src: anytype, _: std.json.ParseOptions) !@This() {
const value = try std.json.innerParse(std.json.Value, allocator, src, .{
.max_value_len = 0x100,
});
if (!value != .object) @panic("coulnd't match against non-object type");
if (value != .object) @panic("coulnd't match against non-object type");
switch (value.object.get("type") orelse @panic("couldn't find property `type`")) {
.integer => |num| return switch (@as(MessageComponentTypes, @enumFromInt(num))) {
.SelectMenu => .{ .SelectMenu = try std.json.parseFromValue(SelectMenuString, allocator, value, .{.max_value_len = 0x100})},
.SelectMenuUsers => .{ .SelectMenuUsers = try std.json.parseFromValue(SelectMenuUsers, allocator, value, .{.max_value_len = 0x100})},
.SelectMenuRoles => .{ .SelectMenuRoles = try std.json.parseFromValue(SelectMenuRoles, allocator, value, .{.max_value_len = 0x100})},
.SelectMenuUsersAndRoles => .{ .SelectMenuUsersAndRoles = try std.json.parseFromValue(SelectMenuUsersAndRoles, allocator, value, .{.max_value_len = 0x100})},
.SelectMenuChannels => .{ .SelectMenuChannels = try std.json.parseFromValue(SelectMenuChannels, allocator, value, .{.max_value_len = 0x100})},
.SelectMenu => .{ .SelectMenu = try std.json.parseFromValueLeaky(SelectMenuString, allocator, value, .{.max_value_len = 0x100})},
.SelectMenuUsers => .{ .SelectMenuUsers = try std.json.parseFromValueLeaky(SelectMenuUsers, allocator, value, .{.max_value_len = 0x100})},
.SelectMenuRoles => .{ .SelectMenuRoles = try std.json.parseFromValueLeaky(SelectMenuRoles, allocator, value, .{.max_value_len = 0x100})},
.SelectMenuUsersAndRoles => .{ .SelectMenuUsersAndRoles = try std.json.parseFromValueLeaky(SelectMenuUsersAndRoles, allocator, value, .{.max_value_len = 0x100})},
.SelectMenuChannels => .{ .SelectMenuChannels = try std.json.parseFromValueLeaky(SelectMenuChannels, allocator, value, .{.max_value_len = 0x100})},
},
else => @panic("got type but couldn't match against non enum member `type`"),
}
@ -175,21 +174,8 @@ pub const SelectMenu = union(MessageComponentTypes) {
}
// legacy
pub fn json(allocator: std.mem.Allocator, value: zjson.JsonType) !@This() {
if (!value.is(.object))
@panic("coulnd't match against non-object type");
switch (value.object.get("type") orelse @panic("couldn't find property `type`")) {
.number => |num| return switch (@as(MessageComponentTypes, @enumFromInt(num.integer))) {
.SelectMenu => .{ .SelectMenu = try zjson.parseInto(SelectMenuString, allocator, value) },
.SelectMenuUsers => .{ .SelectMenuUsers = try zjson.parseInto(SelectMenuUsers, allocator, value) },
.SelectMenuRoles => .{ .SelectMenuRoles = try zjson.parseInto(SelectMenuRoles, allocator, value) },
.SelectMenuUsersAndRoles => .{ .SelectMenuUsersAndRoles = try zjson.parseInto(SelectMenuUsersAndRoles, allocator, value) },
.SelectMenuChannels => .{ .SelectMenuChannels = try zjson.parseInto(SelectMenuChannels, allocator, value) },
},
else => @panic("got type but couldn't match against non enum member `type`"),
}
unreachable;
pub fn json(_: std.mem.Allocator) !SelectMenu {
@compileError("Deprecated, use std.json instead.");
}
};
@ -229,22 +215,33 @@ pub const MessageComponent = union(MessageComponentTypes) {
SelectMenuUsersAndRoles: SelectMenuUsersAndRoles,
SelectMenuChannels: SelectMenuChannels,
pub fn json(allocator: std.mem.Allocator, value: zjson.JsonType) !@This() {
if (!value.is(.object))
@panic("coulnd't match against non-object type");
/// zjson parse
/// legacy
pub fn json(_: std.mem.Allocator) void {
@compileError("Deprecated, use std.json instead.");
}
pub fn jsonParse(allocator: std.mem.Allocator, src: anytype, _: std.json.ParseOptions) !@This() {
const value = try std.json.innerParse(std.json.Value, allocator, src, .{
.max_value_len = 0x100,
});
if (value != .object) @panic("coulnd't match against non-object type");
switch (value.object.get("type") orelse @panic("couldn't find property `type`")) {
.number => |num| return switch (@as(MessageComponentTypes, @enumFromInt(num.integer))) {
.ActionRow => .{ .ActionRow = try zjson.parseInto([]MessageComponent, allocator, value) },
.Button => .{ .Button = try zjson.parseInto(Button, allocator, value) },
.SelectMenu => .{ .SelectMenu = try zjson.parseInto(SelectMenuString, allocator, value) },
.InputText => .{ .InputText = try zjson.parseInto(InputText, allocator, value) },
.SelectMenuUsers => .{ .SelectMenuUsers = try zjson.parseInto(SelectMenuUsers, allocator, value) },
.SelectMenuRoles => .{ .SelectMenuRoles = try zjson.parseInto(SelectMenuRoles, allocator, value) },
.SelectMenuUsersAndRoles => .{ .SelectMenuUsersAndRoles = try zjson.parseInto(SelectMenuUsersAndRoles, allocator, value) },
.SelectMenuChannels => .{ .SelectMenuChannels = try zjson.parseInto(SelectMenuChannels, allocator, value) },
.integer => |num| return switch (@as(MessageComponentTypes, @enumFromInt(num))) {
.ActionRow => .{ .ActionRow = try std.json.parseFromValueLeaky([]MessageComponent, allocator, value, .{.max_value_len = 0x100}) },
.Button => .{ .Button = try std.json.parseFromValueLeaky(Button, allocator, value, .{.max_value_len = 0x100}) },
.SelectMenu => .{ .SelectMenu = try std.json.parseFromValueLeaky(SelectMenuString, allocator, value, .{.max_value_len = 0x100})},
.InputText => .{ .InputText = try std.json.parseFromValueLeaky(InputText, allocator, value, .{.max_value_len = 0x100}) },
.SelectMenuUsers => .{ .SelectMenuUsers = try std.json.parseFromValueLeaky(SelectMenuUsers, allocator, value, .{.max_value_len = 0x100})},
.SelectMenuRoles => .{ .SelectMenuRoles = try std.json.parseFromValueLeaky(SelectMenuRoles, allocator, value, .{.max_value_len = 0x100})},
.SelectMenuUsersAndRoles => .{ .SelectMenuUsersAndRoles = try std.json.parseFromValueLeaky(SelectMenuUsersAndRoles, allocator, value, .{.max_value_len = 0x100})},
.SelectMenuChannels => .{ .SelectMenuChannels = try std.json.parseFromValueLeaky(SelectMenuChannels, allocator, value, .{.max_value_len = 0x100})},
},
else => @panic("got type but couldn't match against non enum member `type`"),
}
return try MessageComponent.jsonParse(allocator, value);
}
};

2
src/structures/interaction.zig
View File

@ -32,7 +32,7 @@ const ApplicationCommandTypes = @import("shared.zig").ApplicationCommandTypes;
const InteractionResponseTypes = @import("shared.zig").InteractionResponseTypes;
const InteractionContextType = @import("command.zig").InteractionContextType;
const Entitlement = @import("monetization.zig").Entitlement;
const Record = @import("../json.zig").Record;
const Record = @import("../json-helper.zig").Record;
pub const Interaction = struct {
/// Id of the interaction

12
src/structures/snowflake.zig
View File

@ -15,7 +15,6 @@
//! PERFORMANCE OF THIS SOFTWARE.
const std = @import("std");
const zjson = @import("../json.zig");
/// Milliseconds since Discord Epoch, the first second of 2015 or 1420070400000.
pub const discord_epoch = 1420070400000;
@ -55,16 +54,13 @@ pub const Snowflake = enum(u64) {
/// zjson parse
/// legacy
pub fn json(_: std.mem.Allocator, value: zjson.JsonType) !@This() {
if (value.is(.string))
return Snowflake.fromRaw(value.string) catch
std.debug.panic("invalid snowflake: {s}\n", .{value.string});
unreachable;
pub fn json(_: std.mem.Allocator) void {
@compileError("Deprecated, use std.json instead.");
}
/// std.json parse
pub fn jsonParse(allocator: std.mem.Allocator, src: []const u8) !@This() {
const value = try std.json.parseFromSlice(std.json.Value, allocator, src, .{
pub fn jsonParse(allocator: std.mem.Allocator, src: anytype, _: std.json.ParseOptions) !@This() {
const value = try std.json.innerParse(std.json.Value, allocator, src, .{
.max_value_len = 0x100
});

2
src/structures/user.zig
View File

@ -20,7 +20,7 @@ const Application = @import("application.zig").Application;
const OAuth2Scope = @import("shared.zig").OAuth2Scope;
const Integration = @import("integration.zig").Integration;
const Partial = @import("partial.zig").Partial;
const Record = @import("../json.zig").Record;
const Record = @import("../json-helper.zig").Record;
/// https://discord.com/developers/docs/resources/user#user-object
pub const User = struct {