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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.0.0-alpha.19",
+  "version": "3.0.0-alpha.19-main-node-pg-client",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -61,13 +61,13 @@
     "ink": "6.8.0",
     "ink-big-text": "2.0.0",
     "ink-spinner": "5.0.0",
-    "postgres": "3.4.8",
+    "pg": "8.16.0",
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.0.0-alpha.19",
-    "envio-linux-arm64": "3.0.0-alpha.19",
-    "envio-darwin-x64": "3.0.0-alpha.19",
-    "envio-darwin-arm64": "3.0.0-alpha.19"
+    "envio-linux-x64": "3.0.0-alpha.19-main-node-pg-client",
+    "envio-linux-arm64": "3.0.0-alpha.19-main-node-pg-client",
+    "envio-darwin-x64": "3.0.0-alpha.19-main-node-pg-client",
+    "envio-darwin-arm64": "3.0.0-alpha.19-main-node-pg-client"
   }
 }

package/src/Config.res

@@ -385,6 +385,7 @@ let parseEntitiesFromJson = (
 
     let table = Table.mkTable(
       entityName,
+      ~stmtId=index->Belt.Int.toString,
       ~fields=Array.concat(fields, derivedFields),
       ~compositeIndices,
     )

package/src/Config.res.mjs

@@ -41,7 +41,7 @@ var schema = S$RescriptSchema.schema(function (s) {
 
 var rowsSchema = S$RescriptSchema.array(schema);
 
-var table = Table.mkTable(name, undefined, [
+var table = Table.mkTable(name, undefined, undefined, [
       Table.mkField("id", "String", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
       Table.mkField("chain_id", "Int32", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
       Table.mkField("registering_event_block_number", "Int32", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
@@ -320,7 +320,7 @@ function parseEntitiesFromJson(entitiesJson, enumConfigsByName) {
                                             };
                                     }));
                       }));
-                var table = Table.mkTable(entityName, compositeIndices, Belt_Array.concat(fields, derivedFields));
+                var table = Table.mkTable(entityName, String(index), compositeIndices, Belt_Array.concat(fields, derivedFields));
                 var schema = S$RescriptSchema.schema(function (s) {
                       var dict = {};
                       Belt_Array.forEach(entityJson.properties, (function (prop) {

package/src/Env.res

@@ -109,7 +109,7 @@ module Db = {
   )
   let ssl = envSafe->EnvSafe.get(
     "ENVIO_PG_SSL_MODE",
-    Postgres.sslOptionsSchema,
+    Pg.sslOptionsSchema,
     //this is a dev fallback option for local deployments, shouldn't run in the prod env
     //the SSL modes should be provided as string otherwise as 'require' | 'allow' | 'prefer' | 'verify-full'
     ~devFallback=Bool(false),

package/src/Env.res.mjs

@@ -1,8 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Pg from "./bindings/Pg.res.mjs";
 import * as EnvSafe from "rescript-envsafe/src/EnvSafe.res.mjs";
 import * as Logging from "./Logging.res.mjs";
-import * as Postgres from "./bindings/Postgres.res.mjs";
 import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
 import * as HyperSyncClient from "./sources/HyperSyncClient.res.mjs";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
@@ -82,7 +82,7 @@ var database = EnvSafe.get(envSafe, "ENVIO_PG_DATABASE", S$RescriptSchema.string
 
 var publicSchema = EnvSafe.get(envSafe, "ENVIO_PG_SCHEMA", S$RescriptSchema.string, undefined, EnvSafe.get(envSafe, "ENVIO_PG_PUBLIC_SCHEMA", S$RescriptSchema.string, undefined, "public", undefined, undefined), undefined, undefined);
 
-var ssl = EnvSafe.get(envSafe, "ENVIO_PG_SSL_MODE", Postgres.sslOptionsSchema, undefined, undefined, false, undefined);
+var ssl = EnvSafe.get(envSafe, "ENVIO_PG_SSL_MODE", Pg.sslOptionsSchema, undefined, undefined, false, undefined);
 
 var maxConnections = EnvSafe.get(envSafe, "ENVIO_PG_MAX_CONNECTIONS", S$RescriptSchema.$$int, undefined, 2, undefined, undefined);
 

package/src/Internal.res.mjs

@@ -148,7 +148,7 @@ var effectCacheItemRowsSchema = S$RescriptSchema.array(S$RescriptSchema.schema(f
         }));
 
 function makeCacheTable(effectName) {
-  return Table.mkTable(cacheTablePrefix + effectName, undefined, [
+  return Table.mkTable(cacheTablePrefix + effectName, undefined, undefined, [
               Table.mkField("id", "String", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
               Table.mkField("output", "Json", cacheOutputSchema, undefined, undefined, true, undefined, undefined, undefined)
             ]);

package/src/PgStorage.res

@@ -1,10 +1,7 @@
 let getCacheRowCountFnName = "get_cache_row_count"
 
-// Only needed for some old tests
-// Remove @genType in the future
-@genType
 let makeClient = () => {
-  Postgres.makeSql(
+  Pg.makePool(
     ~config={
       host: Env.Db.host,
       port: Env.Db.port,
@@ -12,15 +9,7 @@ let makeClient = () => {
       password: Env.Db.password,
       database: Env.Db.database,
       ssl: Env.Db.ssl,
-      // TODO: think how we want to pipe these logs to pino.
-      onnotice: ?(
-        Env.userLogLevel == Some(#warn) || Env.userLogLevel == Some(#error)
-          ? None
-          : Some(_str => ())
-      ),
-      transform: {undefined: Null},
       max: Env.Db.maxConnections,
-      // debug: (~connection, ~query, ~params as _, ~types as _) => Js.log2(connection, query),
     },
   )
 }
@@ -163,6 +152,7 @@ let getEntityHistory = (~entityConfig: Internal.entityConfig): EntityHistory.pgE
       //ignore composite indices
       let table = Table.mkTable(
         historyTableName,
+        ~stmtId="h" ++ entityConfig.index->Belt.Int.toString,
         ~fields=dataFields->Belt.Array.concat([checkpointIdField, actionField]),
       )
 
@@ -387,8 +377,53 @@ VALUES${placeholders.contents}` ++
 // Constants for chunking
 let maxItemsPerQuery = 500
 
-let makeTableBatchSetQuery = (~pgSchema, ~table: Table.table, ~itemSchema: S.t<'item>) => {
-  let {dbSchema, hasArrayField} = table->Table.toSqlParams(~schema=itemSchema, ~pgSchema)
+type tableBatchSetQuery = {
+  query: string,
+  convertOrThrow: array<unknown> => array<unknown>,
+  isInsertValues: bool,
+  jsonStringifier: option<array<unknown> => array<unknown>>,
+}
+
+
+// pg driver doesn't auto-serialize JSONB values like postgres.js did.
+// Pre-stringify JSON field values in items before schema processing.
+let makeJsonStringifier = (table: Table.table, jsonFieldIndices: array<int>) => {
+  if jsonFieldIndices->Utils.Array.notEmpty {
+    let jsonFieldNames = table->Table.getFields->Belt.Array.keepMap(field => {
+      switch field.fieldType {
+      | Json => Some(field->Table.getDbFieldName)
+      | _ => None
+      }
+    })
+    Some(
+      (items: array<unknown>) =>
+        items->Js.Array2.map(item => {
+          let dict = Js.Dict.fromArray(
+            Js.Dict.entries(item->(Utils.magic: unknown => dict<unknown>)),
+          )
+          jsonFieldNames->Js.Array2.forEach(name => {
+            switch dict->Js.Dict.get(name) {
+            | Some(v) =>
+              dict->Js.Dict.set(
+                name,
+                Js.Json.stringify(v->(Utils.magic: unknown => Js.Json.t))->(
+                  Utils.magic: string => unknown
+                ),
+              )
+            | None => ()
+            }
+          })
+          dict->(Utils.magic: dict<unknown> => unknown)
+        }),
+    )
+  } else {
+    None
+  }
+}
+
+let makeTableBatchSetQuery = (~pgSchema, ~table: Table.table, ~itemSchema: S.t<'item>): tableBatchSetQuery => {
+  let {dbSchema, hasArrayField, jsonFieldIndices} = table->Table.toSqlParams(~schema=itemSchema, ~pgSchema)
+  let jsonStringifier = makeJsonStringifier(table, jsonFieldIndices)
 
   // Should move this to a better place
   // We need it for the isRawEvents check in makeTableBatchSet
@@ -411,37 +446,55 @@ let makeTableBatchSetQuery = (~pgSchema, ~table: Table.table, ~itemSchema: S.t<'
   let typeValidation = false
 
   if (isRawEvents || !hasArrayField) && !isHistoryUpdate {
-    {
-      "query": makeInsertUnnestSetQuery(~pgSchema, ~table, ~itemSchema, ~isRawEvents),
-      "convertOrThrow": S.compile(
+    let baseConvert =
+      S.compile(
         S.unnest(dbSchema),
         ~input=Value,
         ~output=Unknown,
         ~mode=Sync,
         ~typeValidation,
-      ),
-      "isInsertValues": false,
+      )->(Utils.magic: (array<unknown> => unknown) => (array<unknown> => array<unknown>))
+    {
+      query: makeInsertUnnestSetQuery(~pgSchema, ~table, ~itemSchema, ~isRawEvents),
+      convertOrThrow: baseConvert,
+      isInsertValues: false,
+      jsonStringifier,
     }
   } else {
     {
-      "query": makeInsertValuesSetQuery(
+      query: makeInsertValuesSetQuery(
         ~pgSchema,
         ~table,
         ~itemSchema,
         ~itemsCount=maxItemsPerQuery,
       ),
-      "convertOrThrow": S.compile(
-        S.unnest(itemSchema)->S.preprocess(_ => {
-          serializer: Utils.Array.flatten->(
-            Utils.magic: (array<array<'a>> => array<'a>) => unknown => unknown
-          ),
-        }),
-        ~input=Value,
-        ~output=Unknown,
-        ~mode=Sync,
-        ~typeValidation,
-      ),
-      "isInsertValues": true,
+      convertOrThrow: (if isHistoryUpdate {
+        // Entity history uses S.object with transformation (Change variant → raw dict)
+        // that gets lost during dbSchema conversion. Use itemSchema directly.
+        // JSON serialization is handled by jsonStringifier in setOrThrow.
+        S.compile(
+          S.unnest(itemSchema->S.toUnknown)->S.preprocess(_ => {
+            serializer: Utils.Array.flatten->(Utils.magic: (array<array<'a>> => array<'a>) => unknown => unknown),
+          }),
+          ~input=Value,
+          ~output=Unknown,
+          ~mode=Sync,
+          ~typeValidation,
+        )->Obj.magic
+      } else {
+        // Non-history tables with Array fields
+        S.compile(
+          S.unnest(dbSchema)->S.preprocess(_ => {
+            serializer: Utils.Array.flatten->(Utils.magic: (array<array<'a>> => array<'a>) => unknown => unknown),
+          }),
+          ~input=Value,
+          ~output=Unknown,
+          ~mode=Sync,
+          ~typeValidation,
+        )->Obj.magic
+      }: array<unknown> => array<unknown>),
+      isInsertValues: true,
+      jsonStringifier,
     }
   }
 }
@@ -486,7 +539,7 @@ exception PgEncodingError({table: Table.table})
 
 // WeakMap for caching table batch set queries
 let setQueryCache = Utils.WeakMap.make()
-let setOrThrow = async (sql, ~items, ~table: Table.table, ~itemSchema, ~pgSchema) => {
+let setOrThrow = async (sql: Pg.sql, ~items, ~table: Table.table, ~itemSchema, ~pgSchema) => {
   if items->Array.length === 0 {
     ()
   } else {
@@ -504,34 +557,40 @@ let setOrThrow = async (sql, ~items, ~table: Table.table, ~itemSchema, ~pgSchema
       }
     }
 
+    // Pre-stringify JSON field values for pg driver compatibility
+    let prepareItems = (rawItems: array<unknown>): array<unknown> =>
+      switch data.jsonStringifier {
+      | Some(stringify) => stringify(rawItems)
+      | None => rawItems
+      }
+
     try {
-      if data["isInsertValues"] {
+      if data.isInsertValues {
         let chunks = chunkArray(items, ~chunkSize=maxItemsPerQuery)
         let responses = []
         chunks->Js.Array2.forEach(chunk => {
           let chunkSize = chunk->Array.length
           let isFullChunk = chunkSize === maxItemsPerQuery
 
-          let params = data["convertOrThrow"](
-            chunk->(Utils.magic: array<'item> => array<unknown>),
-          )
-          // Use prepared query only for full batches where the cached query is reused.
-          // Partial chunks generate unique SQL each time, so preparation has no benefit.
-          let response = isFullChunk
-            ? sql->Postgres.preparedUnsafe(data["query"], params)
-            : sql->Postgres.unpreparedUnsafe(
-                makeInsertValuesSetQuery(~pgSchema, ~table, ~itemSchema, ~itemsCount=chunkSize),
-                params,
-              )
+          let response = sql.query({
+            text: isFullChunk
+              ? data.query
+              // Create a new query for partial chunks on the fly.
+              : makeInsertValuesSetQuery(~pgSchema, ~table, ~itemSchema, ~itemsCount=chunkSize),
+            values: data.convertOrThrow(prepareItems(chunk->(Utils.magic: array<'item> => array<unknown>))),
+            // Don't prepare partial chunks - they vary in size and would pollute the cache
+            name: ?isFullChunk ? Some(`insert_${table.stmtId}`) : None,
+          })
           responses->Js.Array2.push(response)->ignore
         })
         let _ = await Promise.all(responses)
       } else {
         // Use UNNEST approach for single query
-        await sql->Postgres.preparedUnsafe(
-          data["query"],
-          data["convertOrThrow"](items->(Utils.magic: array<'item> => array<unknown>)),
-        )
+        let _ = await sql.query({
+          text: data.query,
+          values: data.convertOrThrow(prepareItems(items->(Utils.magic: array<'item> => array<unknown>))),
+          name: `upsert_${table.stmtId}`,
+        })
       }
     } catch {
     | S.Raised(_) as exn =>
@@ -643,19 +702,21 @@ let getConnectedPsqlExec = {
   }
 }
 
-let deleteByIdsOrThrow = async (sql, ~pgSchema, ~ids, ~table: Table.table) => {
+let deleteByIdsOrThrow = async (sql: Pg.sql, ~pgSchema, ~ids, ~table: Table.table) => {
   switch await (
     switch ids {
     | [_] =>
-      sql->Postgres.preparedUnsafe(
-        makeDeleteByIdQuery(~pgSchema, ~tableName=table.tableName),
-        ids->Obj.magic,
-      )
+      sql.query({
+        name: `delete_id_${table.stmtId}`,
+        text: makeDeleteByIdQuery(~pgSchema, ~tableName=table.tableName),
+        values: ids->Obj.magic,
+      })
     | _ =>
-      sql->Postgres.preparedUnsafe(
-        makeDeleteByIdsQuery(~pgSchema, ~tableName=table.tableName),
-        [ids]->Obj.magic,
-      )
+      sql.query({
+        name: `delete_ids_${table.stmtId}`,
+        text: makeDeleteByIdsQuery(~pgSchema, ~tableName=table.tableName),
+        values: [ids]->Obj.magic,
+      })
     }
   ) {
   | exception exn =>
@@ -716,9 +777,9 @@ FROM UNNEST($1::text[], $2::${checkpointIdPgType}[]) AS u(${Table.idFieldName},
 }
 
 let executeSet = (
-  sql: Postgres.sql,
+  sql: Pg.sql,
   ~items: array<'a>,
-  ~dbFunction: (Postgres.sql, array<'a>) => promise<unit>,
+  ~dbFunction: (Pg.sql, array<'a>) => promise<unit>,
 ) => {
   if items->Array.length > 0 {
     sql->dbFunction(items)
@@ -728,7 +789,7 @@ let executeSet = (
 }
 
 let rec writeBatch = async (
-  sql,
+  pool: Pg.pool,
   ~batch: Batch.t,
   ~rawEvents,
   ~pgSchema,
@@ -825,11 +886,11 @@ let rec writeBatch = async (
 
             if batchDeleteCheckpointIds->Utils.Array.notEmpty {
               promises->Belt.Array.push(
-                sql
-                ->Postgres.preparedUnsafe(
-                  makeInsertDeleteUpdatesQuery(~entityConfig, ~pgSchema),
-                  (batchDeleteEntityIds, batchDeleteCheckpointIds->BigInt.arrayToStringArray)->Obj.magic,
-                )
+                sql.query({
+                  name: `insert_deletes_${entityConfig.index->Belt.Int.toString}`,
+                  text: makeInsertDeleteUpdatesQuery(~entityConfig, ~pgSchema),
+                  values: (batchDeleteEntityIds, batchDeleteCheckpointIds->BigInt.arrayToStringArray)->Obj.magic,
+                })
                 ->Promise.ignoreValue,
               )
             }
@@ -881,7 +942,7 @@ let rec writeBatch = async (
 
           let _ = await promises->Promise.all
         } catch {
-        // There's a race condition that sql->Postgres.beginSql
+        // There's a race condition that pool->Pg.beginSql
         // might throw PG error, earlier, than the handled error
         // from setOrThrow will be passed through.
         // This is needed for the utf8 encoding fix.
@@ -918,7 +979,7 @@ let rec writeBatch = async (
 
             // Improtant: Don't rethrow here, since it'll result in
             // an unhandled rejected promise error.
-            // That's fine not to throw, since sql->Postgres.beginSql
+            // That's fine not to throw, since pool->Pg.beginSql
             // will fail anyways.
           }
         }
@@ -953,7 +1014,7 @@ let rec writeBatch = async (
 
     try {
       let _ = await Promise.all2((
-        sql->Postgres.beginSql(async sql => {
+        pool->Pg.beginSql(async sql => {
           //Rollback tables need to happen first in the traction
           switch rollbackTables {
           | Some(rollbackTables) =>
@@ -1036,7 +1097,7 @@ let rec writeBatch = async (
     let _ = escapeTables->Utils.Set.add(table)
     // Retry with specifying which tables to escape.
     await writeBatch(
-      sql,
+      pool,
       ~escapeTables,
       ~rawEvents,
       ~batch,
@@ -1102,7 +1163,7 @@ AND NOT EXISTS (
 }
 
 let make = (
-  ~sql: Postgres.sql,
+  ~pool: Pg.pool,
   ~pgHost,
   ~pgSchema,
   ~pgPort,
@@ -1114,6 +1175,7 @@ let make = (
   ~onInitialize=?,
   ~onNewTables=?,
 ): Persistence.storage => {
+  let sql = pool->Pg.poolToSql
   // Must match PG_CONTAINER in packages/cli/src/docker_env.rs
   let containerName = "envio-postgres"
   let psqlExecOptions: NodeJs.ChildProcess.execOptions = {
@@ -1127,11 +1189,11 @@ let make = (
   ])
 
   let isInitialized = async () => {
-    let envioTables = await sql->Postgres.unsafe(
-      `SELECT table_schema FROM information_schema.tables WHERE table_schema = '${pgSchema}' AND (table_name = '${// This is for indexer before envio@2.28
+    let {rows: envioTables} = await sql.query({
+      text: `SELECT table_schema FROM information_schema.tables WHERE table_schema = '${pgSchema}' AND (table_name = '${// This is for indexer before envio@2.28
         "event_sync_state"}' OR table_name = '${InternalTable.Chains.table.tableName}');`,
-    )
-    envioTables->Utils.Array.notEmpty
+    })
+    envioTables->Js.Array2.length > 0
   }
 
   let restoreEffectCache = async (~withUpload) => {
@@ -1156,9 +1218,8 @@ let make = (
               let effectName = entry->Js.String2.slice(~from=0, ~to_=-4) // Remove .tsv extension
               let table = Internal.makeCacheTable(~effectName)
 
-              sql
-              ->Postgres.unsafe(makeCreateTableQuery(table, ~pgSchema, ~isNumericArrayAsText=false))
-              ->Promise.then(() => {
+              sql.query({text: makeCreateTableQuery(table, ~pgSchema, ~isNumericArrayAsText=false)})
+              ->Promise.then(_ => {
                 let inputFile = NodeJs.Path.join(cacheDirPath, entry)->NodeJs.Path.toString
 
                 let command = `${psqlExec} -c 'COPY "${pgSchema}"."${table.tableName}" FROM STDIN WITH (FORMAT text, HEADER);' < ${inputFile}`
@@ -1194,7 +1255,8 @@ let make = (
     }
 
     let cacheTableInfo: array<schemaCacheTableInfo> =
-      await sql->Postgres.unsafe(makeSchemaCacheTableInfoQuery(~pgSchema))
+      (await sql.query({text: makeSchemaCacheTableInfoQuery(~pgSchema)})).rows
+      ->(Utils.magic: array<unknown> => array<schemaCacheTableInfo>)
 
     if withUpload && cacheTableInfo->Utils.Array.notEmpty {
       // Integration with other tools like Hasura
@@ -1219,7 +1281,8 @@ let make = (
 
   let initialize = async (~chainConfigs=[], ~entities=[], ~enums=[]): Persistence.initialState => {
     let schemaTableNames: array<schemaTableName> =
-      await sql->Postgres.unsafe(makeSchemaTableNamesQuery(~pgSchema))
+      (await sql.query({text: makeSchemaTableNamesQuery(~pgSchema)})).rows
+      ->(Utils.magic: array<unknown> => array<schemaTableName>)
 
     // The initialization query will completely drop the schema and recreate it from scratch.
     // So we need to check if the schema is not used for anything else than envio.
@@ -1259,10 +1322,10 @@ let make = (
       ~isHasuraEnabled,
     )
     // Execute all queries within a single transaction for integrity
-    let _ = await sql->Postgres.beginSql(sql => {
+    let _ = await pool->Pg.beginSql(sql => {
       // Promise.all might be not safe to use here,
       // but it's just how it worked before.
-      Promise.all(queries->Js.Array2.map(query => sql->Postgres.unsafe(query)))
+      Promise.all(queries->Js.Array2.map(query => sql.query({text: query})))
     })
 
     let cache = await restoreEffectCache(~withUpload=true)
@@ -1297,15 +1360,17 @@ let make = (
     switch await (
       switch ids {
       | [_] =>
-        sql->Postgres.preparedUnsafe(
-          makeLoadByIdQuery(~pgSchema, ~tableName=table.tableName),
-          ids->Obj.magic,
-        )
+        sql.query({
+          name: `load_id_${table.stmtId}`,
+          text: makeLoadByIdQuery(~pgSchema, ~tableName=table.tableName),
+          values: ids->Obj.magic,
+        })
       | _ =>
-        sql->Postgres.preparedUnsafe(
-          makeLoadByIdsQuery(~pgSchema, ~tableName=table.tableName),
-          [ids]->Obj.magic,
-        )
+        sql.query({
+          name: `load_ids_${table.stmtId}`,
+          text: makeLoadByIdsQuery(~pgSchema, ~tableName=table.tableName),
+          values: [ids]->Obj.magic,
+        })
       }
     ) {
     | exception exn =>
@@ -1315,7 +1380,7 @@ let make = (
           reason: exn,
         }),
       )
-    | rows =>
+    | {rows} =>
       try rows->S.parseOrThrow(rowsSchema) catch {
       | exn =>
         raise(
@@ -1345,15 +1410,16 @@ let make = (
         }),
       )
     }
-    switch await sql->Postgres.preparedUnsafe(
-      makeLoadByFieldQuery(
+    switch await sql.query({
+      name: `load_field_${table.tableName}_${fieldName}_${(operator :> string)}`,
+      text: makeLoadByFieldQuery(
         ~pgSchema,
         ~tableName=table.tableName,
         ~fieldName,
         ~operator=(operator :> string),
       ),
-      params,
-    ) {
+      values: params,
+    }) {
     | exception exn =>
       raise(
         Persistence.StorageError({
@@ -1361,7 +1427,7 @@ let make = (
           reason: exn,
         }),
       )
-    | rows =>
+    | {rows} =>
       try rows->S.parseOrThrow(rowsSchema) catch {
       | exn =>
         raise(
@@ -1398,9 +1464,9 @@ let make = (
 
     if initialize {
       let _ =
-        await sql->Postgres.unsafe(
-          makeCreateTableQuery(table, ~pgSchema, ~isNumericArrayAsText=false),
-        )
+        await sql.query({
+          text: makeCreateTableQuery(table, ~pgSchema, ~isNumericArrayAsText=false),
+        })
       // Integration with other tools like Hasura
       switch onNewTables {
       | Some(onNewTables) => await onNewTables(~tableNames=[table.tableName])
@@ -1414,8 +1480,8 @@ let make = (
   let dumpEffectCache = async () => {
     try {
       let cacheTableInfo: array<schemaCacheTableInfo> =
-        (await sql
-        ->Postgres.unsafe(makeSchemaCacheTableInfoQuery(~pgSchema)))
+        ((await sql.query({text: makeSchemaCacheTableInfoQuery(~pgSchema)})).rows
+        ->(Utils.magic: array<unknown> => array<schemaCacheTableInfo>))
         ->Js.Array2.filter(i => i.count > 0)
 
       if cacheTableInfo->Utils.Array.notEmpty {
@@ -1493,15 +1559,15 @@ let make = (
           sourceBlockNumber: rawInitialState.sourceBlockNumber,
         })
       }),
-      sql
-      ->Postgres.unsafe(InternalTable.Checkpoints.makeCommitedCheckpointIdQuery(~pgSchema))
-      ->(Utils.magic: promise<array<unknown>> => promise<array<{"id": string}>>),
-      sql
-      ->Postgres.unsafe(InternalTable.Checkpoints.makeGetReorgCheckpointsQuery(~pgSchema))
-      ->(
-        Utils.magic: promise<array<unknown>> => promise<
-          array<{"id": string, "chain_id": int, "block_number": int, "block_hash": string}>,
-        >
+      sql.query({text: InternalTable.Checkpoints.makeCommitedCheckpointIdQuery(~pgSchema)})
+      ->Promise.thenResolve(r =>
+        r.rows->(Utils.magic: array<unknown> => array<{"id": string}>)
+      ),
+      sql.query({text: InternalTable.Checkpoints.makeGetReorgCheckpointsQuery(~pgSchema)})
+      ->Promise.thenResolve(r =>
+        r.rows->(
+          Utils.magic: array<unknown> => array<{"id": string, "chain_id": int, "block_number": int, "block_hash": string}>
+        )
       ),
     ))
 
@@ -1532,7 +1598,7 @@ let make = (
 
   let reset = async () => {
     let query = `DROP SCHEMA IF EXISTS "${pgSchema}" CASCADE;`
-    await sql->Postgres.unsafe(query)->Promise.ignoreValue
+    await sql.query({text: query})->Promise.ignoreValue
   }
 
   let setChainMeta = chainsData =>
@@ -1569,19 +1635,21 @@ let make = (
   ) => {
     await Promise.all2((
       // Get IDs of entities that should be deleted (created after rollback target with no prior history)
-      sql
-      ->Postgres.preparedUnsafe(
-        makeGetRollbackRemovedIdsQuery(~entityConfig, ~pgSchema),
-        [rollbackTargetCheckpointId->BigInt.toString]->(Utils.magic: array<string> => unknown),
-      )
-      ->(Utils.magic: promise<unknown> => promise<array<{"id": string}>>),
+      sql.query({
+        name: `rollback_removed_${entityConfig.index->Belt.Int.toString}`,
+        text: makeGetRollbackRemovedIdsQuery(~entityConfig, ~pgSchema),
+        values: [rollbackTargetCheckpointId->BigInt.toString]->(Utils.magic: array<string> => array<unknown>),
+      })
+      ->Promise.thenResolve(r =>
+        r.rows->(Utils.magic: array<unknown> => array<{"id": string}>)
+      ),
       // Get entities that should be restored to their state at or before rollback target
-      sql
-      ->Postgres.preparedUnsafe(
-        makeGetRollbackRestoredEntitiesQuery(~entityConfig, ~pgSchema),
-        [rollbackTargetCheckpointId->BigInt.toString]->(Utils.magic: array<string> => unknown),
-      )
-      ->(Utils.magic: promise<unknown> => promise<array<unknown>>),
+      sql.query({
+        name: `rollback_restored_${entityConfig.index->Belt.Int.toString}`,
+        text: makeGetRollbackRestoredEntitiesQuery(~entityConfig, ~pgSchema),
+        values: [rollbackTargetCheckpointId->BigInt.toString]->(Utils.magic: array<string> => array<unknown>),
+      })
+      ->Promise.thenResolve(r => r.rows),
     ))
   }
 
@@ -1616,7 +1684,7 @@ let make = (
     }
 
     await writeBatch(
-      sql,
+      pool,
       ~batch,
       ~rawEvents,
       ~pgSchema,