envio 3.0.0-alpha.0 → 3.0.0-alpha.10

package/src/TestIndexer.res.mjs

@@ -0,0 +1,412 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Env from "./Env.res.mjs";
+import * as Main from "./Main.res.mjs";
+import * as Table from "./db/Table.res.mjs";
+import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as Js_dict from "rescript/lib/es6/js_dict.js";
+import * as Js_json from "rescript/lib/es6/js_json.js";
+import * as Logging from "./Logging.res.mjs";
+import * as Process from "process";
+import * as Belt_Int from "rescript/lib/es6/belt_Int.js";
+import * as ChainMap from "./ChainMap.res.mjs";
+import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as TableIndices from "./TableIndices.res.mjs";
+import * as InternalTable from "./db/InternalTable.res.mjs";
+import * as Worker_threads from "worker_threads";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as TestIndexerProxyStorage from "./TestIndexerProxyStorage.res.mjs";
+
+function toIndexingContract(dc) {
+  return {
+          address: dc.contract_address,
+          contractName: dc.contract_name,
+          startBlock: dc.registering_event_block_number,
+          registrationBlock: dc.registering_event_block_number
+        };
+}
+
+function handleLoadByIds(state, tableName, ids) {
+  var entityDict = Belt_Option.getWithDefault(Js_dict.get(state.entities, tableName), {});
+  var entityConfig = state.entityConfigs[tableName];
+  var results = [];
+  Belt_Array.forEach(ids, (function (id) {
+          var entity = Js_dict.get(entityDict, id);
+          if (entity === undefined) {
+            return ;
+          }
+          var jsonEntity = S$RescriptSchema.reverseConvertToJsonOrThrow(entity, entityConfig.schema);
+          results.push(jsonEntity);
+        }));
+  return results;
+}
+
+function handleLoadByField(state, tableName, fieldName, fieldValue, operator) {
+  var entityDict = Belt_Option.getWithDefault(Js_dict.get(state.entities, tableName), {});
+  var entityConfig = state.entityConfigs[tableName];
+  var results = [];
+  var match = Table.getFieldByName(entityConfig.table, fieldName);
+  var fieldSchema;
+  var exit = 0;
+  if (match !== undefined && match.TAG === "Field") {
+    fieldSchema = match._0.fieldSchema;
+  } else {
+    exit = 1;
+  }
+  if (exit === 1) {
+    fieldSchema = Js_exn.raiseError("Field " + fieldName + " not found in entity " + tableName);
+  }
+  var parsedFieldValue = S$RescriptSchema.convertOrThrow(fieldValue, fieldSchema);
+  Belt_Array.forEach(Js_dict.values(entityDict), (function (entity) {
+          var entityFieldValue = Js_dict.get(entity, fieldName);
+          if (entityFieldValue === undefined) {
+            return ;
+          }
+          var entityFieldValue$1 = Caml_option.valFromOption(entityFieldValue);
+          var matches = operator === "=" ? TableIndices.FieldValue.eq(entityFieldValue$1, parsedFieldValue) : (
+              operator === ">" ? TableIndices.FieldValue.gt(entityFieldValue$1, parsedFieldValue) : TableIndices.FieldValue.lt(entityFieldValue$1, parsedFieldValue)
+            );
+          if (!matches) {
+            return ;
+          }
+          var jsonEntity = S$RescriptSchema.reverseConvertToJsonOrThrow(entity, entityConfig.schema);
+          results.push(jsonEntity);
+        }));
+  return results;
+}
+
+function handleWriteBatch(state, updatedEntities, checkpointIds, checkpointChainIds, checkpointBlockNumbers, checkpointBlockHashes, checkpointEventsProcessed) {
+  var changesByCheckpoint = {};
+  Belt_Array.forEach(updatedEntities, (function (param) {
+          var entityName = param.entityName;
+          var dict = Js_dict.get(state.entities, entityName);
+          var entityDict;
+          if (dict !== undefined) {
+            entityDict = dict;
+          } else {
+            var dict$1 = {};
+            state.entities[entityName] = dict$1;
+            entityDict = dict$1;
+          }
+          var entityConfig = state.entityConfigs[entityName];
+          Belt_Array.forEach(param.updates, (function (update) {
+                  var processChange = function (change) {
+                    if (change.type === "SET") {
+                      var parsedEntity = S$RescriptSchema.parseOrThrow(change.entity, entityConfig.schema);
+                      entityDict[change.entityId] = parsedEntity;
+                      var checkpointKey = String(change.checkpointId);
+                      var changes = Js_dict.get(changesByCheckpoint, checkpointKey);
+                      var entityChanges;
+                      if (changes !== undefined) {
+                        entityChanges = changes;
+                      } else {
+                        var changes$1 = {};
+                        changesByCheckpoint[checkpointKey] = changes$1;
+                        entityChanges = changes$1;
+                      }
+                      var change$1 = Js_dict.get(entityChanges, entityName);
+                      var entityChange;
+                      if (change$1 !== undefined) {
+                        entityChange = change$1;
+                      } else {
+                        var change_sets = [];
+                        var change_deleted = [];
+                        var change$2 = {
+                          sets: change_sets,
+                          deleted: change_deleted
+                        };
+                        entityChanges[entityName] = change$2;
+                        entityChange = change$2;
+                      }
+                      entityChange.sets.push(parsedEntity);
+                      return ;
+                    }
+                    var entityId = change.entityId;
+                    Js_dict.unsafeDeleteKey(entityDict, entityId);
+                    var checkpointKey$1 = String(change.checkpointId);
+                    var changes$2 = Js_dict.get(changesByCheckpoint, checkpointKey$1);
+                    var entityChanges$1;
+                    if (changes$2 !== undefined) {
+                      entityChanges$1 = changes$2;
+                    } else {
+                      var changes$3 = {};
+                      changesByCheckpoint[checkpointKey$1] = changes$3;
+                      entityChanges$1 = changes$3;
+                    }
+                    var change$3 = Js_dict.get(entityChanges$1, entityName);
+                    var entityChange$1;
+                    if (change$3 !== undefined) {
+                      entityChange$1 = change$3;
+                    } else {
+                      var change_sets$1 = [];
+                      var change_deleted$1 = [];
+                      var change$4 = {
+                        sets: change_sets$1,
+                        deleted: change_deleted$1
+                      };
+                      entityChanges$1[entityName] = change$4;
+                      entityChange$1 = change$4;
+                    }
+                    entityChange$1.deleted.push(entityId);
+                  };
+                  Belt_Array.forEach(update.history, processChange);
+                  if (update.history.length === 0) {
+                    return processChange(update.latestChange);
+                  }
+                  
+                }));
+        }));
+  for(var i = 0 ,i_finish = checkpointIds.length; i < i_finish; ++i){
+    var checkpointId = checkpointIds[i];
+    var change = {};
+    change["block"] = checkpointBlockNumbers[i];
+    var hash = checkpointBlockHashes[i];
+    if (hash !== null) {
+      change["blockHash"] = hash;
+    }
+    change["chainId"] = checkpointChainIds[i];
+    change["eventsProcessed"] = checkpointEventsProcessed[i];
+    var checkpointKey = String(checkpointId);
+    var entityChanges = Js_dict.get(changesByCheckpoint, checkpointKey);
+    if (entityChanges !== undefined) {
+      Belt_Array.forEach(Js_dict.entries(entityChanges), (function(change){
+          return function (param) {
+            var match = param[1];
+            var deleted = match.deleted;
+            var sets = match.sets;
+            var entityName = param[0];
+            if (entityName === InternalTable.DynamicContractRegistry.name) {
+              var entityObj = {};
+              if (sets.length !== 0) {
+                var simplifiedSets = Belt_Array.map(sets, (function (entity) {
+                        return {
+                                address: entity.contract_address,
+                                contract: entity.contract_name
+                              };
+                      }));
+                entityObj["sets"] = simplifiedSets;
+              }
+              change["addresses"] = entityObj;
+              return ;
+            }
+            var entityObj$1 = {};
+            if (sets.length !== 0) {
+              entityObj$1["sets"] = sets;
+            }
+            if (deleted.length !== 0) {
+              entityObj$1["deleted"] = deleted;
+            }
+            change[entityName] = entityObj$1;
+          }
+          }(change)));
+    }
+    state.processChanges.push(change);
+  }
+}
+
+function makeInitialState(config, processConfigChains, dynamicContractsByChain) {
+  var chainKeys = Object.keys(processConfigChains);
+  var chains = Belt_Array.map(chainKeys, (function (chainIdStr) {
+          var chainId = Belt_Option.getWithDefault(Belt_Int.fromString(chainIdStr), 0);
+          var chain = ChainMap.Chain.makeUnsafe(chainId);
+          if (!ChainMap.has(config.chainMap, chain)) {
+            Js_exn.raiseError("Chain " + chainIdStr + " is not configured in config.yaml");
+          }
+          var processChainConfig = processConfigChains[chainIdStr];
+          var dynamicContracts = Belt_Option.getWithDefault(Js_dict.get(dynamicContractsByChain, chainIdStr), []);
+          return {
+                  id: chainId,
+                  startBlock: processChainConfig.startBlock,
+                  endBlock: processChainConfig.endBlock,
+                  maxReorgDepth: 0,
+                  progressBlockNumber: -1,
+                  numEventsProcessed: 0,
+                  firstEventBlockNumber: undefined,
+                  timestampCaughtUpToHeadOrEndblock: undefined,
+                  dynamicContracts: dynamicContracts,
+                  sourceBlockNumber: processChainConfig.endBlock
+                };
+        }));
+  return {
+          cleanRun: true,
+          cache: {},
+          chains: chains,
+          checkpointId: InternalTable.Checkpoints.initialCheckpointId,
+          reorgCheckpoints: []
+        };
+}
+
+function validateBlockRange(chainId, configChain, processChainConfig, progressBlock) {
+  if (processChainConfig.startBlock < configChain.startBlock) {
+    Js_exn.raiseError("Invalid block range for chain " + chainId + ": startBlock (" + String(processChainConfig.startBlock) + ") is less than config.startBlock (" + String(configChain.startBlock) + "). " + ("Either use startBlock >= " + String(configChain.startBlock) + " or create a new test indexer with createTestIndexer()."));
+  }
+  var configEndBlock = configChain.endBlock;
+  if (configEndBlock !== undefined && processChainConfig.endBlock > configEndBlock) {
+    Js_exn.raiseError("Invalid block range for chain " + chainId + ": endBlock (" + String(processChainConfig.endBlock) + ") exceeds config.endBlock (" + String(configEndBlock) + "). " + ("Either use endBlock <= " + String(configEndBlock) + " or create a new test indexer with createTestIndexer()."));
+  }
+  if (progressBlock !== undefined && processChainConfig.startBlock <= progressBlock) {
+    return Js_exn.raiseError("Invalid block range for chain " + chainId + ": startBlock (" + String(processChainConfig.startBlock) + ") must be greater than previously processed endBlock (" + String(progressBlock) + "). " + ("Either use startBlock > " + String(progressBlock) + " or create a new test indexer with createTestIndexer()."));
+  }
+  
+}
+
+function makeCreateTestIndexer(config, workerPath, allEntities) {
+  return function () {
+    var entities = {};
+    var entityConfigs = {};
+    Belt_Array.forEach(allEntities, (function (entityConfig) {
+            entities[entityConfig.name] = {};
+            entityConfigs[entityConfig.name] = entityConfig;
+          }));
+    var state = {
+      processInProgress: false,
+      progressBlockByChain: {},
+      entities: entities,
+      entityConfigs: entityConfigs,
+      processChanges: []
+    };
+    return {
+            process: (function (processConfig) {
+                if (state.processInProgress) {
+                  Js_exn.raiseError("createTestIndexer process is already running. Only one process call is allowed at a time");
+                }
+                var chains = processConfig.chains;
+                var chainKeys = Object.keys(chains);
+                var n = chainKeys.length;
+                if (n !== 0) {
+                  if (n !== 1) {
+                    Js_exn.raiseError("createTestIndexer does not support processing multiple chains at once. Found " + String(n) + " chains defined");
+                  }
+                  
+                } else {
+                  Js_exn.raiseError("createTestIndexer requires exactly one chain to be defined");
+                }
+                Belt_Array.forEach(chainKeys, (function (chainIdStr) {
+                        var chainId = Belt_Option.getWithDefault(Belt_Int.fromString(chainIdStr), 0);
+                        var chain = ChainMap.Chain.makeUnsafe(chainId);
+                        var configChain = ChainMap.get(config.chainMap, chain);
+                        var processChainConfig = chains[chainIdStr];
+                        var progressBlock = Js_dict.get(state.progressBlockByChain, chainIdStr);
+                        validateBlockRange(chainIdStr, configChain, processChainConfig, progressBlock);
+                      }));
+                state.processChanges = [];
+                var dynamicContractsByChain = {};
+                var dcDict = Js_dict.get(state.entities, InternalTable.DynamicContractRegistry.name);
+                if (dcDict !== undefined) {
+                  Belt_Array.forEach(Js_dict.values(dcDict), (function (entity) {
+                          var chainIdStr = String(entity.chain_id);
+                          var arr = Js_dict.get(dynamicContractsByChain, chainIdStr);
+                          var contracts;
+                          if (arr !== undefined) {
+                            contracts = arr;
+                          } else {
+                            var arr$1 = [];
+                            dynamicContractsByChain[chainIdStr] = arr$1;
+                            contracts = arr$1;
+                          }
+                          contracts.push(toIndexingContract(entity));
+                        }));
+                }
+                var initialState = makeInitialState(config, chains, dynamicContractsByChain);
+                return new Promise((function (resolve, reject) {
+                              var workerDataObj = {
+                                processConfig: JSON.parse(Js_json.serializeExn(processConfig)),
+                                initialState: initialState
+                              };
+                              var workerData = JSON.parse(Js_json.serializeExn(workerDataObj));
+                              var worker;
+                              try {
+                                worker = new Worker_threads.Worker(workerPath, {
+                                      workerData: workerData
+                                    });
+                              }
+                              catch (raw_exn){
+                                var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+                                reject(exn);
+                                throw exn;
+                              }
+                              state.processInProgress = true;
+                              worker.on("message", (function (msg) {
+                                      var respond = function (data) {
+                                        worker.postMessage({
+                                              id: msg.id,
+                                              payload: {
+                                                type: "response",
+                                                data: data
+                                              }
+                                            });
+                                      };
+                                      var match = msg.payload;
+                                      switch (match.type) {
+                                        case "loadByIds" :
+                                            return respond(handleLoadByIds(state, match.tableName, match.ids));
+                                        case "loadByField" :
+                                            return respond(handleLoadByField(state, match.tableName, match.fieldName, match.fieldValue, match.operator));
+                                        case "writeBatch" :
+                                            handleWriteBatch(state, match.updatedEntities, match.checkpointIds, match.checkpointChainIds, match.checkpointBlockNumbers, match.checkpointBlockHashes, match.checkpointEventsProcessed);
+                                            return respond(null);
+                                        
+                                      }
+                                    }));
+                              worker.on("error", (function (err) {
+                                      state.processInProgress = false;
+                                      worker.terminate();
+                                      reject(err);
+                                    }));
+                              worker.on("exit", (function (code) {
+                                      state.processInProgress = false;
+                                      if (code !== 0) {
+                                        return reject(new Error("Worker exited with code " + String(code)));
+                                      } else {
+                                        Belt_Array.forEach(chainKeys, (function (chainIdStr) {
+                                                var processChainConfig = chains[chainIdStr];
+                                                state.progressBlockByChain[chainIdStr] = processChainConfig.endBlock;
+                                              }));
+                                        return resolve({
+                                                    changes: state.processChanges
+                                                  });
+                                      }
+                                    }));
+                            }));
+              })
+          };
+  };
+}
+
+function initTestWorker(makeGeneratedConfig, makePersistence) {
+  if (Worker_threads.isMainThread) {
+    Js_exn.raiseError("initTestWorker must be called from a worker thread");
+  }
+  var port = Worker_threads.parentPort;
+  var parentPort = (port == null) ? Js_exn.raiseError("initTestWorker: No parent port available") : port;
+  var workerData = Worker_threads.workerData;
+  if (workerData == null) {
+    Logging.error("TestIndexerWorker: No worker data provided");
+    Process.exit(1);
+    return ;
+  }
+  var proxy = TestIndexerProxyStorage.make(parentPort, workerData.initialState);
+  var storage = TestIndexerProxyStorage.makeStorage(proxy);
+  var persistence = makePersistence(storage);
+  if (Env.userLogLevel !== undefined) {
+    
+  } else {
+    Logging.setLogLevel("silent");
+  }
+  Main.start(makeGeneratedConfig, persistence, true);
+}
+
+export {
+  toIndexingContract ,
+  handleLoadByIds ,
+  handleLoadByField ,
+  handleWriteBatch ,
+  makeInitialState ,
+  validateBlockRange ,
+  makeCreateTestIndexer ,
+  initTestWorker ,
+}
+/* Env Not a pure module */

