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

package/src/bindings/Pg.res

@@ -0,0 +1,146 @@
+@unboxed
+type sslOptions =
+  | Bool(bool)
+  | @as("require") Require
+  | @as("allow") Allow
+  | @as("prefer") Prefer
+  | @as("verify-full") VerifyFull
+
+let sslOptionsSchema: S.schema<sslOptions> = S.enum([
+  Bool(true),
+  Bool(false),
+  Require,
+  Allow,
+  Prefer,
+  VerifyFull,
+])
+
+type poolConfig = {
+  host?: string,
+  port?: int,
+  database?: string,
+  username?: string,
+  password?: string,
+  ssl?: sslOptions,
+  max?: int,
+}
+
+@unboxed type ssl = Bool(bool) | Options({rejectUnauthorized: bool})
+type pgConfig = {
+  host?: string,
+  port?: int,
+  user?: string,
+  password?: string,
+  database?: string,
+  ssl?: ssl,
+  max?: int,
+  allowExitOnIdle?: bool,
+}
+type queryConfig = {
+  text: string,
+  values?: array<unknown>,
+  name?: string,
+}
+type queryResult = {
+  rows: array<unknown>,
+}
+
+type sql = {query: queryConfig => promise<queryResult>}
+type client = {
+  ...sql,
+  release: (~destroy: bool=?) => unit,
+}
+type pool = {
+  ...sql,
+  connect: unit => promise<client>,
+  on: (string, Js.Exn.t => unit) => unit,
+}
+external poolToSql: pool => sql = "%identity"
+external clientToSql: client => sql = "%identity"
+@module("pg") @new external makeRawPool: pgConfig => pool = "Pool"
+
+let makePool = (~config: poolConfig): pool => {
+  let pgConfig: pgConfig = {
+    host: ?config.host,
+    port: ?config.port,
+    user: ?config.username,
+    password: ?config.password,
+    database: ?config.database,
+    max: ?config.max,
+    allowExitOnIdle: true,
+    ssl: ?switch config.ssl {
+    | Some(Require) => Some(Options({rejectUnauthorized: false}))
+    | Some(VerifyFull) => Some(Options({rejectUnauthorized: true}))
+    | Some(Prefer | Allow | Bool(true)) => Some(Bool(true))
+    | Some(Bool(false)) => Some(Bool(false))
+    | None => None
+    },
+  }
+
+  let pool = makeRawPool(pgConfig)
+
+  // Prevent unhandled error events from crashing the process.
+  // Individual query errors are still propagated through promises.
+  pool.on("error", (err: Js.Exn.t) => {
+    Js.Console.error2("Pool error:", err->Js.Exn.message->Belt.Option.getWithDefault("Unknown error"))
+  })
+
+  pool
+}
+
+let beginSql = async (pool: pool, fn: sql => promise<'a>) => {
+  let client = await pool.connect()
+  try {
+    let _ = await client.query({text: "BEGIN"})
+    let result = await fn(client->clientToSql)
+    let _ = await client.query({text: "COMMIT"})
+    client.release()
+    result
+  } catch {
+  | exn =>
+    try {
+      let _ = await client.query({text: "ROLLBACK"})
+    } catch {
+    | _ => ()
+    }
+    // Destroy the client instead of returning it to the pool
+    // to avoid reusing a client in a potentially bad state after a failed transaction.
+    client.release(~destroy=true)
+    raise(exn)
+  }
+}
+
+// pg-types default parser for NUMERIC[] (OID 1231) converts elements to numbers,
+// but BigInt.schema and BigDecimal.schema expect string inputs.
+// Override to keep elements as strings.
+module PgTypes = {
+  type arrayParserResult<'a> = {parse: unit => 'a}
+  type arrayParserModule = {create: (string, unknown) => arrayParserResult<unknown>}
+
+  @module("pg") @scope("types")
+  external setTypeParser: (int, string => unknown) => unit = "setTypeParser"
+
+  @module("pg") @scope("types")
+  external arrayParser: arrayParserModule = "arrayParser"
+}
+
+// OID 1231 = NUMERIC[]. Parse elements as strings, not numbers.
+let stringIdentity: unknown = %raw(`String`)
+PgTypes.setTypeParser(1231, val =>
+  PgTypes.arrayParser.create(val, stringIdentity).parse()
+)
+
+@unboxed
+type columnType =
+  | @as("INTEGER") Integer
+  | @as("BIGINT") BigInt
+  | @as("BOOLEAN") Boolean
+  | @as("NUMERIC") Numeric
+  | @as("DOUBLE PRECISION") DoublePrecision
+  | @as("TEXT") Text
+  | @as("SERIAL") Serial
+  | @as("BIGSERIAL") BigSerial
+  | @as("JSONB") JsonB
+  | @as("TIMESTAMP WITH TIME ZONE") TimestampWithTimezone
+  | @as("TIMESTAMP") TimestampWithoutTimezone
+  | Custom(string)

