Update persister-durable-object-storage index file from main

Author: acoreyj

src/persisters/persister-durable-object-sql-storage/index.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-len */
 import type {
   RowStamp,
   TablesStamp,

src/persisters/persister-durable-object-storage/index.ts

@@ -20,7 +20,7 @@ import type {Cell, Value} from '../../@types/store/index.d.ts';
 import {jsonStringWithUndefined} from '../../common/json.ts';
 import {IdMap, mapNew, mapSet, mapToObj} from '../../common/map.ts';
 import {objEnsure, objForEach} from '../../common/obj.ts';
-import {noop, slice} from '../../common/other.ts';
+import {ifNotUndefined, noop, slice} from '../../common/other.ts';
 import {stampNewWithHash, stampUpdate} from '../../common/stamps.ts';
 import {EMPTY_STRING, T, V, strStartsWith} from '../../common/strings.ts';
 import {createCustomPersister} from '../common/create.ts';
@@ -56,96 +56,53 @@ export const createDurableObjectStoragePersister = ((
   const getPersisted = async (): Promise<
     PersistedContent<PersistsType.MergeableStoreOnly>
   > => {
-    // Initialize empty stamped objects for tables and values
     const tables: TablesStamp<true> = stampNewObjectWithHash();
     const values: ValuesStamp<true> = stampNewObjectWithHash();
-
-    // Get all stored entries with the given prefix
-    const storedEntries = await storage.list<StoredValue>({
-      prefix: storagePrefix,
-    });
-
-    // Process each stored entry to reconstruct the persisted data structure
-    storedEntries.forEach(([zeroOrCellOrValue, time, hash], key) => {
-      const keyParts = deconstructKey(key);
-      if (!keyParts) return;
-
-      const [type, ...ids] = keyParts;
-
-      if (type === T) {
-        // Handle tables data
-        processTableEntry(tables, ids, zeroOrCellOrValue, time, hash);
-      } else if (type === V) {
-        // Handle values data
-        processValueEntry(values, ids, zeroOrCellOrValue, time, hash);
-      }
-    });
-
+    (await storage.list<StoredValue>({prefix: storagePrefix})).forEach(
+      async ([zeroOrCellOrValue, time, hash], key) =>
+        ifNotUndefined(deconstructKey(key), ([type, ...ids]) =>
+          type == T
+            ? ifNotUndefined(
+                ids[0],
+                (tableId) => {
+                  const table = objEnsure(
+                    tables[0],
+                    tableId,
+                    stampNewObjectWithHash,
+                  ) as TableStamp<true>;
+                  ifNotUndefined(
+                    ids[1],
+                    (rowId) => {
+                      const row = objEnsure(
+                        table[0],
+                        rowId,
+                        stampNewObjectWithHash,
+                      ) as RowStamp<true>;
+                      ifNotUndefined(
+                        ids[2],
+                        (cellId) =>
+                          (row[0][cellId] = [zeroOrCellOrValue, time, hash]),
+                        () => stampUpdate(row, time, hash),
+                      );
+                    },
+                    () => stampUpdate(table, time, hash),
+                  );
+                },
+                () => stampUpdate(tables, time, hash),
+              )
+            : type == V
+              ? ifNotUndefined(
+                  ids[0],
+                  (valueId) =>
+                    (values[0][valueId] = [zeroOrCellOrValue, time, hash]),
+                  () => stampUpdate(values, time, hash),
+                )
+              : 0,
+        ),
+    );
     return [tables, values];
   };
 
-  // Helper function to process table-related storage entries
-  const processTableEntry = (
-    tables: TablesStamp<true>,
-    ids: Ids,
-    zeroOrCellOrValue: 0 | Cell | Value | undefined,
-    time: string,
-    hash: number,
-  ): void => {
-    const [tableId, rowId, cellId] = ids;
-
-    if (tableId) {
-      // Ensure table exists in the structure
-      const table = objEnsure(
-        tables[0],
-        tableId,
-        stampNewObjectWithHash,
-      ) as TableStamp<true>;
-
-      if (rowId) {
-        // Ensure row exists within the table
-        const row = objEnsure(
-          table[0],
-          rowId,
-          stampNewObjectWithHash,
-        ) as RowStamp<true>;
-
-        if (cellId) {
-          // Cell-level data: store the actual cell value
-          row[0][cellId] = [zeroOrCellOrValue, time, hash];
-        } else {
-          // Row-level metadata: update the row's timestamp and hash
-          stampUpdate(row, time, hash);
-        }
-      } else {
-        // Table-level metadata: update the table's timestamp and hash
-        stampUpdate(table, time, hash);
-      }
-    } else {
-      // Tables-level metadata: update the root tables timestamp and hash
-      stampUpdate(tables, time, hash);
-    }
-  };
-
-  // Helper function to process value-related storage entries
-  const processValueEntry = (
-    values: ValuesStamp<true>,
-    ids: Ids,
-    zeroOrCellOrValue: 0 | Cell | Value | undefined,
-    time: string,
-    hash: number,
-  ): void => {
-    const [valueId] = ids;
-
-    if (valueId) {
-      // Value-level data: store the actual value
-      values[0][valueId] = [zeroOrCellOrValue, time, hash];
-    } else {
-      // Values-level metadata: update the root values timestamp and hash
-      stampUpdate(values, time, hash);
-    }
-  };
-
   const setPersisted = async (
     getContent: () => PersistedContent<PersistsType.MergeableStoreOnly>,
     [
@@ -156,42 +113,25 @@ export const createDurableObjectStoragePersister = ((
       true
     > = getContent() as any,
   ): Promise<void> => {
-    // Prepare a map to collect all storage entries that need to be persisted
     const keysToSet: IdMap<StoredValue> = mapNew();
-
-    // Store the root tables metadata (timestamp and hash)
     mapSet(keysToSet, constructKey(T), [0, tablesHlc, tablesHash]);
-
-    // Process each table in the store
     objForEach(tablesObj, ([tableObj, tableHlc, tableHash], tableId) => {
-      // Store table-level metadata
       mapSet(keysToSet, constructKey(T, tableId), [0, tableHlc, tableHash]);
-
-      // Process each row within the table
       objForEach(tableObj, ([rowObj, rowHlc, rowHash], rowId) => {
-        // Store row-level metadata
         mapSet(keysToSet, constructKey(T, tableId, rowId), [
           0,
           rowHlc,
           rowHash,
         ]);
-
-        // Store each cell value within the row
         objForEach(rowObj, (cellStamp, cellId) =>
           mapSet(keysToSet, constructKey(T, tableId, rowId, cellId), cellStamp),
         );
       });
     });
-
-    // Store the root values metadata (timestamp and hash)
     mapSet(keysToSet, constructKey(V), [0, valuesHlc, valuesHash]);
-
-    // Process each value in the store
     objForEach(valuesObj, (valueStamp, valueId) =>
       mapSet(keysToSet, constructKey(V, valueId), valueStamp),
     );
-
-    // Persist all collected entries to storage in a single batch operation
     await storage.put(mapToObj(keysToSet));
   };