tigerbeetle-node 0.14.178 → 0.14.180

package/src/test.ts

@@ -6,8 +6,10 @@ import {
   TransferFlags,
   CreateAccountError,
   CreateTransferError,
-  GetAccountTransfers,
-  GetAccountTransfersFlags,
+  AccountFilter,
+  AccountFilterFlags,
+  AccountFlags,
+  id,
 } from '.'
 
 const client = createClient({
@@ -57,6 +59,20 @@ test.skip = (name: string, fn: () => Promise<void>) => {
   console.log(name + ': SKIPPED')
 }
 
+test('id() monotonically increasing', async (): Promise<void> => {
+  let idA = id();
+  for (let i = 0; i < 10_000_000; i++) {
+    // Ensure ID is monotonic between milliseconds if the loop executes too fast.
+    if (i % 10_000 == 0) {
+      await new Promise(resolve => setTimeout(resolve, 1))
+    }
+
+    const idB = id();
+    assert.ok(idB > idA, 'id() returned an id that did not monotonically increase');
+    idA = idB;
+  }
+})
+
 test('range check `code` on Account to be u16', async (): Promise<void> => {
   const account = { ...accountA, id: 0n }
 
@@ -65,12 +81,12 @@ test('range check `code` on Account to be u16', async (): Promise<void> => {
   assert.strictEqual(codeError.message, 'code must be a u16.')
 
   const accounts = await client.lookupAccounts([account.id])
-  assert.strictEqual(accounts.length, 0)
+  assert.deepStrictEqual(accounts, [])
 })
 
 test('can create accounts', async (): Promise<void> => {
   const errors = await client.createAccounts([accountA])
-  assert.strictEqual(errors.length, 0)
+  assert.deepStrictEqual(errors, [])
 })
 
 test('can return error on account', async (): Promise<void> => {
@@ -85,7 +101,7 @@ test('error if timestamp is not set to 0n on account', async (): Promise<void> =
   const errors = await client.createAccounts([account])
 
   assert.strictEqual(errors.length, 1)
-  assert.deepStrictEqual(errors[0], { index: 0, result: CreateAccountError.timestamp_must_be_zero })  
+  assert.deepStrictEqual(errors[0], { index: 0, result: CreateAccountError.timestamp_must_be_zero })
 })
 
 test('can lookup accounts', async (): Promise<void> => {
@@ -139,7 +155,7 @@ test('can create a transfer', async (): Promise<void> => {
   }
 
   const errors = await client.createTransfers([transfer])
-  assert.strictEqual(errors.length, 0)
+  assert.deepStrictEqual(errors, [])
 
   const accounts = await client.lookupAccounts([accountA.id, accountB.id])
   assert.strictEqual(accounts.length, 2)
@@ -174,7 +190,7 @@ test('can create a two-phase transfer', async (): Promise<void> => {
   }
 
   const errors = await client.createTransfers([transfer])
-  assert.strictEqual(errors.length, 0)
+  assert.deepStrictEqual(errors, [])
 
   const accounts = await client.lookupAccounts([accountA.id, accountB.id])
   assert.strictEqual(accounts.length, 2)
@@ -225,7 +241,7 @@ test('can post a two-phase transfer', async (): Promise<void> => {
   }
 
   const errors = await client.createTransfers([commit])
-  assert.strictEqual(errors.length, 0)
+  assert.deepStrictEqual(errors, [])
 
   const accounts = await client.lookupAccounts([accountA.id, accountB.id])
   assert.strictEqual(accounts.length, 2)
@@ -258,7 +274,7 @@ test('can reject a two-phase transfer', async (): Promise<void> => {
     timestamp: 0n, // this will be set correctly by the TigerBeetle server
   }
   const transferErrors = await client.createTransfers([transfer])
-  assert.strictEqual(transferErrors.length, 0)
+  assert.deepStrictEqual(transferErrors, [])
 
   // send in the reject
   const reject: Transfer = {
@@ -278,7 +294,7 @@ test('can reject a two-phase transfer', async (): Promise<void> => {
   }
 
   const errors = await client.createTransfers([reject])
-  assert.strictEqual(errors.length, 0)
+  assert.deepStrictEqual(errors, [])
 
   const accounts = await client.lookupAccounts([accountA.id, accountB.id])
   assert.strictEqual(accounts.length, 2)
@@ -363,12 +379,12 @@ test('cannot void an expired transfer', async (): Promise<void> => {
     timestamp: 0n, // this will be set correctly by the TigerBeetle server
   }
   const transferErrors = await client.createTransfers([transfer])
-  assert.strictEqual(transferErrors.length, 0)
+  assert.deepStrictEqual(transferErrors, [])
 
   // Wait for the transfer to expire.
   // TODO: Use `await setTimeout(1000)` when upgrade to Node > 15.
   await new Promise(_ => setTimeout(_, 1000));
-  
+
   // send in the reject
   const reject: Transfer = {
     id: 7n,
@@ -388,7 +404,7 @@ test('cannot void an expired transfer', async (): Promise<void> => {
 
   const errors = await client.createTransfers([reject])
   assert.strictEqual(errors.length, 1)
-  assert.deepStrictEqual(errors[0], { index: 0, result: CreateTransferError.pending_transfer_expired }) 
+  assert.deepStrictEqual(errors[0], { index: 0, result: CreateTransferError.pending_transfer_expired })
 })
 
 test('can get account transfers', async (): Promise<void> => {
@@ -404,11 +420,11 @@ test('can get account transfers', async (): Promise<void> => {
     reserved: 0,
     ledger: 1,
     code: 718,
-    flags: 0,
+    flags: AccountFlags.history,
     timestamp: 0n
   }
   const account_errors = await client.createAccounts([accountC])
-  assert.strictEqual(account_errors.length, 0)
+  assert.deepStrictEqual(account_errors, [])
 
   var transfers_created : Transfer[] = [];
   // Create transfers where the new account is either the debit or credit account:
@@ -431,22 +447,29 @@ test('can get account transfers', async (): Promise<void> => {
   }
 
   const transfers_created_result = await client.createTransfers(transfers_created)
-  assert.strictEqual(transfers_created_result.length, 0)
+  assert.deepStrictEqual(transfers_created_result, [])
 
   // Query all transfers for accountC:
-  var filter: GetAccountTransfers = {
+  var filter: AccountFilter = {
     account_id: accountC.id,
     timestamp_min: 0n,
     timestamp_max: 0n,
     limit: 8190,
-    flags: GetAccountTransfersFlags.credits | GetAccountTransfersFlags.debits,
+    flags: AccountFilterFlags.credits | AccountFilterFlags.debits,
   }
   var transfers = await client.getAccountTransfers(filter)
+  var history = await client.getAccountHistory(filter)
   assert.strictEqual(transfers.length, transfers_created.length)
+  assert.strictEqual(history.length, transfers.length)
+
   var timestamp = 0n;
+  var i = 0;
   for (var transfer of transfers) {
     assert.ok(timestamp < transfer.timestamp);
     timestamp = transfer.timestamp;
+
+    assert.ok(history[i].timestamp == transfer.timestamp);
+    i++;
   }
 
   // Query only the debit transfers for accountC, descending:
@@ -455,14 +478,22 @@ test('can get account transfers', async (): Promise<void> => {
     timestamp_min: 0n,
     timestamp_max: 0n,
     limit: 8190,
-    flags: GetAccountTransfersFlags.debits |  GetAccountTransfersFlags.reversed,
+    flags: AccountFilterFlags.debits |  AccountFilterFlags.reversed,
   }
   transfers = await client.getAccountTransfers(filter)
+  history = await client.getAccountHistory(filter)
+
   assert.strictEqual(transfers.length, transfers_created.length / 2)
+  assert.strictEqual(history.length, transfers.length)
+
   timestamp = 1n << 64n;
+  i = 0;
   for (var transfer of transfers) {
     assert.ok(transfer.timestamp < timestamp);
     timestamp = transfer.timestamp;
+
+    assert.ok(history[i].timestamp == transfer.timestamp);
+    i++;
   }
 
   // Query only the credit transfers for accountC, descending:
@@ -471,14 +502,22 @@ test('can get account transfers', async (): Promise<void> => {
     timestamp_min: 0n,
     timestamp_max: 0n,
     limit: 8190,
-    flags: GetAccountTransfersFlags.credits |  GetAccountTransfersFlags.reversed,
+    flags: AccountFilterFlags.credits |  AccountFilterFlags.reversed,
   }
   transfers = await client.getAccountTransfers(filter)
+  history = await client.getAccountHistory(filter)
+
   assert.strictEqual(transfers.length, transfers_created.length / 2)
+  assert.strictEqual(history.length, transfers.length)
+
   timestamp = 1n << 64n;
+  i = 0;
   for (var transfer of transfers) {
     assert.ok(transfer.timestamp < timestamp);
     timestamp = transfer.timestamp;
+
+    assert.ok(history[i].timestamp == transfer.timestamp);
+    i++;
   }
 
   // Query the first 5 transfers for accountC:
@@ -487,14 +526,22 @@ test('can get account transfers', async (): Promise<void> => {
     timestamp_min: 0n,
     timestamp_max: 0n,
     limit: transfers_created.length / 2,
-    flags: GetAccountTransfersFlags.credits | GetAccountTransfersFlags.debits,
+    flags: AccountFilterFlags.credits | AccountFilterFlags.debits,
   }
   transfers = await client.getAccountTransfers(filter)
+  history = await client.getAccountHistory(filter)
+
   assert.strictEqual(transfers.length, transfers_created.length / 2)
+  assert.strictEqual(history.length, transfers.length)
+
   timestamp = 0n;
+  i = 0;
   for (var transfer of transfers) {
     assert.ok(timestamp < transfer.timestamp);
     timestamp = transfer.timestamp;
+
+    assert.ok(history[i].timestamp == transfer.timestamp);
+    i++;
   }
 
   // Query the next 5 transfers for accountC, with pagination:
@@ -503,13 +550,21 @@ test('can get account transfers', async (): Promise<void> => {
     timestamp_min: timestamp + 1n,
     timestamp_max: 0n,
     limit: transfers_created.length / 2,
-    flags: GetAccountTransfersFlags.credits | GetAccountTransfersFlags.debits,
+    flags: AccountFilterFlags.credits | AccountFilterFlags.debits,
   }
   transfers = await client.getAccountTransfers(filter)
+  history = await client.getAccountHistory(filter)
+
   assert.strictEqual(transfers.length, transfers_created.length / 2)
+  assert.strictEqual(history.length, transfers.length)
+
+  i = 0;
   for (var transfer of transfers) {
     assert.ok(timestamp < transfer.timestamp);
     timestamp = transfer.timestamp;
+
+    assert.ok(history[i].timestamp == transfer.timestamp);
+    i++;
   }
 
   // Query again, no more transfers should be found:
@@ -518,10 +573,13 @@ test('can get account transfers', async (): Promise<void> => {
     timestamp_min: timestamp + 1n,
     timestamp_max: 0n,
     limit: transfers_created.length / 2,
-    flags: GetAccountTransfersFlags.credits | GetAccountTransfersFlags.debits,
+    flags: AccountFilterFlags.credits | AccountFilterFlags.debits,
   }
   transfers = await client.getAccountTransfers(filter)
-  assert.strictEqual(transfers.length, 0)
+  history = await client.getAccountHistory(filter)
+
+  assert.deepStrictEqual(transfers, [])
+  assert.strictEqual(history.length, transfers.length)
 
   // Query the first 5 transfers for accountC ORDER BY DESC:
   filter = {
@@ -529,14 +587,22 @@ test('can get account transfers', async (): Promise<void> => {
     timestamp_min: 0n,
     timestamp_max: 0n,
     limit: transfers_created.length / 2,
-    flags: GetAccountTransfersFlags.credits | GetAccountTransfersFlags.debits | GetAccountTransfersFlags.reversed,
+    flags: AccountFilterFlags.credits | AccountFilterFlags.debits | AccountFilterFlags.reversed,
   }
   transfers = await client.getAccountTransfers(filter)
+  history = await client.getAccountHistory(filter)
+
   assert.strictEqual(transfers.length, transfers_created.length / 2)
+  assert.strictEqual(history.length, transfers.length)
+
   timestamp = 1n << 64n;
+  i = 0;
   for (var transfer of transfers) {
     assert.ok(timestamp > transfer.timestamp);
     timestamp = transfer.timestamp;
+
+    assert.ok(history[i].timestamp == transfer.timestamp);
+    i++;
   }
 
   // Query the next 5 transfers for accountC, with pagination:
@@ -545,13 +611,21 @@ test('can get account transfers', async (): Promise<void> => {
     timestamp_min: 0n,
     timestamp_max: timestamp - 1n,
     limit: transfers_created.length / 2,
-    flags: GetAccountTransfersFlags.credits | GetAccountTransfersFlags.debits | GetAccountTransfersFlags.reversed,
+    flags: AccountFilterFlags.credits | AccountFilterFlags.debits | AccountFilterFlags.reversed,
   }
   transfers = await client.getAccountTransfers(filter)
+  history = await client.getAccountHistory(filter)
+
   assert.strictEqual(transfers.length, transfers_created.length / 2)
+  assert.strictEqual(history.length, transfers.length)
+
+  i = 0;
   for (var transfer of transfers) {
     assert.ok(timestamp > transfer.timestamp);
     timestamp = transfer.timestamp;
+
+    assert.ok(history[i].timestamp == transfer.timestamp);
+    i++;
   }
 
   // Query again, no more transfers should be found:
@@ -560,73 +634,90 @@ test('can get account transfers', async (): Promise<void> => {
     timestamp_min: 0n,
     timestamp_max: timestamp - 1n,
     limit: transfers_created.length / 2,
-    flags: GetAccountTransfersFlags.credits | GetAccountTransfersFlags.debits | GetAccountTransfersFlags.reversed,
+    flags: AccountFilterFlags.credits | AccountFilterFlags.debits | AccountFilterFlags.reversed,
   }
   transfers = await client.getAccountTransfers(filter)
-  assert.strictEqual(transfers.length, 0)  
+  history = await client.getAccountHistory(filter)
+
+  assert.deepStrictEqual(transfers, [])
+  assert.strictEqual(history.length, transfers.length)
 
   // Invalid account:
-  assert.strictEqual((await client.getAccountTransfers({
+  filter = {
     account_id: 0n,
     timestamp_min: 0n,
     timestamp_max: 0n,
     limit: 8190,
-    flags: GetAccountTransfersFlags.credits | GetAccountTransfersFlags.debits,
-  })).length, 0)
+    flags: AccountFilterFlags.credits | AccountFilterFlags.debits,
+  }
+  assert.deepStrictEqual((await client.getAccountTransfers(filter)), [])
+  assert.deepStrictEqual((await client.getAccountHistory(filter)), [])
 
   // Invalid timestamp min:
-  assert.strictEqual((await client.getAccountTransfers({
+  filter = {
     account_id: accountC.id,
     timestamp_min: (1n << 64n) - 1n, // ulong max value
     timestamp_max: 0n,
     limit: 8190,
-    flags: GetAccountTransfersFlags.credits | GetAccountTransfersFlags.debits,
-  })).length, 0)
+    flags: AccountFilterFlags.credits | AccountFilterFlags.debits,
+  }
+  assert.deepStrictEqual((await client.getAccountTransfers(filter)), [])
+  assert.deepStrictEqual((await client.getAccountHistory(filter)), [])
 
   // Invalid timestamp max:
-  assert.strictEqual((await client.getAccountTransfers({
+  filter = {
     account_id: accountC.id,
     timestamp_min: 0n,
     timestamp_max: (1n << 64n) - 1n, // ulong max value
     limit: 8190,
-    flags: GetAccountTransfersFlags.credits | GetAccountTransfersFlags.debits,
-  })).length, 0)
+    flags: AccountFilterFlags.credits | AccountFilterFlags.debits,
+  }
+  assert.deepStrictEqual((await client.getAccountTransfers(filter)), [])
+  assert.deepStrictEqual((await client.getAccountHistory(filter)), [])
 
   // Invalid timestamp range:
-  assert.strictEqual((await client.getAccountTransfers({
+  filter = {
     account_id: accountC.id,
     timestamp_min: (1n << 64n) - 2n, // ulong max - 1
     timestamp_max: 1n,
     limit: 8190,
-    flags: GetAccountTransfersFlags.credits | GetAccountTransfersFlags.debits,
-  })).length, 0)
+    flags: AccountFilterFlags.credits | AccountFilterFlags.debits,
+  }
+  assert.deepStrictEqual((await client.getAccountTransfers(filter)), [])
+  assert.deepStrictEqual((await client.getAccountHistory(filter)), [])
 
   // Zero limit:
-  assert.strictEqual((await client.getAccountTransfers({
+  filter = {
     account_id: accountC.id,
     timestamp_min: 0n,
     timestamp_max: 0n,
     limit: 0,
-    flags: GetAccountTransfersFlags.credits | GetAccountTransfersFlags.debits,
-  })).length, 0)
+    flags: AccountFilterFlags.credits | AccountFilterFlags.debits,
+  }
+  assert.deepStrictEqual((await client.getAccountTransfers(filter)), [])
+  assert.deepStrictEqual((await client.getAccountHistory(filter)), [])
 
   // Empty flags:
-  assert.strictEqual((await client.getAccountTransfers({
+  filter = {
     account_id: accountC.id,
     timestamp_min: 0n,
     timestamp_max: 0n,
     limit: 8190,
-    flags: GetAccountTransfersFlags.none,
-  })).length, 0)
+    flags: AccountFilterFlags.none,
+  }
+  assert.deepStrictEqual((await client.getAccountTransfers(filter)), [])
+  assert.deepStrictEqual((await client.getAccountHistory(filter)), [])
 
   // Invalid flags:
-  assert.strictEqual((await client.getAccountTransfers({
+  filter = {
     account_id: accountC.id,
     timestamp_min: 0n,
     timestamp_max: 0n,
     limit: 8190,
     flags: 0xFFFF,
-  })).length, 0)
+  }
+  assert.deepStrictEqual((await client.getAccountTransfers(filter)), [])
+  assert.deepStrictEqual((await client.getAccountHistory(filter)), [])
 
 })