envio 3.5.1 → 3.6.0

package/src/PgStorage.res.mjs

@@ -103,6 +103,35 @@ function makeCreateTableQuery(table, pgSchema, isNumericArrayAsText, chainIdMode
   ) + `);`;
 }
 
+let rowSchemaCache = new WeakMap();
+
+function getRowSchema(entityConfig) {
+  let cached = rowSchemaCache.get(entityConfig);
+  if (cached !== undefined) {
+    return Primitive_option.valFromOption(cached);
+  }
+  let chainIdField = Table.getChainIdField(entityConfig.table);
+  let schema = chainIdField !== undefined ? S$RescriptSchema.schema(s => {
+      let dict = {};
+      let match = entityConfig.schema.t;
+      let exit = 0;
+      if (typeof match !== "object" || match.TAG !== "object") {
+        exit = 1;
+      } else {
+        match.items.forEach(param => {
+          dict[param.location] = s.m(param.schema);
+        });
+      }
+      if (exit === 1) {
+        Stdlib_JsError.throwWithMessage(`Unexpected non-object schema for entity "` + entityConfig.name + `".`);
+      }
+      dict[chainIdField.fieldName] = s.m(ChainId.schema);
+      return dict;
+    }) : entityConfig.schema;
+  rowSchemaCache.set(entityConfig, schema);
+  return schema;
+}
+
 let entityHistoryCache = new WeakMap();
 
 function getEntityHistory(entityConfig) {
@@ -127,6 +156,7 @@ function getEntityHistory(entityConfig) {
           isNullable: field$1.isNullable,
           isPrimaryKey: true,
           isIndex: field$1.isIndex,
+          isChainId: field$1.isChainId,
           linkedEntity: field$1.linkedEntity,
           defaultValue: field$1.defaultValue,
           description: field$1.description,
@@ -134,6 +164,11 @@ function getEntityHistory(entityConfig) {
           clickhouseDbName: field$1.clickhouseDbName
         }
       };
+    } else if (field$1.isChainId) {
+      return {
+        TAG: "Field",
+        _0: field$1
+      };
     } else {
       return {
         TAG: "Field",
@@ -145,6 +180,7 @@ function getEntityHistory(entityConfig) {
           isNullable: true,
           isPrimaryKey: field$1.isPrimaryKey,
           isIndex: false,
+          isChainId: field$1.isChainId,
           linkedEntity: field$1.linkedEntity,
           defaultValue: field$1.defaultValue,
           description: field$1.description,
@@ -154,15 +190,15 @@ function getEntityHistory(entityConfig) {
       };
     }
   });
-  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 actionField = Table.mkField(EntityHistory.changeFieldName, EntityHistory.changeFieldType, S$RescriptSchema.never, undefined, 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, undefined);
   let entityTableName = entityConfig.table.tableName;
   let historyTableName = EntityHistory.historyTableName(entityTableName, entityConfig.index);
   let table = Table.mkTable(historyTableName, undefined, dataFields.concat([
     checkpointIdField,
     actionField
   ]), undefined);
-  let setChangeSchema = EntityHistory.makeSetUpdateSchema(Table.getIdSchema(entityConfig.table), entityConfig.schema);
+  let setChangeSchema = EntityHistory.makeSetUpdateSchema(Table.getIdSchema(entityConfig.table), getRowSchema(entityConfig));
   let cache_setChangeSchemaRows = S$RescriptSchema.array(setChangeSchema);
   let cache$1 = {
     table: table,
@@ -285,12 +321,21 @@ function makeFilterCondition(filter, table, params) {
   }
 }
 
