tigerbeetle-node 0.8.1 → 0.9.143

package/src/test.ts

@@ -18,28 +18,32 @@ const Zeroed32Bytes = Buffer.alloc(32, 0)
 const Zeroed48Bytes = Buffer.alloc(48, 0)
 const accountA: Account = {
   id: 17n,
-  user_data: 0n,
-  reserved: Zeroed48Bytes,
-  ledger: 1,
-  code: 718,
-  flags: 0,
   debits_pending: 0n,
   debits_posted: 0n,
   credits_pending: 0n,
-  credits_posted: 0n,
+  credits_posted: 0n,  
+  user_data_128: 0n,
+  user_data_64: 0n,
+  user_data_32: 0,
+  reserved: 0,
+  ledger: 1,
+  code: 718,
+  flags: 0,
   timestamp: 0n // this will be set correctly by the TigerBeetle server
 }
 const accountB: Account = {
   id: 19n,
-  user_data: 0n,
-  reserved: Zeroed48Bytes,
-  ledger: 1,
-  code: 719,
-  flags: 0,
   debits_pending: 0n,
   debits_posted: 0n,
   credits_pending: 0n,
-  credits_posted: 0n,
+  credits_posted: 0n,  
+  user_data_128: 0n,
+  user_data_64: 0n,
+  user_data_32: 0,
+  reserved: 0,
+  ledger: 1,
+  code: 719,
+  flags: 0,
   timestamp: 0n // this will be set correctly by the TigerBeetle server
 }
 
