envio 3.3.0-alpha.8 → 3.3.0-rc.0

package/src/Main.res.mjs

@@ -13,6 +13,7 @@ import * as ChainMap from "./ChainMap.res.mjs";
 import * as PgStorage from "./PgStorage.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
+import * as EnvioGlobal from "./EnvioGlobal.res.mjs";
 import * as IndexerLoop from "./IndexerLoop.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as PromClient from "prom-client";
@@ -61,28 +62,24 @@ let stateSchema = S$RescriptSchema.union([
   }))
 ]);
 
-let blockRangeSchema = S$RescriptSchema.strict(S$RescriptSchema.object(s => ({
-  _gte: s.f("_gte", S$RescriptSchema.option(S$RescriptSchema.int)),
-  _lte: s.f("_lte", S$RescriptSchema.option(S$RescriptSchema.int)),
-  _every: s.f("_every", S$RescriptSchema.Option.getOr(S$RescriptSchema.option(S$RescriptSchema.intMin(S$RescriptSchema.int, 1, undefined)), 1))
-})));
+function getIndexerState() {
+  return EnvioGlobal.value.indexerState;
+}
 
-let defaultBlockRange = {
-  _gte: undefined,
-  _lte: undefined,
-  _every: 1
-};
+function setIndexerState(state) {
+  EnvioGlobal.value.indexerState = Primitive_option.some(state);
+}
 
-let indexerStateRef = {
-  contents: undefined
-};
+function getGlobalPersistence() {
+  return EnvioGlobal.value.persistence;
+}
 