package/src/bindings/{Postgres.res.d.mts → Pg.res.d.mts}

@@ -2,4 +2,4 @@
 // when importing code from .res.mjs files in genType .ts files
 // After we upgrade GenType and it starts to include ts-ignore,
 // the line can be removed.
-export type sql = any;
+export type pool = any;

package/src/bindings/Pg.res.mjs

@@ -0,0 +1,110 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pg from "pg";
+import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+var sslOptionsSchema = S$RescriptSchema.$$enum([
+      true,
+      false,
+      "require",
+      "allow",
+      "prefer",
+      "verify-full"
+    ]);
+
+function makePool(config) {
+  var match = config.ssl;
+  var tmp;
+  if (match !== undefined) {
+    if (typeof match !== "boolean") {
+      switch (match) {
+        case "require" :
+            tmp = {
+              rejectUnauthorized: false
+            };
+            break;
+        case "allow" :
+        case "prefer" :
+            tmp = true;
+            break;
+        case "verify-full" :
+            tmp = {
+              rejectUnauthorized: true
+            };
+            break;
+        
+      }
+    } else {
+      tmp = match ? true : false;
+    }
+  } else {
+    tmp = undefined;
+  }
+  var pgConfig_host = config.host;
+  var pgConfig_port = config.port;
+  var pgConfig_user = config.username;
+  var pgConfig_password = config.password;
+  var pgConfig_database = config.database;
+  var pgConfig_max = config.max;
+  var pgConfig_allowExitOnIdle = true;
+  var pgConfig = {
+    host: pgConfig_host,
+    port: pgConfig_port,
+    user: pgConfig_user,
+    password: pgConfig_password,
+    database: pgConfig_database,
+    ssl: tmp,
+    max: pgConfig_max,
+    allowExitOnIdle: pgConfig_allowExitOnIdle
+  };
+  var pool = new Pg.Pool(pgConfig);
+  pool.on("error", (function (err) {
+          console.error("Pool error:", Belt_Option.getWithDefault(err.message, "Unknown error"));
+        }));
+  return pool;
+}
+
+async function beginSql(pool, fn) {
+  var client = await pool.connect();
+  try {
+    await client.query({
+          text: "BEGIN"
+        });
+    var result = await fn(client);
+    await client.query({
+          text: "COMMIT"
+        });
+    client.release(undefined);
+    return result;
+  }
+  catch (exn){
+    try {
+      await client.query({
+            text: "ROLLBACK"
+          });
+    }
+    catch (exn$1){
+      
+    }
+    client.release(true);
+    throw exn;
+  }
+}
+
+var PgTypes = {};
+
+var stringIdentity = String;
+
+Pg.types.setTypeParser(1231, (function (val) {
+        return Pg.types.arrayParser.create(val, stringIdentity).parse();
+      }));
+
+export {
+  sslOptionsSchema ,
+  makePool ,
+  beginSql ,
+  PgTypes ,
+  stringIdentity ,
+}
+/* sslOptionsSchema Not a pure module */

package/src/db/EntityHistory.res

@@ -104,16 +104,18 @@ WHERE d.id = a.id
 }
 
 let pruneStaleEntityHistory = (
-  sql,
+  sql: Pg.sql,
   ~entityName,
   ~entityIndex,
   ~pgSchema,
   ~safeCheckpointId,
 ): promise<unit> => {
-  sql->Postgres.preparedUnsafe(
-    makePruneStaleEntityHistoryQuery(~entityName, ~entityIndex, ~pgSchema),
-    [safeCheckpointId->BigInt.toString]->(Utils.magic: array<string> => unknown),
-  )
+  sql.query({
+    name: `eh_prune_${entityIndex->Belt.Int.toString}`,
+    text: makePruneStaleEntityHistoryQuery(~entityName, ~entityIndex, ~pgSchema),
+    values: [safeCheckpointId->BigInt.toString]->(Utils.magic: array<string> => array<unknown>),
+  })
+  ->Promise.ignoreValue
 }
 
 // If an entity doesn't have a history before the update