@@ -71,7 +75,7 @@ test('can return error on account', async (): Promise<void> => {
   const errors = await client.createAccounts([accountA, accountB])
 
   assert.strictEqual(errors.length, 1)
-  assert.deepStrictEqual(errors[0], { index: 0, code: CreateAccountError.exists })
+  assert.deepStrictEqual(errors[0], { index: 0, result: CreateAccountError.exists })
 })
 
 test('throws error if timestamp is not set to 0n on account', async (): Promise<void> => {
@@ -85,28 +89,30 @@ test('can lookup accounts', async (): Promise<void> => {
   assert.strictEqual(accounts.length, 2)
   const account1 = accounts[0]
   assert.strictEqual(account1.id, 17n)
-  assert.ok(account1.reserved.equals(Zeroed48Bytes))
-  assert.strictEqual(account1.user_data, 0n)
-  assert.strictEqual(account1.code, 718)
-  assert.strictEqual(account1.ledger, 1)
-  assert.strictEqual(account1.flags, 0)
   assert.strictEqual(account1.credits_posted, 0n)
   assert.strictEqual(account1.credits_pending, 0n)
   assert.strictEqual(account1.debits_posted, 0n)
-  assert.strictEqual(account1.debits_pending, 0n)
+  assert.strictEqual(account1.debits_pending, 0n)  
+  assert.strictEqual(account1.user_data_128, 0n)
+  assert.strictEqual(account1.user_data_64, 0n)
+  assert.strictEqual(account1.user_data_32, 0)
+  assert.strictEqual(account1.code, 718)
+  assert.strictEqual(account1.ledger, 1)
+  assert.strictEqual(account1.flags, 0)
   assert.ok(account1.timestamp > 0n)
 
   const account2 = accounts[1]
   assert.strictEqual(account2.id, 19n)
-  assert.ok(account2.reserved.equals(Zeroed48Bytes))
-  assert.strictEqual(account2.user_data, 0n)
-  assert.strictEqual(account2.code, 719)
-  assert.strictEqual(account2.ledger, 1)
-  assert.strictEqual(account2.flags, 0)
   assert.strictEqual(account2.credits_posted, 0n)
   assert.strictEqual(account2.credits_pending, 0n)
   assert.strictEqual(account2.debits_posted, 0n)
   assert.strictEqual(account2.debits_pending, 0n)
+  assert.strictEqual(account2.user_data_128, 0n)
+  assert.strictEqual(account2.user_data_64, 0n)
+  assert.strictEqual(account2.user_data_32, 0)
+  assert.strictEqual(account2.code, 719)
+  assert.strictEqual(account2.ledger, 1)
+  assert.strictEqual(account2.flags, 0)
   assert.ok(account2.timestamp > 0n)
 })
 
@@ -115,14 +121,15 @@ test('can create a transfer', async (): Promise<void> => {
     id: 1n,
     debit_account_id: accountB.id,
     credit_account_id: accountA.id,
-    user_data: 0n,
-    reserved: 0n,
+    amount: 100n,
+    user_data_128: 0n,
+    user_data_64: 0n,
+    user_data_32: 0,
     pending_id: 0n,
-    timeout: 0n,
+    timeout: 0,
     ledger: 1,
     code: 1,
     flags: 0,
-    amount: 100n,
     timestamp: 0n, // this will be set correctly by the TigerBeetle server
   }
 
@@ -149,14 +156,15 @@ test('can create a two-phase transfer', async (): Promise<void> => {
     id: 2n,
     debit_account_id: accountB.id,
     credit_account_id: accountA.id,
-    user_data: 0n,
-    reserved: 0n,
+    amount: 50n,
+    user_data_128: 0n,
+    user_data_64: 0n,
+    user_data_32: 0,
     pending_id: 0n,
-    timeout: BigInt(2e9),
+    timeout: 2e9,
     ledger: 1,
     code: 1,
     flags,
-    amount: 50n,
     timestamp: 0n, // this will be set correctly by the TigerBeetle server
   }
 
@@ -181,12 +189,13 @@ test('can create a two-phase transfer', async (): Promise<void> => {
   assert.strictEqual(transfers[0].id, 2n)
   assert.strictEqual(transfers[0].debit_account_id, accountB.id)
   assert.strictEqual(transfers[0].credit_account_id, accountA.id)
-  assert.strictEqual(transfers[0].user_data, 0n)
-  assert.notStrictEqual(transfers[0].reserved, Zeroed32Bytes)
+  assert.strictEqual(transfers[0].amount, 50n)
+  assert.strictEqual(transfers[0].user_data_128, 0n)
+  assert.strictEqual(transfers[0].user_data_64, 0n)
+  assert.strictEqual(transfers[0].user_data_32, 0)
   assert.strictEqual(transfers[0].timeout > 0, true)
   assert.strictEqual(transfers[0].code, 1)
   assert.strictEqual(transfers[0].flags, 2)
-  assert.strictEqual(transfers[0].amount, 50n)
   assert.strictEqual(transfers[0].timestamp > 0, true)
 })
 
@@ -198,14 +207,15 @@ test('can post a two-phase transfer', async (): Promise<void> => {
     id: 3n,
     debit_account_id: BigInt(0),
     credit_account_id: BigInt(0),
-    user_data: 0n,
-    reserved: 0n,
+    amount: 0n,
+    user_data_128: 0n,
+    user_data_64: 0n,
+    user_data_32: 0,
     pending_id: 2n,// must match the id of the pending transfer
-    timeout: 0n,
+    timeout: 0,
     ledger: 1,
     code: 1,
     flags: flags,
-    amount: 0n,
     timestamp: 0n, // this will be set correctly by the TigerBeetle server
   }
 
@@ -231,14 +241,15 @@ test('can reject a two-phase transfer', async (): Promise<void> => {
     id: 4n,
     debit_account_id: accountB.id,
     credit_account_id: accountA.id,
-    user_data: 0n,
-    reserved: 0n,
+    amount: 50n,
+    user_data_128: 0n,
+    user_data_64: 0n,
+    user_data_32: 0,
     pending_id: 0n,
-    timeout: BigInt(1e9),
+    timeout: 1e9,
     ledger: 1,
     code: 1,
     flags: TransferFlags.pending,
-    amount: 50n,
     timestamp: 0n, // this will be set correctly by the TigerBeetle server
   }
   const transferErrors = await client.createTransfers([transfer])
@@ -249,14 +260,15 @@ test('can reject a two-phase transfer', async (): Promise<void> => {
     id: 5n,
     debit_account_id: BigInt(0),
     credit_account_id: BigInt(0),
-    user_data: 0n,
-    reserved: 0n,
+    amount: 0n,
+    user_data_128: 0n,
+    user_data_64: 0n,
+    user_data_32: 0,
     pending_id: 4n, // must match the id of the pending transfer
-    timeout: 0n,
+    timeout: 0,
     ledger: 1,
     code: 1,
     flags: TransferFlags.void_pending_transfer,
-    amount: 0n,
     timestamp: 0n, // this will be set correctly by the TigerBeetle server
   }
 
@@ -281,37 +293,39 @@ test('can link transfers', async (): Promise<void> => {
     id: 6n,
     debit_account_id: accountB.id,
     credit_account_id: accountA.id,
-    user_data: 0n,
-    reserved: 0n,
+    amount: 100n,
+    user_data_128: 0n,
+    user_data_64: 0n,
+    user_data_32: 0,
     pending_id: 0n,
-    timeout: 0n,
+    timeout: 0,
     ledger: 1,
     code: 1,
     flags: TransferFlags.linked, // points to transfer2
-    amount: 100n,
     timestamp: 0n, // will be set correctly by the TigerBeetle server
   }
   const transfer2: Transfer = {
     id: 6n,
     debit_account_id: accountB.id,
     credit_account_id: accountA.id,
-    user_data: 0n,
-    reserved: 0n,
+    amount: 100n,
+    user_data_128: 0n,
+    user_data_64: 0n,
+    user_data_32: 0,
     pending_id: 0n,
-    timeout: 0n,
+    timeout: 0,
     ledger: 1,
     code: 1,
     // Does not have linked flag as it is the end of the chain.
     // This will also cause it to fail as this is now a duplicate with different flags
     flags: 0,
-    amount: 100n,
     timestamp: 0n, // will be set correctly by the TigerBeetle server
   }
 
   const errors = await client.createTransfers([transfer1, transfer2])
   assert.strictEqual(errors.length, 2)
-  assert.deepStrictEqual(errors[0], { index: 0, code: CreateTransferError.linked_event_failed })
-  assert.deepStrictEqual(errors[1], { index: 1, code: CreateTransferError.exists_with_different_flags })
+  assert.deepStrictEqual(errors[0], { index: 0, result: CreateTransferError.linked_event_failed })
+  assert.deepStrictEqual(errors[1], { index: 1, result: CreateTransferError.exists_with_different_flags })
 
   const accounts = await client.lookupAccounts([accountA.id, accountB.id])
   assert.strictEqual(accounts.length, 2)

package/src/translate.zig

@@ -6,21 +6,21 @@ pub fn register_function(
     env: c.napi_env,
     exports: c.napi_value,
     comptime name: [:0]const u8,
-    function: fn (env: c.napi_env, info: c.napi_callback_info) callconv(.C) c.napi_value,
+    function: *const 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) != c.napi_ok) {
         return throw(env, "Failed to create function " ++ name ++ "().");
     }
 
-    if (c.napi_set_named_property(env, exports, name, napi_function) != c.napi_ok) {
+    if (c.napi_set_named_property(env, exports, @as([*c]const u8, @ptrCast(name)), napi_function) != c.napi_ok) {
         return throw(env, "Failed to add " ++ name ++ "() to exports.");
     }
 }
 
 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);
+    var result = c.napi_throw_error(env, null, @as([*c]const u8, @ptrCast(message)));
     switch (result) {
         c.napi_ok, c.napi_pending_exception => {},
         else => unreachable,
@@ -41,7 +41,7 @@ pub fn capture_undefined(env: c.napi_env) !c.napi_value {
 pub fn set_instance_data(
     env: c.napi_env,
     data: *anyopaque,
-    finalize_callback: fn (env: c.napi_env, data: ?*anyopaque, hint: ?*anyopaque) callconv(.C) void,
+    finalize_callback: *const fn (env: c.napi_env, data: ?*anyopaque, hint: ?*anyopaque) callconv(.C) void,
 ) !void {
     if (c.napi_set_instance_data(env, data, finalize_callback, null) != c.napi_ok) {
         return throw(env, "Failed to initialize environment.");
@@ -70,7 +70,7 @@ pub fn value_external(
     return result;
 }
 
-pub const UserData = packed struct {
+pub const UserData = extern struct {
     env: c.napi_env,
     callback_reference: c.napi_ref,
 };
@@ -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) != c.napi_ok) {
+    if (c.napi_get_named_property(env, object, @as([*c]const u8, @ptrCast(key)), &property) != c.napi_ok) {
         return throw(env, key ++ " must be defined");
     }
 
@@ -133,7 +133,7 @@ pub fn slice_from_value(
 
     if (data_length < 1) return throw(env, key ++ " must not be empty");
 
-    return @ptrCast([*]u8, data.?)[0..data_length];
+    return @as([*]u8, @ptrCast(data.?))[0..data_length];
 }
 
 pub fn bytes_from_object(
@@ -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) != c.napi_ok) {
+    if (c.napi_get_named_property(env, object, @as([*c]const u8, @ptrCast(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) != c.napi_ok) {
+    if (c.napi_get_named_property(env, object, @as([*c]const u8, @ptrCast(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) != c.napi_ok) {
+    if (c.napi_get_named_property(env, object, @as([*c]const u8, @ptrCast(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) != c.napi_ok) {
+    if (c.napi_get_named_property(env, object, @as([*c]const u8, @ptrCast(key)), &property) != c.napi_ok) {
         return throw(env, key ++ " must be defined");
     }
 
@@ -212,7 +212,7 @@ pub fn u16_from_object(env: c.napi_env, object: c.napi_value, comptime key: [:0]
         return throw(env, key ++ " must be a u16.");
     }
 
-    return @intCast(u16, result);
+    return @as(u16, @intCast(result));
 }
 
 pub fn u128_from_value(env: c.napi_env, value: c.napi_value, comptime name: [:0]const u8) !u128 {
@@ -222,7 +222,7 @@ pub fn u128_from_value(env: c.napi_env, value: c.napi_value, comptime name: [:0]
     // we would need to convert, but big endian is not supported by tigerbeetle.
     var result: u128 = 0;
     var sign_bit: c_int = undefined;
-    const words = @ptrCast(*[2]u64, &result);
+    const words = @as(*[2]u64, @ptrCast(&result));
     var word_count: usize = 2;
     switch (c.napi_get_value_bigint_words(env, value, &sign_bit, &word_count, words)) {
         c.napi_ok => {},
@@ -274,7 +274,7 @@ pub fn byte_slice_into_object(
         return throw(env, error_message ++ " Failed to allocate Buffer in V8.");
     }
 
-    if (c.napi_set_named_property(env, object, key, result) != c.napi_ok) {
+    if (c.napi_set_named_property(env, object, @as([*c]const u8, @ptrCast(key)), result) != c.napi_ok) {
         return throw(env, error_message);
     }
 }
@@ -295,13 +295,13 @@ pub fn u128_into_object(
         env,
         0,
         2,
-        @ptrCast(*const [2]u64, &value),
+        @as(*const [2]u64, @ptrCast(&value)),
         &bigint,
     ) != c.napi_ok) {
         return throw(env, error_message);
     }
 
-    if (c.napi_set_named_property(env, object, key, bigint) != c.napi_ok) {
+    if (c.napi_set_named_property(env, object, @as([*c]const u8, @ptrCast(key)), bigint) != c.napi_ok) {
         return throw(env, error_message);
     }
 }
@@ -318,7 +318,7 @@ pub fn u64_into_object(
         return throw(env, error_message);
     }
 
-    if (c.napi_set_named_property(env, object, key, result) != c.napi_ok) {
+    if (c.napi_set_named_property(env, object, @as([*c]const u8, @ptrCast(key)), result) != c.napi_ok) {
         return throw(env, error_message);
     }
 }
@@ -335,7 +335,7 @@ pub fn u32_into_object(
         return throw(env, error_message);
     }
 
-    if (c.napi_set_named_property(env, object, key, result) != c.napi_ok) {
+    if (c.napi_set_named_property(env, object, @as([*c]const u8, @ptrCast(key)), result) != c.napi_ok) {
         return throw(env, error_message);
     }
 }
@@ -370,7 +370,7 @@ fn create_buffer(
         return throw(env, error_message);
     }
 
-    std.mem.copy(u8, @ptrCast([*]u8, data.?)[0..value.len], value[0..value.len]);
+    std.mem.copy(u8, @as([*]u8, @ptrCast(data.?))[0..value.len], value[0..value.len]);
 
     return result;
 }
@@ -426,23 +426,6 @@ pub fn delete_reference(env: c.napi_env, reference: c.napi_ref) !void {
     }
 }
 
-pub fn create_error(
-    env: c.napi_env,
-    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) != c.napi_ok) {
-        return TranslationError.ExceptionThrown;
-    }
-
-    var napi_error: c.napi_value = undefined;
-    if (c.napi_create_error(env, null, napi_string, &napi_error) != c.napi_ok) {
-        return TranslationError.ExceptionThrown;
-    }
-
-    return napi_error;
-}
-
 pub fn call_function(
     env: c.napi_env,
     this: c.napi_value,