envio 3.0.0-alpha.2 → 3.0.0-alpha.20

package/src/TestIndexer.res.mjs

@@ -0,0 +1,527 @@
+// 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 Config from "./Config.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 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 Persistence from "./Persistence.res.mjs";
+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 = change.checkpointId.toString();
+                      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 = change.checkpointId.toString();
+                    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 = checkpointId.toString();
+    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 === Config.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 makeEntityGet(state, entityConfig) {
+  return function (entityId) {
+    if (state.processInProgress) {
+      Js_exn.raiseError("Cannot call " + entityConfig.name + ".get() while indexer.process() is running. Wait for process() to complete before accessing entities directly.");
+    }
+    var entityDict = Belt_Option.getWithDefault(Js_dict.get(state.entities, entityConfig.name), {});
+    return Promise.resolve(Js_dict.get(entityDict, entityId));
+  };
+}
+
+function makeEntitySet(state, entityConfig) {
+  return function (entity) {
+    if (state.processInProgress) {
+      Js_exn.raiseError("Cannot call " + entityConfig.name + ".set() while indexer.process() is running. Wait for process() to complete before modifying entities directly.");
+    }
+    var dict = Js_dict.get(state.entities, entityConfig.name);
+    var entityDict;
+    if (dict !== undefined) {
+      entityDict = dict;
+    } else {
+      var dict$1 = {};
+      state.entities[entityConfig.name] = dict$1;
+      entityDict = dict$1;
+    }
+    entityDict[entity.id] = entity;
+  };
+}
+
+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: []
+    };
+    var entityOpsDict = {};
+    Belt_Array.forEach(allEntities, (function (entityConfig) {
+            if (entityConfig.name !== Config.DynamicContractRegistry.name) {
+              entityOpsDict[entityConfig.name] = {
+                get: makeEntityGet(state, entityConfig),
+                set: makeEntitySet(state, entityConfig)
+              };
+              return ;
+            }
+            
+          }));
+    var chainIds = [];
+    var chains = Object.create(null);
+    Belt_Array.forEach(ChainMap.values(config.chainMap), (function (chainConfig) {
+            var chainIdStr = String(chainConfig.id);
+            chainIds.push(chainConfig.id);
+            var chainObj = Object.create(null);
+            Object.defineProperty(Object.defineProperty(Object.defineProperty(Object.defineProperty(Object.defineProperty(chainObj, "id", {
+                                  enumerable: true,
+                                  value: chainConfig.id
+                                }), "startBlock", {
+                              enumerable: true,
+                              value: chainConfig.startBlock
+                            }), "endBlock", {
+                          enumerable: true,
+                          value: chainConfig.endBlock
+                        }), "name", {
+                      enumerable: true,
+                      value: chainConfig.name
+                    }), "isLive", {
+                  enumerable: true,
+                  value: false
+                });
+            Belt_Array.forEach(chainConfig.contracts, (function (contract) {
+                    var contractObj = Object.create(null);
+                    Object.defineProperty(Object.defineProperty(Object.defineProperty(contractObj, "name", {
+                                  enumerable: true,
+                                  value: contract.name
+                                }), "abi", {
+                              enumerable: true,
+                              value: contract.abi
+                            }), "addresses", {
+                          enumerable: true,
+                          get: (function () {
+                              if (state.processInProgress) {
+                                Js_exn.raiseError("Cannot access " + contract.name + ".addresses while indexer.process() is running. Wait for process() to complete before reading contract addresses.");
+                              }
+                              var addresses = contract.addresses.slice(0);
+                              var dcDict = Js_dict.get(state.entities, Config.DynamicContractRegistry.name);
+                              if (dcDict !== undefined) {
+                                Belt_Array.forEach(Js_dict.values(dcDict), (function (entity) {
+                                        if (entity.contract_name === contract.name && entity.chain_id === chainConfig.id) {
+                                          addresses.push(entity.contract_address);
+                                          return ;
+                                        }
+                                        
+                                      }));
+                              }
+                              return addresses;
+                            })
+                        });
+                    Object.defineProperty(chainObj, contract.name, {
+                          enumerable: true,
+                          value: contractObj
+                        });
+                  }));
+            Object.defineProperty(chains, chainIdStr, {
+                  enumerable: true,
+                  value: chainObj
+                });
+            if (chainConfig.name !== chainIdStr) {
+              Object.defineProperty(chains, chainConfig.name, {
+                    enumerable: false,
+                    value: chainObj
+                  });
+              return ;
+            }
+            
+          }));
+    var result = {};
+    result["chainIds"] = chainIds;
+    result["chains"] = chains;
+    Belt_Array.forEach(Js_dict.entries(entityOpsDict), (function (param) {
+            result[param[0]] = param[1];
+          }));
+    result["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, Config.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: processConfig,
+                        initialState: initialState
+                      };
+                      var worker;
+                      try {
+                        worker = new Worker_threads.Worker(workerPath, {
+                              workerData: workerDataObj
+                            });
+                      }
+                      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
+                                          });
+                              }
+                            }));
+                    }));
+      });
+    return result;
+  };
+}
+
+function initTestWorker(makeGeneratedConfig) {
+  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 config = makeGeneratedConfig();
+  var persistence = Persistence.make(config.userEntities, config.allEnums, storage);
+  if (Env.userLogLevel !== undefined) {
+    
+  } else {
+    Logging.setLogLevel("silent");
+  }
+  Main.start(makeGeneratedConfig, persistence, true);
+}
+
+export {
+  toIndexingContract ,
+  handleLoadByIds ,
+  handleLoadByField ,
+  handleWriteBatch ,
+  makeInitialState ,
+  validateBlockRange ,
+  makeEntityGet ,
+  makeEntitySet ,
+  makeCreateTestIndexer ,
+  initTestWorker ,
+}
+/* Env Not a pure module */