@@ -121,7 +123,7 @@ let pruneStaleEntityHistory = (
 let makeBackfillHistoryQuery = (~pgSchema, ~entityName, ~entityIndex) => {
   let historyTableRef = `"${pgSchema}"."${historyTableName(~entityName, ~entityIndex)}"`
   `WITH target_ids AS (
-  SELECT UNNEST($1::${(Text: Postgres.columnType :> string)}[]) AS id
+  SELECT UNNEST($1::${(Text: Pg.columnType :> string)}[]) AS id
 ),
 missing_history AS (
   SELECT e.*
@@ -135,23 +137,21 @@ SELECT *, 0 AS ${checkpointIdFieldName}, '${(RowAction.SET :> string)}' as ${cha
 FROM missing_history;`
 }
 
-let backfillHistory = (sql, ~pgSchema, ~entityName, ~entityIndex, ~ids: array<string>) => {
-  sql
-  ->Postgres.preparedUnsafe(
-    makeBackfillHistoryQuery(~entityName, ~entityIndex, ~pgSchema),
-    [ids]->Obj.magic,
-  )
+let backfillHistory = (sql: Pg.sql, ~pgSchema, ~entityName, ~entityIndex, ~ids: array<string>) => {
+  sql.query({
+    name: `eh_backfill_${entityIndex->Belt.Int.toString}`,
+    text: makeBackfillHistoryQuery(~entityName, ~entityIndex, ~pgSchema),
+    values: [ids]->Obj.magic,
+  })
   ->Promise.ignoreValue
 }
 
-let rollback = (sql, ~pgSchema, ~entityName, ~entityIndex, ~rollbackTargetCheckpointId: Internal.checkpointId) => {
-  sql
-  ->Postgres.preparedUnsafe(
-    `DELETE FROM "${pgSchema}"."${historyTableName(
-        ~entityName,
-        ~entityIndex,
-      )}" WHERE "${checkpointIdFieldName}" > $1;`,
-    [rollbackTargetCheckpointId->BigInt.toString]->(Utils.magic: array<string> => unknown),
-  )
+let rollback = (sql: Pg.sql, ~pgSchema, ~entityName, ~entityIndex, ~rollbackTargetCheckpointId: Internal.checkpointId) => {
+  let tableName = historyTableName(~entityName, ~entityIndex)
+  sql.query({
+    name: `eh_rollback_${entityIndex->Belt.Int.toString}`,
+    text: `DELETE FROM "${pgSchema}"."${tableName}" WHERE "${checkpointIdFieldName}" > $1;`,
+    values: [rollbackTargetCheckpointId->BigInt.toString]->(Utils.magic: array<string> => array<unknown>),
+  })
   ->Promise.ignoreValue
 }

package/src/db/EntityHistory.res.mjs

@@ -81,7 +81,11 @@ function makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema) {
 }
 
 function pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, safeCheckpointId) {
-  return sql.unsafe(makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema), [safeCheckpointId.toString()], {prepare: true});
+  return sql.query({
+              text: makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema),
+              values: [safeCheckpointId.toString()],
+              name: "eh_prune_" + String(entityIndex)
+            });
 }
 
 function makeBackfillHistoryQuery(pgSchema, entityName, entityIndex) {
@@ -90,11 +94,20 @@ function makeBackfillHistoryQuery(pgSchema, entityName, entityIndex) {
 }
 
 function backfillHistory(sql, pgSchema, entityName, entityIndex, ids) {
-  return sql.unsafe(makeBackfillHistoryQuery(pgSchema, entityName, entityIndex), [ids], {prepare: true});
+  return sql.query({
+              text: makeBackfillHistoryQuery(pgSchema, entityName, entityIndex),
+              values: [ids],
+              name: "eh_backfill_" + String(entityIndex)
+            });
 }
 
 function rollback(sql, pgSchema, entityName, entityIndex, rollbackTargetCheckpointId) {
-  return sql.unsafe("DELETE FROM \"" + pgSchema + "\".\"" + historyTableName(entityName, entityIndex) + "\" WHERE \"" + checkpointIdFieldName + "\" > $1;", [rollbackTargetCheckpointId.toString()], {prepare: true});
+  var tableName = historyTableName(entityName, entityIndex);
+  return sql.query({
+              text: "DELETE FROM \"" + pgSchema + "\".\"" + tableName + "\" WHERE \"" + checkpointIdFieldName + "\" > $1;",
+              values: [rollbackTargetCheckpointId.toString()],
+              name: "eh_rollback_" + String(entityIndex)
+            });
 }
 
 var checkpointIdFieldType = "UInt64";

package/src/db/InternalTable.res

@@ -199,10 +199,9 @@ WHERE "${(#id: field :> string)}" = $1;`
 FROM "${pgSchema}"."${table.tableName}" as chains;`
   }
 
