refactor: Make VatStore deal in objects and arrays

Author: rekmarks

packages/kernel-test/src/vatstore.test.ts

@@ -119,8 +119,8 @@ describe('exercise vatstore', async () => {
         if (vatID === 'v1') {
           const origUpdateKVData = result.updateKVData;
           vi.spyOn(result, 'updateKVData').mockImplementation(
-            (sets: Map<string, string>, deletes: Set<string>): void => {
-              kvUpdates.push([Object.fromEntries(sets), Array.from(deletes)]);
+            (sets: Record<string, string>, deletes: string[]): void => {
+              kvUpdates.push([sets, deletes]);
               origUpdateKVData(sets, deletes);
             },
           );

packages/kernel/src/VatHandle.ts

@@ -148,7 +148,7 @@ export class VatHandle {
       method: 'initVat',
       params: {
         vatConfig: this.config,
-        state: Object.fromEntries(this.#vatStore.getKVData()),
+        state: this.#vatStore.getKVData(),
       },
     });
   }
@@ -297,10 +297,7 @@ export class VatHandle {
     if (method === 'deliver' || method === 'initVat') {
       // TypeScript fails to narrow the result type on its own
       const [sets, deletes] = result as VatCheckpoint;
-      this.#vatStore.updateKVData(
-        new Map(Object.entries(sets)),
-        new Set(deletes),
-      );
+      this.#vatStore.updateKVData(sets, deletes);
     }
     return result;
   }

packages/kernel/src/store/vat-kv-store.ts

@@ -17,7 +17,7 @@ export type VatKVStore = KVStore & {
  * @returns a VatKVStore wrapped around `state`.
  */
 export function makeVatKVStore(state: Map<string, string>): VatKVStore {
-  let sets: Map<string, string> = new Map();
+  let sets: Record<string, string> = {};
   let deletes: Set<string> = new Set();
   let keyCache: string[] | null = null;
   let lastNextKey: string | null = null;
@@ -61,22 +61,19 @@ export function makeVatKVStore(state: Map<string, string>): VatKVStore {
     },
     set(key: string, value: string): void {
       state.set(key, value);
-      sets.set(key, value);
+      sets[key] = value;
       deletes.delete(key);
       keyCache = null;
     },
     delete(key: string): void {
       state.delete(key);
-      sets.delete(key);
+      delete sets[key];
       deletes.add(key);
       keyCache = null;
     },
     checkpoint(): VatCheckpoint {
-      const result: VatCheckpoint = [
-        Object.fromEntries(sets),
-        Array.from(deletes),
-      ];
-      sets = new Map();
+      const result: VatCheckpoint = [sets, Array.from(deletes)];
+      sets = {};
       deletes = new Set();
       return result;
     },

packages/kernel/test/storage.ts

@@ -85,18 +85,20 @@ type ClearableVatStore = VatStore & {
  * @returns the mock {@link VatStore}.
  */
 function makeMapVatStore(_vatID: string): ClearableVatStore {
-  const map = new Map<string, string>();
+  let kvData: Record<string, string> = {};
   return {
-    getKVData: () => map,
-    updateKVData: (sets: Map<string, string>, deletes: Set<string>) => {
-      for (const [key, value] of sets.entries()) {
-        map.set(key, value);
+    getKVData: () => kvData,
+    updateKVData: (sets: Record<string, string>, deletes: string[]) => {
+      for (const [key, value] of Object.entries(sets)) {
+        kvData[key] = value;
       }
-      for (const key of deletes.values()) {
-        map.delete(key);
+      for (const key of deletes) {
+        delete kvData[key];
       }
     },
-    clear: () => map.clear(),
+    clear: () => {
+      kvData = {};
+    },
   };
 }
 

packages/store/src/sqlite/nodejs.test.ts

@@ -9,10 +9,10 @@ const mockKVData = [
   { key: 'key2', value: 'value2' },
 ];
 
-const mockKVDataForMap: [string, string][] = [
-  ['key1', 'value1'],
-  ['key2', 'value2'],
-];
+const mockKVDataForMap: Record<string, string> = {
+  key1: 'value1',
+  key2: 'value2',
+};
 
 const mockStatement = {
   run: vi.fn(),
@@ -118,17 +118,17 @@ describe('makeSQLKernelDatabase', () => {
     ]);
   });
 
-  it('vatStore.getKVData returns a map of the data', async () => {
+  it('vatStore.getKVData returns the data', async () => {
     const db = await makeSQLKernelDatabase({});
     const vatStore = db.makeVatStore('vvat');
     const data = vatStore.getKVData();
-    expect(data).toStrictEqual(new Map(mockKVDataForMap));
+    expect(data).toStrictEqual({ ...mockKVDataForMap });
   });
 
   it('vatStore.updateKVData updates the database', async () => {
     const db = await makeSQLKernelDatabase({});
     const vatStore = db.makeVatStore('vvat');
-    vatStore.updateKVData(new Map(mockKVDataForMap), new Set(['del1', 'del2']));
+    vatStore.updateKVData({ ...mockKVDataForMap }, ['del1', 'del2']);
     expect(mockStatement.run).toHaveBeenCalled(); // begin transaction
     expect(mockStatement.run).toHaveBeenCalledWith('vvat', 'key1', 'value1'); // set
     expect(mockStatement.run).toHaveBeenCalledWith('vvat', 'key2', 'value2'); // set

packages/store/src/sqlite/nodejs.ts

@@ -177,15 +177,15 @@ export async function makeSQLKernelDatabase({
      *
      * @returns the vatstore contents as a key-value Map.
      */
-    function getKVData(): Map<string, string> {
-      const result = new Map<string, string>();
+    function getKVData(): Record<string, string> {
+      const result: Record<string, string> = {};
       type KVPair = {
         key: string;
         value: string;
       };
       for (const kvPair of sqlVatstoreGetAll.iterate(vatID)) {
         const { key, value } = kvPair as KVPair;
-        result.set(key, value);
+        result[key] = value;
       }
       return result;
     }
@@ -197,14 +197,14 @@ export async function makeSQLKernelDatabase({
      * @param deletes - A set of keys that have been deleted.
      */
     function updateKVData(
-      sets: Map<string, string>,
-      deletes: Set<string>,
+      sets: Record<string, string>,
+      deletes: string[],
     ): void {
       db.transaction(() => {
-        for (const [key, value] of sets.entries()) {
+        for (const [key, value] of Object.entries(sets)) {
           sqlVatstoreSet.run(vatID, key, value);
         }
-        for (const value of deletes.values()) {
+        for (const value of deletes) {
           sqlVatstoreDelete.run(vatID, value);
         }
       })();

packages/store/src/sqlite/wasm.test.ts

@@ -10,10 +10,10 @@ const mockKVData = [
   { key: 'key2', value: 'value2' },
 ] as const;
 
-const mockKVDataForMap: [string, string][] = [
-  ['key1', 'value1'],
-  ['key2', 'value2'],
-];
+const mockKVDataForMap: Record<string, string> = {
+  key1: 'value1',
+  key2: 'value2',
+};
 
 const mockStatement = {
   bind: vi.fn(),
@@ -157,13 +157,13 @@ describe('makeSQLKernelDatabase', () => {
       .mockReturnValueOnce(mockKVData[1].key)
       .mockReturnValueOnce(mockKVData[1].value);
     const data = vatStore.getKVData();
-    expect(data).toStrictEqual(new Map(mockKVDataForMap));
+    expect(data).toStrictEqual({ ...mockKVDataForMap });
   });
 
   it('vatStore.updateKVData updates the database', async () => {
     const db = await makeSQLKernelDatabase({});
     const vatStore = db.makeVatStore('vvat');
-    vatStore.updateKVData(new Map(mockKVDataForMap), new Set(['del1', 'del2']));
+    vatStore.updateKVData({ ...mockKVDataForMap }, ['del1', 'del2']);
     // begin transaction
     expect(mockStatement.step).toHaveBeenCalled();
     expect(mockStatement.reset).toHaveBeenCalled();

packages/store/src/sqlite/wasm.ts

@@ -239,14 +239,14 @@ export async function makeSQLKernelDatabase({
      *
      * @returns the vatstore contents as a key-value Map.
      */
-    function getKVData(): Map<string, string> {
-      const result = new Map<string, string>();
+    function getKVData(): Record<string, string> {
+      const result: Record<string, string> = {};
       sqlVatstoreGetAll.bind([vatID]);
       try {
         while (sqlVatstoreGetAll.step()) {
           const key = sqlVatstoreGetAll.getString(0) as string;
           const value = sqlVatstoreGetAll.getString(1) as string;
-          result.set(key, value);
+          result[key] = value;
         }
       } finally {
         sqlVatstoreGetAll.reset();
@@ -261,18 +261,18 @@ export async function makeSQLKernelDatabase({
      * @param deletes - A set of keys that have been deleted.
      */
     function updateKVData(
-      sets: Map<string, string>,
-      deletes: Set<string>,
+      sets: Record<string, string>,
+      deletes: string[],
     ): void {
       try {
         sqlBeginTransaction.step();
         sqlBeginTransaction.reset();
-        for (const [key, value] of sets.entries()) {
+        for (const [key, value] of Object.entries(sets)) {
           sqlVatstoreSet.bind([vatID, key, value]);
           sqlVatstoreSet.step();
           sqlVatstoreSet.reset();
         }
-        for (const value of deletes.values()) {
+        for (const value of deletes) {
           sqlVatstoreDelete.bind([vatID, value]);
           sqlVatstoreDelete.step();
           sqlVatstoreDelete.reset();

packages/store/src/types.ts

@@ -7,8 +7,8 @@ export type KVStore = {
 };
 
 export type VatStore = {
-  getKVData(): Map<string, string>;
-  updateKVData(sets: Map<string, string>, deletes: Set<string>): void;
+  getKVData(): Record<string, string>;
+  updateKVData(sets: Record<string, string>, deletes: string[]): void;
 };
 
 export type KernelDatabase = {