envio 3.1.1 → 3.2.0

package/src/PgStorage.res.mjs

@@ -13,11 +13,11 @@ import * as Schema from "./db/Schema.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import Postgres from "postgres";
-import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as EventUtils from "./EventUtils.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as ChainFetcher from "./ChainFetcher.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as EntityHistory from "./db/EntityHistory.res.mjs";
 import * as InternalTable from "./db/InternalTable.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
@@ -49,7 +49,7 @@ function makeClient() {
 
 function makeCreateIndexQuery(tableName, indexFields, pgSchema) {
   let indexName = tableName + "_" + indexFields.join("_");
-  let index = Belt_Array.map(indexFields, idx => `"` + idx + `"`).join(", ");
+  let index = indexFields.map(idx => `"` + idx + `"`).join(", ");
   return `CREATE INDEX IF NOT EXISTS "` + indexName + `" ON "` + pgSchema + `"."` + tableName + `"(` + index + `);`;
 }
 
@@ -71,7 +71,7 @@ function directionToIndexName(direction) {
 
 function makeCreateCompositeIndexQuery(tableName, indexFields, pgSchema) {
   let indexName = tableName + "_" + indexFields.map(f => f.fieldName + directionToIndexName(f.direction)).join("_");
-  let index = Belt_Array.map(indexFields, f => `"` + f.fieldName + `"` + directionToSql(f.direction)).join(", ");
+  let index = indexFields.map(f => `"` + f.fieldName + `"` + directionToSql(f.direction)).join(", ");
   return `CREATE INDEX IF NOT EXISTS "` + indexName + `" ON "` + pgSchema + `"."` + tableName + `"(` + index + `);`;
 }
 
@@ -88,14 +88,14 @@ function makeCreateTableQuery(table, pgSchema, isNumericArrayAsText) {
   let fieldsMapped = Table.getFields(table).map(field => {
     let defaultValue = field.defaultValue;
     let isNullable = field.isNullable;
-    let fieldName = Table.getDbFieldName(field);
+    let fieldName = Table.getPgDbFieldName(field);
     return `"` + fieldName + `" ` + Table.getPgFieldType(field.fieldType, pgSchema, field.isArray, isNumericArrayAsText, isNullable) + (
       defaultValue !== undefined ? ` DEFAULT ` + defaultValue : (
           isNullable ? `` : ` NOT NULL`
         )
     );
   }).join(", ");
-  let primaryKeyFieldNames = Table.getPrimaryKeyFieldNames(table);
+  let primaryKeyFieldNames = Table.getPgPrimaryKeyFieldNames(table);
   let primaryKey = primaryKeyFieldNames.map(field => `"` + field + `"`).join(", ");
   return `CREATE TABLE IF NOT EXISTS "` + pgSchema + `"."` + table.tableName + `"(` + fieldsMapped + (
     primaryKeyFieldNames.length !== 0 ? `, PRIMARY KEY(` + primaryKey + `)` : ""
@@ -109,7 +109,7 @@ function getEntityHistory(entityConfig) {
   if (cache !== undefined) {
     return cache;
   }
-  let dataFields = Belt_Array.keepMap(entityConfig.table.fields, field => {
+  let dataFields = Stdlib_Array.filterMap(entityConfig.table.fields, field => {
     if (field.TAG !== "Field") {
       return;
     }
@@ -128,7 +128,9 @@ function getEntityHistory(entityConfig) {
           isIndex: field$1.isIndex,
           linkedEntity: field$1.linkedEntity,
           defaultValue: field$1.defaultValue,
-          description: field$1.description
+          description: field$1.description,
+          postgresDbName: field$1.postgresDbName,
+          clickhouseDbName: field$1.clickhouseDbName
         }
       };
     } else {
@@ -144,16 +146,18 @@ function getEntityHistory(entityConfig) {
           isIndex: false,
           linkedEntity: field$1.linkedEntity,
           defaultValue: field$1.defaultValue,
-          description: field$1.description
+          description: field$1.description,
+          postgresDbName: field$1.postgresDbName,
+          clickhouseDbName: field$1.clickhouseDbName
         }
       };
     }
   });
-  let actionField = Table.mkField(EntityHistory.changeFieldName, EntityHistory.changeFieldType, S$RescriptSchema.never, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
-  let checkpointIdField = Table.mkField(EntityHistory.checkpointIdFieldName, EntityHistory.checkpointIdFieldType, EntityHistory.unsafeCheckpointIdSchema, undefined, undefined, undefined, true, undefined, undefined, undefined);
+  let actionField = Table.mkField(EntityHistory.changeFieldName, EntityHistory.changeFieldType, S$RescriptSchema.never, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+  let checkpointIdField = Table.mkField(EntityHistory.checkpointIdFieldName, EntityHistory.checkpointIdFieldType, EntityHistory.unsafeCheckpointIdSchema, undefined, undefined, undefined, true, undefined, undefined, undefined, undefined, undefined);
   let entityTableName = entityConfig.table.tableName;
   let historyTableName = EntityHistory.historyTableName(entityTableName, entityConfig.index);
-  let table = Table.mkTable(historyTableName, undefined, Belt_Array.concat(dataFields, [
+  let table = Table.mkTable(historyTableName, undefined, dataFields.concat([
     checkpointIdField,
     actionField
   ]), undefined);
@@ -210,7 +214,7 @@ GRANT ALL ON SCHEMA "` + pgSchema + `" TO public;`)
   });
   entities.forEach(entity => {
     Table.getDerivedFromFields(entity.table).forEach(derivedFromField => {
-      let indexField = Utils.unwrapResultExn(Schema.getDerivedFromFieldName(derivedSchema, derivedFromField));
+      let indexField = Utils.unwrapResultExn(Schema.getDerivedFromPgFieldName(derivedSchema, derivedFromField));
       query.contents = query.contents + "\n" + makeCreateIndexQuery(derivedFromField.derivedFromEntity, [indexField], pgSchema);
     });
   });
@@ -234,16 +238,69 @@ $$ LANGUAGE plpgsql;`
   ];
 }
 
-function makeLoadByIdQuery(pgSchema, tableName) {
-  return `SELECT * FROM "` + pgSchema + `"."` + tableName + `" WHERE id = $1 LIMIT 1;`;
+function makeLoadQuery(pgSchema, tableName, condition) {
+  return `SELECT * FROM "` + pgSchema + `"."` + tableName + `" WHERE ` + condition + `;`;
 }
 
-function makeLoadByFieldQuery(pgSchema, tableName, fieldName, operator) {
-  return `SELECT * FROM "` + pgSchema + `"."` + tableName + `" WHERE "` + fieldName + `" ` + operator + ` $1;`;
-}
-
-function makeLoadByIdsQuery(pgSchema, tableName) {
-  return `SELECT * FROM "` + pgSchema + `"."` + tableName + `" WHERE id = ANY($1::text[]);`;
+function makeFilterCondition(filter, table, params) {
+  let getQueryFieldOrThrow = fieldName => {
+    let queryField = Table.queryFields(table)[fieldName];
+    if (queryField !== undefined) {
+      return queryField;
+    }
+    throw {
+      RE_EXN_ID: Persistence.StorageError,
+      message: `Failed loading "` + table.tableName + `" from storage. The table doesn't have the field "` + fieldName + `".`,
+      reason: {
+        RE_EXN_ID: Table.NonExistingTableField,
+        _1: fieldName
+      },
+      Error: new Error()
+    };
+  };
+  let serializeParamOrThrow = (queryField, fieldName, fieldValue, isArray) => {
+    let param;
+    try {
+      param = S$RescriptSchema.reverseConvertToJsonOrThrow(fieldValue, isArray ? queryField.arrayFieldSchema : queryField.fieldSchema);
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      throw {
+        RE_EXN_ID: Persistence.StorageError,
+        message: `Failed loading "` + table.tableName + `" from storage by field "` + fieldName + `". Couldn't serialize provided value.`,
+        reason: exn,
+        Error: new Error()
+      };
+    }
+    params.push(param);
+    return `$` + params.length.toString();
+  };
+  let scalarCondition = (fieldName, fieldValue, op) => {
+    let queryField = getQueryFieldOrThrow(fieldName);
+    return `"` + queryField.pgDbFieldName + `" ` + op + ` ` + serializeParamOrThrow(queryField, fieldName, fieldValue, false);
+  };
+  switch (filter.operator) {
+    case "=" :
+      return scalarCondition(filter.fieldName, filter.fieldValue, "=");
+    case ">" :
+      return scalarCondition(filter.fieldName, filter.fieldValue, ">");
+    case "<" :
+      return scalarCondition(filter.fieldName, filter.fieldValue, "<");
+    case "in" :
+      let fieldName = filter.fieldName;
+      let queryField = getQueryFieldOrThrow(fieldName);
+      return `"` + queryField.pgDbFieldName + `" = ANY(` + serializeParamOrThrow(queryField, fieldName, filter.fieldValue, true) + `)`;
+    case "and" :
+      let filters = filter.filters;
+      if (filters.length !== 0) {
+        return `(` + filters.map(filter => makeFilterCondition(filter, table, params)).join(" AND ") + `)`;
+      }
+      throw {
+        RE_EXN_ID: Persistence.StorageError,
+        message: `Failed loading "` + table.tableName + `" from storage. The "and" filter must contain at least one nested filter.`,
+        reason: new Error(`Empty "and" filter`),
+        Error: new Error()
+      };
+  }
 }
 
 function makeDeleteByIdQuery(pgSchema, tableName) {
@@ -261,7 +318,7 @@ function makeLoadAllQuery(pgSchema, tableName) {
 function makeInsertUnnestSetQuery(pgSchema, table, itemSchema, isRawEvents) {
   let match = Table.toSqlParams(table, itemSchema, pgSchema);
   let quotedNonPrimaryFieldNames = match.quotedNonPrimaryFieldNames;
-  let primaryKeyFieldNames = Table.getPrimaryKeyFieldNames(table);
+  let primaryKeyFieldNames = Table.getPgPrimaryKeyFieldNames(table);
   return `INSERT INTO "` + pgSchema + `"."` + table.tableName + `" (` + match.quotedFieldNames.join(", ") + `)
 SELECT * FROM unnest(` + match.arrayFieldTypes.map((arrayFieldType, idx) => `$` + (idx + 1 | 0).toString() + `::` + arrayFieldType).join(",") + `)` + (
     isRawEvents || primaryKeyFieldNames.length === 0 ? `` : `ON CONFLICT(` + primaryKeyFieldNames.map(fieldName => `"` + fieldName + `"`).join(",") + `) DO ` + (
@@ -274,7 +331,7 @@ function makeInsertValuesSetQuery(pgSchema, table, itemSchema, itemsCount) {
   let match = Table.toSqlParams(table, itemSchema, pgSchema);
   let quotedNonPrimaryFieldNames = match.quotedNonPrimaryFieldNames;
   let quotedFieldNames = match.quotedFieldNames;
-  let primaryKeyFieldNames = Table.getPrimaryKeyFieldNames(table);
+  let primaryKeyFieldNames = Table.getPgPrimaryKeyFieldNames(table);
   let fieldsCount = quotedFieldNames.length;
   let placeholders = "";
   for (let idx = 1; idx <= itemsCount; ++idx) {
@@ -517,15 +574,15 @@ async function deleteByIdsOrThrow(sql, pgSchema, ids, table) {
 
 function makeInsertDeleteUpdatesQuery(entityConfig, pgSchema) {
   let historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
-  let allHistoryFieldNames = Belt_Array.keepMap(entityConfig.table.fields, fieldOrDerived => {
+  let allHistoryFieldNames = Stdlib_Array.filterMap(entityConfig.table.fields, fieldOrDerived => {
     if (fieldOrDerived.TAG === "Field") {
-      return Table.getDbFieldName(fieldOrDerived._0);
+      return Table.getPgDbFieldName(fieldOrDerived._0);
     }
   });
   allHistoryFieldNames.push(EntityHistory.checkpointIdFieldName);
   allHistoryFieldNames.push(EntityHistory.changeFieldName);
-  let allHistoryFieldNamesStr = Belt_Array.map(allHistoryFieldNames, name => `"` + name + `"`).join(", ");
-  let selectParts = Belt_Array.map(allHistoryFieldNames, fieldName => {
+  let allHistoryFieldNamesStr = allHistoryFieldNames.map(name => `"` + name + `"`).join(", ");
+  let selectParts = allHistoryFieldNames.map(fieldName => {
     if (fieldName === Table.idFieldName) {
       return `u.` + Table.idFieldName;
     } else if (fieldName === EntityHistory.checkpointIdFieldName) {
@@ -567,12 +624,11 @@ function convertFieldsToJson(fields) {
 
 function makeRawEvent(eventItem, config) {
   let event = eventItem.event;
-  let block = event.block;
-  let logIndex = event.logIndex;
   let blockNumber = eventItem.blockNumber;
   let eventConfig = eventItem.eventConfig;
+  let logIndex = event.logIndex;
   let eventId = EventUtils.packEventIndex(blockNumber, logIndex);
-  let blockFields = convertFieldsToJson(block);
+  let blockFields = convertFieldsToJson(event.block);
   let transactionFields = convertFieldsToJson(event.transaction);
   config.ecosystem.cleanUpRawEventFieldsInPlace(blockFields);
   let params = S$RescriptSchema.reverseConvertOrThrow(event.params, eventConfig.paramsRawEventSchema);
@@ -585,7 +641,7 @@ function makeRawEvent(eventItem, config) {
     block_number: blockNumber,
     log_index: logIndex,
     src_address: event.srcAddress,
-    block_hash: config.ecosystem.getId(block),
+    block_hash: eventItem.blockHash,
     block_timestamp: eventItem.timestamp,
     block_fields: blockFields,
     transaction_fields: transactionFields,
@@ -601,7 +657,7 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
     };
     let rawEvents;
     if (config.enableRawEvents) {
-      let rows = Belt_Array.keepMap(batch.items, item => {
+      let rows = Stdlib_Array.filterMap(batch.items, item => {
         if (item.kind === 0) {
           return makeRawEvent(item, config);
         }
@@ -621,7 +677,7 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
         return classifyWriteError(specificError, InternalTable.RawEvents.table, exn);
       }
     };
-    let setEntities = Belt_Array.map(updatedEntities, param => {
+    let setEntities = updatedEntities.map(param => {
       let entityConfig = param.entityConfig;
       let entitiesToSet = [];
       let idsToDelete = [];
@@ -632,7 +688,7 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
       let idsWithDiff = new Set();
       let latestChangeById = {};
       let orderedIds = [];
-      Belt_Array.forEach(param.changes, change => {
+      param.changes.forEach(change => {
         let entityId = change.entityId;
         if (Stdlib_Option.isNone(latestChangeById[entityId])) {
           orderedIds.push(entityId);
@@ -653,7 +709,7 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
         batchDeleteCheckpointIds.push(change.checkpointId);
       });
       let backfillHistoryIds = new Set();
-      Belt_Array.forEach(orderedIds, entityId => {
+      orderedIds.forEach(entityId => {
         let match = latestChangeById[entityId];
         if (match.type === "SET") {
           entitiesToSet.push(match.entity);
@@ -727,7 +783,7 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
           if (rollbackTables !== undefined) {
             await rollbackTables(sql);
           }
-          let setOperations = Belt_Array.concat([
+          let setOperations = [
             sql => InternalTable.Chains.setProgressedChains(sql, pgSchema, Utils.Dict.mapValuesToArray(batch.progressedChainsById, chainAfterBatch => ({
               chainId: chainAfterBatch.fetchState.chainId,
               progressBlockNumber: chainAfterBatch.progressBlockNumber,
@@ -735,14 +791,14 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
               totalEventsProcessed: chainAfterBatch.totalEventsProcessed
             }))),
             setRawEvents
-          ], setEntities);
+          ].concat(setEntities);
           if (chainMetaData !== undefined) {
             setOperations.push(sql => InternalTable.Chains.setMeta(sql, pgSchema, chainMetaData));
           }
           if (shouldSaveHistory) {
             setOperations.push(sql => InternalTable.Checkpoints.insert(sql, pgSchema, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointBlockHashes, batch.checkpointEventsProcessed));
           }
-          await Promise.all(Belt_Array.map(setOperations, dbFunc => dbFunc(sql)));
+          await Promise.all(setOperations.map(dbFunc => dbFunc(sql)));
           if (sinkPromise === undefined) {
             return;
           }
@@ -752,7 +808,7 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
           }
           throw exn;
         }),
-        Promise.all(Belt_Array.map(updatedEffectsCache, param => setEffectCacheOrThrow(param.effect, param.items, param.shouldInitialize)))
+        Promise.all(updatedEffectsCache.map(param => setEffectCacheOrThrow(param.effect, param.items, param.shouldInitialize)))
       ]);
       let specificError$1 = specificError.contents;
       if (specificError$1 === undefined) {
@@ -776,12 +832,12 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
 }
 
 function makeGetRollbackRestoredEntitiesQuery(entityConfig, pgSchema) {
-  let dataFieldNames = Belt_Array.keepMap(entityConfig.table.fields, fieldOrDerived => {
+  let dataFieldNames = Stdlib_Array.filterMap(entityConfig.table.fields, fieldOrDerived => {
     if (fieldOrDerived.TAG === "Field") {
-      return Table.getDbFieldName(fieldOrDerived._0);
+      return Table.getPgDbFieldName(fieldOrDerived._0);
     }
   });
-  let dataFieldsCommaSeparated = Belt_Array.map(dataFieldNames, name => `"` + name + `"`).join(", ");
+  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 + `"
@@ -956,70 +1012,33 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
       envioInfo: envioInfo
     };
   };
-  let loadByIdsOrThrow = async (ids, table, rowsSchema) => {
+  let loadOrThrow = async (filter, table) => {
+    let params = [];
+    let condition = makeFilterCondition(filter, table, params);
     let rows;
     try {
-      rows = await (
-        ids.length !== 1 ? sql.unsafe(makeLoadByIdsQuery(pgSchema, table.tableName), [ids], {prepare: true}) : sql.unsafe(makeLoadByIdQuery(pgSchema, table.tableName), ids, {prepare: true})
-      );
+      rows = await sql.unsafe(makeLoadQuery(pgSchema, table.tableName, condition), params, {prepare: true});
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       throw {
         RE_EXN_ID: Persistence.StorageError,
-        message: `Failed loading "` + table.tableName + `" from storage by ids`,
+        message: `Failed loading "` + table.tableName + `" from storage by condition: ` + condition,
         reason: exn,
         Error: new Error()
       };
     }
     try {
-      return S$RescriptSchema.parseOrThrow(rows, rowsSchema);
+      return S$RescriptSchema.parseOrThrow(rows, Table.pgRowsSchema(table));
     } catch (raw_exn$1) {
       let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
       throw {
         RE_EXN_ID: Persistence.StorageError,
-        message: `Failed to parse "` + table.tableName + `" loaded from storage by ids`,
+        message: `Failed to parse "` + table.tableName + `" loaded from storage by condition: ` + condition,
         reason: exn$1,
         Error: new Error()
       };
     }
   };
-  let loadByFieldOrThrow = async (fieldName, fieldSchema, fieldValue, operator, table, rowsSchema) => {
-    let params;
-    try {
-      params = [S$RescriptSchema.reverseConvertToJsonOrThrow(fieldValue, fieldSchema)];
-    } catch (raw_exn) {
-      let exn = Primitive_exceptions.internalToException(raw_exn);
-      throw {
-        RE_EXN_ID: Persistence.StorageError,
-        message: `Failed loading "` + table.tableName + `" from storage by field "` + fieldName + `". Couldn't serialize provided value.`,
-        reason: exn,
-        Error: new Error()
-      };
-    }
-    let rows;
-    try {
-      rows = await sql.unsafe(makeLoadByFieldQuery(pgSchema, table.tableName, fieldName, operator), params, {prepare: true});
-    } catch (raw_exn$1) {
-      let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
-      throw {
-        RE_EXN_ID: Persistence.StorageError,
-        message: `Failed loading "` + table.tableName + `" from storage by field "` + fieldName + `"`,
-        reason: exn$1,
-        Error: new Error()
-      };
-    }
-    try {
-      return S$RescriptSchema.parseOrThrow(rows, rowsSchema);
-    } catch (raw_exn$2) {
-      let exn$2 = Primitive_exceptions.internalToException(raw_exn$2);
-      throw {
-        RE_EXN_ID: Persistence.StorageError,
-        message: `Failed to parse "` + table.tableName + `" loaded from storage by ids`,
-        reason: exn$2,
-        Error: new Error()
-      };
-    }
-  };
   let setOrThrow$1 = (items, table, itemSchema) => setOrThrow(sql, items, table, itemSchema, pgSchema);
   let setEffectCacheOrThrow = async (effect, items, initialize) => {
     let match = effect.storageMeta;
@@ -1050,7 +1069,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
         return Logging.error(`Failed to dump cache. ` + psqlExec._0);
       }
       let psqlExec$1 = psqlExec._0;
-      Logging.info(`Dumping cache: ` + cacheTableInfo.map(param => param.table_name + " (" + String(param.count) + " rows)").join(", "));
+      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);
@@ -1076,7 +1095,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
   let resumeInitialState = async () => {
     let match = await Promise.all([
       restoreEffectCache(false),
-      InternalTable.Chains.getInitialState(sql, pgSchema).then(rawInitialStates => Belt_Array.map(rawInitialStates, rawInitialState => ({
+      InternalTable.Chains.getInitialState(sql, pgSchema).then(rawInitialStates => rawInitialStates.map(rawInitialState => ({
         id: rawInitialState.id,
         startBlock: rawInitialState.startBlock,
         endBlock: Primitive_option.fromNull(rawInitialState.endBlock),
@@ -1093,7 +1112,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
       InternalTable.EnvioInfo.read(sql, pgSchema)
     ]);
     let checkpointId = BigInt(match[2][0].id);
-    let reorgCheckpoints = Belt_Array.map(match[3], raw => ({
+    let reorgCheckpoints = match[3].map(raw => ({
       id: BigInt(raw.id),
       chain_id: raw.chain_id,
       block_number: raw.block_number,
@@ -1156,8 +1175,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
     isInitialized: isInitialized,
     initialize: initialize,
     resumeInitialState: resumeInitialState,
-    loadByIdsOrThrow: loadByIdsOrThrow,
-    loadByFieldOrThrow: loadByFieldOrThrow,
+    loadOrThrow: loadOrThrow,
     dumpEffectCache: dumpEffectCache,
     reset: reset,
     setChainMeta: setChainMeta,
@@ -1204,13 +1222,13 @@ function makeStorageFromEnv(config, sqlOpt, pgSchemaOpt, isHasuraEnabledOpt) {
   return make(sql, Env.Db.host, pgSchema, Env.Db.port, Env.Db.user, Env.Db.database, Env.Db.password, isHasuraEnabled, tmp, isHasuraEnabled ? () => Stdlib_Promise.$$catch(Hasura.trackDatabase(Env.Hasura.graphqlEndpoint, {
       role: Env.Hasura.role,
       secret: Env.Hasura.secret
-    }, pgSchema, Config.getPgUserEntities(config), Env.Hasura.aggregateEntities, Env.Hasura.responseLimit, Schema.make(Belt_Array.map(config.allEntities, e => e.table))), err => Promise.resolve(Logging.errorWithExn(Utils.prettifyExn(err), `Error tracking tables`))) : undefined, isHasuraEnabled ? tableNames => Stdlib_Promise.$$catch(Hasura.trackTables(Env.Hasura.graphqlEndpoint, {
+    }, pgSchema, Config.getPgUserEntities(config), Env.Hasura.aggregateEntities, Env.Hasura.responseLimit, Schema.make(config.allEntities.map(e => e.table))), err => Promise.resolve(Logging.errorWithExn(Utils.prettifyExn(err), `Error tracking tables`))) : undefined, isHasuraEnabled ? tableNames => Stdlib_Promise.$$catch(Hasura.trackTables(Env.Hasura.graphqlEndpoint, {
       role: Env.Hasura.role,
       secret: Env.Hasura.secret
     }, pgSchema, tableNames.map(tableName => ({
       tableName: tableName,
       description: undefined,
-      columnDescriptions: {}
+      columnConfigs: {}
     }))), err => Promise.resolve(Logging.errorWithExn(Utils.prettifyExn(err), `Error tracking new tables`))) : undefined);
 }
 
@@ -1233,9 +1251,8 @@ export {
   entityHistoryCache,
   getEntityHistory,
   makeInitializeTransaction,
-  makeLoadByIdQuery,
-  makeLoadByFieldQuery,
-  makeLoadByIdsQuery,
+  makeLoadQuery,
+  makeFilterCondition,
   makeDeleteByIdQuery,
   makeDeleteByIdsQuery,
   makeLoadAllQuery,

package/src/Ports.res

@@ -0,0 +1,5 @@
+module MarkBatchProcessed = {
+  type input = unit
+  type output = unit
+  type t = input => output
+}

package/src/Ports.res.mjs

@@ -0,0 +1,9 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let MarkBatchProcessed = {};
+
+export {
+  MarkBatchProcessed,
+}
+/* No side effect */

package/src/Prometheus.res

@@ -11,16 +11,16 @@ module Labels = {
   let getLabelNames = (schema: S.t<'a>) =>
     switch schema->S.classify {
     | Object({items}) =>
-      let nonStringFields = items->Belt.Array.reduce([], (nonStringFields, item) => {
+      let nonStringFields = items->Array.reduce([], (nonStringFields, item) => {
         if item.schema->schemaIsString {
           nonStringFields
         } else {
-          nonStringFields->Belt.Array.concat([item.location])
+          nonStringFields->Array.concat([item.location])
         }
       })
 
       switch nonStringFields {
-      | [] => items->Belt.Array.map(item => item.location)->Ok
+      | [] => items->Array.map(item => item.location)->Ok
       | nonStringItems =>
         let nonStringItems = nonStringItems->Array.joinUnsafe(", ")
         Error(

package/src/Prometheus.res.mjs

@@ -2,8 +2,8 @@
 
 import * as Utils from "./Utils.res.mjs";
 import * as Hrtime from "./bindings/Hrtime.res.mjs";
-import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as PromClient from "./bindings/PromClient.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
@@ -40,17 +40,17 @@ function getLabelNames(schema) {
     };
   }
   let items = match.items;
-  let nonStringFields = Belt_Array.reduce(items, [], (nonStringFields, item) => {
+  let nonStringFields = Stdlib_Array.reduce(items, [], (nonStringFields, item) => {
     if (schemaIsString(item.schema)) {
       return nonStringFields;
     } else {
-      return Belt_Array.concat(nonStringFields, [item.location]);
+      return nonStringFields.concat([item.location]);
     }
   });
   if (nonStringFields.length === 0) {
     return {
       TAG: "Ok",
-      _0: Belt_Array.map(items, item => item.location)
+      _0: items.map(item => item.location)
     };
   }
   let nonStringItems = nonStringFields.join(", ");

package/src/ReorgDetection.res

@@ -53,7 +53,7 @@ let make = (
 ) => {
   let dataByBlockNumber = Dict.make()
 
-  chainReorgCheckpoints->Belt.Array.forEach(block => {
+  chainReorgCheckpoints->Array.forEach(block => {
     dataByBlockNumber->Utils.Dict.setByInt(
       block.blockNumber,
       {
@@ -161,13 +161,13 @@ let getLatestValidScannedBlock = (
 
   let getPrevScannedBlockNumber = idx =>
     ascBlockNumberKeys
-    ->Belt.Array.get(idx - 1)
+    ->Array.get(idx - 1)
     ->Option.map(key => {
       (verifiedDataByBlockNumber->Dict.getUnsafe(key)).blockNumber
     })
 
   let rec loop = idx => {
-    switch ascBlockNumberKeys->Belt.Array.get(idx) {
+    switch ascBlockNumberKeys->Array.get(idx) {
     | Some(blockNumberKey) =>
       switch reorgDetection.dataByBlockNumber->Utils.Dict.dangerouslyGetNonOption(blockNumberKey) {
       | Some(scannedBlock)
@@ -196,7 +196,7 @@ let rollbackToValidBlockNumber = (
   let newDataByBlockNumber = Dict.make()
 
   let rec loop = idx => {
-    switch ascBlockNumberKeys->Belt.Array.get(idx) {
+    switch ascBlockNumberKeys->Array.get(idx) {
     | Some(blockNumberKey) => {
         let scannedBlock = dataByBlockNumber->Dict.getUnsafe(blockNumberKey)
         let shouldKeep = scannedBlock.blockNumber <= blockNumber

package/src/ReorgDetection.res.mjs

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 
 function reorgDetectedToLogParams(reorgDetected, shouldRollbackOnReorg) {
@@ -17,7 +16,7 @@ function reorgDetectedToLogParams(reorgDetected, shouldRollbackOnReorg) {
 
 function make(chainReorgCheckpoints, maxReorgDepth, shouldRollbackOnReorg) {
   let dataByBlockNumber = {};
-  Belt_Array.forEach(chainReorgCheckpoints, block => {
+  chainReorgCheckpoints.forEach(block => {
     dataByBlockNumber[block.block_number] = {
       blockHash: block.block_hash,
       blockNumber: block.block_number
@@ -97,11 +96,11 @@ function getLatestValidScannedBlock(reorgDetection, blockNumbersAndHashes) {
     verifiedDataByBlockNumber[blockData.blockNumber.toString()] = blockData;
   }
   let ascBlockNumberKeys = Object.keys(verifiedDataByBlockNumber);
-  let getPrevScannedBlockNumber = idx => Stdlib_Option.map(Belt_Array.get(ascBlockNumberKeys, idx - 1 | 0), key => verifiedDataByBlockNumber[key].blockNumber);
+  let getPrevScannedBlockNumber = idx => Stdlib_Option.map(ascBlockNumberKeys[idx - 1 | 0], key => verifiedDataByBlockNumber[key].blockNumber);
   let _idx = 0;
   while (true) {
     let idx$1 = _idx;
-    let blockNumberKey = Belt_Array.get(ascBlockNumberKeys, idx$1);
+    let blockNumberKey = ascBlockNumberKeys[idx$1];
     if (blockNumberKey === undefined) {
       return getPrevScannedBlockNumber(idx$1);
     }
@@ -124,7 +123,7 @@ function rollbackToValidBlockNumber(param, blockNumber) {
   let loop = _idx => {
     while (true) {
       let idx = _idx;
-      let blockNumberKey = Belt_Array.get(ascBlockNumberKeys, idx);
+      let blockNumberKey = ascBlockNumberKeys[idx];
       if (blockNumberKey === undefined) {
         return;
       }