-let globalPersistenceRef = {
-  contents: undefined
-};
+function setGlobalPersistence(persistence) {
+  EnvioGlobal.value.persistence = Primitive_option.some(persistence);
+}
 
 function getInitialChainState(chainId) {
-  let persistence = globalPersistenceRef.contents;
+  let persistence = EnvioGlobal.value.persistence;
   if (persistence === undefined) {
     return;
   }
@@ -134,7 +131,7 @@ function buildChainsObject(config) {
     }), "isRealtime", {
       enumerable: true,
       get: () => {
-        let state = indexerStateRef.contents;
+        let state = EnvioGlobal.value.indexerState;
         if (state !== undefined) {
           return IndexerState.isRealtime(Primitive_option.valFromOption(state));
         } else if (Env.updateSyncTimeOnRestart) {
@@ -162,7 +159,7 @@ function buildChainsObject(config) {
       }), "addresses", {
         enumerable: true,
         get: () => {
-          let state = indexerStateRef.contents;
+          let state = EnvioGlobal.value.indexerState;
           if (state !== undefined) {
             let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
             let chainState = IndexerState.getChainState(Primitive_option.valFromOption(state), chain);
@@ -278,69 +275,9 @@ function getGlobalIndexer() {
     HandlerRegister.throwIfFinishedRegistration("~internalAndWillBeRemovedSoon_onRollbackCommit");
     RollbackCommit.register(callback);
   };
-  let extractRange = (filter, name, ecosystem) => {
-    try {
-      let inner = S$RescriptSchema.parseOrThrow(filter, ecosystem.onBlockFilterSchema);
-      if (inner !== undefined) {
-        return S$RescriptSchema.parseOrThrow(Primitive_option.valFromOption(inner), blockRangeSchema);
-      } else {
-        return defaultBlockRange;
-      }
-    } catch (raw_exn) {
-      let exn = Primitive_exceptions.internalToException(raw_exn);
-      if (exn.RE_EXN_ID === S$RescriptSchema.Raised) {
-        return Stdlib_JsError.throwWithMessage(`\`indexer.` + ecosystem.onBlockMethodName + `("` + name + `")\` \`where\` returned an invalid filter: ` + Utils.prettifyExn(exn._1));
-      }
-      throw exn;
-    }
-  };
   let onBlockFn = (rawOptions, handler) => {
     HandlerRegister.throwIfFinishedRegistration("onBlock");
-    let config = Config.load();
-    let ecosystem = config.ecosystem;
-    let match = buildChainsObject(config);
-    let chains = match[0];
-    let name = rawOptions.name;
-    let logger = Logging.createChild({
-      onBlock: name
-    });
-    let w = rawOptions.where;
-    let where = w === undefined || w === null ? undefined : (
-        typeof w === "function" ? rawOptions.where : Stdlib_JsError.throwWithMessage(`\`indexer.` + ecosystem.onBlockMethodName + `("` + name + `")\` expected \`where\` to be a function or omitted, but got ` + typeof w + `.`)
-      );
-    let matchedAny = {
-      contents: false
-    };
-    ChainMap.values(config.chainMap).forEach(chainConfig => {
-      let chainId = chainConfig.id;
-      let chainObj = chains[chainId.toString()];
-      let result = where !== undefined ? where({
-          chain: chainObj
-        }) : true;
-      let match = result === true ? [
-          true,
-          defaultBlockRange
-        ] : (
-          result === false ? [
-              false,
-              defaultBlockRange
-            ] : (
-              typeof result === "object" && !Array.isArray(result) && result !== null ? [
-                  true,
-                  extractRange(result, name, ecosystem)
-                ] : Stdlib_JsError.throwWithMessage(`\`indexer.` + ecosystem.onBlockMethodName + `("` + name + `")\` \`where\` predicate returned an invalid value of type ` + typeof result + `. Expected boolean or a filter object.`)
-            )
-        );
-      if (!match[0]) {
-        return;
-      }
-      let range = match[1];
-      matchedAny.contents = true;
-      HandlerRegister.registerOnBlock(name, chainId, range._every, range._gte, range._lte, handler);
-    });
-    if (!matchedAny.contents) {
-      return Logging.childWarn(logger, `\`indexer.` + ecosystem.onBlockMethodName + `\` matched 0 chains. Check the \`where\` predicate.`);
-    }
+    HandlerRegister.registerOnBlock(rawOptions.name, rawOptions.where, handler, config => buildChainsObject(config)[0]);
   };
   let keysMemo = {
     contents: undefined
@@ -478,7 +415,7 @@ function startServer(getState, persistence, isDevelopmentMode) {
   });
   app.get("/metrics", (_req, res) => {
     res.set("Content-Type", PromClient.register.contentType);
-    Metrics.collect(indexerStateRef.contents).then(metrics => res.end(metrics));
+    Metrics.collect(EnvioGlobal.value.indexerState).then(metrics => res.end(metrics));
   });
   app.get("/metrics/runtime", (_req, res) => {
     res.set("Content-Type", runtimeRegistry.contentType);
@@ -529,7 +466,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
   let config = Config.load();
   let isDevelopmentMode = !isTest && config.isDev;
   let persistence$1 = persistence !== undefined ? persistence : PgStorage.makePersistenceFromConfig(config, undefined);
-  globalPersistenceRef.contents = persistence$1;
+  EnvioGlobal.value.persistence = Primitive_option.some(persistence$1);
   await Persistence.init(persistence$1, ChainMap.values(config.chainMap), Config.stripSensitiveData(Config.getPublicConfigJson()), isDevelopmentMode ? "envio dev -r" : "envio start -r", isDevelopmentMode ? "envio dev" : "envio start", reset);
   let registrationsByChainId = await HandlerLoader.registerAllHandlers(config);
   let config$1 = isTest ? ({
@@ -573,7 +510,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
   Prometheus.RollbackEnabled.set(config$2.shouldRollbackOnReorg);
   if (!isTest) {
     startServer(() => {
-      let state = indexerStateRef.contents;
+      let state = EnvioGlobal.value.indexerState;
       if (state === undefined) {
         return {
           status: "initializing"
@@ -595,7 +532,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
   if (shouldUseTui) {
     Tui.start(() => state);
   }
-  indexerStateRef.contents = Primitive_option.some(state);
+  EnvioGlobal.value.indexerState = Primitive_option.some(state);
   IndexerLoop.start(state);
   return await runUntilFatalError;
 }
@@ -603,10 +540,10 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
 export {
   chainDataSchema,
   stateSchema,
-  blockRangeSchema,
-  defaultBlockRange,
-  indexerStateRef,
-  globalPersistenceRef,
+  getIndexerState,
+  setIndexerState,
+  getGlobalPersistence,
+  setGlobalPersistence,
   getInitialChainState,
   buildChainsObject,
   getGlobalIndexer,

package/src/Metrics.res

@@ -47,7 +47,7 @@ let renderSourceRequests = (~samples: array<SourceManager.requestStatSample>) =>
       if sample.seconds !== 0. {
         secondsOut :=
           secondsOut.contents ++
-          `\n${sourceRequestSecondsTotalName}${labels} ${sample.seconds->Float.toString}`
+          `\n${sourceRequestSecondsTotalName}${labels} ${sample.seconds->Float.toFixed(~digits=3)}`
       }
     })
     countOut.contents ++ secondsOut.contents

package/src/Metrics.res.mjs

@@ -44,7 +44,7 @@ function renderSourceRequests(samples) {
     let labels = `{source="` + sample.sourceName + `",chainId="` + sample.chainId.toString() + `",method="` + sample.method + `"}`;
     countOut.contents = countOut.contents + (`\n` + sourceRequestTotalName + labels + ` ` + sample.count.toString());
     if (sample.seconds !== 0) {
-      secondsOut.contents = secondsOut.contents + (`\n` + sourceRequestSecondsTotalName + labels + ` ` + sample.seconds.toString());
+      secondsOut.contents = secondsOut.contents + (`\n` + sourceRequestSecondsTotalName + labels + ` ` + sample.seconds.toFixed(3));
       return;
     }
   });

package/src/Persistence.res

@@ -6,9 +6,14 @@
 // DbFunctions, Db, Migrations, InMemoryStore modules which use codegen code directly.
 
 // The type reflects an cache table in the db
-// It might be present even if the effect is not used in the application
+// It might be present even if the effect is not used in the application.
+// `initialState.cache` is keyed by `tableName` (the full cache address), so a
+// cross-chain and a chain-scoped cache for the same effect are tracked
+// independently.
 type effectCacheRecord = {
   effectName: string,
+  scope: Internal.chainScope,
+  tableName: string,
   // Number of rows in the table
   mutable count: int,
 }
@@ -40,8 +45,12 @@ type initialState = {
   envioInfo: option<JSON.t>,
 }
 
+// Carries the already-resolved cache address (`table`) rather than an effect +
+// scope: the scope is contextual (resolved per call from the handler's chain),
+// so the write layer only needs the concrete table it targets.
 type updatedEffectCache = {
-  effect: Internal.effect,
+  table: Table.table,
+  itemSchema: S.t<Internal.effectCacheItem>,
   items: array<Internal.effectCacheItem>,
   shouldInitialize: bool,
 }
@@ -112,7 +121,7 @@ type storage = {
   getRollbackData: (
     ~entityConfig: Internal.entityConfig,
     ~rollbackTargetCheckpointId: Internal.checkpointId,
-  ) => promise<(array<{"id": string}>, array<unknown>)>,
+  ) => promise<(array<string>, array<unknown>)>,
   // Write batch to storage
   writeBatch: (
     ~batch: Batch.t,

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 (