-  let getInitialState = (sql, ~pgSchema) => {
-    sql
-    ->Postgres.unsafe(makeGetInitialStateQuery(~pgSchema))
-    ->(Utils.magic: promise<array<unknown>> => promise<array<rawInitialState>>)
+  let getInitialState = (sql: Pg.sql, ~pgSchema) => {
+    sql.query({text: makeGetInitialStateQuery(~pgSchema)})
+    ->Promise.thenResolve(r => r.rows->(Utils.magic: array<unknown> => array<rawInitialState>))
   }
 
   let progressFields: array<progressFields> = [#progress_block, #events_processed, #source_block]
@@ -219,7 +218,7 @@ SET ${setClauses->Js.Array2.joinWith(",\n    ")}
 WHERE "id" = $1;`
   }
 
-  let setMeta = (sql, ~pgSchema, ~chainsData: dict<metaFields>) => {
+  let setMeta = (sql: Pg.sql, ~pgSchema, ~chainsData: dict<metaFields>) => {
     let query = makeMetaFieldsUpdateQuery(~pgSchema)
 
     let promises = []
@@ -237,7 +236,7 @@ WHERE "id" = $1;`
         params->Js.Array2.push(value)->ignore
       })
 
-      promises->Js.Array2.push(sql->Postgres.preparedUnsafe(query, params->Obj.magic))->ignore
+      promises->Js.Array2.push(sql.query({name: "chains_set_meta", text: query, values: params->Obj.magic}))->ignore
     })
 
     Promise.all(promises)
@@ -250,7 +249,7 @@ WHERE "id" = $1;`
     totalEventsProcessed: float,
   }
 
-  let setProgressedChains = (sql, ~pgSchema, ~progressedChains: array<progressedChain>) => {
+  let setProgressedChains = (sql: Pg.sql, ~pgSchema, ~progressedChains: array<progressedChain>) => {
     let query = makeProgressFieldsUpdateQuery(~pgSchema)
 
     let promises = []
@@ -274,7 +273,7 @@ WHERE "id" = $1;`
         ->ignore
       })
 
-      promises->Js.Array2.push(sql->Postgres.preparedUnsafe(query, params->Obj.magic))->ignore
+      promises->Js.Array2.push(sql.query({name: "chains_set_progress", text: query, values: params->Obj.magic}))->ignore
     })
 
     Promise.all(promises)->Promise.ignoreValue
