envio 3.1.1 → 3.2.0

package/src/SafeCheckpointTracking.res

@@ -15,13 +15,13 @@ let make = (
   ~chainReorgCheckpoints: array<Internal.reorgCheckpoint>,
 ) => {
   if maxReorgDepth > 0 && shouldRollbackOnReorg {
-    let checkpointIds = Belt.Array.makeUninitializedUnsafe(chainReorgCheckpoints->Array.length)
-    let checkpointBlockNumbers = Belt.Array.makeUninitializedUnsafe(
+    let checkpointIds = Utils.Array.jsArrayCreate(chainReorgCheckpoints->Array.length)
+    let checkpointBlockNumbers = Utils.Array.jsArrayCreate(
       chainReorgCheckpoints->Array.length,
     )
     chainReorgCheckpoints->Array.forEachWithIndex((checkpoint, idx) => {
-      checkpointIds->Belt.Array.setUnsafe(idx, checkpoint.checkpointId)
-      checkpointBlockNumbers->Belt.Array.setUnsafe(idx, checkpoint.blockNumber)
+      checkpointIds->Array.setUnsafe(idx, checkpoint.checkpointId)
+      checkpointBlockNumbers->Array.setUnsafe(idx, checkpoint.blockNumber)
     })
     Some({
       checkpointIds,
@@ -39,7 +39,7 @@ let getSafeCheckpointId = (safeCheckpointTracking: t, ~sourceBlockNumber: int) =
   switch safeCheckpointTracking.checkpointIds {
   | [] => 0n
   | _
-    if safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(0) >
+    if safeCheckpointTracking.checkpointBlockNumbers->Array.getUnsafe(0) >
       safeBlockNumber => 0n
   | [checkpointId] => checkpointId
   | _ => {
@@ -49,11 +49,11 @@ let getSafeCheckpointId = (safeCheckpointTracking: t, ~sourceBlockNumber: int) =
 
       while idx.contents < trackingCheckpointsCount && result.contents === None {
         if (
-          safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx.contents) >
+          safeCheckpointTracking.checkpointBlockNumbers->Array.getUnsafe(idx.contents) >
             safeBlockNumber
         ) {
           result :=
-            Some(safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(idx.contents - 1))
+            Some(safeCheckpointTracking.checkpointIds->Array.getUnsafe(idx.contents - 1))
         }
         idx := idx.contents + 1
       }
@@ -61,7 +61,7 @@ let getSafeCheckpointId = (safeCheckpointTracking: t, ~sourceBlockNumber: int) =
       switch result.contents {
       | Some(checkpointId) => checkpointId
       | None =>
-        safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(trackingCheckpointsCount - 1)
+        safeCheckpointTracking.checkpointIds->Array.getUnsafe(trackingCheckpointsCount - 1)
       }
     }
   }
@@ -82,21 +82,21 @@ let updateOnNewBatch = (
 
   // Copy + Clean up old checkpoints
   for idx in 0 to safeCheckpointTracking.checkpointIds->Array.length - 1 {
-    let checkpointId = safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(idx)
+    let checkpointId = safeCheckpointTracking.checkpointIds->Array.getUnsafe(idx)
     if checkpointId >= safeCheckpointId {
       mutCheckpointIds->Array.push(checkpointId)->ignore
       mutCheckpointBlockNumbers
-      ->Array.push(safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx))
+      ->Array.push(safeCheckpointTracking.checkpointBlockNumbers->Array.getUnsafe(idx))
       ->ignore
     }
   }
 
   // Append new checkpoints
   for idx in 0 to batchCheckpointIds->Array.length - 1 {
-    if batchCheckpointChainIds->Belt.Array.getUnsafe(idx) === chainId {
-      mutCheckpointIds->Array.push(batchCheckpointIds->Belt.Array.getUnsafe(idx))->ignore
+    if batchCheckpointChainIds->Array.getUnsafe(idx) === chainId {
+      mutCheckpointIds->Array.push(batchCheckpointIds->Array.getUnsafe(idx))->ignore
       mutCheckpointBlockNumbers
-      ->Array.push(batchCheckpointBlockNumbers->Belt.Array.getUnsafe(idx))
+      ->Array.push(batchCheckpointBlockNumbers->Array.getUnsafe(idx))
       ->ignore
     }
   }
@@ -113,13 +113,13 @@ let rollback = (safeCheckpointTracking: t, ~targetBlockNumber: int) => {
   let mutCheckpointBlockNumbers = []
 
   for idx in 0 to safeCheckpointTracking.checkpointIds->Array.length - 1 {
-    let blockNumber = safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx)
+    let blockNumber = safeCheckpointTracking.checkpointBlockNumbers->Array.getUnsafe(idx)
     if blockNumber <= targetBlockNumber {
       mutCheckpointIds
-      ->Array.push(safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(idx))
+      ->Array.push(safeCheckpointTracking.checkpointIds->Array.getUnsafe(idx))
       ->ignore
       mutCheckpointBlockNumbers
-      ->Array.push(safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx))
+      ->Array.push(safeCheckpointTracking.checkpointBlockNumbers->Array.getUnsafe(idx))
       ->ignore
     }
   }

package/src/SafeCheckpointTracking.res.mjs

@@ -5,8 +5,8 @@ function make(maxReorgDepth, shouldRollbackOnReorg, chainReorgCheckpoints) {
   if (!(maxReorgDepth > 0 && shouldRollbackOnReorg)) {
     return;
   }
-  let checkpointIds = new Array(chainReorgCheckpoints.length);
-  let checkpointBlockNumbers = new Array(chainReorgCheckpoints.length);
+  let checkpointIds = Array(chainReorgCheckpoints.length);
+  let checkpointBlockNumbers = Array(chainReorgCheckpoints.length);
   chainReorgCheckpoints.forEach((checkpoint, idx) => {
     checkpointIds[idx] = checkpoint.id;
     checkpointBlockNumbers[idx] = checkpoint.block_number;

package/src/SimulateItems.res

@@ -38,7 +38,7 @@ let evmSimulateBlockSchema = S.schema(s =>
   }
 )
 
-type evmSimulateBlock = {number: int, timestamp: int}
+type evmSimulateBlock = {number: int, timestamp: int, hash: string}
 
 let parseEvmSimulateBlock = (
   ~defaultBlockNumber: int,
@@ -125,7 +125,7 @@ let fuelSimulateBlockSchema = S.schema(s =>
   }
 )
 
-type fuelSimulateBlock = {height: int, time: int}
+type fuelSimulateBlock = {height: int, time: int, id: string}
 
 let parseFuelSimulateBlock = (
   ~defaultBlockNumber: int,
@@ -259,15 +259,15 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
         rawItem["block"]->(Utils.magic: 'a => Nullable.t<JSON.t>)->Nullable.toOption
       let transactionJson: option<JSON.t> =
         rawItem["transaction"]->(Utils.magic: 'a => Nullable.t<JSON.t>)->Nullable.toOption
-      let (block, blockNumber, timestamp) = switch config.ecosystem.name {
+      let (block, blockNumber, timestamp, blockHash) = switch config.ecosystem.name {
       | Fuel =>
         let block = parseFuelSimulateBlock(~defaultBlockNumber=currentBlock.contents, ~blockJson)
         let blockFields = block->(Utils.magic: Internal.eventBlock => fuelSimulateBlock)
-        (block, blockFields.height, blockFields.time)
+        (block, blockFields.height, blockFields.time, blockFields.id)
       | Evm =>
         let block = parseEvmSimulateBlock(~defaultBlockNumber=currentBlock.contents, ~blockJson)
         let blockFields = block->(Utils.magic: Internal.eventBlock => evmSimulateBlock)
-        (block, blockFields.number, blockFields.timestamp)
+        (block, blockFields.number, blockFields.timestamp, blockFields.hash)
       | Svm => JsError.throwWithMessage("simulate is not supported for SVM ecosystem")
       }
       let transaction = switch config.ecosystem.name {
@@ -286,6 +286,7 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
           timestamp,
           chain,
           blockNumber,
+          blockHash,
           logIndex,
           event: {
             contractName: eventConfig.contractName,
@@ -320,18 +321,13 @@ let patchConfig = (~config: Config.t, ~processConfig: JSON.t): Config.t => {
       let chainIdStr = chain->ChainMap.Chain.toChainId->Int.toString
       switch chainsDict->Dict.get(chainIdStr) {
       | Some(processChainJson) =>
-        let simulateRaw: option<array<JSON.t>> =
-          (processChainJson->(Utils.magic: JSON.t => {..}))["simulate"]->Nullable.toOption
+        let raw = processChainJson->(Utils.magic: JSON.t => {..})
+        let simulateRaw: option<array<JSON.t>> = raw["simulate"]->Nullable.toOption
         switch simulateRaw {
         | Some(simulateItems) =>
           let items = parse(~simulateItems, ~config, ~chainConfig)
-          // Use endBlock from processConfig (the user-specified range)
-          let startBlock: int =
-            (processChainJson->(Utils.magic: JSON.t => {..}))["startBlock"]->(
-              Utils.magic: 'a => int
-            )
-          let endBlock: int =
-            (processChainJson->(Utils.magic: JSON.t => {..}))["endBlock"]->(Utils.magic: 'a => int)
+          let startBlock: int = raw["startBlock"]->(Utils.magic: 'a => int)
+          let endBlock: int = raw["endBlock"]->(Utils.magic: 'a => int)
           let source = SimulateSource.make(~items, ~endBlock, ~chain)
           {...chainConfig, startBlock, endBlock, sourceConfig: Config.CustomSources([source])}
         | None => chainConfig

package/src/SimulateItems.res.mjs

@@ -201,7 +201,8 @@ function parse(simulateItems, config, chainConfig) {
         match$3 = [
           block,
           block.number,
-          block.timestamp
+          block.timestamp,
+          block.hash
         ];
         break;
       case "fuel" :
@@ -209,7 +210,8 @@ function parse(simulateItems, config, chainConfig) {
         match$3 = [
           block$1,
           block$1.height,
-          block$1.time
+          block$1.time,
+          block$1.id
         ];
         break;
       case "svm" :
@@ -237,6 +239,7 @@ function parse(simulateItems, config, chainConfig) {
       timestamp: match$3[2],
       chain: chain,
       blockNumber: blockNumber,
+      blockHash: match$3[3],
       logIndex: logIndex,
       event: {
         contractName: eventConfig.contractName,

package/src/Sink.res

@@ -34,7 +34,7 @@ let makeClickHouse = (~host, ~database, ~username, ~password): t => {
     },
     writeBatch: async (~batch, ~updatedEntities) => {
       await Promise.all(
-        updatedEntities->Belt.Array.map(({entityConfig, changes}) => {
+        updatedEntities->Array.map(({entityConfig, changes}) => {
           ClickHouse.setUpdatesOrThrow(client, ~cache, ~changes, ~entityConfig, ~database)
         }),
       )->Utils.Promise.ignoreValue

package/src/Sink.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 ClickHouse from "./bindings/ClickHouse.res.mjs";
 import * as Client from "@clickhouse/client";
 
@@ -21,7 +20,7 @@ function makeClickHouse(host, database, username, password) {
     },
     resume: checkpointId => ClickHouse.resume(client, database, checkpointId),
     writeBatch: async (batch, updatedEntities) => {
-      await Promise.all(Belt_Array.map(updatedEntities, param => ClickHouse.setUpdatesOrThrow(client, cache, param.changes, param.entityConfig, database)));
+      await Promise.all(updatedEntities.map(param => ClickHouse.setUpdatesOrThrow(client, cache, param.changes, param.entityConfig, database)));
       return await ClickHouse.setCheckpointsOrThrow(client, batch, database);
     }
   };

package/src/SvmTypes.res

@@ -0,0 +1,9 @@
+module Pubkey = {
+  type t
+  let schema =
+    S.string->S.setName("SVM.Pubkey")->(Utils.magic: S.t<string> => S.t<t>)
+  external fromStringUnsafe: string => t = "%identity"
+  external fromStringsUnsafe: array<string> => array<t> = "%identity"
+  external toString: t => string = "%identity"
+  external toStrings: array<t> => array<string> = "%identity"
+}

package/src/SvmTypes.res.mjs

@@ -0,0 +1,14 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+let schema = S$RescriptSchema.setName(S$RescriptSchema.string, "SVM.Pubkey");
+
+let Pubkey = {
+  schema: schema
+};
+
+export {
+  Pubkey,
+}
+/* schema Not a pure module */

package/src/TestIndexer.res

@@ -43,67 +43,32 @@ let toIndexingAddress = (dc: InternalTable.EnvioAddresses.t): Internal.indexingA
   registrationBlock: dc.registrationBlock,
 }
 
-let handleLoadByIds = (
-  state: testIndexerState,
-  ~tableName: string,
-  ~ids: array<string>,
-): JSON.t => {
-  let entityDict = state.entities->Dict.get(tableName)->Option.getOr(Dict.make())
-  let entityConfig = state.entityConfigs->Dict.getUnsafe(tableName)
-  let results = []
-  ids->Array.forEach(id => {
-    switch entityDict->Dict.get(id) {
-    | Some(entity) =>
-      // Serialize entity back to JSON for worker thread
-      let jsonEntity = entity->S.reverseConvertToJsonOrThrow(entityConfig.schema)
-      results->Array.push(jsonEntity)->ignore
-    | None => ()
-    }
-  })
-  results->JSON.Encode.array
-}
-
-let handleLoadByField = (
-  state: testIndexerState,
-  ~tableName: string,
-  ~fieldName: string,
-  ~fieldValue: JSON.t,
-  ~operator: Persistence.operator,
-): JSON.t => {
+let handleLoad = (state: testIndexerState, ~tableName: string, ~filter: EntityFilter.t): JSON.t => {
   let entityDict = state.entities->Dict.get(tableName)->Option.getOr(Dict.make())
   let entityConfig = state.entityConfigs->Dict.getUnsafe(tableName)
   let results = []
 
-  // Get the field schema from the entity's table to properly parse the JSON field value
-  let fieldSchema = switch entityConfig.table->Table.getFieldByDbName(fieldName) {
-  | Some(Table.Field({fieldSchema})) => fieldSchema
-  | _ => JsError.throwWithMessage(`Field ${fieldName} not found in entity ${tableName}`)
+  // Field values arrive as JSON from the worker boundary, so parse them
+  // with the field's schema before comparing. This properly handles
+  // bigint and BigDecimal comparisons
+  let parseLeaf = (~fieldName, ~fieldValue: unknown, ~isArray): unknown => {
+    let queryField = switch entityConfig.table->Table.queryFields->Dict.get(fieldName) {
+    | Some(queryField) => queryField
+    | None => JsError.throwWithMessage(`Field ${fieldName} not found in entity ${tableName}`)
+    }
+    fieldValue->S.convertOrThrow(isArray ? queryField.arrayFieldSchema : queryField.fieldSchema)
   }
+  let filter = filter->EntityFilter.mapValues(~mapValue=parseLeaf)
 
-  // Parse JSON field value to typed value using the field's schema
-  let parsedFieldValue = fieldValue->S.convertOrThrow(fieldSchema)->TableIndices.FieldValue.castFrom
-
-  // Compare using TableIndices.FieldValue logic (same approach as InMemoryTable)
-  // This properly handles bigint and BigDecimal comparisons
   entityDict
   ->Dict.valuesToArray
   ->Array.forEach(entity => {
     // Cast entity to dict of field values (same approach as InMemoryTable)
-    let entityAsDict = entity->(Utils.magic: Internal.entity => dict<TableIndices.FieldValue.t>)
-    switch entityAsDict->Dict.get(fieldName) {
-    | Some(entityFieldValue) => {
-        let matches = switch operator {
-        | #"=" => entityFieldValue->TableIndices.FieldValue.eq(parsedFieldValue)
-        | #">" => entityFieldValue->TableIndices.FieldValue.gt(parsedFieldValue)
-        | #"<" => entityFieldValue->TableIndices.FieldValue.lt(parsedFieldValue)
-        }
-        if matches {
-          // Serialize entity back to JSON for worker thread
-          let jsonEntity = entity->S.reverseConvertToJsonOrThrow(entityConfig.schema)
-          results->Array.push(jsonEntity)->ignore
-        }
-      }
-    | None => ()
+    let entityAsDict = entity->(Utils.magic: Internal.entity => dict<EntityFilter.FieldValue.t>)
+    if filter->EntityFilter.matches(~entity=entityAsDict) {
+      // Serialize entity back to JSON for worker thread
+      let jsonEntity = entity->S.reverseConvertToJsonOrThrow(entityConfig.schema)
+      results->Array.push(jsonEntity)->ignore
     }
   })
 
@@ -777,12 +742,7 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
                   )
 
                 switch msg.payload {
-                | LoadByIds({tableName, ids}) => state->handleLoadByIds(~tableName, ~ids)->respond
-
-                | LoadByField({tableName, fieldName, fieldValue, operator}) =>
-                  state
-                  ->handleLoadByField(~tableName, ~fieldName, ~fieldValue, ~operator)
-                  ->respond
+                | Load({tableName, filter}) => state->handleLoad(~tableName, ~filter)->respond
 
                 | WriteBatch({
                     updatedEntities,

package/src/TestIndexer.res.mjs

@@ -11,7 +11,7 @@ import * as ChainMap from "./ChainMap.res.mjs";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Persistence from "./Persistence.res.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
-import * as TableIndices from "./TableIndices.res.mjs";
+import * as EntityFilter from "./db/EntityFilter.res.mjs";
 import * as InternalTable from "./db/InternalTable.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as SimulateItems from "./SimulateItems.res.mjs";
@@ -32,47 +32,18 @@ function toIndexingAddress(dc) {
   };
 }
 
-function handleLoadByIds(state, tableName, ids) {
+function handleLoad(state, tableName, filter) {
   let entityDict = Stdlib_Option.getOr(state.entities[tableName], {});
   let entityConfig = state.entityConfigs[tableName];
   let results = [];
-  ids.forEach(id => {
-    let entity = entityDict[id];
-    if (entity === undefined) {
-      return;
-    }
-    let jsonEntity = S$RescriptSchema.reverseConvertToJsonOrThrow(entity, entityConfig.schema);
-    results.push(jsonEntity);
-  });
-  return results;
-}
-
-function handleLoadByField(state, tableName, fieldName, fieldValue, operator) {
-  let entityDict = Stdlib_Option.getOr(state.entities[tableName], {});
-  let entityConfig = state.entityConfigs[tableName];
-  let results = [];
-  let match = Table.getFieldByDbName(entityConfig.table, fieldName);
-  let fieldSchema;
-  let exit = 0;
-  if (match !== undefined && match.TAG === "Field") {
-    fieldSchema = match._0.fieldSchema;
-  } else {
-    exit = 1;
-  }
-  if (exit === 1) {
-    fieldSchema = Stdlib_JsError.throwWithMessage(`Field ` + fieldName + ` not found in entity ` + tableName);
-  }
-  let parsedFieldValue = S$RescriptSchema.convertOrThrow(fieldValue, fieldSchema);
+  let parseLeaf = (fieldName, fieldValue, isArray) => {
+    let queryField = Table.queryFields(entityConfig.table)[fieldName];
+    let queryField$1 = queryField !== undefined ? queryField : Stdlib_JsError.throwWithMessage(`Field ` + fieldName + ` not found in entity ` + tableName);
+    return S$RescriptSchema.convertOrThrow(fieldValue, isArray ? queryField$1.arrayFieldSchema : queryField$1.fieldSchema);
+  };
+  let filter$1 = EntityFilter.mapValues(filter, parseLeaf);
   Object.values(entityDict).forEach(entity => {
-    let entityFieldValue = entity[fieldName];
-    if (entityFieldValue === undefined) {
-      return;
-    }
-    let entityFieldValue$1 = Primitive_option.valFromOption(entityFieldValue);
-    let matches = operator === "=" ? TableIndices.FieldValue.eq(entityFieldValue$1, parsedFieldValue) : (
-        operator === ">" ? TableIndices.FieldValue.gt(entityFieldValue$1, parsedFieldValue) : TableIndices.FieldValue.lt(entityFieldValue$1, parsedFieldValue)
-      );
-    if (!matches) {
+    if (!EntityFilter.matches(filter$1, entity)) {
       return;
     }
     let jsonEntity = S$RescriptSchema.reverseConvertToJsonOrThrow(entity, entityConfig.schema);
@@ -561,15 +532,11 @@ function makeCreateTestIndexer(config, workerPath) {
               });
             };
             let 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.checkpointEventsProcessed);
-                return respond(null);
+            if (match.type === "load") {
+              return respond(handleLoad(state, match.tableName, match.filter));
             }
+            handleWriteBatch(state, match.updatedEntities, match.checkpointIds, match.checkpointChainIds, match.checkpointBlockNumbers, match.checkpointEventsProcessed);
+            respond(null);
           });
           worker.on("error", err => {
             worker.terminate();
@@ -675,8 +642,7 @@ function initTestWorker() {
 
 export {
   toIndexingAddress,
-  handleLoadByIds,
-  handleLoadByField,
+  handleLoad,
   handleWriteBatch,
   makeInitialState,
   rawChainConfigSchema,

package/src/TestIndexerProxyStorage.res

@@ -15,13 +15,11 @@ type serializableUpdatedEntity = {
 // Worker -> Main thread payloads
 @tag("type")
 type workerPayload =
-  | @as("loadByIds") LoadByIds({tableName: string, ids: array<string>})
-  | @as("loadByField")
-  LoadByField({
+  | @as("load")
+  Load({
       tableName: string,
-      fieldName: string,
-      fieldValue: JSON.t,
-      operator: Persistence.operator,
+      // Leaf field values are JSON-serialized with the table's field schemas
+      filter: EntityFilter.t,
     })
   | @as("writeBatch")
   WriteBatch({
@@ -107,27 +105,29 @@ let makeStorage = (proxy: t): Persistence.storage => {
     )
   },
   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,
-  ) => {
+  loadOrThrow: async (~filter, ~table: Table.table) => {
+    let serializeLeafOrThrow = (~fieldName, ~fieldValue: unknown, ~isArray) => {
+      let queryField = switch table->Table.queryFields->Dict.get(fieldName) {
+      | Some(queryField) => queryField
+      | None =>
+        JsError.throwWithMessage(
+          `TestIndexer: The table "${table.tableName}" doesn't have the field "${fieldName}"`,
+        )
+      }
+      fieldValue
+      ->S.reverseConvertToJsonOrThrow(
+        isArray ? queryField.arrayFieldSchema : queryField.fieldSchema,
+      )
+      ->(Utils.magic: JSON.t => unknown)
+    }
     let response = await proxy->sendRequest(
-      ~payload=LoadByField({
+      ~payload=Load({
         tableName: table.tableName,
-        fieldName,
-        fieldValue: fieldValue->S.reverseConvertToJsonOrThrow(fieldSchema),
-        operator,
+        // Field values must be JSON-safe to survive the worker thread boundary
+        filter: filter->EntityFilter.mapValues(~mapValue=serializeLeafOrThrow),
       }),
     )
-    response->S.parseOrThrow(rowsSchema)
+    response->S.parseOrThrow(table->Table.rowsSchema)
   },
   writeBatch: async (
     ~batch,

package/src/TestIndexerProxyStorage.res.mjs

@@ -1,6 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Table from "./db/Table.res.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as EntityFilter from "./db/EntityFilter.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
@@ -51,23 +53,18 @@ function makeStorage(proxy) {
     isInitialized: async () => true,
     initialize: async (param, param$1, param$2, param$3) => Stdlib_JsError.throwWithMessage("TestIndexer: initialize should not be called. Use resumeInitialState instead."),
     resumeInitialState: async () => proxy.initialState,
-    loadByIdsOrThrow: async (ids, table, rowsSchema) => {
+    loadOrThrow: async (filter, table) => {
+      let serializeLeafOrThrow = (fieldName, fieldValue, isArray) => {
+        let queryField = Table.queryFields(table)[fieldName];
+        let queryField$1 = queryField !== undefined ? queryField : Stdlib_JsError.throwWithMessage(`TestIndexer: The table "` + table.tableName + `" doesn't have the field "` + fieldName + `"`);
+        return S$RescriptSchema.reverseConvertToJsonOrThrow(fieldValue, isArray ? queryField$1.arrayFieldSchema : queryField$1.fieldSchema);
+      };
       let response = await sendRequest(proxy, {
-        type: "loadByIds",
+        type: "load",
         tableName: table.tableName,
-        ids: ids
+        filter: EntityFilter.mapValues(filter, serializeLeafOrThrow)
       });
-      return S$RescriptSchema.parseOrThrow(response, rowsSchema);
-    },
-    loadByFieldOrThrow: async (fieldName, fieldSchema, fieldValue, operator, table, rowsSchema) => {
-      let response = await sendRequest(proxy, {
-        type: "loadByField",
-        tableName: table.tableName,
-        fieldName: fieldName,
-        fieldValue: S$RescriptSchema.reverseConvertToJsonOrThrow(fieldValue, fieldSchema),
-        operator: operator
-      });
-      return S$RescriptSchema.parseOrThrow(response, rowsSchema);
+      return S$RescriptSchema.parseOrThrow(response, Table.rowsSchema(table));
     },
     dumpEffectCache: async () => {},
     reset: async () => {},
@@ -121,4 +118,4 @@ export {
   sendRequest,
   makeStorage,
 }
-/* S-RescriptSchema Not a pure module */
+/* Table Not a pure module */

package/src/Throttler.res

@@ -12,7 +12,7 @@ let make = (~intervalMillis: int, ~logger) => {
   isRunning: false,
   isAwaitingInterval: false,
   scheduled: None,
-  intervalMillis: intervalMillis->Belt.Int.toFloat,
+  intervalMillis: intervalMillis->Int.toFloat,
   logger,
 }
 
@@ -53,7 +53,7 @@ let rec startInternal = (throttler: t) => {
       let _ = setTimeout(() => {
         throttler.isAwaitingInterval = false
         throttler->startInternal
-      }, Belt.Int.fromFloat(throttler.intervalMillis -. timeSinceLastRun))
+      }, Int.fromFloat(throttler.intervalMillis -. timeSinceLastRun))
     }
   | _ => ()
   }

package/src/Time.res

@@ -16,7 +16,7 @@ let rec retryAsyncWithExponentialBackOff = async (
       let nextRetryCount = retryCount + 1
       let log = retryCount === 0 ? Logging.childTrace : Logging.childWarn
       logger->log({
-        "msg": `Retrying query ${nextRetryCount->Belt.Int.toString}/${maxRetries->Belt.Int.toString} in ${backOffMillis->Belt.Int.toString}ms - waiting for correct result.`,
+        "msg": `Retrying query ${nextRetryCount->Int.toString}/${maxRetries->Int.toString} in ${backOffMillis->Int.toString}ms - waiting for correct result.`,
         "err": exn->Utils.prettifyExn,
       })
       await resolvePromiseAfterDelay(~delayMilliseconds=backOffMillis)
@@ -32,7 +32,7 @@ let rec retryAsyncWithExponentialBackOff = async (
       exn
       ->ErrorHandling.make(
         ~logger,
-        ~msg=`Failure. Max retries ${retryCount->Belt.Int.toString}/${maxRetries->Belt.Int.toString} exceeded`,
+        ~msg=`Failure. Max retries ${retryCount->Int.toString}/${maxRetries->Int.toString} exceeded`,
       )
       ->ErrorHandling.log
       await Promise.reject(exn->JsExn.anyToExnInternal)

package/src/Time.res.mjs

@@ -20,13 +20,13 @@ async function retryAsyncWithExponentialBackOff(backOffMillisOpt, multiplicative
       let nextRetryCount = retryCount + 1 | 0;
       let log = retryCount === 0 ? Logging.childTrace : Logging.childWarn;
       log(logger, {
-        msg: `Retrying query ` + String(nextRetryCount) + `/` + String(maxRetries) + ` in ` + String(backOffMillis) + `ms - waiting for correct result.`,
+        msg: `Retrying query ` + nextRetryCount.toString() + `/` + maxRetries.toString() + ` in ` + backOffMillis.toString() + `ms - waiting for correct result.`,
         err: Utils.prettifyExn(exn)
       });
       await Utils.delay(backOffMillis);
       return await retryAsyncWithExponentialBackOff(backOffMillis * multiplicative | 0, multiplicative, nextRetryCount, maxRetries, logger, f);
     }
-    ErrorHandling.log(ErrorHandling.make(exn, logger, `Failure. Max retries ` + String(retryCount) + `/` + String(maxRetries) + ` exceeded`));
+    ErrorHandling.log(ErrorHandling.make(exn, logger, `Failure. Max retries ` + retryCount.toString() + `/` + maxRetries.toString() + ` exceeded`));
     return await Promise.reject(Primitive_exceptions.internalToException(exn));
   }
 }