envio 3.0.0-alpha.19 → 3.0.0-alpha.19-main-node-pg-client

package/src/PgStorage.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Pg from "./bindings/Pg.res.mjs";
 import * as Fs from "fs";
 import * as Env from "./Env.res.mjs";
 import * as Path from "path";
@@ -14,9 +15,7 @@ import * as Schema from "./db/Schema.res.mjs";
 import * as Js_dict from "rescript/lib/es6/js_dict.js";
 import * as Logging from "./Logging.res.mjs";
 import * as $$Promise from "./bindings/Promise.res.mjs";
-import * as Caml_obj from "rescript/lib/es6/caml_obj.js";
 import * as Internal from "./Internal.res.mjs";
-import Postgres from "postgres";
 import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as Caml_option from "rescript/lib/es6/caml_option.js";
@@ -31,20 +30,14 @@ import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
 var getCacheRowCountFnName = "get_cache_row_count";
 
 function makeClient() {
-  return Postgres({
+  return Pg.makePool({
               host: Env.Db.host,
               port: Env.Db.port,
               database: Env.Db.database,
               username: Env.Db.user,
               password: Env.Db.password,
               ssl: Env.Db.ssl,
-              max: Env.Db.maxConnections,
-              onnotice: Caml_obj.equal(Env.userLogLevel, "warn") || Caml_obj.equal(Env.userLogLevel, "error") ? undefined : (function (_str) {
-                    
-                  }),
-              transform: {
-                undefined: null
-              }
+              max: Env.Db.maxConnections
             });
 }
 
@@ -164,7 +157,7 @@ function getEntityHistory(entityConfig) {
   var checkpointIdField = Table.mkField(EntityHistory.checkpointIdFieldName, EntityHistory.checkpointIdFieldType, EntityHistory.unsafeCheckpointIdSchema, undefined, undefined, undefined, true, undefined, undefined);
   var entityTableName = entityConfig.table.tableName;
   var historyTableName = EntityHistory.historyTableName(entityTableName, entityConfig.index);
-  var table = Table.mkTable(historyTableName, undefined, Belt_Array.concat(dataFields, [
+  var table = Table.mkTable(historyTableName, "h" + String(entityConfig.index), undefined, Belt_Array.concat(dataFields, [
             checkpointIdField,
             actionField
           ]));
@@ -310,29 +303,66 @@ function makeInsertValuesSetQuery(pgSchema, table, itemSchema, itemsCount) {
         ) + ";";
 }
 
+function makeJsonStringifier(table, jsonFieldIndices) {
+  if (!Utils.$$Array.notEmpty(jsonFieldIndices)) {
+    return ;
+  }
+  var jsonFieldNames = Belt_Array.keepMap(Table.getFields(table), (function (field) {
+          var match = field.fieldType;
+          if (typeof match !== "object" && match === "Json") {
+            return Table.getDbFieldName(field);
+          }
+          
+        }));
+  return (function (items) {
+            return items.map(function (item) {
+                        var dict = Js_dict.fromArray(Js_dict.entries(item));
+                        jsonFieldNames.forEach(function (name) {
+                              var v = Js_dict.get(dict, name);
+                              if (v !== undefined) {
+                                dict[name] = JSON.stringify(Caml_option.valFromOption(v));
+                                return ;
+                              }
+                              
+                            });
+                        return dict;
+                      });
+          });
+}
+
 function makeTableBatchSetQuery(pgSchema, table, itemSchema) {
   var match = Table.toSqlParams(table, itemSchema, pgSchema);
+  var dbSchema = match.dbSchema;
+  var jsonStringifier = makeJsonStringifier(table, match.jsonFieldIndices);
   var isRawEvents = table.tableName === InternalTable.RawEvents.table.tableName;
   var isHistoryUpdate = table.tableName.startsWith(EntityHistory.historyTablePrefix);
-  if ((isRawEvents || !match.hasArrayField) && !isHistoryUpdate) {
-    return {
-            query: makeInsertUnnestSetQuery(pgSchema, table, itemSchema, isRawEvents),
-            convertOrThrow: S$RescriptSchema.compile(S$RescriptSchema.unnest(match.dbSchema), "Output", "Input", "Sync", false),
-            isInsertValues: false
-          };
-  } else {
+  if (!((isRawEvents || !match.hasArrayField) && !isHistoryUpdate)) {
     return {
             query: makeInsertValuesSetQuery(pgSchema, table, itemSchema, 500),
-            convertOrThrow: S$RescriptSchema.compile(S$RescriptSchema.preprocess(S$RescriptSchema.unnest(itemSchema), (function (param) {
-                        return {
-                                s: (function (prim) {
-                                    return prim.flat(1);
-                                  })
-                              };
-                      })), "Output", "Input", "Sync", false),
-            isInsertValues: true
+            convertOrThrow: isHistoryUpdate ? S$RescriptSchema.compile(S$RescriptSchema.preprocess(S$RescriptSchema.unnest(itemSchema), (function (param) {
+                          return {
+                                  s: (function (prim) {
+                                      return prim.flat(1);
+                                    })
+                                };
+                        })), "Output", "Input", "Sync", false) : S$RescriptSchema.compile(S$RescriptSchema.preprocess(S$RescriptSchema.unnest(dbSchema), (function (param) {
+                          return {
+                                  s: (function (prim) {
+                                      return prim.flat(1);
+                                    })
+                                };
+                        })), "Output", "Input", "Sync", false),
+            isInsertValues: true,
+            jsonStringifier: jsonStringifier
           };
   }
+  var baseConvert = S$RescriptSchema.compile(S$RescriptSchema.unnest(dbSchema), "Output", "Input", "Sync", false);
+  return {
+          query: makeInsertUnnestSetQuery(pgSchema, table, itemSchema, isRawEvents),
+          convertOrThrow: baseConvert,
+          isInsertValues: false,
+          jsonStringifier: jsonStringifier
+        };
 }
 
 function chunkArray(arr, chunkSize) {
@@ -373,26 +403,42 @@ async function setOrThrow(sql, items, table, itemSchema, pgSchema) {
   var cached = setQueryCache.get(table);
   var data;
   if (cached !== undefined) {
-    data = Caml_option.valFromOption(cached);
+    data = cached;
   } else {
     var newQuery = makeTableBatchSetQuery(pgSchema, table, itemSchema);
     setQueryCache.set(table, newQuery);
     data = newQuery;
   }
+  var prepareItems = function (rawItems) {
+    var stringify = data.jsonStringifier;
+    if (stringify !== undefined) {
+      return stringify(rawItems);
+    } else {
+      return rawItems;
+    }
+  };
   try {
-    if (!data.isInsertValues) {
-      return await sql.unsafe(data.query, data.convertOrThrow(items), {prepare: true});
+    if (data.isInsertValues) {
+      var chunks = chunkArray(items, 500);
+      var responses = [];
+      chunks.forEach(function (chunk) {
+            var chunkSize = chunk.length;
+            var isFullChunk = chunkSize === 500;
+            var response = sql.query({
+                  text: isFullChunk ? data.query : makeInsertValuesSetQuery(pgSchema, table, itemSchema, chunkSize),
+                  values: data.convertOrThrow(prepareItems(chunk)),
+                  name: isFullChunk ? "insert_" + table.stmtId : undefined
+                });
+            responses.push(response);
+          });
+      await Promise.all(responses);
+      return ;
     }
-    var chunks = chunkArray(items, 500);
-    var responses = [];
-    chunks.forEach(function (chunk) {
-          var chunkSize = chunk.length;
-          var isFullChunk = chunkSize === 500;
-          var params = data.convertOrThrow(chunk);
-          var response = isFullChunk ? sql.unsafe(data.query, params, {prepare: true}) : sql.unsafe(makeInsertValuesSetQuery(pgSchema, table, itemSchema, chunkSize), params);
-          responses.push(response);
+    await sql.query({
+          text: data.query,
+          values: data.convertOrThrow(prepareItems(items)),
+          name: "upsert_" + table.stmtId
         });
-    await Promise.all(responses);
     return ;
   }
   catch (raw_exn){
@@ -477,7 +523,15 @@ async function getConnectedPsqlExec(pgUser, pgHost, pgDatabase, pgPort, containe
 async function deleteByIdsOrThrow(sql, pgSchema, ids, table) {
   try {
     await (
-      ids.length !== 1 ? sql.unsafe(makeDeleteByIdsQuery(pgSchema, table.tableName), [ids], {prepare: true}) : sql.unsafe(makeDeleteByIdQuery(pgSchema, table.tableName), ids, {prepare: true})
+      ids.length !== 1 ? sql.query({
+              text: makeDeleteByIdsQuery(pgSchema, table.tableName),
+              values: [ids],
+              name: "delete_ids_" + table.stmtId
+            }) : sql.query({
+              text: makeDeleteByIdQuery(pgSchema, table.tableName),
+              values: ids,
+              name: "delete_id_" + table.stmtId
+            })
     );
     return ;
   }
@@ -529,7 +583,7 @@ function executeSet(sql, items, dbFunction) {
   }
 }
 
-async function writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, escapeTables) {
+async function writeBatch(pool, batch, rawEvents, pgSchema, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, escapeTables) {
   try {
     var shouldSaveHistory = Config.shouldSaveHistory(config, isInReorgThreshold);
     var specificError = {
@@ -580,10 +634,14 @@ async function writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpo
                     await EntityHistory.backfillHistory(sql, pgSchema, entityConfig.name, entityConfig.index, Array.from(backfillHistoryIds));
                   }
                   if (Utils.$$Array.notEmpty(batchDeleteCheckpointIds)) {
-                    promises.push(sql.unsafe(makeInsertDeleteUpdatesQuery(entityConfig, pgSchema), [
-                              batchDeleteEntityIds,
-                              $$BigInt.arrayToStringArray(batchDeleteCheckpointIds)
-                            ], {prepare: true}));
+                    promises.push(sql.query({
+                              text: makeInsertDeleteUpdatesQuery(entityConfig, pgSchema),
+                              values: [
+                                batchDeleteEntityIds,
+                                $$BigInt.arrayToStringArray(batchDeleteCheckpointIds)
+                              ],
+                              name: "insert_deletes_" + String(entityConfig.index)
+                            }));
                   }
                   if (Utils.$$Array.notEmpty(batchSetUpdates)) {
                     if (shouldRemoveInvalidUtf8) {
@@ -655,40 +713,40 @@ async function writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpo
         }) : undefined;
     try {
       await Promise.all([
-            sql.begin(async function (sql) {
-                  if (rollbackTables !== undefined) {
-                    await rollbackTables(sql);
-                  }
-                  var setOperations = Belt_Array.concat([
-                        (function (sql) {
-                            return InternalTable.Chains.setProgressedChains(sql, pgSchema, Utils.Dict.mapValuesToArray(batch.progressedChainsById, (function (chainAfterBatch) {
-                                              return {
-                                                      chainId: chainAfterBatch.fetchState.chainId,
-                                                      progressBlockNumber: chainAfterBatch.progressBlockNumber,
-                                                      sourceBlockNumber: chainAfterBatch.sourceBlockNumber,
-                                                      totalEventsProcessed: chainAfterBatch.totalEventsProcessed
-                                                    };
-                                            })));
-                          }),
-                        setRawEvents
-                      ], setEntities);
-                  if (shouldSaveHistory) {
-                    setOperations.push(function (sql) {
-                          return InternalTable.Checkpoints.insert(sql, pgSchema, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointBlockHashes, batch.checkpointEventsProcessed);
-                        });
-                  }
-                  await Promise.all(Belt_Array.map(setOperations, (function (dbFunc) {
-                              return dbFunc(sql);
-                            })));
-                  if (sinkPromise === undefined) {
-                    return ;
-                  }
-                  var exn = await Caml_option.valFromOption(sinkPromise);
-                  if (exn === undefined) {
-                    return ;
-                  }
-                  throw exn;
-                }),
+            Pg.beginSql(pool, (async function (sql) {
+                    if (rollbackTables !== undefined) {
+                      await rollbackTables(sql);
+                    }
+                    var setOperations = Belt_Array.concat([
+                          (function (sql) {
+                              return InternalTable.Chains.setProgressedChains(sql, pgSchema, Utils.Dict.mapValuesToArray(batch.progressedChainsById, (function (chainAfterBatch) {
+                                                return {
+                                                        chainId: chainAfterBatch.fetchState.chainId,
+                                                        progressBlockNumber: chainAfterBatch.progressBlockNumber,
+                                                        sourceBlockNumber: chainAfterBatch.sourceBlockNumber,
+                                                        totalEventsProcessed: chainAfterBatch.totalEventsProcessed
+                                                      };
+                                              })));
+                            }),
+                          setRawEvents
+                        ], setEntities);
+                    if (shouldSaveHistory) {
+                      setOperations.push(function (sql) {
+                            return InternalTable.Checkpoints.insert(sql, pgSchema, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointBlockHashes, batch.checkpointEventsProcessed);
+                          });
+                    }
+                    await Promise.all(Belt_Array.map(setOperations, (function (dbFunc) {
+                                return dbFunc(sql);
+                              })));
+                    if (sinkPromise === undefined) {
+                      return ;
+                    }
+                    var exn = await Caml_option.valFromOption(sinkPromise);
+                    if (exn === undefined) {
+                      return ;
+                    }
+                    throw exn;
+                  })),
             Promise.all(Belt_Array.map(updatedEffectsCache, (function (param) {
                         return setEffectCacheOrThrow(param.effect, param.items, param.shouldInitialize);
                       })))
@@ -710,7 +768,7 @@ async function writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpo
     if (exn$1.RE_EXN_ID === PgEncodingError) {
       var escapeTables$1 = escapeTables !== undefined ? Caml_option.valFromOption(escapeTables) : new Set();
       escapeTables$1.add(exn$1.table);
-      return await writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, Caml_option.some(escapeTables$1));
+      return await writeBatch(pool, batch, rawEvents, pgSchema, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, Caml_option.some(escapeTables$1));
     }
     throw exn$1;
   }
@@ -735,7 +793,7 @@ function makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema) {
   return "SELECT DISTINCT " + Table.idFieldName + "\nFROM \"" + pgSchema + "\".\"" + historyTableName + "\"\nWHERE \"" + EntityHistory.checkpointIdFieldName + "\" > $1\nAND NOT EXISTS (\n  SELECT 1\n  FROM \"" + pgSchema + "\".\"" + historyTableName + "\" h\n  WHERE h." + Table.idFieldName + " = \"" + historyTableName + "\"." + Table.idFieldName + "\n    AND h.\"" + EntityHistory.checkpointIdFieldName + "\" <= $1\n)";
 }
 
-function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isHasuraEnabled, sink, onInitialize, onNewTables) {
+function make(pool, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isHasuraEnabled, sink, onInitialize, onNewTables) {
   var containerName = "envio-postgres";
   var psqlExecOptions_env = Js_dict.fromArray([
         [
@@ -752,8 +810,10 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
   };
   var cacheDirPath = Path.resolve(".envio", "cache");
   var isInitialized = async function () {
-    var envioTables = 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 + "');");
-    return Utils.$$Array.notEmpty(envioTables);
+    var match = await pool.query({
+          text: "SELECT table_schema FROM information_schema.tables WHERE table_schema = '" + pgSchema + "' AND (table_name = 'event_sync_state' OR table_name = '" + InternalTable.Chains.table.tableName + "');"
+        });
+    return match.rows.length > 0;
   };
   var restoreEffectCache = async function (withUpload) {
     if (withUpload) {
@@ -785,7 +845,9 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
           await Promise.all(cacheFiles.map(function (entry) {
                     var effectName = entry.slice(0, -4);
                     var table = Internal.makeCacheTable(effectName);
-                    return sql.unsafe(makeCreateTableQuery(table, pgSchema, false)).then(function () {
+                    return pool.query({
+                                  text: makeCreateTableQuery(table, pgSchema, false)
+                                }).then(function (param) {
                                 var inputFile = Path.join(cacheDirPath, entry);
                                 var command = psqlExec$1 + " -c 'COPY \"" + pgSchema + "\".\"" + table.tableName + "\" FROM STDIN WITH (FORMAT text, HEADER);' < " + inputFile;
                                 return new Promise((function (resolve, reject) {
@@ -817,7 +879,9 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
       }
       
     }
-    var cacheTableInfo = await sql.unsafe(makeSchemaCacheTableInfoQuery(pgSchema));
+    var cacheTableInfo = (await pool.query({
+            text: makeSchemaCacheTableInfoQuery(pgSchema)
+          })).rows;
     if (withUpload && Utils.$$Array.notEmpty(cacheTableInfo) && onNewTables !== undefined) {
       await onNewTables(cacheTableInfo.map(function (info) {
                 return info.table_name;
@@ -837,7 +901,9 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
     var chainConfigs = chainConfigsOpt !== undefined ? chainConfigsOpt : [];
     var entities = entitiesOpt !== undefined ? entitiesOpt : [];
     var enums = enumsOpt !== undefined ? enumsOpt : [];
-    var schemaTableNames = await sql.unsafe(makeSchemaTableNamesQuery(pgSchema));
+    var schemaTableNames = (await pool.query({
+            text: makeSchemaTableNamesQuery(pgSchema)
+          })).rows;
     if (Utils.$$Array.notEmpty(schemaTableNames) && !schemaTableNames.some(function (table) {
             return table.table_name === InternalTable.Chains.table.tableName ? true : table.table_name === "event_sync_state";
           })) {
@@ -847,11 +913,13 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
       await sink.initialize(chainConfigs, entities, enums);
     }
     var queries = makeInitializeTransaction(pgSchema, pgUser, isHasuraEnabled, chainConfigs, entities, enums, Utils.$$Array.isEmpty(schemaTableNames));
-    await sql.begin(function (sql) {
-          return Promise.all(queries.map(function (query) {
-                          return sql.unsafe(query);
-                        }));
-        });
+    await Pg.beginSql(pool, (function (sql) {
+            return Promise.all(queries.map(function (query) {
+                            return sql.query({
+                                        text: query
+                                      });
+                          }));
+          }));
     var cache = await restoreEffectCache(true);
     if (onInitialize !== undefined) {
       await onInitialize();
@@ -878,10 +946,18 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
           };
   };
   var loadByIdsOrThrow = async function (ids, table, rowsSchema) {
-    var rows;
+    var val;
     try {
-      rows = await (
-        ids.length !== 1 ? sql.unsafe(makeLoadByIdsQuery(pgSchema, table.tableName), [ids], {prepare: true}) : sql.unsafe(makeLoadByIdQuery(pgSchema, table.tableName), ids, {prepare: true})
+      val = await (
+        ids.length !== 1 ? pool.query({
+                text: makeLoadByIdsQuery(pgSchema, table.tableName),
+                values: [ids],
+                name: "load_ids_" + table.stmtId
+              }) : pool.query({
+                text: makeLoadByIdQuery(pgSchema, table.tableName),
+                values: ids,
+                name: "load_id_" + table.stmtId
+              })
       );
     }
     catch (raw_exn){
@@ -894,7 +970,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
           };
     }
     try {
-      return S$RescriptSchema.parseOrThrow(rows, rowsSchema);
+      return S$RescriptSchema.parseOrThrow(val.rows, rowsSchema);
     }
     catch (raw_exn$1){
       var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
@@ -920,9 +996,13 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
             Error: new Error()
           };
     }
-    var rows;
+    var val;
     try {
-      rows = await sql.unsafe(makeLoadByFieldQuery(pgSchema, table.tableName, fieldName, operator), params, {prepare: true});
+      val = await pool.query({
+            text: makeLoadByFieldQuery(pgSchema, table.tableName, fieldName, operator),
+            values: params,
+            name: "load_field_" + table.tableName + "_" + fieldName + "_" + operator
+          });
     }
     catch (raw_exn$1){
       var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
@@ -934,7 +1014,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
           };
     }
     try {
-      return S$RescriptSchema.parseOrThrow(rows, rowsSchema);
+      return S$RescriptSchema.parseOrThrow(val.rows, rowsSchema);
     }
     catch (raw_exn$2){
       var exn$2 = Caml_js_exceptions.internalToOCamlException(raw_exn$2);
@@ -947,13 +1027,15 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
     }
   };
   var setOrThrow$1 = function (items, table, itemSchema) {
-    return setOrThrow(sql, items, table, itemSchema, pgSchema);
+    return setOrThrow(pool, items, table, itemSchema, pgSchema);
   };
   var setEffectCacheOrThrow = async function (effect, items, initialize) {
     var match = effect.storageMeta;
     var table = match.table;
     if (initialize) {
-      await sql.unsafe(makeCreateTableQuery(table, pgSchema, false));
+      await pool.query({
+            text: makeCreateTableQuery(table, pgSchema, false)
+          });
       if (onNewTables !== undefined) {
         await onNewTables([table.tableName]);
       }
@@ -963,7 +1045,9 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
   };
   var dumpEffectCache = async function () {
     try {
-      var cacheTableInfo = (await sql.unsafe(makeSchemaCacheTableInfoQuery(pgSchema))).filter(function (i) {
+      var cacheTableInfo = (await pool.query({
+                text: makeSchemaCacheTableInfoQuery(pgSchema)
+              })).rows.filter(function (i) {
             return i.count > 0;
           });
       if (!Utils.$$Array.notEmpty(cacheTableInfo)) {
@@ -1011,7 +1095,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
   var resumeInitialState = async function () {
     var match = await Promise.all([
           restoreEffectCache(false),
-          InternalTable.Chains.getInitialState(sql, pgSchema).then(function (rawInitialStates) {
+          InternalTable.Chains.getInitialState(pool, pgSchema).then(function (rawInitialStates) {
                 return Belt_Array.map(rawInitialStates, (function (rawInitialState) {
                               return {
                                       id: rawInitialState.id,
@@ -1027,8 +1111,16 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
                                     };
                             }));
               }),
-          sql.unsafe(InternalTable.Checkpoints.makeCommitedCheckpointIdQuery(pgSchema)),
-          sql.unsafe(InternalTable.Checkpoints.makeGetReorgCheckpointsQuery(pgSchema))
+          pool.query({
+                  text: InternalTable.Checkpoints.makeCommitedCheckpointIdQuery(pgSchema)
+                }).then(function (r) {
+                return r.rows;
+              }),
+          pool.query({
+                  text: InternalTable.Checkpoints.makeGetReorgCheckpointsQuery(pgSchema)
+                }).then(function (r) {
+                return r.rows;
+              })
         ]);
     var checkpointId = BigInt(match[2][0].id);
     var reorgCheckpoints = Belt_Array.map(match[3], (function (raw) {
@@ -1052,29 +1144,43 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
   };
   var reset = async function () {
     var query = "DROP SCHEMA IF EXISTS \"" + pgSchema + "\" CASCADE;";
-    return await sql.unsafe(query);
+    return await pool.query({
+                text: query
+              });
   };
   var setChainMeta = function (chainsData) {
-    return InternalTable.Chains.setMeta(sql, pgSchema, chainsData).then(function (param) {
+    return InternalTable.Chains.setMeta(pool, pgSchema, chainsData).then(function (param) {
                 return undefined;
               });
   };
   var pruneStaleCheckpoints = function (safeCheckpointId) {
-    return InternalTable.Checkpoints.pruneStaleCheckpoints(sql, pgSchema, safeCheckpointId);
+    return InternalTable.Checkpoints.pruneStaleCheckpoints(pool, pgSchema, safeCheckpointId);
   };
   var pruneStaleEntityHistory = function (entityName, entityIndex, safeCheckpointId) {
-    return EntityHistory.pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, safeCheckpointId);
+    return EntityHistory.pruneStaleEntityHistory(pool, entityName, entityIndex, pgSchema, safeCheckpointId);
   };
   var getRollbackTargetCheckpoint = function (reorgChainId, lastKnownValidBlockNumber) {
-    return InternalTable.Checkpoints.getRollbackTargetCheckpoint(sql, pgSchema, reorgChainId, lastKnownValidBlockNumber);
+    return InternalTable.Checkpoints.getRollbackTargetCheckpoint(pool, pgSchema, reorgChainId, lastKnownValidBlockNumber);
   };
   var getRollbackProgressDiff = function (rollbackTargetCheckpointId) {
-    return InternalTable.Checkpoints.getRollbackProgressDiff(sql, pgSchema, rollbackTargetCheckpointId);
+    return InternalTable.Checkpoints.getRollbackProgressDiff(pool, pgSchema, rollbackTargetCheckpointId);
   };
   var getRollbackData = async function (entityConfig, rollbackTargetCheckpointId) {
     return await Promise.all([
-                sql.unsafe(makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true}),
-                sql.unsafe(makeGetRollbackRestoredEntitiesQuery(entityConfig, pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true})
+                pool.query({
+                        text: makeGetRollbackRemovedIdsQuery(entityConfig, pgSchema),
+                        values: [rollbackTargetCheckpointId.toString()],
+                        name: "rollback_removed_" + String(entityConfig.index)
+                      }).then(function (r) {
+                      return r.rows;
+                    }),
+                pool.query({
+                        text: makeGetRollbackRestoredEntitiesQuery(entityConfig, pgSchema),
+                        values: [rollbackTargetCheckpointId.toString()],
+                        name: "rollback_restored_" + String(entityConfig.index)
+                      }).then(function (r) {
+                      return r.rows;
+                    })
               ]);
   };
   var writeBatchMethod = async function (batch, rawEvents, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, updatedEffectsCache, updatedEntities) {
@@ -1089,7 +1195,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
     } else {
       sinkPromise = undefined;
     }
-    return await writeBatch(sql, batch, rawEvents, pgSchema, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, undefined);
+    return await writeBatch(pool, batch, rawEvents, pgSchema, rollbackTargetCheckpointId, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, undefined);
   };
   return {
           isInitialized: isInitialized,
@@ -1132,6 +1238,7 @@ export {
   makeInsertUnnestSetQuery ,
   makeInsertValuesSetQuery ,
   maxItemsPerQuery ,
+  makeJsonStringifier ,
   makeTableBatchSetQuery ,
   chunkArray ,
   removeInvalidUtf8InPlace ,

package/src/bindings/ClickHouse.res

@@ -158,7 +158,7 @@ let setCheckpointsOrThrow = async (client, ~batch: Batch.t, ~database: string) =
     for idx in 0 to checkpointsCount - 1 {
       checkpointRows
       ->Js.Array2.push((
-        batch.checkpointIds->Belt.Array.getUnsafe(idx),
+        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),

package/src/bindings/ClickHouse.res.mjs

@@ -134,7 +134,7 @@ async function setCheckpointsOrThrow(client, batch, database) {
   var checkpointRows = [];
   for(var idx = 0; idx < checkpointsCount; ++idx){
     checkpointRows.push([
-          batch.checkpointIds[idx],
+          batch.checkpointIds[idx].toString(),
           batch.checkpointChainIds[idx],
           batch.checkpointBlockNumbers[idx],
           batch.checkpointBlockHashes[idx],