package/src/TestIndexerProxyStorage.res

@@ -0,0 +1,210 @@
+open Belt
+
+// Message types for communication between worker and main thread
+type requestId = int
+
+// Serializable change with entity as JSON (for worker thread messaging)
+@tag("type")
+type serializableChange =
+  | @as("SET") Set({entityId: string, entity: Js.Json.t, checkpointId: float})
+  | @as("DELETE") Delete({entityId: string, checkpointId: float})
+
+type serializableEntityUpdate = {
+  latestChange: serializableChange,
+  history: array<serializableChange>,
+  containsRollbackDiffChange: bool,
+}
+
+type serializableUpdatedEntity = {
+  entityName: string,
+  updates: array<serializableEntityUpdate>,
+}
+
+// Worker -> Main thread payloads
+@tag("type")
+type workerPayload =
+  | @as("loadByIds") LoadByIds({tableName: string, ids: array<string>})
+  | @as("loadByField")
+  LoadByField({
+      tableName: string,
+      fieldName: string,
+      fieldValue: Js.Json.t,
+      operator: Persistence.operator,
+    })
+  | @as("writeBatch")
+  WriteBatch({
+      updatedEntities: array<serializableUpdatedEntity>,
+      checkpointIds: array<float>,
+      checkpointChainIds: array<int>,
+      checkpointBlockNumbers: array<int>,
+      checkpointBlockHashes: array<Js.Null.t<string>>,
+      checkpointEventsProcessed: array<int>,
+    })
+
+// Main thread -> Worker payloads
+@tag("type")
+type mainPayload =
+  | @as("response") Response({data: Js.Json.t})
+  | @as("error") Error({message: string})
+
+// Message wrapper with id
+type message<'payload> = {id: requestId, payload: 'payload}
+type workerMessage = message<workerPayload>
+type mainMessage = message<mainPayload>
+
+// Pending request tracker
+type pendingRequest = {
+  resolve: Js.Json.t => unit,
+  reject: exn => unit,
+}
+
+type t = {
+  parentPort: NodeJs.WorkerThreads.messagePort,
+  initialState: Persistence.initialState,
+  pendingRequests: dict<pendingRequest>,
+  mutable requestCounter: int,
+}
+
+let make = (~parentPort, ~initialState): t => {
+  let proxy = {
+    parentPort,
+    initialState,
+    pendingRequests: Js.Dict.empty(),
+    requestCounter: 0,
+  }
+
+  // Set up message listener for responses from main thread
+  parentPort->NodeJs.WorkerThreads.onPortMessage((msg: mainMessage) => {
+    let idStr = msg.id->Int.toString
+    let {resolve, reject} = switch proxy.pendingRequests->Utils.Dict.dangerouslyGetNonOption(
+      idStr,
+    ) {
+    | Some(pending) => pending
+    | None => Js.Exn.raiseError(`TestIndexer: No pending request found for id ${idStr}`)
+    }
+    Js.Dict.unsafeDeleteKey(proxy.pendingRequests->Obj.magic, idStr)
+
+    switch msg.payload {
+    | Response({data}) => resolve(data)
+    | Error({message}) => reject(Utils.Error.make(message))
+    }
+  })
+
+  proxy
+}
+
+let nextRequestId = (proxy: t): requestId => {
+  proxy.requestCounter = proxy.requestCounter + 1
+  proxy.requestCounter
+}
+
+let sendRequest = (proxy: t, ~payload: workerPayload): promise<Js.Json.t> => {
+  Promise.make((resolve, reject) => {
+    let id = proxy->nextRequestId
+    proxy.pendingRequests->Js.Dict.set(id->Int.toString, {resolve, reject})
+    proxy.parentPort->NodeJs.WorkerThreads.postMessage({id, payload})
+  })
+}
+
+let makeStorage = (proxy: t): Persistence.storage => {
+  isInitialized: async () => true,
+  initialize: async (~chainConfigs as _=?, ~entities as _=?, ~enums as _=?) => {
+    Js.Exn.raiseError(
+      "TestIndexer: initialize should not be called. Use resumeInitialState instead.",
+    )
+  },
+  resumeInitialState: async () => proxy.initialState,
+  loadByIdsOrThrow: async (~ids, ~table: Table.table, ~rowsSchema) => {
+    let response = await proxy->sendRequest(~payload=LoadByIds({tableName: table.tableName, ids}))
+    response->S.parseOrThrow(rowsSchema)
+  },
+  loadByFieldOrThrow: async (
+    ~fieldName,
+    ~fieldSchema,
+    ~fieldValue,
+    ~operator,
+    ~table: Table.table,
+    ~rowsSchema,
+  ) => {
+    let response = await proxy->sendRequest(
+      ~payload=LoadByField({
+        tableName: table.tableName,
+        fieldName,
+        fieldValue: fieldValue->S.reverseConvertToJsonOrThrow(fieldSchema),
+        operator,
+      }),
+    )
+    response->S.parseOrThrow(rowsSchema)
+  },
+  setOrThrow: async (~items as _, ~table as _, ~itemSchema as _) => {
+    // Not used anywhere, no-op
+    ()
+  },
+  writeBatch: async (
+    ~batch,
+    ~rawEvents as _,
+    ~rollbackTargetCheckpointId as _,
+    ~isInReorgThreshold as _,
+    ~config as _,
+    ~allEntities as _,
+    ~updatedEffectsCache as _,
+    ~updatedEntities,
+  ) => {
+    // Encode entities to JSON for serialization across worker boundary
+    let serializableEntities = updatedEntities->Array.map((
+      {entityConfig, updates}: Persistence.updatedEntity,
+    ) => {
+      let encodeChange = (change: Change.t<Internal.entity>): serializableChange => {
+        switch change {
+        | Set({entityId, entity, checkpointId}) =>
+          Set({
+            entityId,
+            entity: entity->S.reverseConvertToJsonOrThrow(entityConfig.schema),
+            checkpointId,
+          })
+        | Delete({entityId, checkpointId}) => Delete({entityId, checkpointId})
+        }
+      }
+      {
+        entityName: entityConfig.name,
+        updates: updates->Array.map(update => {
+          latestChange: encodeChange(update.latestChange),
+          history: update.history->Array.map(encodeChange),
+          containsRollbackDiffChange: update.containsRollbackDiffChange,
+        }),
+      }
+    })
+    let _ = await proxy->sendRequest(
+      ~payload=WriteBatch({
+        updatedEntities: serializableEntities,
+        checkpointIds: batch.checkpointIds,
+        checkpointChainIds: batch.checkpointChainIds,
+        checkpointBlockNumbers: batch.checkpointBlockNumbers,
+        checkpointBlockHashes: batch.checkpointBlockHashes,
+        checkpointEventsProcessed: batch.checkpointEventsProcessed,
+      }),
+    )
+  },
+  setEffectCacheOrThrow: async (~effect as _, ~items as _, ~initialize as _) => (),
+  dumpEffectCache: async () => (),
+  executeUnsafe: async _ => Obj.magic(),
+  setChainMeta: async _ => Obj.magic(),
+  pruneStaleCheckpoints: async (~safeCheckpointId as _) => (),
+  pruneStaleEntityHistory: async (~entityName as _, ~entityIndex as _, ~safeCheckpointId as _) =>
+    (),
+  getRollbackTargetCheckpoint: async (~reorgChainId as _, ~lastKnownValidBlockNumber as _) => {
+    Js.Exn.raiseError(
+      "TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.",
+    )
+  },
+  getRollbackProgressDiff: async (~rollbackTargetCheckpointId as _) => {
+    Js.Exn.raiseError(
+      "TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.",
+    )
+  },
+  getRollbackData: async (~entityConfig as _, ~rollbackTargetCheckpointId as _) => {
+    Js.Exn.raiseError(
+      "TestIndexer: Rollback is not supported. Set rollbackOnReorg to false in config.",
+    )
+  },
+}