@milaboratories/pl-client 2.16.26 → 2.16.28

package/src/core/ll_transaction.test.ts

@@ -1,57 +1,75 @@
-import { getTestLLClient } from '../test/test_config';
-import { TxAPI_Open_Request_WritableTx } from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api';
-import { createLocalResourceId } from './types';
-import { test, expect } from 'vitest';
+import { getTestLLClient } from "../test/test_config";
+import { TxAPI_Open_Request_WritableTx } from "../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api";
+import { createLocalResourceId } from "./types";
+import { test, expect } from "vitest";
 
-import { isTimeoutOrCancelError } from './errors';
-import { Aborted } from '@milaboratories/ts-helpers';
+import { isTimeoutOrCancelError } from "./errors";
+import { Aborted } from "@milaboratories/ts-helpers";
 
-test('check successful transaction', async () => {
+test("check successful transaction", async () => {
   const client = await getTestLLClient();
   const tx = client.createTx(true);
 
-  const openResp = await tx.send({
-    oneofKind: 'txOpen',
-    txOpen: { name: 'test', writable: TxAPI_Open_Request_WritableTx.WRITABLE, enableFormattedErrors: false }
-  }, false);
-  const commitResp = await tx.send({
-    oneofKind: 'txCommit',
-    txCommit: {}
-  }, false);
+  const openResp = await tx.send(
+    {
+      oneofKind: "txOpen",
+      txOpen: {
+        name: "test",
+        writable: TxAPI_Open_Request_WritableTx.WRITABLE,
+        enableFormattedErrors: false,
+      },
+    },
+    false,
+  );
+  const commitResp = await tx.send(
+    {
+      oneofKind: "txCommit",
+      txCommit: {},
+    },
+    false,
+  );
 
   expect(openResp.txOpen.tx?.isValid).toBeTruthy();
   expect(commitResp.txCommit.success).toBeTruthy();
   await tx.await();
 });
 
-test('transaction timeout test', async () => {
+test("transaction timeout test", async () => {
   const client = await getTestLLClient();
   const tx = client.createTx(true, { timeout: 500 });
 
   await expect(async () => {
     const response = await tx.send(
       {
-        oneofKind: 'txOpen',
-        txOpen: { name: 'test', writable: TxAPI_Open_Request_WritableTx.WRITABLE, enableFormattedErrors: false }
+        oneofKind: "txOpen",
+        txOpen: {
+          name: "test",
+          writable: TxAPI_Open_Request_WritableTx.WRITABLE,
+          enableFormattedErrors: false,
+        },
       },
-      false
+      false,
     );
     expect(response.txOpen.tx?.isValid).toBeTruthy();
     await tx.await();
   }).rejects.toThrow(Aborted);
 });
 
-test('check timeout error type (passive)', async () => {
+test("check timeout error type (passive)", async () => {
   const client = await getTestLLClient();
   const tx = client.createTx(true, { timeout: 500 });
 
   try {
     const response = await tx.send(
       {
-        oneofKind: 'txOpen',
-        txOpen: { name: 'test', writable: TxAPI_Open_Request_WritableTx.WRITABLE, enableFormattedErrors: false }
+        oneofKind: "txOpen",
+        txOpen: {
+          name: "test",
+          writable: TxAPI_Open_Request_WritableTx.WRITABLE,
+          enableFormattedErrors: false,
+        },
       },
-      false
+      false,
     );
     expect(response.txOpen.tx?.isValid).toBeTruthy();
     await tx.await();
@@ -60,17 +78,21 @@ test('check timeout error type (passive)', async () => {
   }
 });
 
-test('check timeout error type (active)', async () => {
+test("check timeout error type (active)", async () => {
   const client = await getTestLLClient();
   const tx = client.createTx(true, { timeout: 500 });
 
   try {
     const openResponse = await tx.send(
       {
-        oneofKind: 'txOpen',
-        txOpen: { name: 'test', writable: TxAPI_Open_Request_WritableTx.WRITABLE, enableFormattedErrors: false }
+        oneofKind: "txOpen",
+        txOpen: {
+          name: "test",
+          writable: TxAPI_Open_Request_WritableTx.WRITABLE,
+          enableFormattedErrors: false,
+        },
       },
-      false
+      false,
     );
     expect(openResponse.txOpen.tx?.isValid).toBeTruthy();
 
@@ -82,30 +104,30 @@ test('check timeout error type (active)', async () => {
       (Math.random() * 256) & 0xff,
       (Math.random() * 256) & 0xff,
       (Math.random() * 256) & 0xff,
-      (Math.random() * 256) & 0xff
+      (Math.random() * 256) & 0xff,
     ]);
 
     const createResponse = await tx.send(
       {
-        oneofKind: 'resourceCreateValue',
+        oneofKind: "resourceCreateValue",
         resourceCreateValue: {
           id: createLocalResourceId(false, 1, 1),
-          type: { name: 'TestValue', version: '1' },
+          type: { name: "TestValue", version: "1" },
           data: rData,
-          errorIfExists: false
-        }
+          errorIfExists: false,
+        },
       },
-      false
+      false,
     );
     const id = (await createResponse).resourceCreateValue.resourceId;
 
     while (true) {
       const vr = await tx.send(
         {
-          oneofKind: 'resourceGet',
-          resourceGet: { resourceId: id, loadFields: false }
+          oneofKind: "resourceGet",
+          resourceGet: { resourceId: id, loadFields: false },
         },
-        false
+        false,
       );
 
       expect(Buffer.compare(vr.resourceGet.resource!.data, rData)).toBe(0);
@@ -115,17 +137,21 @@ test('check timeout error type (active)', async () => {
   }
 });
 
-test('check is abort error (active)', async () => {
+test("check is abort error (active)", async () => {
   const client = await getTestLLClient();
   const tx = client.createTx(true, { abortSignal: AbortSignal.timeout(100) });
 
   try {
     const openResponse = await tx.send(
       {
-        oneofKind: 'txOpen',
-        txOpen: { name: 'test', writable: TxAPI_Open_Request_WritableTx.WRITABLE, enableFormattedErrors: false }
+        oneofKind: "txOpen",
+        txOpen: {
+          name: "test",
+          writable: TxAPI_Open_Request_WritableTx.WRITABLE,
+          enableFormattedErrors: false,
+        },
       },
-      false
+      false,
     );
     expect(openResponse.txOpen.tx?.isValid).toBeTruthy();
 
@@ -137,30 +163,30 @@ test('check is abort error (active)', async () => {
       Math.random() & 0xff,
       Math.random() & 0xff,
       Math.random() & 0xff,
-      Math.random() & 0xff
+      Math.random() & 0xff,
     ]);
 
     const createResponse = await tx.send(
       {
-        oneofKind: 'resourceCreateValue',
+        oneofKind: "resourceCreateValue",
         resourceCreateValue: {
           id: createLocalResourceId(false, 1, 1),
-          type: { name: 'TestValue', version: '1' },
+          type: { name: "TestValue", version: "1" },
           data: rData,
-          errorIfExists: false
-        }
+          errorIfExists: false,
+        },
       },
-      false
+      false,
     );
     const id = (await createResponse).resourceCreateValue.resourceId;
 
     while (true) {
       const vr = await tx.send(
         {
-          oneofKind: 'resourceGet',
-          resourceGet: { resourceId: id, loadFields: false }
+          oneofKind: "resourceGet",
+          resourceGet: { resourceId: id, loadFields: false },
         },
-        false
+        false,
       );
 
       expect(Buffer.compare(vr.resourceGet.resource!.data, rData)).toBe(0);

package/src/core/ll_transaction.ts

@@ -1,52 +1,52 @@
 import type {
   TxAPI_ClientMessage,
   TxAPI_ServerMessage,
-} from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api';
-import type { BiDiStream } from './abstract_stream';
-import Denque from 'denque';
-import type { Status } from '../proto-grpc/github.com/googleapis/googleapis/google/rpc/status';
+} from "../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api";
+import type { BiDiStream } from "./abstract_stream";
+import Denque from "denque";
+import type { Status } from "../proto-grpc/github.com/googleapis/googleapis/google/rpc/status";
 import {
   PlErrorCodeNotFound,
   RecoverablePlError,
   rethrowMeaningfulError,
   UnrecoverablePlError,
-} from './errors';
-import { StatefulPromise } from './StatefulPromise';
+} from "./errors";
+import { StatefulPromise } from "./StatefulPromise";
 
-export type ClientMessageRequest = TxAPI_ClientMessage['request'];
+export type ClientMessageRequest = TxAPI_ClientMessage["request"];
 
-export type ServerMessageResponse = TxAPI_ServerMessage['response'];
+export type ServerMessageResponse = TxAPI_ServerMessage["response"];
 
 type TxStream = BiDiStream<TxAPI_ClientMessage, TxAPI_ServerMessage>;
 
-export type OneOfKind<T extends { oneofKind: unknown }, Kind extends T['oneofKind']> = Extract<
+export type OneOfKind<T extends { oneofKind: unknown }, Kind extends T["oneofKind"]> = Extract<
   T,
   { oneofKind: Kind }
 >;
 
-interface SingleResponseHandler<Kind extends ServerMessageResponse['oneofKind']> {
+interface SingleResponseHandler<Kind extends ServerMessageResponse["oneofKind"]> {
   kind: Kind;
   expectMultiResponse: false;
   resolve: (v: OneOfKind<ServerMessageResponse, Kind>) => void;
   reject: (e: Error) => void;
 }
 
-interface MultiResponseHandler<Kind extends ServerMessageResponse['oneofKind']> {
+interface MultiResponseHandler<Kind extends ServerMessageResponse["oneofKind"]> {
   kind: Kind;
   expectMultiResponse: true;
   resolve: (v: OneOfKind<ServerMessageResponse, Kind>[]) => void;
   reject: (e: Error) => void;
 }
 
-type AnySingleResponseHandler = SingleResponseHandler<ServerMessageResponse['oneofKind']>;
+type AnySingleResponseHandler = SingleResponseHandler<ServerMessageResponse["oneofKind"]>;
 
-type AnyMultiResponseHandler = MultiResponseHandler<ServerMessageResponse['oneofKind']>;
+type AnyMultiResponseHandler = MultiResponseHandler<ServerMessageResponse["oneofKind"]>;
 
 type AnyResponseHandler =
-  | SingleResponseHandler<ServerMessageResponse['oneofKind']>
-  | MultiResponseHandler<ServerMessageResponse['oneofKind']>;
+  | SingleResponseHandler<ServerMessageResponse["oneofKind"]>
+  | MultiResponseHandler<ServerMessageResponse["oneofKind"]>;
 
-function createResponseHandler<Kind extends ServerMessageResponse['oneofKind']>(
+function createResponseHandler<Kind extends ServerMessageResponse["oneofKind"]>(
   kind: Kind,
   expectMultiResponse: boolean,
   resolve:
@@ -62,9 +62,9 @@ function isRecoverable(status: Status): boolean {
 }
 
 export class RethrowError extends Error {
-  name = 'RethrowError';
+  name = "RethrowError";
   constructor(public readonly rethrowLambda: () => never) {
-    super('Rethrow error, you should never see this one.');
+    super("Rethrow error, you should never see this one.");
   }
 }
 
@@ -166,7 +166,7 @@ export class LLPlTransaction {
 
             if (message.multiMessage !== undefined && !message.multiMessage.isLast) {
               this.assignErrorFactoryIfNotSet(() => {
-                throw new Error('Unexpected message sequence.');
+                throw new Error("Unexpected message sequence.");
               });
               break;
             }
@@ -185,8 +185,8 @@ export class LLPlTransaction {
         }
 
         if (
-          currentHandler.kind !== message.response.oneofKind
-          && message?.multiMessage?.isEmpty !== true
+          currentHandler.kind !== message.response.oneofKind &&
+          message?.multiMessage?.isEmpty !== true
         ) {
           const errorMessage = `inconsistent request response types: ${currentHandler.kind} !== ${message.response.oneofKind}`;
 
@@ -266,7 +266,7 @@ export class LLPlTransaction {
       const handler = this.responseHandlerQueue.shift();
       if (!handler) break;
       if (this.errorFactory) handler.reject(new RethrowError(this.errorFactory));
-      else handler.reject(new Error('no reply'));
+      else handler.reject(new Error("no reply"));
     }
 
     // closing outgoing stream
@@ -292,29 +292,31 @@ export class LLPlTransaction {
     if (processingResult !== null) processingResult();
   }
 
-  public async send<Kind extends ClientMessageRequest['oneofKind']>(
+  public async send<Kind extends ClientMessageRequest["oneofKind"]>(
     r: OneOfKind<ClientMessageRequest, Kind>,
-    expectMultiResponse: false
+    expectMultiResponse: false,
   ): Promise<OneOfKind<ServerMessageResponse, Kind>>;
-  public async send<Kind extends ClientMessageRequest['oneofKind']>(
+  public async send<Kind extends ClientMessageRequest["oneofKind"]>(
     r: OneOfKind<ClientMessageRequest, Kind>,
-    expectMultiResponse: true
+    expectMultiResponse: true,
   ): Promise<OneOfKind<ServerMessageResponse, Kind>[]>;
   /** Generate proper client message and send it to the server, and returns a promise of future response. */
-  public async send<Kind extends ClientMessageRequest['oneofKind']>(
+  public async send<Kind extends ClientMessageRequest["oneofKind"]>(
     r: OneOfKind<ClientMessageRequest, Kind>,
     expectMultiResponse: boolean,
   ): Promise<OneOfKind<ServerMessageResponse, Kind> | OneOfKind<ServerMessageResponse, Kind>[]> {
     if (this.errorFactory) return Promise.reject(new RethrowError(this.errorFactory));
 
-    if (this.closed) return Promise.reject(new Error('Transaction already closed'));
+    if (this.closed) return Promise.reject(new Error("Transaction already closed"));
 
     // Note: Promise synchronously executes a callback passed to a constructor
-    const result = StatefulPromise.fromDeferredReject(new Promise<OneOfKind<ServerMessageResponse, Kind>>((resolve, reject) => {
-      this.responseHandlerQueue.push(
-        createResponseHandler(r.oneofKind, expectMultiResponse, resolve, reject),
-      );
-    }));
+    const result = StatefulPromise.fromDeferredReject(
+      new Promise<OneOfKind<ServerMessageResponse, Kind>>((resolve, reject) => {
+        this.responseHandlerQueue.push(
+          createResponseHandler(r.oneofKind, expectMultiResponse, resolve, reject),
+        );
+      }),
+    );
 
     // Awaiting message dispatch to catch any associated errors.
     // There is no hurry, we are not going to receive a response until message is sent.
@@ -327,7 +329,7 @@ export class LLPlTransaction {
       return await result;
     } catch (e: any) {
       if (e instanceof RethrowError) e.rethrowLambda();
-      throw new Error('Error while waiting for response', { cause: e });
+      throw new Error("Error while waiting for response", { cause: e });
     }
   }
 
@@ -342,6 +344,6 @@ export class LLPlTransaction {
 
   private isTerminalResponse(message: TxAPI_ServerMessage): boolean {
     const kind = message.response.oneofKind;
-    return kind === 'txCommit' || kind === 'txDiscard';
+    return kind === "txCommit" || kind === "txDiscard";
   }
 }

package/src/core/stat.ts

@@ -34,7 +34,7 @@ export type TxStat = {
   kvGetBytes: number;
 };
 
-export type TxStatWithoutTime = Omit<TxStat, 'timeMs'>;
+export type TxStatWithoutTime = Omit<TxStat, "timeMs">;
 
 export function initialTxStatWithoutTime(): TxStatWithoutTime {
   return {

package/src/core/transaction.test.ts

@@ -1,65 +1,65 @@
-import { withTempRoot } from '../test/test_config';
-import { StructTestResource, ValueTestResource } from '../helpers/pl';
-import { field, toGlobalFieldId, toGlobalResourceId } from './transaction';
-import { RecoverablePlError } from './errors';
-import * as tp from 'node:timers/promises';
-import { test, expect } from 'vitest';
-import { StatefulPromise } from './StatefulPromise';
-
-test('get field', async () => {
+import { withTempRoot } from "../test/test_config";
+import { StructTestResource, ValueTestResource } from "../helpers/pl";
+import { field, toGlobalFieldId, toGlobalResourceId } from "./transaction";
+import { RecoverablePlError } from "./errors";
+import * as tp from "node:timers/promises";
+import { test, expect } from "vitest";
+import { StatefulPromise } from "./StatefulPromise";
+
+test("get field", async () => {
   await withTempRoot(async (pl) => {
-    const [rr0, theField1] = await pl.withWriteTx('resource1', async (tx) => {
+    const [rr0, theField1] = await pl.withWriteTx("resource1", async (tx) => {
       const r0 = tx.createStruct(StructTestResource);
       const r1 = tx.createStruct(StructTestResource);
-      const f0 = { resourceId: tx.clientRoot, fieldName: 'test0' };
-      const f1 = { resourceId: tx.clientRoot, fieldName: 'test1' };
+      const f0 = { resourceId: tx.clientRoot, fieldName: "test0" };
+      const f1 = { resourceId: tx.clientRoot, fieldName: "test1" };
 
-      tx.createField(f0, 'Dynamic');
-      tx.createField(f1, 'Dynamic');
+      tx.createField(f0, "Dynamic");
+      tx.createField(f1, "Dynamic");
       tx.setField(f0, r0);
       tx.setField(f1, r1);
 
-      const theField1 = { resourceId: r1, fieldName: 'theField' };
-      tx.createField(theField1, 'Input');
+      const theField1 = { resourceId: r1, fieldName: "theField" };
+      tx.createField(theField1, "Input");
       tx.lock(r1);
-      tx.setField(theField1, tx.getFutureFieldValue(r0, 'theField', 'Input'));
+      tx.setField(theField1, tx.getFutureFieldValue(r0, "theField", "Input"));
 
       await tx.commit();
       return [await r0.globalId, await toGlobalFieldId(theField1)];
     });
 
-    const theField0 = { resourceId: rr0, fieldName: 'theField' };
+    const theField0 = { resourceId: rr0, fieldName: "theField" };
 
-    let fieldState = await pl.withReadTx('test', async (tx) => {
+    let fieldState = await pl.withReadTx("test", async (tx) => {
       return await tx.getField(theField1);
     });
-    expect(fieldState.status === 'Empty' || fieldState.status === 'Assigned').toBe(true);
+    expect(fieldState.status === "Empty" || fieldState.status === "Assigned").toBe(true);
 
-    await pl.withWriteTx('resource1', async (tx) => {
-      tx.createField(theField0, 'Input');
+    await pl.withWriteTx("resource1", async (tx) => {
+      tx.createField(theField0, "Input");
       tx.lock(rr0);
-      tx.setField(theField0, tx.createValue(ValueTestResource, Buffer.from('hello')));
+      tx.setField(theField0, tx.createValue(ValueTestResource, Buffer.from("hello")));
       await tx.commit();
       return theField0;
     });
 
     while (true) {
-      fieldState = await pl.withReadTx('test', async (tx) => {
+      fieldState = await pl.withReadTx("test", async (tx) => {
         return await tx.getField(theField1);
       });
-      if (fieldState.status === 'Resolved') break;
+      if (fieldState.status === "Resolved") break;
       await tp.setTimeout(10);
     }
   });
 });
 
-test('handle absent resource error', async () => {
+test("handle absent resource error", async () => {
   await withTempRoot(async (pl) => {
-    const [rr0, ff0] = await pl.withWriteTx('testCreateResource', async (tx) => {
+    const [rr0, ff0] = await pl.withWriteTx("testCreateResource", async (tx) => {
       const r0 = tx.createStruct(StructTestResource);
-      const f0 = { resourceId: tx.clientRoot, fieldName: 'test0' };
+      const f0 = { resourceId: tx.clientRoot, fieldName: "test0" };
 
-      tx.createField(f0, 'Dynamic');
+      tx.createField(f0, "Dynamic");
       tx.setField(f0, r0);
 
       await tx.commit();
@@ -67,18 +67,18 @@ test('handle absent resource error', async () => {
     });
 
     await pl.withWriteTx(
-      'testDeleteResource',
+      "testDeleteResource",
       async (tx) => {
         await tx.getResourceData(rr0, true);
         tx.removeField(ff0);
         await tx.commit();
       },
-      { sync: true }
+      { sync: true },
     );
 
     StatefulPromise.debug = true;
 
-    let rState = await pl.withReadTx('testRetrieveResource', async (tx) => {
+    let rState = await pl.withReadTx("testRetrieveResource", async (tx) => {
       await expect(async () => {
         await tx.getResourceData(rr0, true);
       }).rejects.toThrow(RecoverablePlError);
@@ -89,7 +89,7 @@ test('handle absent resource error', async () => {
 
     expect(rState.fields).toHaveLength(0);
 
-    rState = await pl.withReadTx('testRetrieveResource', async (tx) => {
+    rState = await pl.withReadTx("testRetrieveResource", async (tx) => {
       await expect(async () => {
         await tx.listKeyValues(rr0);
       }).rejects.toThrow(RecoverablePlError);
@@ -98,7 +98,7 @@ test('handle absent resource error', async () => {
 
     expect(rState.fields).toHaveLength(0);
 
-    rState = await pl.withReadTx('testRetrieveResource', async (tx) => {
+    rState = await pl.withReadTx("testRetrieveResource", async (tx) => {
       await expect(async () => {
         await tx.getField(ff0);
       }).rejects.toThrow(RecoverablePlError);
@@ -107,72 +107,72 @@ test('handle absent resource error', async () => {
 
     expect(rState.fields).toHaveLength(0);
 
-    await pl.withReadTx('testFieldAbsent', async (tx) => {
+    await pl.withReadTx("testFieldAbsent", async (tx) => {
       expect(await tx.getFieldIfExists(ff0)).toBeUndefined();
     });
   });
 });
 
-test('handle KV storage', async () => {
+test("handle KV storage", async () => {
   await withTempRoot(async (pl) => {
-    await pl.withWriteTx('writeKV', async (tx) => {
-      tx.setKValue(tx.clientRoot, 'a', 'a');
-      tx.setKValue(tx.clientRoot, 'b', 'b');
+    await pl.withWriteTx("writeKV", async (tx) => {
+      tx.setKValue(tx.clientRoot, "a", "a");
+      tx.setKValue(tx.clientRoot, "b", "b");
       await tx.commit();
     });
 
-    await pl.withReadTx('testReadIndividual', async (tx) => {
-      expect(await tx.getKValueString(tx.clientRoot, 'a')).toEqual('a');
-      expect(await tx.getKValueString(tx.clientRoot, 'b')).toEqual('b');
+    await pl.withReadTx("testReadIndividual", async (tx) => {
+      expect(await tx.getKValueString(tx.clientRoot, "a")).toEqual("a");
+      expect(await tx.getKValueString(tx.clientRoot, "b")).toEqual("b");
     });
 
-    await pl.withReadTx('testReadIndividualAndList', async (tx) => {
-      expect(await tx.getKValueString(tx.clientRoot, 'a')).toEqual('a');
-      expect(await tx.getKValueString(tx.clientRoot, 'b')).toEqual('b');
+    await pl.withReadTx("testReadIndividualAndList", async (tx) => {
+      expect(await tx.getKValueString(tx.clientRoot, "a")).toEqual("a");
+      expect(await tx.getKValueString(tx.clientRoot, "b")).toEqual("b");
       expect(await tx.listKeyValuesString(tx.clientRoot)).toEqual([
-        { key: 'a', value: 'a' },
-        { key: 'b', value: 'b' }
+        { key: "a", value: "a" },
+        { key: "b", value: "b" },
       ]);
-      expect(await tx.getKValueString(tx.clientRoot, 'a')).toEqual('a');
-      expect(await tx.getKValueString(tx.clientRoot, 'b')).toEqual('b');
+      expect(await tx.getKValueString(tx.clientRoot, "a")).toEqual("a");
+      expect(await tx.getKValueString(tx.clientRoot, "b")).toEqual("b");
     });
 
-    await pl.withWriteTx('deleteKV', async (tx) => {
-      tx.deleteKValue(tx.clientRoot, 'a');
+    await pl.withWriteTx("deleteKV", async (tx) => {
+      tx.deleteKValue(tx.clientRoot, "a");
       await tx.commit();
     });
 
-    await pl.withReadTx('testReadIndividualAndList2', async (tx) => {
-      expect(await tx.getKValueString(tx.clientRoot, 'b')).toEqual('b');
-      expect(await tx.listKeyValuesString(tx.clientRoot)).toEqual([{ key: 'b', value: 'b' }]);
-      expect(await tx.getKValueString(tx.clientRoot, 'b')).toEqual('b');
+    await pl.withReadTx("testReadIndividualAndList2", async (tx) => {
+      expect(await tx.getKValueString(tx.clientRoot, "b")).toEqual("b");
+      expect(await tx.listKeyValuesString(tx.clientRoot)).toEqual([{ key: "b", value: "b" }]);
+      expect(await tx.getKValueString(tx.clientRoot, "b")).toEqual("b");
     });
   });
 });
 
-test('handle empty KV storage', async () => {
+test("handle empty KV storage", async () => {
   await withTempRoot(async (pl) => {
-    await pl.withReadTx('testReadIndividualAndList', async (tx) => {
+    await pl.withReadTx("testReadIndividualAndList", async (tx) => {
       expect(await tx.listKeyValuesString(tx.clientRoot)).toEqual([]);
     });
   });
 });
 
-test('handle KV storage 2', async () => {
+test("handle KV storage 2", async () => {
   await withTempRoot(async (pl) => {
-    const r1 = await pl.withWriteTx('writeKV', async (tx) => {
+    const r1 = await pl.withWriteTx("writeKV", async (tx) => {
       const rr1 = tx.createEphemeral(StructTestResource);
-      tx.createField(field(rr1, 'a'), 'Dynamic', rr1);
-      tx.setKValue(rr1, 'a', 'a');
-      tx.setKValue(rr1, 'b', 'b');
+      tx.createField(field(rr1, "a"), "Dynamic", rr1);
+      tx.setKValue(rr1, "a", "a");
+      tx.setKValue(rr1, "b", "b");
       await tx.commit();
       return await toGlobalResourceId(rr1);
     });
 
-    await pl.withReadTx('testReadIndividualAndList', async (tx) => {
+    await pl.withReadTx("testReadIndividualAndList", async (tx) => {
       expect(await tx.listKeyValuesString(r1)).toEqual([
-        { key: 'a', value: 'a' },
-        { key: 'b', value: 'b' }
+        { key: "a", value: "a" },
+        { key: "b", value: "b" },
       ]);
     });
   });