-function makeDeleteByIdQuery(pgSchema, tableName) {
-  return `DELETE FROM "` + pgSchema + `"."` + tableName + `" WHERE id = $1;`;
+function makeChainIdCondition(table, chainId) {
+  let match = Table.getChainIdField(table);
+  if (match !== undefined && chainId !== undefined) {
+    return ` AND "` + Table.getPgDbFieldName(match) + `" = $2`;
+  } else {
+    return "";
+  }
 }
 
-function makeDeleteByIdsQuery(pgSchema, tableName, idPgType) {
-  return `DELETE FROM "` + pgSchema + `"."` + tableName + `" WHERE id = ANY($1::` + idPgType + `[]);`;
+function makeDeleteByIdQuery(pgSchema, tableName, chainIdCondition) {
+  return `DELETE FROM "` + pgSchema + `"."` + tableName + `" WHERE id = $1` + chainIdCondition + `;`;
+}
+
+function makeDeleteByIdsQuery(pgSchema, tableName, idPgType, chainIdCondition) {
+  return `DELETE FROM "` + pgSchema + `"."` + tableName + `" WHERE id = ANY($1::` + idPgType + `[])` + chainIdCondition + `;`;
 }
 
 function makeLoadAllQuery(pgSchema, tableName) {
@@ -547,11 +592,16 @@ async function getConnectedPsqlExec(pgUser, pgHost, pgDatabase, pgPort, containe
   return result;
 }
 
-async function deleteByIdsOrThrow(sql, pgSchema, ids, table) {
+async function deleteByIdsOrThrow(sql, pgSchema, ids, table, chainIdOpt) {
+  let chainId = chainIdOpt !== undefined ? Primitive_option.valFromOption(chainIdOpt) : undefined;
+  let chainIdCondition = makeChainIdCondition(table, chainId);
+  let chainIdParams = chainId !== undefined ? (
+      chainIdCondition !== "" ? [Primitive_option.valFromOption(chainId)] : []
+    ) : [];
   let idsJson = Table.encodeIdsToJson(table, ids);
   try {
     await (
-      ids.length !== 1 ? sql.unsafe(makeDeleteByIdsQuery(pgSchema, table.tableName, Table.getIdPgFieldType(table, pgSchema)), [idsJson], {prepare: true}) : sql.unsafe(makeDeleteByIdQuery(pgSchema, table.tableName), idsJson, {prepare: true})
+      ids.length !== 1 ? sql.unsafe(makeDeleteByIdsQuery(pgSchema, table.tableName, Table.getIdPgFieldType(table, pgSchema), chainIdCondition), [idsJson].concat(chainIdParams), {prepare: true}) : sql.unsafe(makeDeleteByIdQuery(pgSchema, table.tableName, chainIdCondition), idsJson.concat(chainIdParams), {prepare: true})
     );
     return;
   } catch (raw_exn) {
@@ -565,7 +615,7 @@ async function deleteByIdsOrThrow(sql, pgSchema, ids, table) {
   }
 }
 
-function makeInsertDeleteUpdatesQuery(entityConfig, pgSchema) {
+function makeInsertDeleteUpdatesQuery(entityConfig, pgSchema, chainId) {
   let historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
   let allHistoryFieldNames = Stdlib_Array.filterMap(entityConfig.table.fields, fieldOrDerived => {
     if (fieldOrDerived.TAG === "Field") {
@@ -575,6 +625,8 @@ function makeInsertDeleteUpdatesQuery(entityConfig, pgSchema) {
   allHistoryFieldNames.push(EntityHistory.checkpointIdFieldName);
   allHistoryFieldNames.push(EntityHistory.changeFieldName);
   let allHistoryFieldNamesStr = allHistoryFieldNames.map(name => `"` + name + `"`).join(", ");
+  let match = Table.getChainIdField(entityConfig.table);
+  let chainIdColumn = match !== undefined && chainId !== undefined ? Table.getPgDbFieldName(match) : "";
   let selectParts = allHistoryFieldNames.map(fieldName => {
     if (fieldName === Table.idFieldName) {
       return `u.` + Table.idFieldName;
@@ -582,6 +634,8 @@ function makeInsertDeleteUpdatesQuery(entityConfig, pgSchema) {
       return `u.` + EntityHistory.checkpointIdFieldName;
     } else if (fieldName === EntityHistory.changeFieldName) {
       return `'` + "DELETE" + `'`;
+    } else if (chainIdColumn !== "" && fieldName === chainIdColumn) {
+      return "$3";
     } else {
       return "NULL";
     }
@@ -640,9 +694,36 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
       }
     };
     let setEntities = updatedEntities.map(param => {
+      let changes = param.changes;
+      let scope = param.scope;
       let entityConfig = param.entityConfig;
       let entitiesToSet = [];
       let idsToDelete = [];
+      let scopeChainId;
+      scopeChainId = scope === "crossChain" ? undefined : Primitive_option.some(scope);
+      let match = Table.getChainIdField(entityConfig.table);
+      let changes$1;
+      if (match !== undefined && scopeChainId !== undefined) {
+        let chainId = Primitive_option.valFromOption(scopeChainId);
+        changes$1 = changes.map(change => {
+          if (change.type === "SET") {
+            return {
+              type: "SET",
+              entityId: change.entityId,
+              entity: Internal.stampChainId(change.entity, match.fieldName, chainId),
+              checkpointId: change.checkpointId
+            };
+          } else {
+            return change;
+          }
+        });
+      } else {
+        changes$1 = changes;
+      }
+      let match$1 = Table.getChainIdField(entityConfig.table);
+      let chainIdParams = match$1 !== undefined ? (
+          scopeChainId !== undefined ? [Primitive_option.valFromOption(scopeChainId)] : []
+        ) : [];
       let diffCheckpointId = Stdlib_Option.map(rollback, r => r.diffCheckpointId);
       let batchSetUpdates = [];
       let batchDeleteEntityIds = [];
@@ -650,7 +731,7 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
       let idsWithDiff = new Set();
       let latestChangeById = {};
       let orderedIds = [];
-      param.changes.forEach(change => {
+      changes$1.forEach(change => {
         let entityId = change.entityId;
         let entityKey = EntityId.toKey(entityId);
         if (Stdlib_Option.isNone(latestChangeById[entityKey])) {
@@ -691,13 +772,13 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
           let promises = [];
           if (shouldSaveHistory) {
             if (backfillHistoryIds.size !== 0) {
-              await EntityHistory.backfillHistory(sql, pgSchema, entityConfig.table, entityConfig.index, Array.from(backfillHistoryIds));
+              await EntityHistory.backfillHistory(sql, pgSchema, entityConfig.table, entityConfig.index, scopeChainId, Array.from(backfillHistoryIds));
             }
             if (Utils.$$Array.notEmpty(batchDeleteCheckpointIds)) {
-              promises.push(sql.unsafe(makeInsertDeleteUpdatesQuery(entityConfig, pgSchema), [
+              promises.push(sql.unsafe(makeInsertDeleteUpdatesQuery(entityConfig, pgSchema, scopeChainId), [
                 Table.encodeIdsToJson(entityConfig.table, batchDeleteEntityIds),
                 Utils.$$BigInt.arrayToStringArray(batchDeleteCheckpointIds)
-              ], {prepare: true}));
+              ].concat(chainIdParams), {prepare: true}));
             }
             if (Utils.$$Array.notEmpty(batchSetUpdates)) {
               if (shouldRemoveInvalidUtf8) {
@@ -717,10 +798,10 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
             if (shouldRemoveInvalidUtf8) {
               removeInvalidUtf8InPlace(entitiesToSet);
             }
-            promises.push(setOrThrow(sql, entitiesToSet, entityConfig.table, entityConfig.schema, pgSchema, chainIdMode));
+            promises.push(setOrThrow(sql, entitiesToSet, entityConfig.table, getRowSchema(entityConfig), pgSchema, chainIdMode));
           }
           if (Utils.$$Array.notEmpty(idsToDelete)) {
-            promises.push(deleteByIdsOrThrow(sql, pgSchema, idsToDelete, entityConfig.table));
+            promises.push(deleteByIdsOrThrow(sql, pgSchema, idsToDelete, entityConfig.table, Primitive_option.some(scopeChainId)));
           }
           await Promise.all(promises);
           return;
@@ -795,6 +876,18 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
   }
 }
 
+function rollbackKeyColumns(entityConfig) {
+  let field = Table.getChainIdField(entityConfig.table);
+  if (field !== undefined) {
+    return [
+      Table.idFieldName,
+      Table.getPgDbFieldName(field)
+    ];
+  } else {
+    return [Table.idFieldName];
+  }
+}
+
 function makeGetRollbackPreTargetRowsQuery(entityConfig, pgSchema) {
   let dataFieldNames = Stdlib_Array.filterMap(entityConfig.table.fields, fieldOrDerived => {
     if (fieldOrDerived.TAG === "Field") {
@@ -803,27 +896,32 @@ function makeGetRollbackPreTargetRowsQuery(entityConfig, pgSchema) {
   });
   let dataFieldsCommaSeparated = dataFieldNames.map(name => `"` + name + `"`).join(", ");
   let historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
-  return `SELECT DISTINCT ON ("` + Table.idFieldName + `") ` + dataFieldsCommaSeparated + `, "` + EntityHistory.changeFieldName + `"
+  let keyColumns = rollbackKeyColumns(entityConfig);
+  let keyColumnsCommaSeparated = keyColumns.map(c => `"` + c + `"`).join(", ");
+  let keyMatch = keyColumns.map(c => `h."` + c + `" = "` + historyTableName + `"."` + c + `"`).join(" AND ");
+  return `SELECT DISTINCT ON (` + keyColumnsCommaSeparated + `) ` + dataFieldsCommaSeparated + `, "` + EntityHistory.changeFieldName + `"
   FROM "` + pgSchema + `"."` + historyTableName + `"
   WHERE "` + EntityHistory.checkpointIdFieldName + `" <= $1
     AND EXISTS (
       SELECT 1
       FROM "` + pgSchema + `"."` + historyTableName + `" h
-      WHERE h."` + Table.idFieldName + `" = "` + historyTableName + `"."` + Table.idFieldName + `"
+      WHERE ` + keyMatch + `
         AND h."` + EntityHistory.checkpointIdFieldName + `" > $1
     )
-  ORDER BY "` + Table.idFieldName + `", "` + EntityHistory.checkpointIdFieldName + `" DESC`;
+  ORDER BY ` + keyColumnsCommaSeparated + `, "` + EntityHistory.checkpointIdFieldName + `" DESC`;
 }
 
 function makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema) {
   let historyTableName = EntityHistory.historyTableName(entityConfig.name, entityConfig.index);
-  return `SELECT DISTINCT "` + Table.idFieldName + `"
+  let keyColumns = rollbackKeyColumns(entityConfig);
+  let keyMatch = keyColumns.map(c => `h."` + c + `" = "` + historyTableName + `"."` + c + `"`).join(" AND ");
+  return `SELECT DISTINCT ` + keyColumns.map(c => `"` + c + `"`).join(", ") + `
   FROM "` + pgSchema + `"."` + historyTableName + `"
   WHERE "` + EntityHistory.checkpointIdFieldName + `" > $1
     AND NOT EXISTS (
       SELECT 1
       FROM "` + pgSchema + `"."` + historyTableName + `" h
-      WHERE h."` + Table.idFieldName + `" = "` + historyTableName + `"."` + Table.idFieldName + `"
+      WHERE ` + keyMatch + `
         AND h."` + EntityHistory.checkpointIdFieldName + `" <= $1
     )`;
 }
@@ -833,7 +931,9 @@ let rollbackRowStateSchema = Utils.$$WeakMap.memoize(table => S$RescriptSchema.o
   s.f(EntityHistory.changeFieldName, EntityHistory.RowAction.schema)
 ]));
 
-let rollbackRemovedIdsSchema = Utils.$$WeakMap.memoize(table => S$RescriptSchema.array(S$RescriptSchema.object(s => s.f(Table.idFieldName, Table.getIdSchema(table)))));
+let rollbackChainIdSchema = Utils.$$WeakMap.memoize(table => Stdlib_Option.map(Table.getChainIdField(table), field => S$RescriptSchema.object(s => s.f(Table.getPgDbFieldName(field), ChainId.schema))));
+
+let rollbackRemovedIdSchema = Utils.$$WeakMap.memoize(table => S$RescriptSchema.object(s => s.f(Table.idFieldName, Table.getIdSchema(table))));
 
 function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isHasuraEnabled, chainIdModeOpt, sink, onInitialize, onNewTables) {
   let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
@@ -863,16 +963,12 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
     let catalog = await refreshIndexCatalog();
     let invalidIndexNames = IndexCatalog.invalidNames(catalog);
     if (invalidIndexNames.length !== 0) {
-      Logging.warn({
+      return Logging.warn({
         storage: storageName,
         msg: `Ignoring invalid PostgreSQL indexes in schema "` + pgSchema + `". They can't serve queries, so the indexer builds its own alongside them.`,
         indexes: invalidIndexNames
       });
     }
-    return Logging.info({
-      storage: storageName,
-      msg: `Found ` + IndexCatalog.size(catalog).toString() + ` existing indexes in the indexer schema.`
-    });
   };
   let isInitialized = async () => Utils.$$Array.notEmpty(await sql.unsafe(`SELECT table_schema FROM information_schema.tables WHERE table_schema = '` + pgSchema + `' AND (table_name = '` + "event_sync_state" + `' OR table_name = '` + InternalTable.Chains.table.tableName + `');`));
   let scanCacheDir = async () => {
@@ -1062,7 +1158,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::` + addrCh
       };
     }
     try {
-      return S$RescriptSchema.parseOrThrow(rows, Table.pgRowsSchema(table));
+      return S$RescriptSchema.parseOrThrow(rows, Table.pgEntityRowsSchema(table));
     } catch (raw_exn$1) {
       let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
       throw {
@@ -1331,7 +1427,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::` + addrCh
   };
   let setChainMeta = chainsData => InternalTable.Chains.setMeta(sql, pgSchema, chainsData).then(param => (undefined));
   let pruneStaleCheckpoints = safeCheckpointId => InternalTable.Checkpoints.pruneStaleCheckpoints(sql, pgSchema, safeCheckpointId);
-  let pruneStaleEntityHistory = (entityName, entityIndex, safeCheckpointId) => EntityHistory.pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, safeCheckpointId);
+  let pruneStaleEntityHistory = (entityName, entityIndex, chainIdColumn, safeCheckpointId) => EntityHistory.pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, chainIdColumn, safeCheckpointId);
   let getRollbackTargetCheckpoint = (reorgChainId, lastKnownValidBlockNumber) => InternalTable.Checkpoints.getRollbackTargetCheckpoint(sql, pgSchema, reorgChainId, lastKnownValidBlockNumber);
   let getRollbackProgressDiff = rollbackTargetCheckpointId => InternalTable.Checkpoints.getRollbackProgressDiff(sql, pgSchema, rollbackTargetCheckpointId);
   let getRollbackData = async (entityConfig, rollbackTargetCheckpointId) => {
@@ -1339,7 +1435,18 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::` + addrCh
       sql.unsafe(makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true}),
       sql.unsafe(makeGetRollbackPreTargetRowsQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true})
     ]);
-    let removedIds = S$RescriptSchema.parseOrThrow(match[0], rollbackRemovedIdsSchema(entityConfig.table));
+    let chainIdSchema = rollbackChainIdSchema(entityConfig.table);
+    let scopeOf = row => {
+      if (chainIdSchema !== undefined) {
+        return S$RescriptSchema.parseOrThrow(row, Primitive_option.valFromOption(chainIdSchema));
+      } else {
+        return "crossChain";
+      }
+    };
+    let removals = match[0].map(row => ({
+      entityId: S$RescriptSchema.parseOrThrow(row, rollbackRemovedIdSchema(entityConfig.table)),
+      scope: scopeOf(row)
+    }));
     let restoredEntitiesResult = [];
     match[1].forEach(row => {
       let match = S$RescriptSchema.parseOrThrow(row, rollbackRowStateSchema(entityConfig.table));
@@ -1347,10 +1454,13 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::` + addrCh
         restoredEntitiesResult.push(row);
         return;
       }
-      removedIds.push(match[0]);
+      removals.push({
+        entityId: match[0],
+        scope: scopeOf(row)
+      });
     });
     return [
-      removedIds,
+      removals,
       restoredEntitiesResult
     ];
   };
@@ -1459,11 +1569,14 @@ export {
   slowOnLargeDatabaseNotice,
   getSchemaIndexes,
   makeCreateTableQuery,
+  rowSchemaCache,
+  getRowSchema,
   entityHistoryCache,
   getEntityHistory,
   makeInitializeTransaction,
   makeLoadQuery,
   makeFilterCondition,
+  makeChainIdCondition,
   makeDeleteByIdQuery,
   makeDeleteByIdsQuery,
   makeLoadAllQuery,
@@ -1487,12 +1600,14 @@ export {
   makeInsertDeleteUpdatesQuery,
   executeSet,
   writeBatch,
+  rollbackKeyColumns,
   makeGetRollbackPreTargetRowsQuery,
   makeGetRollbackRemovedIdsQuery,
   rollbackRowStateSchema,
-  rollbackRemovedIdsSchema,
+  rollbackChainIdSchema,
+  rollbackRemovedIdSchema,
   make,
   makeStorageFromEnv,
   makePersistenceFromConfig,
 }
-/* entityHistoryCache Not a pure module */
+/* rowSchemaCache Not a pure module */

package/src/PruneStaleHistory.res

@@ -103,6 +103,7 @@ let pruneEntities = async (state: IndexerState.t, ~entities, ~safeCheckpointId)
     switch await persistence.storage.pruneStaleEntityHistory(
       ~entityName=entityConfig.name,
       ~entityIndex=entityConfig.index,
+      ~chainIdColumn=entityConfig.table->Table.getChainIdField->Option.map(Table.getPgDbFieldName),
       ~safeCheckpointId,
     ) {
     | () =>

package/src/PruneStaleHistory.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Env from "./Env.res.mjs";
+import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Logging from "./Logging.res.mjs";
@@ -69,7 +70,7 @@ async function pruneEntities(state, entities, safeCheckpointId) {
     let exit = 0;
     let val;
     try {
-      val = await persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, safeCheckpointId);
+      val = await persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, Stdlib_Option.map(Table.getChainIdField(entityConfig.table), Table.getPgDbFieldName), safeCheckpointId);
       exit = 1;
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);

package/src/Sink.res

@@ -22,7 +22,7 @@ let makeClickHouse = (~host, ~database, ~username, ~password, ~chainIdMode: Chai
   // Don't pass database to the client; it would fail if the database doesn't
   // exist yet. Each query qualifies the name explicitly or runs USE first.
 
-  let cache = Utils.WeakMap.make()
+  let cache = Dict.make()
 
   {
     name: "clickhouse",
@@ -34,8 +34,8 @@ let makeClickHouse = (~host, ~database, ~username, ~password, ~chainIdMode: Chai
     },
     writeBatch: async (~batch, ~updatedEntities) => {
       await Promise.all(
-        updatedEntities->Array.map(({entityConfig, changes}) => {
-          ClickHouse.setUpdatesOrThrow(client, ~cache, ~changes, ~entityConfig, ~database)
+        updatedEntities->Array.map(({entityConfig, scope, changes}) => {
+          ClickHouse.setUpdatesOrThrow(client, ~cache, ~changes, ~entityConfig, ~scope, ~database)
         }),
       )->Utils.Promise.ignoreValue
       await ClickHouse.setCheckpointsOrThrow(client, ~batch, ~database)

package/src/Sink.res.mjs

@@ -10,7 +10,7 @@ function makeClickHouse(host, database, username, password, chainIdModeOpt) {
     username: username,
     password: password
   });
-  let cache = new WeakMap();
+  let cache = {};
   return {
     name: "clickhouse",
     initialize: ($staropt$star, $staropt$star$1, $staropt$star$2) => {
@@ -21,7 +21,7 @@ function makeClickHouse(host, database, username, password, chainIdModeOpt) {
     },
     resume: checkpointId => ClickHouse.resume(client, database, checkpointId),
     writeBatch: async (batch, updatedEntities) => {
-      await Promise.all(updatedEntities.map(param => ClickHouse.setUpdatesOrThrow(client, cache, param.changes, param.entityConfig, database)));
+      await Promise.all(updatedEntities.map(param => ClickHouse.setUpdatesOrThrow(client, cache, param.changes, param.entityConfig, param.scope, database)));
       return await ClickHouse.setCheckpointsOrThrow(client, batch, database);
     }
   };