@@ -380,11 +379,11 @@ WHERE cp."${(#block_hash: field :> string)}" IS NOT NULL
 
   let makeInsertCheckpointQuery = (~pgSchema) => {
     `INSERT INTO "${pgSchema}"."${table.tableName}" ("${(#id: field :> string)}", "${(#chain_id: field :> string)}", "${(#block_number: field :> string)}", "${(#block_hash: field :> string)}", "${(#events_processed: field :> string)}")
-SELECT * FROM unnest($1::${(BigInt: Postgres.columnType :> string)}[],$2::${(Integer: Postgres.columnType :> string)}[],$3::${(Integer: Postgres.columnType :> string)}[],$4::${(Text: Postgres.columnType :> string)}[],$5::${(Integer: Postgres.columnType :> string)}[]);`
+SELECT * FROM unnest($1::${(BigInt: Pg.columnType :> string)}[],$2::${(Integer: Pg.columnType :> string)}[],$3::${(Integer: Pg.columnType :> string)}[],$4::${(Text: Pg.columnType :> string)}[],$5::${(Integer: Pg.columnType :> string)}[]);`
   }
 
   let insert = (
-    sql,
+    sql: Pg.sql,
     ~pgSchema,
     ~checkpointIds,
     ~checkpointChainIds,
@@ -396,10 +395,10 @@ SELECT * FROM unnest($1::${(BigInt: Postgres.columnType :> string)}[],$2::${(Int
 
     // Convert bigint arrays to string arrays for postgres driver compatibility
     let checkpointIdStrings = checkpointIds->BigInt.arrayToStringArray
-    sql
-    ->Postgres.preparedUnsafe(
-      query,
-      (
+    sql.query({
+      name: "checkpoints_insert",
+      text: query,
+      values: (
         checkpointIdStrings,
         checkpointChainIds,
         checkpointBlockNumbers,
@@ -408,18 +407,18 @@ SELECT * FROM unnest($1::${(BigInt: Postgres.columnType :> string)}[],$2::${(Int
       )->(
         Utils.magic: (
           (array<string>, array<int>, array<int>, array<Js.Null.t<string>>, array<int>)
-        ) => unknown
+        ) => array<unknown>
       ),
-    )
+    })
     ->Promise.ignoreValue
   }
 
-  let rollback = (sql, ~pgSchema, ~rollbackTargetCheckpointId: Internal.checkpointId) => {
-    sql
-    ->Postgres.preparedUnsafe(
-      `DELETE FROM "${pgSchema}"."${table.tableName}" WHERE "${(#id: field :> string)}" > $1;`,
-      [rollbackTargetCheckpointId->BigInt.toString]->(Utils.magic: array<string> => unknown),
-    )
+  let rollback = (sql: Pg.sql, ~pgSchema, ~rollbackTargetCheckpointId: Internal.checkpointId) => {
+    sql.query({
+      name: "checkpoints_rollback",
+      text: `DELETE FROM "${pgSchema}"."${table.tableName}" WHERE "${(#id: field :> string)}" > $1;`,
+      values: [rollbackTargetCheckpointId->BigInt.toString]->(Utils.magic: array<string> => array<unknown>),
+    })
     ->Promise.ignoreValue
   }
 
@@ -427,12 +426,12 @@ SELECT * FROM unnest($1::${(BigInt: Postgres.columnType :> string)}[],$2::${(Int
     `DELETE FROM "${pgSchema}"."${table.tableName}" WHERE "${(#id: field :> string)}" < $1;`
   }
 
-  let pruneStaleCheckpoints = (sql, ~pgSchema, ~safeCheckpointId: bigint) => {
-    sql
-    ->Postgres.preparedUnsafe(
-      makePruneStaleCheckpointsQuery(~pgSchema),
-      [safeCheckpointId->BigInt.toString]->Obj.magic,
-    )
+  let pruneStaleCheckpoints = (sql: Pg.sql, ~pgSchema, ~safeCheckpointId: bigint) => {
+    sql.query({
+      name: "checkpoints_prune",
+      text: makePruneStaleCheckpointsQuery(~pgSchema),
+      values: [safeCheckpointId->BigInt.toString]->Obj.magic,
+    })
     ->Promise.ignoreValue
   }
 
@@ -446,25 +445,24 @@ LIMIT 1;`
   }
 
   let getRollbackTargetCheckpoint = (
-    sql,
+    sql: Pg.sql,
     ~pgSchema,
     ~reorgChainId: int,
     ~lastKnownValidBlockNumber: int,
   ) => {
-    let rawResult: promise<array<{"id": string}>> =
-      sql
-      ->Postgres.preparedUnsafe(
-        makeGetRollbackTargetCheckpointQuery(~pgSchema),
-        (reorgChainId, lastKnownValidBlockNumber)->Obj.magic,
-      )
-      ->(Utils.magic: promise<unknown> => promise<array<{"id": string}>>)
-    rawResult->Promise.thenResolve(rows => {
+    sql.query({
+      name: "checkpoints_rollback_target",
+      text: makeGetRollbackTargetCheckpointQuery(~pgSchema),
+      values: (reorgChainId, lastKnownValidBlockNumber)->Obj.magic,
+    })
+    ->Promise.thenResolve(r => {
+      let rows = r.rows->(Utils.magic: array<unknown> => array<{"id": string}>)
       rows->Belt.Array.get(0)->Belt.Option.map(row => row["id"]->BigInt.fromStringUnsafe)
     })
   }
 
   let makeGetRollbackProgressDiffQuery = (~pgSchema) => {
-    `SELECT 
+    `SELECT
   "${(#chain_id: field :> string)}",
   SUM("${(#events_processed: field :> string)}") as events_processed_diff,
   MIN("${(#block_number: field :> string)}") - 1 as new_progress_block_number
@@ -474,23 +472,23 @@ GROUP BY "${(#chain_id: field :> string)}";`
   }
 
   let getRollbackProgressDiff = (
-    sql,
+    sql: Pg.sql,
     ~pgSchema,
     ~rollbackTargetCheckpointId: Internal.checkpointId,
   ) => {
-    sql
-    ->Postgres.preparedUnsafe(
-      makeGetRollbackProgressDiffQuery(~pgSchema),
-      [rollbackTargetCheckpointId->BigInt.toString]->Obj.magic,
-    )
-    ->(
-      Utils.magic: promise<unknown> => promise<
-        array<{
+    sql.query({
+      name: "checkpoints_rollback_diff",
+      text: makeGetRollbackProgressDiffQuery(~pgSchema),
+      values: [rollbackTargetCheckpointId->BigInt.toString]->Obj.magic,
+    })
+    ->Promise.thenResolve(r =>
+      r.rows->(
+        Utils.magic: array<unknown> => array<{
           "chain_id": int,
           "events_processed_diff": string,
           "new_progress_block_number": int,
-        }>,
-      >
+        }>
+      )
     )
   }
 }