tigerbeetle-node 0.4.2 → 0.5.2

package/src/tigerbeetle/src/vsr.zig

@@ -16,7 +16,7 @@ pub const Clock = @import("vsr/clock.zig").Clock;
 pub const Journal = @import("vsr/journal.zig").Journal;
 
 /// Viewstamped Replication protocol commands:
-pub const Command = packed enum(u8) {
+pub const Command = enum(u8) {
     reserved,
 
     ping,
@@ -387,14 +387,14 @@ pub const Timeout = struct {
     /// Allows the attempts counter to wrap from time to time.
     /// The overflow period is kept short to surface any related bugs sooner rather than later.
     /// We do not saturate the counter as this would cause round-robin retries to get stuck.
-    pub fn backoff(self: *Timeout, prng: *std.rand.DefaultPrng) void {
+    pub fn backoff(self: *Timeout, random: std.rand.Random) void {
         assert(self.ticking);
 
         self.ticks = 0;
         self.attempts +%= 1;
 
         log.debug("{}: {s} backing off", .{ self.id, self.name });
-        self.set_after_for_rtt_and_attempts(prng);
+        self.set_after_for_rtt_and_attempts(random);
     }
 
     /// It's important to check that when fired() is acted on that the timeout is stopped/started,
@@ -403,7 +403,7 @@ pub const Timeout = struct {
         if (self.ticking and self.ticks >= self.after) {
             log.debug("{}: {s} fired", .{ self.id, self.name });
             if (self.ticks > self.after) {
-                log.emerg("{}: {s} is firing every tick", .{ self.id, self.name });
+                log.err("{}: {s} is firing every tick", .{ self.id, self.name });
                 @panic("timeout was not reset correctly");
             }
             return true;
@@ -423,13 +423,13 @@ pub const Timeout = struct {
     /// Sets the value of `after` as a function of `rtt` and `attempts`.
     /// Adds exponential backoff and jitter.
     /// May be called only after a timeout has been stopped or reset, to prevent backward jumps.
-    pub fn set_after_for_rtt_and_attempts(self: *Timeout, prng: *std.rand.DefaultPrng) void {
+    pub fn set_after_for_rtt_and_attempts(self: *Timeout, random: std.rand.Random) void {
         // If `after` is reduced by this function to less than `ticks`, then `fired()` will panic:
         assert(self.ticks == 0);
         assert(self.rtt > 0);
 
         const after = (self.rtt * self.rtt_multiple) + exponential_backoff_with_jitter(
-            prng,
+            random,
             config.backoff_min_ticks,
             config.backoff_max_ticks,
             self.attempts,
@@ -488,7 +488,7 @@ pub const Timeout = struct {
 
 /// Calculates exponential backoff with jitter to prevent cascading failure due to thundering herds.
 pub fn exponential_backoff_with_jitter(
-    prng: *std.rand.DefaultPrng,
+    random: std.rand.Random,
     min: u64,
     max: u64,
     attempt: u64,
@@ -504,35 +504,39 @@ pub fn exponential_backoff_with_jitter(
     // 1<<0 = 1, 1<<1 = 2, 1<<2 = 4, 1<<3 = 8
     const power = std.math.shlExact(u128, 1, exponent) catch unreachable; // Do not truncate.
 
+    // Ensure that `backoff` is calculated correctly when min is 0, taking `std.math.max(1, min)`.
+    // Otherwise, the final result will always be 0. This was an actual bug we encountered.
+    const min_non_zero = std.math.max(1, min);
+    assert(min_non_zero > 0);
+    assert(power > 0);
+
     // Calculate the capped exponential backoff component, `min(range, min * 2 ^ attempt)`:
-    const backoff = std.math.min(range, std.math.max(1, min) * power);
-    const jitter = prng.random.uintAtMostBiased(u64, backoff);
+    const backoff = std.math.min(range, min_non_zero * power);
+    const jitter = random.uintAtMostBiased(u64, backoff);
 
     const result = @intCast(u64, min + jitter);
     assert(result >= min);
     assert(result <= max);
+
     return result;
 }
 
 test "exponential_backoff_with_jitter" {
     const testing = std.testing;
 
-    const attempts = 1000;
     var prng = std.rand.DefaultPrng.init(0);
+    const random = prng.random();
+
+    const attempts = 1000;
     const max: u64 = std.math.maxInt(u64);
     const min = max - attempts;
+
     var attempt = max - attempts;
     while (attempt < max) : (attempt += 1) {
-        const ebwj = exponential_backoff_with_jitter(&prng, min, max, attempt);
+        const ebwj = exponential_backoff_with_jitter(random, min, max, attempt);
         try testing.expect(ebwj >= min);
         try testing.expect(ebwj <= max);
     }
-
-    // Check that `backoff` is calculated correctly when min is 0 by taking `std.math.max(1, min)`.
-    // Otherwise, the final result will always be 0. This was an actual bug we encountered.
-    // If the PRNG ever changes, then there is a small chance that we may collide for 0,
-    // but this is outweighed by the probability that we refactor and fail to take the max.
-    try testing.expect(exponential_backoff_with_jitter(&prng, 0, max, 0) > 0);
 }
 
 /// Returns An array containing the remote or local addresses of each of the 2f + 1 replicas:
@@ -544,17 +548,17 @@ test "exponential_backoff_with_jitter" {
 /// The caller owns the memory of the returned slice of addresses.
 /// TODO Unit tests.
 /// TODO Integrate into `src/cli.zig`.
-pub fn parse_addresses(allocator: *std.mem.Allocator, raw: []const u8) ![]std.net.Address {
+pub fn parse_addresses(allocator: std.mem.Allocator, raw: []const u8) ![]std.net.Address {
     var addresses = try allocator.alloc(std.net.Address, config.replicas_max);
     errdefer allocator.free(addresses);
 
     var index: usize = 0;
-    var comma_iterator = std.mem.split(raw, ",");
+    var comma_iterator = std.mem.split(u8, raw, ",");
     while (comma_iterator.next()) |raw_address| : (index += 1) {
         if (raw_address.len == 0) return error.AddressHasTrailingComma;
         if (index == config.replicas_max) return error.AddressLimitExceeded;
 
-        var colon_iterator = std.mem.split(raw_address, ":");
+        var colon_iterator = std.mem.split(u8, raw_address, ":");
         // The split iterator will always return non-null once, even if the delimiter is not found:
         const raw_ipv4 = colon_iterator.next().?;
 

package/src/translate.zig

@@ -9,11 +9,11 @@ pub fn register_function(
     function: fn (env: c.napi_env, info: c.napi_callback_info) callconv(.C) c.napi_value,
 ) !void {
     var napi_function: c.napi_value = undefined;
-    if (c.napi_create_function(env, null, 0, function, null, &napi_function) != .napi_ok) {
+    if (c.napi_create_function(env, null, 0, function, null, &napi_function) != c.napi_ok) {
         return throw(env, "Failed to create function " ++ name ++ "().");
     }
 
-    if (c.napi_set_named_property(env, exports, name, napi_function) != .napi_ok) {
+    if (c.napi_set_named_property(env, exports, name, napi_function) != c.napi_ok) {
         return throw(env, "Failed to add " ++ name ++ "() to exports.");
     }
 }
@@ -22,7 +22,7 @@ const TranslationError = error{ExceptionThrown};
 pub fn throw(env: c.napi_env, comptime message: [:0]const u8) TranslationError {
     var result = c.napi_throw_error(env, null, message);
     switch (result) {
-        .napi_ok, .napi_pending_exception => {},
+        c.napi_ok, c.napi_pending_exception => {},
         else => unreachable,
     }
 
@@ -31,7 +31,7 @@ pub fn throw(env: c.napi_env, comptime message: [:0]const u8) TranslationError {
 
 pub fn capture_undefined(env: c.napi_env) !c.napi_value {
     var result: c.napi_value = undefined;
-    if (c.napi_get_undefined(env, &result) != .napi_ok) {
+    if (c.napi_get_undefined(env, &result) != c.napi_ok) {
         return throw(env, "Failed to capture the value of \"undefined\".");
     }
 
@@ -40,17 +40,17 @@ pub fn capture_undefined(env: c.napi_env) !c.napi_value {
 
 pub fn set_instance_data(
     env: c.napi_env,
-    data: *c_void,
-    finalize_callback: fn (env: c.napi_env, data: ?*c_void, hint: ?*c_void) callconv(.C) void,
+    data: *anyopaque,
+    finalize_callback: fn (env: c.napi_env, data: ?*anyopaque, hint: ?*anyopaque) callconv(.C) void,
 ) !void {
-    if (c.napi_set_instance_data(env, data, finalize_callback, null) != .napi_ok) {
+    if (c.napi_set_instance_data(env, data, finalize_callback, null) != c.napi_ok) {
         return throw(env, "Failed to initialize environment.");
     }
 }
 
-pub fn create_external(env: c.napi_env, context: *c_void) !c.napi_value {
+pub fn create_external(env: c.napi_env, context: *anyopaque) !c.napi_value {
     var result: c.napi_value = null;
-    if (c.napi_create_external(env, context, null, null, &result) != .napi_ok) {
+    if (c.napi_create_external(env, context, null, null, &result) != c.napi_ok) {
         return throw(env, "Failed to create external for client context.");
     }
 
@@ -61,9 +61,9 @@ pub fn value_external(
     env: c.napi_env,
     value: c.napi_value,
     comptime error_message: [:0]const u8,
-) !?*c_void {
-    var result: ?*c_void = undefined;
-    if (c.napi_get_value_external(env, value, &result) != .napi_ok) {
+) !?*anyopaque {
+    var result: ?*anyopaque = undefined;
+    if (c.napi_get_value_external(env, value, &result) != c.napi_ok) {
         return throw(env, error_message);
     }
 
@@ -79,13 +79,13 @@ pub const UserData = packed struct {
 /// This reference will be destroyed when we return the server response to JS.
 pub fn user_data_from_value(env: c.napi_env, value: c.napi_value) !UserData {
     var callback_type: c.napi_valuetype = undefined;
-    if (c.napi_typeof(env, value, &callback_type) != .napi_ok) {
+    if (c.napi_typeof(env, value, &callback_type) != c.napi_ok) {
         return throw(env, "Failed to check callback type.");
     }
-    if (callback_type != .napi_function) return throw(env, "Callback must be a Function.");
+    if (callback_type != c.napi_function) return throw(env, "Callback must be a Function.");
 
     var callback_reference: c.napi_ref = undefined;
-    if (c.napi_create_reference(env, value, 1, &callback_reference) != .napi_ok) {
+    if (c.napi_create_reference(env, value, 1, &callback_reference) != c.napi_ok) {
         return throw(env, "Failed to create reference to callback.");
     }
 
@@ -95,9 +95,9 @@ pub fn user_data_from_value(env: c.napi_env, value: c.napi_value) !UserData {
     };
 }
 
-pub fn globals(env: c.napi_env) !?*c_void {
-    var data: ?*c_void = null;
-    if (c.napi_get_instance_data(env, &data) != .napi_ok) {
+pub fn globals(env: c.napi_env) !?*anyopaque {
+    var data: ?*anyopaque = null;
+    if (c.napi_get_instance_data(env, &data) != c.napi_ok) {
         return throw(env, "Failed to decode globals.");
     }
 
@@ -110,7 +110,7 @@ pub fn slice_from_object(
     comptime key: [:0]const u8,
 ) ![]const u8 {
     var property: c.napi_value = undefined;
-    if (c.napi_get_named_property(env, object, key, &property) != .napi_ok) {
+    if (c.napi_get_named_property(env, object, key, &property) != c.napi_ok) {
         return throw(env, key ++ " must be defined");
     }
 
@@ -123,13 +123,13 @@ pub fn slice_from_value(
     comptime key: [:0]const u8,
 ) ![]u8 {
     var is_buffer: bool = undefined;
-    assert(c.napi_is_buffer(env, value, &is_buffer) == .napi_ok);
+    assert(c.napi_is_buffer(env, value, &is_buffer) == c.napi_ok);
 
     if (!is_buffer) return throw(env, key ++ " must be a buffer");
 
-    var data: ?*c_void = null;
+    var data: ?*anyopaque = null;
     var data_length: usize = undefined;
-    assert(c.napi_get_buffer_info(env, value, &data, &data_length) == .napi_ok);
+    assert(c.napi_get_buffer_info(env, value, &data, &data_length) == c.napi_ok);
 
     if (data_length < 1) return throw(env, key ++ " must not be empty");
 
@@ -143,7 +143,7 @@ pub fn bytes_from_object(
     comptime key: [:0]const u8,
 ) ![length]u8 {
     var property: c.napi_value = undefined;
-    if (c.napi_get_named_property(env, object, key, &property) != .napi_ok) {
+    if (c.napi_get_named_property(env, object, key, &property) != c.napi_ok) {
         return throw(env, key ++ " must be defined");
     }
 
@@ -181,7 +181,7 @@ pub fn bytes_from_buffer(
 
 pub fn u128_from_object(env: c.napi_env, object: c.napi_value, comptime key: [:0]const u8) !u128 {
     var property: c.napi_value = undefined;
-    if (c.napi_get_named_property(env, object, key, &property) != .napi_ok) {
+    if (c.napi_get_named_property(env, object, key, &property) != c.napi_ok) {
         return throw(env, key ++ " must be defined");
     }
 
@@ -190,7 +190,7 @@ pub fn u128_from_object(env: c.napi_env, object: c.napi_value, comptime key: [:0
 
 pub fn u64_from_object(env: c.napi_env, object: c.napi_value, comptime key: [:0]const u8) !u64 {
     var property: c.napi_value = undefined;
-    if (c.napi_get_named_property(env, object, key, &property) != .napi_ok) {
+    if (c.napi_get_named_property(env, object, key, &property) != c.napi_ok) {
         return throw(env, key ++ " must be defined");
     }
 
@@ -199,7 +199,7 @@ pub fn u64_from_object(env: c.napi_env, object: c.napi_value, comptime key: [:0]
 
 pub fn u32_from_object(env: c.napi_env, object: c.napi_value, comptime key: [:0]const u8) !u32 {
     var property: c.napi_value = undefined;
-    if (c.napi_get_named_property(env, object, key, &property) != .napi_ok) {
+    if (c.napi_get_named_property(env, object, key, &property) != c.napi_ok) {
         return throw(env, key ++ " must be defined");
     }
 
@@ -225,8 +225,8 @@ pub fn u128_from_value(env: c.napi_env, value: c.napi_value, comptime name: [:0]
     const words = @ptrCast(*[2]u64, &result);
     var word_count: usize = 2;
     switch (c.napi_get_value_bigint_words(env, value, &sign_bit, &word_count, words)) {
-        .napi_ok => {},
-        .napi_bigint_expected => return throw(env, name ++ " must be a BigInt"),
+        c.napi_ok => {},
+        c.napi_bigint_expected => return throw(env, name ++ " must be a BigInt"),
         else => unreachable,
     }
     if (sign_bit != 0) return throw(env, name ++ " must be positive");
@@ -239,8 +239,8 @@ pub fn u64_from_value(env: c.napi_env, value: c.napi_value, comptime name: [:0]c
     var result: u64 = undefined;
     var lossless: bool = undefined;
     switch (c.napi_get_value_bigint_uint64(env, value, &result, &lossless)) {
-        .napi_ok => {},
-        .napi_bigint_expected => return throw(env, name ++ " must be an unsigned 64-bit BigInt"),
+        c.napi_ok => {},
+        c.napi_bigint_expected => return throw(env, name ++ " must be an unsigned 64-bit BigInt"),
         else => unreachable,
     }
     if (!lossless) return throw(env, name ++ " conversion was lossy");
@@ -254,8 +254,8 @@ pub fn u32_from_value(env: c.napi_env, value: c.napi_value, comptime name: [:0]c
     // In that case we need to use the appropriate napi method to do more type checking here.
     // We want to make sure this is: unsigned, and an integer.
     switch (c.napi_get_value_uint32(env, value, &result)) {
-        .napi_ok => {},
-        .napi_number_expected => return throw(env, name ++ " must be a number"),
+        c.napi_ok => {},
+        c.napi_number_expected => return throw(env, name ++ " must be a number"),
         else => unreachable,
     }
     return result;
@@ -270,11 +270,11 @@ pub fn byte_slice_into_object(
 ) !void {
     var result: c.napi_value = undefined;
     // create a copy that is managed by V8.
-    if (c.napi_create_buffer_copy(env, value.len, value.ptr, null, &result) != .napi_ok) {
+    if (c.napi_create_buffer_copy(env, value.len, value.ptr, null, &result) != c.napi_ok) {
         return throw(env, error_message ++ " Failed to allocate Buffer in V8.");
     }
 
-    if (c.napi_set_named_property(env, object, key, result) != .napi_ok) {
+    if (c.napi_set_named_property(env, object, key, result) != c.napi_ok) {
         return throw(env, error_message);
     }
 }
@@ -297,11 +297,11 @@ pub fn u128_into_object(
         2,
         @ptrCast(*const [2]u64, &value),
         &bigint,
-    ) != .napi_ok) {
+    ) != c.napi_ok) {
         return throw(env, error_message);
     }
 
-    if (c.napi_set_named_property(env, object, key, bigint) != .napi_ok) {
+    if (c.napi_set_named_property(env, object, key, bigint) != c.napi_ok) {
         return throw(env, error_message);
     }
 }
@@ -314,11 +314,11 @@ pub fn u64_into_object(
     comptime error_message: [:0]const u8,
 ) !void {
     var result: c.napi_value = undefined;
-    if (c.napi_create_bigint_uint64(env, value, &result) != .napi_ok) {
+    if (c.napi_create_bigint_uint64(env, value, &result) != c.napi_ok) {
         return throw(env, error_message);
     }
 
-    if (c.napi_set_named_property(env, object, key, result) != .napi_ok) {
+    if (c.napi_set_named_property(env, object, key, result) != c.napi_ok) {
         return throw(env, error_message);
     }
 }
@@ -331,18 +331,18 @@ pub fn u32_into_object(
     comptime error_message: [:0]const u8,
 ) !void {
     var result: c.napi_value = undefined;
-    if (c.napi_create_uint32(env, value, &result) != .napi_ok) {
+    if (c.napi_create_uint32(env, value, &result) != c.napi_ok) {
         return throw(env, error_message);
     }
 
-    if (c.napi_set_named_property(env, object, key, result) != .napi_ok) {
+    if (c.napi_set_named_property(env, object, key, result) != c.napi_ok) {
         return throw(env, error_message);
     }
 }
 
 pub fn create_object(env: c.napi_env, comptime error_message: [:0]const u8) !c.napi_value {
     var result: c.napi_value = undefined;
-    if (c.napi_create_object(env, &result) != .napi_ok) {
+    if (c.napi_create_object(env, &result) != c.napi_ok) {
         return throw(env, error_message);
     }
 
@@ -354,9 +354,9 @@ fn create_buffer(
     value: []const u8,
     comptime error_message: [:0]const u8,
 ) !c.napi_value {
-    var data: ?*c_void = undefined;
+    var data: ?*anyopaque = undefined;
     var result: c.napi_value = undefined;
-    if (c.napi_create_buffer(env, value.len, &data, &result) != .napi_ok) {
+    if (c.napi_create_buffer(env, value.len, &data, &result) != c.napi_ok) {
         return throw(env, error_message);
     }
 
@@ -371,7 +371,7 @@ pub fn create_array(
     comptime error_message: [:0]const u8,
 ) !c.napi_value {
     var result: c.napi_value = undefined;
-    if (c.napi_create_array_with_length(env, length, &result) != .napi_ok) {
+    if (c.napi_create_array_with_length(env, length, &result) != c.napi_ok) {
         return throw(env, error_message);
     }
 
@@ -385,14 +385,14 @@ pub fn set_array_element(
     value: c.napi_value,
     comptime error_message: [:0]const u8,
 ) !void {
-    if (c.napi_set_element(env, array, index, value) != .napi_ok) {
+    if (c.napi_set_element(env, array, index, value) != c.napi_ok) {
         return throw(env, error_message);
     }
 }
 
 pub fn array_element(env: c.napi_env, array: c.napi_value, index: u32) !c.napi_value {
     var element: c.napi_value = undefined;
-    if (c.napi_get_element(env, array, index, &element) != .napi_ok) {
+    if (c.napi_get_element(env, array, index, &element) != c.napi_ok) {
         return throw(env, "Failed to get array element.");
     }
 
@@ -401,17 +401,17 @@ pub fn array_element(env: c.napi_env, array: c.napi_value, index: u32) !c.napi_v
 
 pub fn array_length(env: c.napi_env, array: c.napi_value) !u32 {
     var is_array: bool = undefined;
-    assert(c.napi_is_array(env, array, &is_array) == .napi_ok);
+    assert(c.napi_is_array(env, array, &is_array) == c.napi_ok);
     if (!is_array) return throw(env, "Batch must be an Array.");
 
     var length: u32 = undefined;
-    assert(c.napi_get_array_length(env, array, &length) == .napi_ok);
+    assert(c.napi_get_array_length(env, array, &length) == c.napi_ok);
 
     return length;
 }
 
 pub fn delete_reference(env: c.napi_env, reference: c.napi_ref) !void {
-    if (c.napi_delete_reference(env, reference) != .napi_ok) {
+    if (c.napi_delete_reference(env, reference) != c.napi_ok) {
         return throw(env, "Failed to delete callback reference.");
     }
 }
@@ -421,12 +421,12 @@ pub fn create_error(
     comptime message: [:0]const u8,
 ) TranslationError!c.napi_value {
     var napi_string: c.napi_value = undefined;
-    if (c.napi_create_string_utf8(env, message, std.mem.len(message), &napi_string) != .napi_ok) {
+    if (c.napi_create_string_utf8(env, message, std.mem.len(message), &napi_string) != c.napi_ok) {
         return TranslationError.ExceptionThrown;
     }
 
     var napi_error: c.napi_value = undefined;
-    if (c.napi_create_error(env, null, napi_string, &napi_error) != .napi_ok) {
+    if (c.napi_create_error(env, null, napi_string, &napi_error) != c.napi_ok) {
         return TranslationError.ExceptionThrown;
     }
 
@@ -442,17 +442,17 @@ pub fn call_function(
 ) !void {
     const result = c.napi_call_function(env, this, callback, argc, argv, null);
     switch (result) {
-        .napi_ok => {},
+        c.napi_ok => {},
         // the user's callback may throw a JS exception or call other functions that do so. We
         // therefore don't throw another error.
-        .napi_pending_exception => {},
+        c.napi_pending_exception => {},
         else => return throw(env, "Failed to invoke results callback."),
     }
 }
 
 pub fn scope(env: c.napi_env, comptime error_message: [:0]const u8) !c.napi_value {
     var result: c.napi_value = undefined;
-    if (c.napi_get_global(env, &result) != .napi_ok) {
+    if (c.napi_get_global(env, &result) != c.napi_ok) {
         return throw(env, error_message);
     }
 
@@ -465,7 +465,7 @@ pub fn reference_value(
     comptime error_message: [:0]const u8,
 ) !c.napi_value {
     var result: c.napi_value = undefined;
-    if (c.napi_get_reference_value(env, callback_reference, &result) != .napi_ok) {
+    if (c.napi_get_reference_value(env, callback_reference, &result) != c.napi_ok) {
         return throw(env, error_message);
     }