envio 3.3.0-alpha.9 → 3.3.0

package/src/PgStorage.res

@@ -654,8 +654,6 @@ let makeSchemaTableNamesQuery = (~pgSchema) => {
   `SELECT table_name FROM information_schema.tables WHERE table_schema = '${pgSchema}';`
 }
 
-let cacheTablePrefixLength = Internal.cacheTablePrefix->String.length
-
 type schemaCacheTableInfo = {
   @as("table_name")
   tableName: string,
@@ -663,13 +661,24 @@ type schemaCacheTableInfo = {
   count: int,
 }
 
+// Matches both the cross-chain (`envio_effect_<name>`) and chain-scoped
+// (`envio_<chainId>_effect_<name>`) cache-table formats. Kept in sync with
+// Internal.EffectCache.
 let makeSchemaCacheTableInfoQuery = (~pgSchema) => {
-  `SELECT 
+  // The column guard requires the effect-cache shape (exactly an `id` + `output`
+  // pair) so a user entity table that happens to match the name pattern is never
+  // mistaken for an effect cache.
+  `SELECT
     t.table_name,
     ${getCacheRowCountFnName}(t.table_name) as count
    FROM information_schema.tables t
-   WHERE t.table_schema = '${pgSchema}' 
-   AND t.table_name LIKE '${Internal.cacheTablePrefix}%';`
+   WHERE t.table_schema = '${pgSchema}'
+   AND t.table_name ~ '^envio_([0-9]+_)?effect_.+'
+   AND (
+     SELECT array_agg(c.column_name::text ORDER BY c.column_name::text)
+     FROM information_schema.columns c
+     WHERE c.table_schema = t.table_schema AND c.table_name = t.table_name
+   ) = ARRAY['id', 'output'];`
 }
 
 type psqlExecState =
@@ -1111,8 +1120,10 @@ let rec writeBatch = async (
         // Since effect cache currently doesn't support rollback,
         // we can run it outside of the transaction for simplicity.
         updatedEffectsCache
-        ->Array.map(({effect, items, shouldInitialize}: Persistence.updatedEffectCache) => {
-          setEffectCacheOrThrow(~effect, ~items, ~initialize=shouldInitialize)
+        ->Array.map((
+          {table, itemSchema, items, shouldInitialize}: Persistence.updatedEffectCache,
+        ) => {
+          setEffectCacheOrThrow(~table, ~itemSchema, ~items, ~initialize=shouldInitialize)
         })
         ->Promise.all,
       ))
@@ -1157,9 +1168,9 @@ let rec writeBatch = async (
   }
 }
 
-// Returns the most recent entity state for IDs that need to be restored during rollback.
-// For each ID modified after the rollback target, retrieves its latest state at or before the target.
-let makeGetRollbackRestoredEntitiesQuery = (~entityConfig: Internal.entityConfig, ~pgSchema) => {
+// Returns the most recent history row at or before the rollback target for IDs changed after it.
+// envio_change is included so ReScript can turn SET rows into restores and DELETE rows into removals.
+let makeGetRollbackPreTargetRowsQuery = (~entityConfig: Internal.entityConfig, ~pgSchema) => {
   let dataFieldNames = entityConfig.table.fields->Array.filterMap(fieldOrDerived =>
     switch fieldOrDerived {
     | Field(field) => field->Table.getPgDbFieldName->Some
@@ -1175,36 +1186,41 @@ let makeGetRollbackRestoredEntitiesQuery = (~entityConfig: Internal.entityConfig
     ~entityIndex=entityConfig.index,
   )
 
-  `SELECT DISTINCT ON (${Table.idFieldName}) ${dataFieldsCommaSeparated}
-FROM "${pgSchema}"."${historyTableName}"
-WHERE "${EntityHistory.checkpointIdFieldName}" <= $1
-  AND EXISTS (
-    SELECT 1
-    FROM "${pgSchema}"."${historyTableName}" h
-    WHERE h.${Table.idFieldName} = "${historyTableName}".${Table.idFieldName}
-      AND h."${EntityHistory.checkpointIdFieldName}" > $1
-  )
-ORDER BY ${Table.idFieldName}, "${EntityHistory.checkpointIdFieldName}" DESC`
+  `SELECT DISTINCT ON ("${Table.idFieldName}") ${dataFieldsCommaSeparated}, "${EntityHistory.changeFieldName}"
+  FROM "${pgSchema}"."${historyTableName}"
+  WHERE "${EntityHistory.checkpointIdFieldName}" <= $1
+    AND EXISTS (
+      SELECT 1
+      FROM "${pgSchema}"."${historyTableName}" h
+      WHERE h."${Table.idFieldName}" = "${historyTableName}"."${Table.idFieldName}"
+        AND h."${EntityHistory.checkpointIdFieldName}" > $1
+    )
+  ORDER BY "${Table.idFieldName}", "${EntityHistory.checkpointIdFieldName}" DESC`
 }
 
 // Returns entity IDs that were created after the rollback target and have no history before it.
-// These entities should be deleted during rollback.
+// DELETE rows at or before the target are returned by the restore query and classified in ReScript.
 let makeGetRollbackRemovedIdsQuery = (~entityConfig: Internal.entityConfig, ~pgSchema) => {
   let historyTableName = EntityHistory.historyTableName(
     ~entityName=entityConfig.name,
     ~entityIndex=entityConfig.index,
   )
-  `SELECT DISTINCT ${Table.idFieldName}
-FROM "${pgSchema}"."${historyTableName}"
-WHERE "${EntityHistory.checkpointIdFieldName}" > $1
-AND NOT EXISTS (
-  SELECT 1
-  FROM "${pgSchema}"."${historyTableName}" h
-  WHERE h.${Table.idFieldName} = "${historyTableName}".${Table.idFieldName}
-    AND h."${EntityHistory.checkpointIdFieldName}" <= $1
-)`
+  `SELECT DISTINCT "${Table.idFieldName}"
+  FROM "${pgSchema}"."${historyTableName}"
+  WHERE "${EntityHistory.checkpointIdFieldName}" > $1
+    AND NOT EXISTS (
+      SELECT 1
+      FROM "${pgSchema}"."${historyTableName}" h
+      WHERE h."${Table.idFieldName}" = "${historyTableName}"."${Table.idFieldName}"
+        AND h."${EntityHistory.checkpointIdFieldName}" <= $1
+    )`
 }
 
+let rollbackRowStateSchema = S.object(s => (
+  s.field(Table.idFieldName, S.string),
+  s.field(EntityHistory.changeFieldName, EntityHistory.RowAction.schema),
+))
+
 let make = (
   ~sql: Postgres.sql,
   ~pgHost,
@@ -1238,32 +1254,66 @@ let make = (
     envioTables->Utils.Array.notEmpty
   }
 
-  let restoreEffectCache = async (~withUpload) => {
-    if withUpload {
-      // Try to restore cache tables from binary files
-      let nothingToUploadErrorMessage = "Nothing to upload."
-
-      switch await Promise.all2((
-        NodeJs.Fs.Promises.readdir(cacheDirPath)
-        ->Promise.thenResolve(e => Ok(e))
-        ->Promise.catch(_ => Promise.resolve(Error(nothingToUploadErrorMessage))),
-        getConnectedPsqlExec(~pgUser, ~pgHost, ~pgDatabase, ~pgPort, ~containerName),
-      )) {
-      | (Ok(entries), Ok(psqlExec)) => {
-          let cacheFiles = entries->Array.filter(entry => {
-            entry->String.endsWith(".tsv")
+  // Scans .envio/cache into a list of (cache table, absolute TSV path). Flat
+  // `<name>.tsv` files map to cross-chain caches; a numeric subdirectory
+  // `<chainId>/<name>.tsv` maps to a chain-scoped cache. Exactly one directory
+  // level is supported. A non-numeric directory that contains TSVs is rejected.
+  // Returns [] when .envio/cache doesn't exist.
+  let scanCacheDir = async () => {
+    let topEntries = try {
+      await NodeJs.Fs.Promises.readdir(cacheDirPath)
+    } catch {
+    | _ => []
+    }
+    let result = []
+    let _ = await topEntries
+    ->Array.map(async entry => {
+      let entryPath = NodeJs.Path.join(cacheDirPath, entry)
+      let isDir = (await NodeJs.Fs.Promises.stat(entryPath))->NodeJs.Fs.Promises.statsIsDirectory
+      if isDir {
+        let subEntries = await NodeJs.Fs.Promises.readdir(entryPath)
+        let tsvs = subEntries->Array.filter(sub => sub->String.endsWith(".tsv"))
+        switch Internal.EffectCache.parseChainId(entry) {
+        | Some(chainId) =>
+          tsvs->Array.forEach(sub => {
+            let effectName = sub->String.slice(~start=0, ~end=-4)
+            let table = Internal.makeCacheTable(~effectName, ~scope=Chain(chainId))
+            result
+            ->Array.push((table, NodeJs.Path.join(entryPath, sub)->NodeJs.Path.toString))
+            ->ignore
           })
+        | None =>
+          if tsvs->Utils.Array.notEmpty {
+            JsError.throwWithMessage(
+              `Invalid effect cache directory ".envio/cache/${entry}". Chain cache directories must be named by a numeric chain id (e.g. "1"). Found cache files: ${tsvs->Array.joinUnsafe(
+                  ", ",
+                )}.`,
+            )
+          }
+        }
+      } else if entry->String.endsWith(".tsv") {
+        let effectName = entry->String.slice(~start=0, ~end=-4)
+        let table = Internal.makeCacheTable(~effectName, ~scope=CrossChain)
+        result->Array.push((table, entryPath->NodeJs.Path.toString))->ignore
+      }
+    })
+    ->Promise.all
+    result
+  }
 
-          let _ = await cacheFiles
-          ->Array.map(entry => {
-            let effectName = entry->String.slice(~start=0, ~end=-4)
-            let table = Internal.makeCacheTable(~effectName)
-
+  let restoreEffectCache = async (~withUpload) => {
+    if withUpload {
+      // Try to restore cache tables from the .envio/cache TSV files
+      switch await scanCacheDir() {
+      | [] => Logging.info("No cache found to upload.")
+      | entries =>
+        switch await getConnectedPsqlExec(~pgUser, ~pgHost, ~pgDatabase, ~pgPort, ~containerName) {
+        | Ok(psqlExec) =>
+          let _ = await entries
+          ->Array.map(((table, inputFile)) => {
             sql
             ->Postgres.unsafe(makeCreateTableQuery(table, ~pgSchema, ~isNumericArrayAsText=false))
             ->Promise.then(() => {
-              let inputFile = NodeJs.Path.join(cacheDirPath, entry)->NodeJs.Path.toString
-
               let command = `${psqlExec} -c 'COPY "${pgSchema}"."${table.tableName}" FROM STDIN WITH (FORMAT text, HEADER);' < ${inputFile}`
 
               Promise.make(
@@ -1283,14 +1333,8 @@ let make = (
             })
           })
           ->Promise.all
-
           Logging.info("Successfully uploaded cache.")
-        }
-      | (Error(message), _)
-      | (_, Error(message)) =>
-        if message === nothingToUploadErrorMessage {
-          Logging.info("No cache found to upload.")
-        } else {
+        | Error(message) =>
           Logging.error(`Failed to upload cache, continuing without it. ${message}`)
         }
       }
@@ -1315,8 +1359,14 @@ let make = (
 
     let cache = Dict.make()
     cacheTableInfo->Array.forEach(({tableName, count}) => {
-      let effectName = tableName->String.slice(~start=cacheTablePrefixLength)
-      cache->Dict.set(effectName, ({effectName, count}: Persistence.effectCacheRecord))
+      switch Internal.EffectCache.fromTableName(tableName) {
+      | Some((effectName, scope)) =>
+        cache->Dict.set(
+          tableName,
+          ({effectName, scope, tableName, count}: Persistence.effectCacheRecord),
+        )
+      | None => ()
+      }
     })
     cache
   }
@@ -1480,12 +1530,11 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
   }
 
   let setEffectCacheOrThrow = async (
-    ~effect: Internal.effect,
+    ~table: Table.table,
+    ~itemSchema,
     ~items: array<Internal.effectCacheItem>,
     ~initialize: bool,
   ) => {
-    let {table, itemSchema} = effect.storageMeta
-
     if initialize {
       let _ = await sql->Postgres.unsafe(
         makeCreateTableQuery(table, ~pgSchema, ~isNumericArrayAsText=false),
@@ -1531,24 +1580,36 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
             )
 
             let promises = cacheTableInfo->Array.map(async ({tableName}) => {
-              let cacheName = tableName->String.slice(~start=cacheTablePrefixLength)
-              let outputFile =
-                NodeJs.Path.join(cacheDirPath, cacheName ++ ".tsv")->NodeJs.Path.toString
+              switch Internal.EffectCache.fromTableName(tableName) {
+              | Some((effectName, scope)) =>
+                // Reverse mapping: chain-scoped caches dump into a per-chain
+                // subdirectory, created here if needed.
+                let outputPath = NodeJs.Path.join(
+                  cacheDirPath,
+                  Internal.EffectCache.toCachePath(~effectName, ~scope),
+                )
+                let _ = await NodeJs.Fs.Promises.mkdir(
+                  ~path=NodeJs.Path.dirname(outputPath->NodeJs.Path.toString),
+                  ~options={recursive: true},
+                )
+                let outputFile = outputPath->NodeJs.Path.toString
 
-              let command = `${psqlExec} -c 'COPY "${pgSchema}"."${tableName}" TO STDOUT WITH (FORMAT text, HEADER);' > ${outputFile}`
+                let command = `${psqlExec} -c 'COPY "${pgSchema}"."${tableName}" TO STDOUT WITH (FORMAT text, HEADER);' > ${outputFile}`
 
-              Promise.make((resolve, reject) => {
-                NodeJs.ChildProcess.execWithOptions(
-                  command,
-                  psqlExecOptions,
-                  (~error, ~stdout, ~stderr as _) => {
-                    switch error {
-                    | Value(error) => reject(error)
-                    | Null => resolve(stdout)
-                    }
-                  },
-                )
-              })
+                await Promise.make((resolve, reject) => {
+                  NodeJs.ChildProcess.execWithOptions(
+                    command,
+                    psqlExecOptions,
+                    (~error, ~stdout, ~stderr as _) => {
+                      switch error {
+                      | Value(error) => reject(error)
+                      | Null => resolve(stdout)
+                      }
+                    },
+                  )
+                })
+              | None => ""
+              }
             })
 
             let _ = await promises->Promise.all
@@ -1663,7 +1724,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
     ~entityConfig: Internal.entityConfig,
     ~rollbackTargetCheckpointId,
   ) => {
-    await Promise.all2((
+    let (removedIdRows, rollbackRows) = await Promise.all2((
       // Get IDs of entities that should be deleted (created after rollback target with no prior history)
       sql
       ->Postgres.preparedUnsafe(
@@ -1671,14 +1732,26 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
         [rollbackTargetCheckpointId->BigInt.toString]->(Utils.magic: array<string> => unknown),
       )
       ->(Utils.magic: promise<unknown> => promise<array<{"id": string}>>),
-      // Get entities that should be restored to their state at or before rollback target
+      // Get the latest pre-target row, including its SET or DELETE action.
       sql
       ->Postgres.preparedUnsafe(
-        makeGetRollbackRestoredEntitiesQuery(~entityConfig, ~pgSchema),
+        makeGetRollbackPreTargetRowsQuery(~entityConfig, ~pgSchema),
         [rollbackTargetCheckpointId->BigInt.toString]->(Utils.magic: array<string> => unknown),
       )
       ->(Utils.magic: promise<unknown> => promise<array<unknown>>),
     ))
+
+    let removedIds = removedIdRows->Array.map(row => row["id"])
+    let restoredEntitiesResult = []
+    rollbackRows->Array.forEach(row => {
+      let (entityId, action) = row->S.parseOrThrow(rollbackRowStateSchema)
+      switch action {
+      | SET => restoredEntitiesResult->Array.push(row)->ignore
+      | DELETE => removedIds->Array.push(entityId)->ignore
+      }
+    })
+
+    (removedIds, restoredEntitiesResult)
   }
 
   let writeBatchMethod = async (

package/src/PgStorage.res.mjs

@@ -493,15 +493,18 @@ function makeSchemaTableNamesQuery(pgSchema) {
   return `SELECT table_name FROM information_schema.tables WHERE table_schema = '` + pgSchema + `';`;
 }
 
-let cacheTablePrefixLength = Internal.cacheTablePrefix.length;
-
 function makeSchemaCacheTableInfoQuery(pgSchema) {
-  return `SELECT 
+  return `SELECT
     t.table_name,
     ` + getCacheRowCountFnName + `(t.table_name) as count
    FROM information_schema.tables t
-   WHERE t.table_schema = '` + pgSchema + `' 
-   AND t.table_name LIKE '` + Internal.cacheTablePrefix + `%';`;
+   WHERE t.table_schema = '` + pgSchema + `'
+   AND t.table_name ~ '^envio_([0-9]+_)?effect_.+'
+   AND (
+     SELECT array_agg(c.column_name::text ORDER BY c.column_name::text)
+     FROM information_schema.columns c
+     WHERE c.table_schema = t.table_schema AND c.table_name = t.table_name
+   ) = ARRAY['id', 'output'];`;
 }
 
 let psqlExecState = {
@@ -766,7 +769,7 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
           }
           throw exn;
         }),
-        Promise.all(updatedEffectsCache.map(param => setEffectCacheOrThrow(param.effect, param.items, param.shouldInitialize)))
+        Promise.all(updatedEffectsCache.map(param => setEffectCacheOrThrow(param.table, param.itemSchema, param.items, param.shouldInitialize)))
       ]);
       let specificError$1 = specificError.contents;
       if (specificError$1 === undefined) {
@@ -789,7 +792,7 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
   }
 }
 
-function makeGetRollbackRestoredEntitiesQuery(entityConfig, pgSchema) {
+function makeGetRollbackPreTargetRowsQuery(entityConfig, pgSchema) {
   let dataFieldNames = Stdlib_Array.filterMap(entityConfig.table.fields, fieldOrDerived => {
     if (fieldOrDerived.TAG === "Field") {
       return Table.getPgDbFieldName(fieldOrDerived._0);
@@ -797,31 +800,36 @@ function makeGetRollbackRestoredEntitiesQuery(entityConfig, pgSchema) {
   });
   let dataFieldsCommaSeparated = dataFieldNames.map(name => `"` + name + `"`).join(", ");
   let historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
-  return `SELECT DISTINCT ON (` + Table.idFieldName + `) ` + dataFieldsCommaSeparated + `
-FROM "` + pgSchema + `"."` + historyTableName + `"
-WHERE "` + EntityHistory.checkpointIdFieldName + `" <= $1
-  AND EXISTS (
-    SELECT 1
-    FROM "` + pgSchema + `"."` + historyTableName + `" h
-    WHERE h.` + Table.idFieldName + ` = "` + historyTableName + `".` + Table.idFieldName + `
-      AND h."` + EntityHistory.checkpointIdFieldName + `" > $1
-  )
-ORDER BY ` + Table.idFieldName + `, "` + EntityHistory.checkpointIdFieldName + `" DESC`;
+  return `SELECT DISTINCT ON ("` + Table.idFieldName + `") ` + dataFieldsCommaSeparated + `, "` + EntityHistory.changeFieldName + `"
+  FROM "` + pgSchema + `"."` + historyTableName + `"
+  WHERE "` + EntityHistory.checkpointIdFieldName + `" <= $1
+    AND EXISTS (
+      SELECT 1
+      FROM "` + pgSchema + `"."` + historyTableName + `" h
+      WHERE h."` + Table.idFieldName + `" = "` + historyTableName + `"."` + Table.idFieldName + `"
+        AND h."` + EntityHistory.checkpointIdFieldName + `" > $1
+    )
+  ORDER BY "` + Table.idFieldName + `", "` + EntityHistory.checkpointIdFieldName + `" DESC`;
 }
 
 function makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema) {
   let historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
-  return `SELECT DISTINCT ` + Table.idFieldName + `
-FROM "` + pgSchema + `"."` + historyTableName + `"
-WHERE "` + EntityHistory.checkpointIdFieldName + `" > $1
-AND NOT EXISTS (
-  SELECT 1
-  FROM "` + pgSchema + `"."` + historyTableName + `" h
-  WHERE h.` + Table.idFieldName + ` = "` + historyTableName + `".` + Table.idFieldName + `
-    AND h."` + EntityHistory.checkpointIdFieldName + `" <= $1
-)`;
+  return `SELECT DISTINCT "` + Table.idFieldName + `"
+  FROM "` + pgSchema + `"."` + historyTableName + `"
+  WHERE "` + EntityHistory.checkpointIdFieldName + `" > $1
+    AND NOT EXISTS (
+      SELECT 1
+      FROM "` + pgSchema + `"."` + historyTableName + `" h
+      WHERE h."` + Table.idFieldName + `" = "` + historyTableName + `"."` + Table.idFieldName + `"
+        AND h."` + EntityHistory.checkpointIdFieldName + `" <= $1
+    )`;
 }
 
+let rollbackRowStateSchema = S$RescriptSchema.object(s => [
+  s.f(Table.idFieldName, S$RescriptSchema.string),
+  s.f(EntityHistory.changeFieldName, EntityHistory.RowAction.schema)
+]);
+
 function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isHasuraEnabled, sink, onInitialize, onNewTables) {
   let containerName = "envio-postgres";
   let psqlExecOptions_env = Object.fromEntries([
@@ -839,32 +847,60 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
   };
   let cacheDirPath = Path.resolve(".envio", "cache");
   let isInitialized = async () => Utils.$$Array.notEmpty(await sql.unsafe(`SELECT table_schema FROM information_schema.tables WHERE table_schema = '` + pgSchema + `' AND (table_name = '` + "event_sync_state" + `' OR table_name = '` + InternalTable.Chains.table.tableName + `');`));
+  let scanCacheDir = async () => {
+    let topEntries;
+    try {
+      topEntries = await Fs.promises.readdir(cacheDirPath);
+    } catch (exn) {
+      topEntries = [];
+    }
+    let result = [];
+    await Promise.all(topEntries.map(async entry => {
+      let entryPath = Path.join(cacheDirPath, entry);
+      let isDir = (await Fs.promises.stat(entryPath)).isDirectory();
+      if (isDir) {
+        let subEntries = await Fs.promises.readdir(entryPath);
+        let tsvs = subEntries.filter(sub => sub.endsWith(".tsv"));
+        let chainId = Internal.EffectCache.parseChainId(entry);
+        if (chainId !== undefined) {
+          tsvs.forEach(sub => {
+            let effectName = sub.slice(0, -4);
+            let table = Internal.makeCacheTable(effectName, chainId);
+            result.push([
+              table,
+              Path.join(entryPath, sub)
+            ]);
+          });
+          return;
+        } else if (Utils.$$Array.notEmpty(tsvs)) {
+          return Stdlib_JsError.throwWithMessage(`Invalid effect cache directory ".envio/cache/` + entry + `". Chain cache directories must be named by a numeric chain id (e.g. "1"). Found cache files: ` + tsvs.join(", ") + `.`);
+        } else {
+          return;
+        }
+      }
+      if (!entry.endsWith(".tsv")) {
+        return;
+      }
+      let effectName = entry.slice(0, -4);
+      let table = Internal.makeCacheTable(effectName, "crossChain");
+      result.push([
+        table,
+        entryPath
+      ]);
+    }));
+    return result;
+  };
   let restoreEffectCache = async withUpload => {
     if (withUpload) {
-      let nothingToUploadErrorMessage = "Nothing to upload.";
-      let match = await Promise.all([
-        Stdlib_Promise.$$catch(Fs.promises.readdir(cacheDirPath).then(e => ({
-          TAG: "Ok",
-          _0: e
-        })), param => Promise.resolve({
-          TAG: "Error",
-          _0: nothingToUploadErrorMessage
-        })),
-        getConnectedPsqlExec(pgUser, pgHost, pgDatabase, pgPort, containerName)
-      ]);
-      let exit = 0;
-      let message;
-      let entries = match[0];
-      if (entries.TAG === "Ok") {
-        let psqlExec = match[1];
+      let entries = await scanCacheDir();
+      if (entries.length !== 0) {
+        let psqlExec = await getConnectedPsqlExec(pgUser, pgHost, pgDatabase, pgPort, containerName);
         if (psqlExec.TAG === "Ok") {
           let psqlExec$1 = psqlExec._0;
-          let cacheFiles = entries._0.filter(entry => entry.endsWith(".tsv"));
-          await Promise.all(cacheFiles.map(entry => {
-            let effectName = entry.slice(0, -4);
-            let table = Internal.makeCacheTable(effectName);
+          await Promise.all(entries.map(param => {
+            let inputFile = param[1];
+            let table = param[0];
             return sql.unsafe(makeCreateTableQuery(table, pgSchema, false)).then(() => {
-              let inputFile = Path.join(cacheDirPath, entry);
               let command = psqlExec$1 + ` -c 'COPY "` + pgSchema + `"."` + table.tableName + `" FROM STDIN WITH (FORMAT text, HEADER);' < ` + inputFile;
               return new Promise((resolve, reject) => {
                 Child_process.exec(command, psqlExecOptions, (error, stdout, param) => {
@@ -879,19 +915,10 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
           }));
           Logging.info("Successfully uploaded cache.");
         } else {
-          message = match[1]._0;
-          exit = 1;
+          Logging.error(`Failed to upload cache, continuing without it. ` + psqlExec._0);
         }
       } else {
-        message = entries._0;
-        exit = 1;
-      }
-      if (exit === 1) {
-        if (message === nothingToUploadErrorMessage) {
-          Logging.info("No cache found to upload.");
-        } else {
-          Logging.error(`Failed to upload cache, continuing without it. ` + message);
-        }
+        Logging.info("No cache found to upload.");
       }
     }
     let cacheTableInfo = await sql.unsafe(makeSchemaCacheTableInfoQuery(pgSchema));
@@ -900,11 +927,17 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
     }
     let cache = {};
     cacheTableInfo.forEach(param => {
-      let effectName = param.table_name.slice(cacheTablePrefixLength);
-      cache[effectName] = {
-        effectName: effectName,
-        count: param.count
-      };
+      let tableName = param.table_name;
+      let match = Internal.EffectCache.fromTableName(tableName);
+      if (match !== undefined) {
+        cache[tableName] = {
+          effectName: match[0],
+          scope: match[1],
+          tableName: tableName,
+          count: param.count
+        };
+        return;
+      }
     });
     return cache;
   };
@@ -998,16 +1031,14 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
     }
   };
   let setOrThrow$1 = (items, table, itemSchema) => setOrThrow(sql, items, table, itemSchema, pgSchema);
-  let setEffectCacheOrThrow = async (effect, items, initialize) => {
-    let match = effect.storageMeta;
-    let table = match.table;
+  let setEffectCacheOrThrow = async (table, itemSchema, items, initialize) => {
     if (initialize) {
       await sql.unsafe(makeCreateTableQuery(table, pgSchema, false));
       if (onNewTables !== undefined) {
         await onNewTables([table.tableName]);
       }
     }
-    return await setOrThrow$1(items, table, match.itemSchema);
+    return await setOrThrow$1(items, table, itemSchema);
   };
   let dumpEffectCache = async () => {
     try {
@@ -1030,10 +1061,16 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
       Logging.info(`Dumping cache: ` + cacheTableInfo.map(param => param.table_name + " (" + param.count.toString() + " rows)").join(", "));
       let promises = cacheTableInfo.map(async param => {
         let tableName = param.table_name;
-        let cacheName = tableName.slice(cacheTablePrefixLength);
-        let outputFile = Path.join(cacheDirPath, cacheName + ".tsv");
-        let command = psqlExec$1 + ` -c 'COPY "` + pgSchema + `"."` + tableName + `" TO STDOUT WITH (FORMAT text, HEADER);' > ` + outputFile;
-        return new Promise((resolve, reject) => {
+        let match = Internal.EffectCache.fromTableName(tableName);
+        if (match === undefined) {
+          return "";
+        }
+        let outputPath = Path.join(cacheDirPath, Internal.EffectCache.toCachePath(match[0], match[1]));
+        await Fs.promises.mkdir(Path.dirname(outputPath), {
+          recursive: true
+        });
+        let command = psqlExec$1 + ` -c 'COPY "` + pgSchema + `"."` + tableName + `" TO STDOUT WITH (FORMAT text, HEADER);' > ` + outputPath;
+        return await new Promise((resolve, reject) => {
           Child_process.exec(command, psqlExecOptions, (error, stdout, param) => {
             if (error === null) {
               return resolve(stdout);
@@ -1097,10 +1134,26 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
   let pruneStaleEntityHistory = (entityName, entityIndex, safeCheckpointId) => EntityHistory.pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, safeCheckpointId);
   let getRollbackTargetCheckpoint = (reorgChainId, lastKnownValidBlockNumber) => InternalTable.Checkpoints.getRollbackTargetCheckpoint(sql, pgSchema, reorgChainId, lastKnownValidBlockNumber);
   let getRollbackProgressDiff = rollbackTargetCheckpointId => InternalTable.Checkpoints.getRollbackProgressDiff(sql, pgSchema, rollbackTargetCheckpointId);
-  let getRollbackData = async (entityConfig, rollbackTargetCheckpointId) => await Promise.all([
-    sql.unsafe(makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true}),
-    sql.unsafe(makeGetRollbackRestoredEntitiesQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true})
-  ]);
+  let getRollbackData = async (entityConfig, rollbackTargetCheckpointId) => {
+    let match = await Promise.all([
+      sql.unsafe(makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true}),
+      sql.unsafe(makeGetRollbackPreTargetRowsQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true})
+    ]);
+    let removedIds = match[0].map(row => row.id);
+    let restoredEntitiesResult = [];
+    match[1].forEach(row => {
+      let match = S$RescriptSchema.parseOrThrow(row, rollbackRowStateSchema);
+      if (match[1] === "SET") {
+        restoredEntitiesResult.push(row);
+        return;
+      }
+      removedIds.push(match[0]);
+    });
+    return [
+      removedIds,
+      restoredEntitiesResult
+    ];
+  };
   let writeBatchMethod = async (batch, rollback, isInReorgThreshold, config, allEntities, updatedEffectsCache, updatedEntities, chainMetaData) => {
     let pgUpdates = [];
     let chUpdates = [];
@@ -1227,15 +1280,15 @@ export {
   setQueryCache,
   setOrThrow,
   makeSchemaTableNamesQuery,
-  cacheTablePrefixLength,
   makeSchemaCacheTableInfoQuery,
   getConnectedPsqlExec,
   deleteByIdsOrThrow,
   makeInsertDeleteUpdatesQuery,
   executeSet,
   writeBatch,
-  makeGetRollbackRestoredEntitiesQuery,
+  makeGetRollbackPreTargetRowsQuery,
   makeGetRollbackRemovedIdsQuery,
+  rollbackRowStateSchema,
   make,
   makeStorageFromEnv,
   makePersistenceFromConfig,