envio 3.0.2 → 3.1.0-rc.0

package/src/TestIndexer.res.mjs

@@ -95,71 +95,66 @@ function handleWriteBatch(state, updatedEntities, checkpointIds, checkpointChain
       entityDict = dict$1;
     }
     let entityConfig = state.entityConfigs[entityName];
-    param.updates.forEach(update => {
-      let processChange = change => {
-        if (change.type === "SET") {
-          let parsedEntity = S$RescriptSchema.parseOrThrow(change.entity, entityConfig.schema);
-          entityDict[change.entityId] = parsedEntity;
-          let checkpointKey = change.checkpointId.toString();
-          let changes = changesByCheckpoint[checkpointKey];
-          let entityChanges;
-          if (changes !== undefined) {
-            entityChanges = changes;
-          } else {
-            let changes$1 = {};
-            changesByCheckpoint[checkpointKey] = changes$1;
-            entityChanges = changes$1;
-          }
-          let change$1 = entityChanges[entityName];
-          let entityChange;
-          if (change$1 !== undefined) {
-            entityChange = change$1;
-          } else {
-            let change_sets = [];
-            let change_deleted = [];
-            let change$2 = {
-              sets: change_sets,
-              deleted: change_deleted
-            };
-            entityChanges[entityName] = change$2;
-            entityChange = change$2;
-          }
-          entityChange.sets.push(parsedEntity);
-          return;
-        }
-        let entityId = change.entityId;
-        Stdlib_Dict.$$delete(entityDict, entityId);
-        let checkpointKey$1 = change.checkpointId.toString();
-        let changes$2 = changesByCheckpoint[checkpointKey$1];
-        let entityChanges$1;
-        if (changes$2 !== undefined) {
-          entityChanges$1 = changes$2;
+    let processChange = change => {
+      if (change.type === "SET") {
+        let parsedEntity = S$RescriptSchema.parseOrThrow(change.entity, entityConfig.schema);
+        entityDict[change.entityId] = parsedEntity;
+        let checkpointKey = change.checkpointId.toString();
+        let changes = changesByCheckpoint[checkpointKey];
+        let entityChanges;
+        if (changes !== undefined) {
+          entityChanges = changes;
         } else {
-          let changes$3 = {};
-          changesByCheckpoint[checkpointKey$1] = changes$3;
-          entityChanges$1 = changes$3;
+          let changes$1 = {};
+          changesByCheckpoint[checkpointKey] = changes$1;
+          entityChanges = changes$1;
         }
-        let change$3 = entityChanges$1[entityName];
-        let entityChange$1;
-        if (change$3 !== undefined) {
-          entityChange$1 = change$3;
+        let change$1 = entityChanges[entityName];
+        let entityChange;
+        if (change$1 !== undefined) {
+          entityChange = change$1;
         } else {
-          let change_sets$1 = [];
-          let change_deleted$1 = [];
-          let change$4 = {
-            sets: change_sets$1,
-            deleted: change_deleted$1
+          let change_sets = [];
+          let change_deleted = [];
+          let change$2 = {
+            sets: change_sets,
+            deleted: change_deleted
           };
-          entityChanges$1[entityName] = change$4;
-          entityChange$1 = change$4;
+          entityChanges[entityName] = change$2;
+          entityChange = change$2;
         }
-        entityChange$1.deleted.push(entityId);
-      };
-      update.history.forEach(processChange);
-      if (update.history.length === 0) {
-        return processChange(update.latestChange);
+        entityChange.sets.push(parsedEntity);
+        return;
       }
-    });
+      let entityId = change.entityId;
+      Stdlib_Dict.$$delete(entityDict, entityId);
+      let checkpointKey$1 = change.checkpointId.toString();
+      let changes$2 = changesByCheckpoint[checkpointKey$1];
+      let entityChanges$1;
+      if (changes$2 !== undefined) {
+        entityChanges$1 = changes$2;
+      } else {
+        let changes$3 = {};
+        changesByCheckpoint[checkpointKey$1] = changes$3;
+        entityChanges$1 = changes$3;
+      }
+      let change$3 = entityChanges$1[entityName];
+      let entityChange$1;
+      if (change$3 !== undefined) {
+        entityChange$1 = change$3;
+      } else {
+        let change_sets$1 = [];
+        let change_deleted$1 = [];
+        let change$4 = {
+          sets: change_sets$1,
+          deleted: change_deleted$1
+        };
+        entityChanges$1[entityName] = change$4;
+        entityChange$1 = change$4;
+      }
+      entityChange$1.deleted.push(entityId);
+    };
+    param.changes.forEach(processChange);
   });
   for (let i = 0, i_finish = checkpointIds.length; i < i_finish; ++i) {
     let checkpointId = checkpointIds[i];
@@ -649,12 +644,31 @@ function initTestWorker() {
   }
   let patchConfig = (config, _registrations) => {
     let config$1 = SimulateItems.patchConfig(config, processConfig);
-    if (!exitAfterFirstEventBlock) {
+    if (exitAfterFirstEventBlock) {
+      return {
+        name: config$1.name,
+        description: config$1.description,
+        handlers: config$1.handlers,
+        contractHandlers: config$1.contractHandlers,
+        shouldRollbackOnReorg: config$1.shouldRollbackOnReorg,
+        shouldSaveFullHistory: config$1.shouldSaveFullHistory,
+        storage: config$1.storage,
+        chainMap: config$1.chainMap,
+        defaultChain: config$1.defaultChain,
+        ecosystem: config$1.ecosystem,
+        enableRawEvents: config$1.enableRawEvents,
+        maxAddrInPartition: config$1.maxAddrInPartition,
+        batchSize: 1,
+        lowercaseAddresses: config$1.lowercaseAddresses,
+        isDev: config$1.isDev,
+        userEntitiesByName: config$1.userEntitiesByName,
+        userEntities: config$1.userEntities,
+        allEntities: config$1.allEntities,
+        allEnums: config$1.allEnums
+      };
+    } else {
       return config$1;
     }
-    let newrecord = {...config$1};
-    newrecord.batchSize = 1;
-    return newrecord;
   };
   Main.start(persistence, undefined, true, exitAfterFirstEventBlock, patchConfig);
 }

package/src/TestIndexerProxyStorage.res

@@ -7,15 +7,9 @@ type serializableChange =
   | @as("SET") Set({entityId: string, entity: JSON.t, checkpointId: bigint})
   | @as("DELETE") Delete({entityId: string, checkpointId: bigint})
 
-type serializableEntityUpdate = {
-  latestChange: serializableChange,
-  history: array<serializableChange>,
-  containsRollbackDiffChange: bool,
-}
-
 type serializableUpdatedEntity = {
   entityName: string,
-  updates: array<serializableEntityUpdate>,
+  changes: array<serializableChange>,
 }
 
 // Worker -> Main thread payloads
@@ -138,7 +132,7 @@ let makeStorage = (proxy: t): Persistence.storage => {
   writeBatch: async (
     ~batch,
     ~rawEvents as _,
-    ~rollbackTargetCheckpointId as _,
+    ~rollback as _,
     ~isInReorgThreshold as _,
     ~config as _,
     ~allEntities as _,
@@ -147,7 +141,7 @@ let makeStorage = (proxy: t): Persistence.storage => {
   ) => {
     // Encode entities to JSON for serialization across worker boundary
     let serializableEntities = updatedEntities->Array.map((
-      {entityConfig, updates}: Persistence.updatedEntity,
+      {entityConfig, changes}: Persistence.updatedEntity,
     ) => {
       let encodeChange = (change: Change.t<Internal.entity>): serializableChange => {
         switch change {
@@ -162,11 +156,7 @@ let makeStorage = (proxy: t): Persistence.storage => {
       }
       {
         entityName: entityConfig.name,
-        updates: updates->Array.map(update => {
-          latestChange: encodeChange(update.latestChange),
-          history: update.history->Array.map(encodeChange),
-          containsRollbackDiffChange: update.containsRollbackDiffChange,
-        }),
+        changes: changes->Array.map(encodeChange),
       }
     })
     let _ = await proxy->sendRequest(

package/src/TestIndexerProxyStorage.res.mjs

@@ -98,11 +98,7 @@ function makeStorage(proxy) {
         };
         return {
           entityName: entityConfig.name,
-          updates: param.updates.map(update => ({
-            latestChange: encodeChange(update.latestChange),
-            history: update.history.map(encodeChange),
-            containsRollbackDiffChange: update.containsRollbackDiffChange
-          }))
+          changes: param.changes.map(encodeChange)
         };
       });
       await sendRequest(proxy, {

package/src/UserContext.res

@@ -7,7 +7,6 @@ type contextParams = {
   loadManager: LoadManager.t,
   persistence: Persistence.t,
   isPreload: bool,
-  shouldSaveHistory: bool,
   chains: Internal.chains,
   config: Config.t,
   mutable isResolved: bool,
@@ -223,12 +222,12 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
           params.inMemoryStore
           ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig)
           ->InMemoryTable.Entity.set(
+            ~committedCheckpointId=params.inMemoryStore.committedCheckpointId,
             Set({
               entityId: entity.id,
               checkpointId: params.checkpointId,
               entity,
             }),
-            ~shouldSaveHistory=params.shouldSaveHistory,
           )
         }
 
@@ -329,11 +328,11 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
           params.inMemoryStore
           ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig)
           ->InMemoryTable.Entity.set(
+            ~committedCheckpointId=params.inMemoryStore.committedCheckpointId,
             Delete({
               entityId,
               checkpointId: params.checkpointId,
             }),
-            ~shouldSaveHistory=params.shouldSaveHistory,
           )
         }
       }->(Utils.magic: (string => unit) => unknown)
@@ -379,7 +378,6 @@ let handlerTraps: Utils.Proxy.traps<contextParams> = {
           inMemoryStore: params.inMemoryStore,
           loadManager: params.loadManager,
           persistence: params.persistence,
-          shouldSaveHistory: params.shouldSaveHistory,
           checkpointId: params.checkpointId,
           chains: params.chains,
           isResolved: params.isResolved,

package/src/UserContext.res.mjs

@@ -125,22 +125,22 @@ function throwClickHouseReadOnly(entityConfig, op) {
 
 let entityTraps_get = (params, prop) => {
   let isClickHouseOnly = !params.entityConfig.storage.postgres;
-  let set = params.isPreload ? noopSet : entity => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.inMemoryStore, params.entityConfig), {
+  let set = params.isPreload ? noopSet : entity => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.inMemoryStore, params.entityConfig), params.inMemoryStore.committedCheckpointId, {
       type: "SET",
       entityId: entity.id,
       entity: entity,
       checkpointId: params.checkpointId
-    }, params.shouldSaveHistory, undefined);
+    });
   switch (prop) {
     case "deleteUnsafe" :
       if (params.isPreload) {
         return noopDeleteUnsafe;
       } else {
-        return entityId => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.inMemoryStore, params.entityConfig), {
+        return entityId => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.inMemoryStore, params.entityConfig), params.inMemoryStore.committedCheckpointId, {
           type: "DELETE",
           entityId: entityId,
           checkpointId: params.checkpointId
-        }, params.shouldSaveHistory, undefined);
+        });
       }
     case "get" :
       if (isClickHouseOnly) {
@@ -218,7 +218,6 @@ let handlerTraps_get = (params, prop) => {
           loadManager: params.loadManager,
           persistence: params.persistence,
           isPreload: params.isPreload,
-          shouldSaveHistory: params.shouldSaveHistory,
           chains: params.chains,
           config: params.config,
           isResolved: params.isResolved,

package/src/Utils.res

@@ -114,8 +114,6 @@ module Dict = {
   @get_index
   external dangerouslyGetByIntNonOption: (dict<'a>, int) => option<'a> = ""
 
-  let has: (dict<'a>, string) => bool = %raw(`(dict, key) => key in dict`)
-
   let push = (dict, key, value) => {
     switch dict->dangerouslyGetNonOption(key) {
     | Some(arr) => arr->Array.push(value)

package/src/Utils.res.mjs

@@ -72,8 +72,6 @@ function getOrInsertEmptyDict(dict, key) {
   return d$1;
 }
 
-let has = ((dict, key) => key in dict);
-
 function push(dict, key, value) {
   let arr = dict[key];
   if (arr !== undefined) {
@@ -171,7 +169,6 @@ let incrementByInt = ((dict, key) => {
 let Dict = {
   $$delete: Stdlib_Dict.$$delete,
   getOrInsertEmptyDict: getOrInsertEmptyDict,
-  has: has,
   push: push,
   pushMany: pushMany,
   merge: merge,

package/src/bindings/ClickHouse.res

@@ -35,8 +35,10 @@ type queryResult<'a>
 @send
 external query: (client, queryParams) => promise<queryResult<'a>> = "query"
 
+// The default `JSON` query format resolves to a `ResponseJSON` wrapper whose
+// rows live under `data`, not at the top level.
 @send
-external json: queryResult<'a> => promise<'a> = "json"
+external json: queryResult<'a> => promise<{"data": array<'a>}> = "json"
 
 let getClickHouseFieldType = (
   ~fieldType: Table.fieldType,
@@ -76,13 +78,13 @@ let getClickHouseFieldType = (
   | Json => "String"
   | Date => "DateTime64(3, 'UTC')"
   | Enum({config}) => {
-      let variantsLength = config.variants->Belt.Array.length
+      let variantsLength = config.variants->Array.length
       // Theoretically we can store 256 variants in Enum8,
       // but it'd require to explicitly start with a negative index (probably)
       let enumType = variantsLength <= 127 ? "Enum8" : "Enum16"
       let enumValues =
         config.variants
-        ->Belt.Array.map(variant => {
+        ->Array.map(variant => {
           let variantStr = variant->(Utils.magic: 'a => string)
           `'${variantStr}'`
         })
@@ -105,7 +107,7 @@ let getClickHouseFieldType = (
 let makeClickHouseEntitySchema = (table: Table.table): S.t<Internal.entity> => {
   S.schema(s => {
     let dict = Dict.make()
-    table.fields->Belt.Array.forEach(field => {
+    table.fields->Array.forEach(field => {
       switch field {
       | Field(f) => {
           let fieldName = f->Table.getDbFieldName
@@ -203,11 +205,11 @@ let setCheckpointsOrThrow = async (client, ~batch: Batch.t, ~database: string) =
     for idx in 0 to checkpointsCount - 1 {
       checkpointRows
       ->Array.push((
-        batch.checkpointIds->Belt.Array.getUnsafe(idx)->BigInt.toString,
-        batch.checkpointChainIds->Belt.Array.getUnsafe(idx),
-        batch.checkpointBlockNumbers->Belt.Array.getUnsafe(idx),
-        batch.checkpointBlockHashes->Belt.Array.getUnsafe(idx),
-        batch.checkpointEventsProcessed->Belt.Array.getUnsafe(idx),
+        batch.checkpointIds->Array.getUnsafe(idx)->BigInt.toString,
+        batch.checkpointChainIds->Array.getUnsafe(idx),
+        batch.checkpointBlockNumbers->Array.getUnsafe(idx),
+        batch.checkpointBlockHashes->Array.getUnsafe(idx),
+        batch.checkpointEventsProcessed->Array.getUnsafe(idx),
       ))
       ->ignore
     }
@@ -233,17 +235,17 @@ let setCheckpointsOrThrow = async (client, ~batch: Batch.t, ~database: string) =
 
 type setUpdatesCache = {
   tableName: string,
-  convertOrThrow: Change.t<Internal.entity> => JSON.t,
+  convertOrThrow: array<Change.t<Internal.entity>> => array<JSON.t>,
 }
 
 let setUpdatesOrThrow = async (
   client,
   ~cache: Utils.WeakMap.t<Internal.entityConfig, setUpdatesCache>,
-  ~updates: array<Internal.inMemoryStoreEntityUpdate<Internal.entity>>,
+  ~changes: array<Change.t<Internal.entity>>,
   ~entityConfig: Internal.entityConfig,
   ~database: string,
 ) => {
-  if updates->Array.length === 0 {
+  if changes->Array.length === 0 {
     ()
   } else {
     let {convertOrThrow, tableName} = switch cache->Utils.WeakMap.get(entityConfig) {
@@ -255,23 +257,29 @@ let setUpdatesOrThrow = async (
             ~entityIndex=entityConfig.index,
           )}\``,
         convertOrThrow: S.compile(
-          S.union([
-            EntityHistory.makeSetUpdateSchema(makeClickHouseEntitySchema(entityConfig.table)),
-            S.object(s => {
-              s.tag(EntityHistory.changeFieldName, EntityHistory.RowAction.DELETE)
-              Change.Delete({
-                entityId: s.field(Table.idFieldName, S.string),
-                checkpointId: s.field(
-                  EntityHistory.checkpointIdFieldName,
-                  EntityHistory.unsafeCheckpointIdSchema,
-                ),
-              })
-            }),
-          ]),
+          S.array(
+            S.union([
+              EntityHistory.makeSetUpdateSchema(makeClickHouseEntitySchema(entityConfig.table)),
+              S.object(s => {
+                s.tag(EntityHistory.changeFieldName, EntityHistory.RowAction.DELETE)
+                Change.Delete({
+                  entityId: s.field(Table.idFieldName, S.string),
+                  checkpointId: s.field(
+                    EntityHistory.checkpointIdFieldName,
+                    EntityHistory.unsafeCheckpointIdSchema,
+                  ),
+                })
+              }),
+            ]),
+          ),
           ~input=Value,
           ~output=Json,
           ~typeValidation=false,
           ~mode=Sync,
+        )->(
+          Utils.magic: (array<Change.t<Internal.entity>> => JSON.t) => array<
+            Change.t<Internal.entity>,
+          > => array<JSON.t>
         ),
       }
 
@@ -280,10 +288,9 @@ let setUpdatesOrThrow = async (
     }
 
     try {
-      // Convert entity updates to ClickHouse row format
-      let values = updates->Array.map(update => {
-        update.latestChange->convertOrThrow
-      })
+      // The entity history table is the source of truth for ClickHouse, so every
+      // intermediate change must be persisted, not only the current value.
+      let values = changes->convertOrThrow
 
       await insertWithRetry(client, ~table=tableName, ~values, ~format="JSONEachRow")
     } catch {
@@ -305,7 +312,7 @@ let makeCreateHistoryTableQuery = (
   ~replicated: bool=false,
 ) => {
   let tableEngine = replicated ? "ReplicatedMergeTree" : "MergeTree()"
-  let fieldDefinitions = entityConfig.table.fields->Belt.Array.keepMap(field => {
+  let fieldDefinitions = entityConfig.table.fields->Array.filterMap(field => {
     switch field {
     | Field(field) =>
       Some({
@@ -389,7 +396,7 @@ let makeCreateViewQuery = (~entityConfig: Internal.entityConfig, ~database: stri
 
   let entityFields =
     entityConfig.table.fields
-    ->Belt.Array.keepMap(field => {
+    ->Array.filterMap(field => {
       switch field {
       | Field(field) => {
           let fieldName = field->Table.getDbFieldName
@@ -433,12 +440,12 @@ let initialize = async (
 
     switch databaseEngine {
     | Some(engineSpec) => {
-        let expectedEngineName = engineSpec->String.split("(")->Belt.Array.getUnsafe(0)->String.trim
+        let expectedEngineName = engineSpec->String.split("(")->Array.getUnsafe(0)->String.trim
         let existingResult = await client->query({
           query: `SELECT engine FROM system.databases WHERE name = '${database}'`,
         })
-        let rows: array<{"engine": string}> = await existingResult->json
-        switch rows->Belt.Array.get(0) {
+        let rows = (await existingResult->json)["data"]
+        switch rows->Array.get(0) {
         | Some(row) if row["engine"] !== expectedEngineName =>
           JsError.throwWithMessage(
             `ClickHouse database "${database}" exists with engine "${row["engine"]}" but ENVIO_CLICKHOUSE_DATABASE_ENGINE specifies "${expectedEngineName}". Drop the database manually to change its engine.`,
@@ -456,14 +463,14 @@ let initialize = async (
     await client->exec({query: `USE ${database}`})
 
     await Promise.all(
-      entities->Belt.Array.map(entityConfig =>
+      entities->Array.map(entityConfig =>
         client->exec({query: makeCreateHistoryTableQuery(~entityConfig, ~database, ~replicated)})
       ),
     )->Utils.Promise.ignoreValue
     await client->exec({query: makeCreateCheckpointsTableQuery(~database, ~replicated)})
 
     await Promise.all(
-      entities->Belt.Array.map(entityConfig =>
+      entities->Array.map(entityConfig =>
         client->exec({query: makeCreateViewQuery(~entityConfig, ~database)})
       ),
     )->Utils.Promise.ignoreValue
@@ -496,11 +503,11 @@ let resume = async (client, ~database: string, ~checkpointId: Internal.checkpoin
     let tablesResult = await client->query({
       query: `SHOW TABLES FROM ${database} LIKE '${EntityHistory.historyTablePrefix}%'`,
     })
-    let tables: array<{"name": string}> = await tablesResult->json
+    let tables = (await tablesResult->json)["data"]
 
     // Delete rows with checkpoint IDs higher than the target for each history table
     await Promise.all(
-      tables->Belt.Array.map(table => {
+      tables->Array.map(table => {
         let tableName = table["name"]
         client->exec({
           query: `ALTER TABLE ${database}.\`${tableName}\` DELETE WHERE \`${EntityHistory.checkpointIdFieldName}\` > ${checkpointId->BigInt.toString}`,

package/src/bindings/ClickHouse.res.mjs

@@ -4,8 +4,8 @@ import * as Env from "../Env.res.mjs";
 import * as Table from "../db/Table.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 import * as Logging from "../Logging.res.mjs";
-import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as Persistence from "../Persistence.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_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
@@ -65,7 +65,7 @@ function getClickHouseFieldType(fieldType, isNullable, isArray) {
         let config$1 = fieldType.config;
         let variantsLength = config$1.variants.length;
         let enumType = variantsLength <= 127 ? "Enum8" : "Enum16";
-        let enumValues = Belt_Array.map(config$1.variants, variant => `'` + variant + `'`).join(", ");
+        let enumValues = config$1.variants.map(variant => `'` + variant + `'`).join(", ");
         baseType = enumType + `(` + enumValues + `)`;
         break;
       case "Entity" :
@@ -84,7 +84,7 @@ function getClickHouseFieldType(fieldType, isNullable, isArray) {
 function makeClickHouseEntitySchema(table) {
   return S$RescriptSchema.schema(s => {
     let dict = {};
-    Belt_Array.forEach(table.fields, field => {
+    table.fields.forEach(field => {
       if (field.TAG !== "Field") {
         return;
       }
@@ -192,8 +192,8 @@ async function setCheckpointsOrThrow(client, batch, database) {
   }
 }
 
-async function setUpdatesOrThrow(client, cache, updates, entityConfig, database) {
-  if (updates.length === 0) {
+async function setUpdatesOrThrow(client, cache, changes, entityConfig, database) {
+  if (changes.length === 0) {
     return;
   }
   let cached = cache.get(entityConfig);
@@ -202,7 +202,7 @@ async function setUpdatesOrThrow(client, cache, updates, entityConfig, database)
     match = cached;
   } else {
     let cached_tableName = database + `.\`` + EntityHistory.historyTableName(entityConfig.name, entityConfig.index) + `\``;
-    let cached_convertOrThrow = S$RescriptSchema.compile(S$RescriptSchema.union([
+    let cached_convertOrThrow = S$RescriptSchema.compile(S$RescriptSchema.array(S$RescriptSchema.union([
       EntityHistory.makeSetUpdateSchema(makeClickHouseEntitySchema(entityConfig.table)),
       S$RescriptSchema.object(s => {
         s.tag(EntityHistory.changeFieldName, "DELETE");
@@ -212,7 +212,7 @@ async function setUpdatesOrThrow(client, cache, updates, entityConfig, database)
           checkpointId: s.f(EntityHistory.checkpointIdFieldName, EntityHistory.unsafeCheckpointIdSchema)
         };
       })
-    ]), "Output", "Json", "Sync", false);
+    ])), "Output", "Json", "Sync", false);
     let cached$1 = {
       tableName: cached_tableName,
       convertOrThrow: cached_convertOrThrow
@@ -220,10 +220,9 @@ async function setUpdatesOrThrow(client, cache, updates, entityConfig, database)
     cache.set(entityConfig, cached$1);
     match = cached$1;
   }
-  let convertOrThrow = match.convertOrThrow;
   let tableName = match.tableName;
   try {
-    let values = updates.map(update => convertOrThrow(update.latestChange));
+    let values = match.convertOrThrow(changes);
     return await insertWithRetry(client, tableName, values, "JSONEachRow", undefined);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
@@ -239,7 +238,7 @@ async function setUpdatesOrThrow(client, cache, updates, entityConfig, database)
 function makeCreateHistoryTableQuery(entityConfig, database, replicatedOpt) {
   let replicated = replicatedOpt !== undefined ? replicatedOpt : false;
   let tableEngine = replicated ? "ReplicatedMergeTree" : "MergeTree()";
-  let fieldDefinitions = Belt_Array.keepMap(entityConfig.table.fields, field => {
+  let fieldDefinitions = Stdlib_Array.filterMap(entityConfig.table.fields, field => {
     if (field.TAG !== "Field") {
       return;
     }
@@ -277,7 +276,7 @@ ORDER BY (` + "id" + `)`;
 function makeCreateViewQuery(entityConfig, database) {
   let historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
   let checkpointsTableName = InternalTable.Checkpoints.table.tableName;
-  let entityFields = Belt_Array.keepMap(entityConfig.table.fields, field => {
+  let entityFields = Stdlib_Array.filterMap(entityConfig.table.fields, field => {
     if (field.TAG !== "Field") {
       return;
     }
@@ -307,8 +306,8 @@ async function initialize(client, database, entities, param) {
       let existingResult = await client.query({
         query: `SELECT engine FROM system.databases WHERE name = '` + database + `'`
       });
-      let rows = await existingResult.json();
-      let row = Belt_Array.get(rows, 0);
+      let rows = (await existingResult.json()).data;
+      let row = rows[0];
       if (row !== undefined) {
         let row$1 = Primitive_option.valFromOption(row);
         if (row$1.engine !== expectedEngineName) {
@@ -325,13 +324,13 @@ async function initialize(client, database, entities, param) {
     await client.exec({
       query: `USE ` + database
     });
-    await Promise.all(Belt_Array.map(entities, entityConfig => client.exec({
+    await Promise.all(entities.map(entityConfig => client.exec({
       query: makeCreateHistoryTableQuery(entityConfig, database, replicated)
     })));
     await client.exec({
       query: makeCreateCheckpointsTableQuery(database, replicated)
     });
-    await Promise.all(Belt_Array.map(entities, entityConfig => client.exec({
+    await Promise.all(entities.map(entityConfig => client.exec({
       query: makeCreateViewQuery(entityConfig, database)
     })));
     return Logging.trace("ClickHouse storage initialization completed successfully");
@@ -356,8 +355,8 @@ async function resume(client, database, checkpointId) {
     let tablesResult = await client.query({
       query: `SHOW TABLES FROM ` + database + ` LIKE '` + EntityHistory.historyTablePrefix + `%'`
     });
-    let tables = await tablesResult.json();
-    await Promise.all(Belt_Array.map(tables, table => {
+    let tables = (await tablesResult.json()).data;
+    await Promise.all(tables.map(table => {
       let tableName = table.name;
       return client.exec({
         query: `ALTER TABLE ` + database + `.\`` + tableName + `\` DELETE WHERE \`` + EntityHistory.checkpointIdFieldName + `\` > ` + checkpointId.toString()

package/src/bindings/Vitest.res

@@ -117,6 +117,9 @@ module Async = {
   @module("vitest") @scope("it")
   external it_skipIf: bool => (string, testContext => promise<unit>) => unit = "skipIf"
 
+  @module("vitest") @scope("it")
+  external it_fails: (string, testContext => promise<unit>) => unit = "fails"
+
   let isClaudeCloud: bool = %raw(`process.env.CLAUDE_CODE_CONTAINER_ID != null`)
   let itSkipInClaudeCloud = (name, fn) => it_skipIf(isClaudeCloud)(name, fn)