envio 2.32.1 → 3.0.0-alpha-main-clickhouse-sink

package/src/db/EntityHistory.res

@@ -5,41 +5,47 @@ module RowAction = {
   let variants = [SET, DELETE]
   let name = "ENVIO_HISTORY_CHANGE"
   let schema = S.enum(variants)
-}
-
-type entityUpdateAction<'entityType> =
-  | Set('entityType)
-  | Delete
-
-type entityUpdate<'entityType> = {
-  entityId: string,
-  entityUpdateAction: entityUpdateAction<'entityType>,
-  checkpointId: int,
+  let config: Table.enumConfig<t> = {
+    name,
+    variants,
+    schema,
+  }
 }
 
 // Prefix with envio_ to avoid colleasions
 let changeFieldName = "envio_change"
-let checkpointIdFieldName = "checkpoint_id"
+let checkpointIdFieldName = "envio_checkpoint_id"
+let checkpointIdFieldType = Uint32
+let changeFieldType = Enum({config: RowAction.config->Table.fromGenericEnumConfig})
+
+let unsafeCheckpointIdSchema =
+  S.string
+  ->S.setName("CheckpointId")
+  ->S.transform(s => {
+    parser: string =>
+      switch string->Belt.Float.fromString {
+      | Some(float) => float
+      | None => s.fail("The string is not valid CheckpointId")
+      },
+    serializer: float => float->Belt.Float.toString,
+  })
 
-let makeSetUpdateSchema: S.t<'entity> => S.t<entityUpdate<'entity>> = entitySchema => {
+let makeSetUpdateSchema: S.t<'entity> => S.t<Change.t<'entity>> = entitySchema => {
   S.object(s => {
     s.tag(changeFieldName, RowAction.SET)
-    {
-      checkpointId: s.field(checkpointIdFieldName, S.int),
-      entityId: s.field("id", S.string),
-      entityUpdateAction: Set(s.flatten(entitySchema)),
-    }
+    Change.Set({
+      checkpointId: s.field(checkpointIdFieldName, unsafeCheckpointIdSchema),
+      entityId: s.field(Table.idFieldName, S.string),
+      entity: s.flatten(entitySchema),
+    })
   })
 }
 
-type t<'entity> = {
-  table: table,
-  setUpdateSchema: S.t<entityUpdate<'entity>>,
+type pgEntityHistory<'entity> = {
+  table: Table.table,
+  setChangeSchema: S.t<Change.t<'entity>>,
   // Used for parsing
-  setUpdateSchemaRows: S.t<array<entityUpdate<'entity>>>,
-  makeInsertDeleteUpdatesQuery: (~pgSchema: string) => string,
-  makeGetRollbackRemovedIdsQuery: (~pgSchema: string) => string,
-  makeGetRollbackRestoredEntitiesQuery: (~pgSchema: string) => string,
+  setChangeSchemaRows: S.t<array<Change.t<'entity>>>,
 }
 
 let maxPgTableNameLength = 63
@@ -55,120 +61,6 @@ let historyTableName = (~entityName, ~entityIndex) => {
   }
 }
 
-let fromTable = (table: table, ~schema: S.t<'entity>, ~entityIndex): t<'entity> => {
-  let id = "id"
-
-  let dataFields = table.fields->Belt.Array.keepMap(field =>
-    switch field {
-    | Field(field) =>
-      switch field.fieldName {
-      //id is not nullable and should be part of the pk
-      | "id" => {...field, fieldName: id, isPrimaryKey: true}->Field->Some
-      | _ =>
-        {
-          ...field,
-          isNullable: true, //All entity fields are nullable in the case
-          isIndex: false, //No need to index any additional entity data fields in entity history
-        }
-        ->Field
-        ->Some
-      }
-
-    | DerivedFrom(_) => None
-    }
-  )
-
-  let actionField = mkField(changeFieldName, Custom(RowAction.name), ~fieldSchema=S.never)
-
-  let checkpointIdField = mkField(
-    checkpointIdFieldName,
-    Integer,
-    ~fieldSchema=S.int,
-    ~isPrimaryKey=true,
-  )
-
-  let entityTableName = table.tableName
-  let historyTableName = historyTableName(~entityName=entityTableName, ~entityIndex)
-  //ignore composite indices
-  let table = mkTable(
-    historyTableName,
-    ~fields=dataFields->Belt.Array.concat([checkpointIdField, actionField]),
-  )
-
-  let setUpdateSchema = makeSetUpdateSchema(schema)
-
-  let makeInsertDeleteUpdatesQuery = {
-    // Get all field names for the INSERT statement
-    let allFieldNames = table.fields->Belt.Array.map(field => field->getFieldName)
-    let allFieldNamesStr =
-      allFieldNames->Belt.Array.map(name => `"${name}"`)->Js.Array2.joinWith(", ")
-
-    // Build the SELECT part: id from unnest, checkpoint_id from unnest, 'DELETE' for action, NULL for all other fields
-    let selectParts = allFieldNames->Belt.Array.map(fieldName => {
-      switch fieldName {
-      | "id" => "u.id"
-      | field if field == checkpointIdFieldName => "u.checkpoint_id"
-      | field if field == changeFieldName => "'DELETE'"
-      | _ => "NULL"
-      }
-    })
-    let selectPartsStr = selectParts->Js.Array2.joinWith(", ")
-    (~pgSchema) => {
-      `INSERT INTO "${pgSchema}"."${historyTableName}" (${allFieldNamesStr})
-SELECT ${selectPartsStr}
-FROM UNNEST($1::text[], $2::int[]) AS u(id, checkpoint_id)`
-    }
-  }
-
-  // Get data field names for rollback queries (exclude changeFieldName and checkpointIdFieldName)
-  let dataFieldNames =
-    table.fields
-    ->Belt.Array.map(field => field->getFieldName)
-    ->Belt.Array.keep(fieldName =>
-      fieldName != changeFieldName && fieldName != checkpointIdFieldName
-    )
-  let dataFieldsCommaSeparated =
-    dataFieldNames->Belt.Array.map(name => `"${name}"`)->Js.Array2.joinWith(", ")
-
-  // Returns entity IDs that were created after the rollback target and have no history before it.
-  // These entities should be deleted during rollback.
-  let makeGetRollbackRemovedIdsQuery = (~pgSchema) => {
-    `SELECT DISTINCT id
-FROM "${pgSchema}"."${historyTableName}"
-WHERE "${checkpointIdFieldName}" > $1
-  AND NOT EXISTS (
-    SELECT 1
-    FROM "${pgSchema}"."${historyTableName}" h
-    WHERE h.id = "${historyTableName}".id
-      AND h."${checkpointIdFieldName}" <= $1
-  )`
-  }
-
-  // Returns the most recent entity state for IDs that need to be restored during rollback.
-  // For each ID modified after the rollback target, retrieves its latest state at or before the target.
-  let makeGetRollbackRestoredEntitiesQuery = (~pgSchema) => {
-    `SELECT DISTINCT ON (id) ${dataFieldsCommaSeparated}
-FROM "${pgSchema}"."${historyTableName}"
-WHERE "${checkpointIdFieldName}" <= $1
-  AND EXISTS (
-    SELECT 1
-    FROM "${pgSchema}"."${historyTableName}" h
-    WHERE h.id = "${historyTableName}".id
-      AND h."${checkpointIdFieldName}" > $1
-  )
-ORDER BY id, "${checkpointIdFieldName}" DESC`
-  }
-
-  {
-    table,
-    setUpdateSchema,
-    setUpdateSchemaRows: S.array(setUpdateSchema),
-    makeInsertDeleteUpdatesQuery,
-    makeGetRollbackRemovedIdsQuery,
-    makeGetRollbackRestoredEntitiesQuery,
-  }
-}
-
 type safeReorgBlocks = {
   chainIds: array<int>,
   blockNumbers: array<int>,
@@ -225,11 +117,11 @@ let pruneStaleEntityHistory = (
 }
 
 // If an entity doesn't have a history before the update
-// we create it automatically with checkpoint_id 0
+// we create it automatically with envio_checkpoint_id 0
 let makeBackfillHistoryQuery = (~pgSchema, ~entityName, ~entityIndex) => {
   let historyTableRef = `"${pgSchema}"."${historyTableName(~entityName, ~entityIndex)}"`
   `WITH target_ids AS (
-  SELECT UNNEST($1::${(Text: Table.fieldType :> string)}[]) AS id
+  SELECT UNNEST($1::${(Text: Postgres.columnType :> string)}[]) AS id
 ),
 missing_history AS (
   SELECT e.*
@@ -252,22 +144,7 @@ let backfillHistory = (sql, ~pgSchema, ~entityName, ~entityIndex, ~ids: array<st
   ->Promise.ignoreValue
 }
 
-let insertDeleteUpdates = (
-  sql,
-  ~pgSchema,
-  ~entityHistory,
-  ~batchDeleteEntityIds,
-  ~batchDeleteCheckpointIds,
-) => {
-  sql
-  ->Postgres.preparedUnsafe(
-    entityHistory.makeInsertDeleteUpdatesQuery(~pgSchema),
-    (batchDeleteEntityIds, batchDeleteCheckpointIds)->Obj.magic,
-  )
-  ->Promise.ignoreValue
-}
-
-let rollback = (sql, ~pgSchema, ~entityName, ~entityIndex, ~rollbackTargetCheckpointId: int) => {
+let rollback = (sql, ~pgSchema, ~entityName, ~entityIndex, ~rollbackTargetCheckpointId: float) => {
   sql
   ->Postgres.preparedUnsafe(
     `DELETE FROM "${pgSchema}"."${historyTableName(

package/src/db/EntityHistory.res.js

@@ -3,7 +3,7 @@
 
 var Table = require("./Table.res.js");
 var Js_string = require("rescript/lib/js/js_string.js");
-var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var Belt_Float = require("rescript/lib/js/belt_Float.js");
 var S$RescriptSchema = require("rescript-schema/src/S.res.js");
 
 var variants = [
@@ -15,26 +15,52 @@ var name = "ENVIO_HISTORY_CHANGE";
 
 var schema = S$RescriptSchema.$$enum(variants);
 
+var config = {
+  name: name,
+  variants: variants,
+  schema: schema
+};
+
 var RowAction = {
   variants: variants,
   name: name,
-  schema: schema
+  schema: schema,
+  config: config
 };
 
 var changeFieldName = "envio_change";
 
-var checkpointIdFieldName = "checkpoint_id";
+var checkpointIdFieldName = "envio_checkpoint_id";
+
+var changeFieldType = {
+  type: "Enum",
+  config: config
+};
+
+var unsafeCheckpointIdSchema = S$RescriptSchema.transform(S$RescriptSchema.setName(S$RescriptSchema.string, "CheckpointId"), (function (s) {
+        return {
+                p: (function (string) {
+                    var $$float = Belt_Float.fromString(string);
+                    if ($$float !== undefined) {
+                      return $$float;
+                    } else {
+                      return s.fail("The string is not valid CheckpointId", undefined);
+                    }
+                  }),
+                s: (function ($$float) {
+                    return String($$float);
+                  })
+              };
+      }));
 
 function makeSetUpdateSchema(entitySchema) {
   return S$RescriptSchema.object(function (s) {
               s.tag(changeFieldName, "SET");
               return {
-                      entityId: s.f("id", S$RescriptSchema.string),
-                      entityUpdateAction: {
-                        TAG: "Set",
-                        _0: s.flatten(entitySchema)
-                      },
-                      checkpointId: s.f(checkpointIdFieldName, S$RescriptSchema.$$int)
+                      type: "SET",
+                      entityId: s.f(Table.idFieldName, S$RescriptSchema.string),
+                      entity: s.flatten(entitySchema),
+                      checkpointId: s.f(checkpointIdFieldName, unsafeCheckpointIdSchema)
                     };
             });
 }
@@ -50,103 +76,6 @@ function historyTableName(entityName, entityIndex) {
   return Js_string.slice(0, 63 - entityIndexStr.length | 0, fullName) + entityIndexStr;
 }
 
-function fromTable(table, schema, entityIndex) {
-  var dataFields = Belt_Array.keepMap(table.fields, (function (field) {
-          if (field.TAG !== "Field") {
-            return ;
-          }
-          var field$1 = field._0;
-          var match = field$1.fieldName;
-          if (match === "id") {
-            return {
-                    TAG: "Field",
-                    _0: {
-                      fieldName: "id",
-                      fieldType: field$1.fieldType,
-                      fieldSchema: field$1.fieldSchema,
-                      isArray: field$1.isArray,
-                      isNullable: field$1.isNullable,
-                      isPrimaryKey: true,
-                      isIndex: field$1.isIndex,
-                      linkedEntity: field$1.linkedEntity,
-                      defaultValue: field$1.defaultValue
-                    }
-                  };
-          } else {
-            return {
-                    TAG: "Field",
-                    _0: {
-                      fieldName: field$1.fieldName,
-                      fieldType: field$1.fieldType,
-                      fieldSchema: field$1.fieldSchema,
-                      isArray: field$1.isArray,
-                      isNullable: true,
-                      isPrimaryKey: field$1.isPrimaryKey,
-                      isIndex: false,
-                      linkedEntity: field$1.linkedEntity,
-                      defaultValue: field$1.defaultValue
-                    }
-                  };
-          }
-        }));
-  var actionField = Table.mkField(changeFieldName, name, S$RescriptSchema.never, undefined, undefined, undefined, undefined, undefined, undefined);
-  var checkpointIdField = Table.mkField(checkpointIdFieldName, "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, true, undefined, undefined);
-  var entityTableName = table.tableName;
-  var historyTableName$1 = historyTableName(entityTableName, entityIndex);
-  var table$1 = Table.mkTable(historyTableName$1, undefined, Belt_Array.concat(dataFields, [
-            checkpointIdField,
-            actionField
-          ]));
-  var setUpdateSchema = makeSetUpdateSchema(schema);
-  var allFieldNames = Belt_Array.map(table$1.fields, (function (field) {
-          return Table.getFieldName(field);
-        }));
-  var allFieldNamesStr = Belt_Array.map(allFieldNames, (function (name) {
-            return "\"" + name + "\"";
-          })).join(", ");
-  var selectParts = Belt_Array.map(allFieldNames, (function (fieldName) {
-          if (fieldName === "id") {
-            return "u.id";
-          } else if (fieldName === checkpointIdFieldName) {
-            return "u.checkpoint_id";
-          } else if (fieldName === changeFieldName) {
-            return "'DELETE'";
-          } else {
-            return "NULL";
-          }
-        }));
-  var selectPartsStr = selectParts.join(", ");
-  var makeInsertDeleteUpdatesQuery = function (pgSchema) {
-    return "INSERT INTO \"" + pgSchema + "\".\"" + historyTableName$1 + "\" (" + allFieldNamesStr + ")\nSELECT " + selectPartsStr + "\nFROM UNNEST($1::text[], $2::int[]) AS u(id, checkpoint_id)";
-  };
-  var dataFieldNames = Belt_Array.keep(Belt_Array.map(table$1.fields, (function (field) {
-              return Table.getFieldName(field);
-            })), (function (fieldName) {
-          if (fieldName !== changeFieldName) {
-            return fieldName !== checkpointIdFieldName;
-          } else {
-            return false;
-          }
-        }));
-  var dataFieldsCommaSeparated = Belt_Array.map(dataFieldNames, (function (name) {
-            return "\"" + name + "\"";
-          })).join(", ");
-  var makeGetRollbackRemovedIdsQuery = function (pgSchema) {
-    return "SELECT DISTINCT id\nFROM \"" + pgSchema + "\".\"" + historyTableName$1 + "\"\nWHERE \"" + checkpointIdFieldName + "\" > $1\n  AND NOT EXISTS (\n    SELECT 1\n    FROM \"" + pgSchema + "\".\"" + historyTableName$1 + "\" h\n    WHERE h.id = \"" + historyTableName$1 + "\".id\n      AND h.\"" + checkpointIdFieldName + "\" <= $1\n  )";
-  };
-  var makeGetRollbackRestoredEntitiesQuery = function (pgSchema) {
-    return "SELECT DISTINCT ON (id) " + dataFieldsCommaSeparated + "\nFROM \"" + pgSchema + "\".\"" + historyTableName$1 + "\"\nWHERE \"" + checkpointIdFieldName + "\" <= $1\n  AND EXISTS (\n    SELECT 1\n    FROM \"" + pgSchema + "\".\"" + historyTableName$1 + "\" h\n    WHERE h.id = \"" + historyTableName$1 + "\".id\n      AND h.\"" + checkpointIdFieldName + "\" > $1\n  )\nORDER BY id, \"" + checkpointIdFieldName + "\" DESC";
-  };
-  return {
-          table: table$1,
-          setUpdateSchema: setUpdateSchema,
-          setUpdateSchemaRows: S$RescriptSchema.array(setUpdateSchema),
-          makeInsertDeleteUpdatesQuery: makeInsertDeleteUpdatesQuery,
-          makeGetRollbackRemovedIdsQuery: makeGetRollbackRemovedIdsQuery,
-          makeGetRollbackRestoredEntitiesQuery: makeGetRollbackRestoredEntitiesQuery
-        };
-}
-
 function makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema) {
   var historyTableRef = "\"" + pgSchema + "\".\"" + historyTableName(entityName, entityIndex) + "\"";
   return "WITH anchors AS (\n  SELECT t.id, MAX(t." + checkpointIdFieldName + ") AS keep_checkpoint_id\n  FROM " + historyTableRef + " t WHERE t." + checkpointIdFieldName + " <= $1\n  GROUP BY t.id\n)\nDELETE FROM " + historyTableRef + " d\nUSING anchors a\nWHERE d.id = a.id\n  AND (\n    d." + checkpointIdFieldName + " < a.keep_checkpoint_id\n    OR (\n      d." + checkpointIdFieldName + " = a.keep_checkpoint_id AND\n      NOT EXISTS (\n        SELECT 1 FROM " + historyTableRef + " ps \n        WHERE ps.id = d.id AND ps." + checkpointIdFieldName + " > $1\n      ) \n    )\n  );";
@@ -165,31 +94,27 @@ function backfillHistory(sql, pgSchema, entityName, entityIndex, ids) {
   return sql.unsafe(makeBackfillHistoryQuery(pgSchema, entityName, entityIndex), [ids], {prepare: true});
 }
 
-function insertDeleteUpdates(sql, pgSchema, entityHistory, batchDeleteEntityIds, batchDeleteCheckpointIds) {
-  return sql.unsafe(entityHistory.makeInsertDeleteUpdatesQuery(pgSchema), [
-              batchDeleteEntityIds,
-              batchDeleteCheckpointIds
-            ], {prepare: true});
-}
-
 function rollback(sql, pgSchema, entityName, entityIndex, rollbackTargetCheckpointId) {
   return sql.unsafe("DELETE FROM \"" + pgSchema + "\".\"" + historyTableName(entityName, entityIndex) + "\" WHERE \"" + checkpointIdFieldName + "\" > $1;", [rollbackTargetCheckpointId], {prepare: true});
 }
 
+var checkpointIdFieldType = "Uint32";
+
 var maxPgTableNameLength = 63;
 
 exports.RowAction = RowAction;
 exports.changeFieldName = changeFieldName;
 exports.checkpointIdFieldName = checkpointIdFieldName;
+exports.checkpointIdFieldType = checkpointIdFieldType;
+exports.changeFieldType = changeFieldType;
+exports.unsafeCheckpointIdSchema = unsafeCheckpointIdSchema;
 exports.makeSetUpdateSchema = makeSetUpdateSchema;
 exports.maxPgTableNameLength = maxPgTableNameLength;
 exports.historyTablePrefix = historyTablePrefix;
 exports.historyTableName = historyTableName;
-exports.fromTable = fromTable;
 exports.makePruneStaleEntityHistoryQuery = makePruneStaleEntityHistoryQuery;
 exports.pruneStaleEntityHistory = pruneStaleEntityHistory;
 exports.makeBackfillHistoryQuery = makeBackfillHistoryQuery;
 exports.backfillHistory = backfillHistory;
-exports.insertDeleteUpdates = insertDeleteUpdates;
 exports.rollback = rollback;
 /* schema Not a pure module */

package/src/db/InternalTable.res

@@ -46,21 +46,19 @@ module DynamicContractRegistry = {
   let table = mkTable(
     name,
     ~fields=[
-      mkField("id", Text, ~isPrimaryKey, ~fieldSchema=S.string),
-      mkField("chain_id", Integer, ~fieldSchema=S.int),
-      mkField("registering_event_block_number", Integer, ~fieldSchema=S.int),
-      mkField("registering_event_log_index", Integer, ~fieldSchema=S.int),
-      mkField("registering_event_block_timestamp", Integer, ~fieldSchema=S.int),
-      mkField("registering_event_contract_name", Text, ~fieldSchema=S.string),
-      mkField("registering_event_name", Text, ~fieldSchema=S.string),
-      mkField("registering_event_src_address", Text, ~fieldSchema=Address.schema),
-      mkField("contract_address", Text, ~fieldSchema=Address.schema),
-      mkField("contract_name", Text, ~fieldSchema=S.string),
+      mkField("id", String, ~isPrimaryKey, ~fieldSchema=S.string),
+      mkField("chain_id", Int32, ~fieldSchema=S.int),
+      mkField("registering_event_block_number", Int32, ~fieldSchema=S.int),
+      mkField("registering_event_log_index", Int32, ~fieldSchema=S.int),
+      mkField("registering_event_block_timestamp", Int32, ~fieldSchema=S.int),
+      mkField("registering_event_contract_name", String, ~fieldSchema=S.string),
+      mkField("registering_event_name", String, ~fieldSchema=S.string),
+      mkField("registering_event_src_address", String, ~fieldSchema=Address.schema),
+      mkField("contract_address", String, ~fieldSchema=Address.schema),
+      mkField("contract_name", String, ~fieldSchema=S.string),
     ],
   )
 
-  let entityHistory = table->EntityHistory.fromTable(~schema, ~entityIndex=index)
-
   external castToInternal: t => Internal.entity = "%identity"
 
   let config = {
@@ -69,7 +67,6 @@ module DynamicContractRegistry = {
     schema,
     rowsSchema,
     table,
-    entityHistory,
   }->Internal.fromGenericEntityConfig
 }
 
@@ -131,19 +128,19 @@ module Chains = {
   let table = mkTable(
     "envio_chains",
     ~fields=[
-      mkField((#id: field :> string), Integer, ~fieldSchema=S.int, ~isPrimaryKey),
+      mkField((#id: field :> string), Int32, ~fieldSchema=S.int, ~isPrimaryKey),
       // Values populated from config
-      mkField((#start_block: field :> string), Integer, ~fieldSchema=S.int),
-      mkField((#end_block: field :> string), Integer, ~fieldSchema=S.null(S.int), ~isNullable),
-      mkField((#max_reorg_depth: field :> string), Integer, ~fieldSchema=S.int),
+      mkField((#start_block: field :> string), Int32, ~fieldSchema=S.int),
+      mkField((#end_block: field :> string), Int32, ~fieldSchema=S.null(S.int), ~isNullable),
+      mkField((#max_reorg_depth: field :> string), Int32, ~fieldSchema=S.int),
       // Block number of the latest block that was fetched from the source
-      mkField((#buffer_block: field :> string), Integer, ~fieldSchema=S.int),
+      mkField((#buffer_block: field :> string), Int32, ~fieldSchema=S.int),
       // Block number of the currently active source
-      mkField((#source_block: field :> string), Integer, ~fieldSchema=S.int),
+      mkField((#source_block: field :> string), Int32, ~fieldSchema=S.int),
       // Block number of the first event that was processed for this chain
       mkField(
         (#first_event_block: field :> string),
-        Integer,
+        Int32,
         ~fieldSchema=S.null(S.int),
         ~isNullable,
       ),
@@ -151,17 +148,17 @@ module Chains = {
       // null during historical sync, set to current time when sync is complete
       mkField(
         (#ready_at: field :> string),
-        TimestampWithNullTimezone,
+        Date,
         ~fieldSchema=S.null(Utils.Schema.dbDate),
         ~isNullable,
       ),
-      mkField((#events_processed: field :> string), Integer, ~fieldSchema=S.int),
+      mkField((#events_processed: field :> string), Int32, ~fieldSchema=S.int),
       // TODO: In the future it should reference a table with sources
       mkField((#_is_hyper_sync: field :> string), Boolean, ~fieldSchema=S.bool),
       // Fully processed block number
-      mkField((#progress_block: field :> string), Integer, ~fieldSchema=S.int),
+      mkField((#progress_block: field :> string), Int32, ~fieldSchema=S.int),
       // TODO: Should deprecate after changing the ETA calculation logic
-      mkField((#_num_batches_fetched: field :> string), Integer, ~fieldSchema=S.int),
+      mkField((#_num_batches_fetched: field :> string), Int32, ~fieldSchema=S.int),
     ],
   )
 
@@ -368,11 +365,11 @@ module PersistedState = {
     "persisted_state",
     ~fields=[
       mkField("id", Serial, ~fieldSchema=S.int, ~isPrimaryKey),
-      mkField("envio_version", Text, ~fieldSchema=S.string),
-      mkField("config_hash", Text, ~fieldSchema=S.string),
-      mkField("schema_hash", Text, ~fieldSchema=S.string),
-      mkField("handler_files_hash", Text, ~fieldSchema=S.string),
-      mkField("abi_files_hash", Text, ~fieldSchema=S.string),
+      mkField("envio_version", String, ~fieldSchema=S.string),
+      mkField("config_hash", String, ~fieldSchema=S.string),
+      mkField("schema_hash", String, ~fieldSchema=S.string),
+      mkField("handler_files_hash", String, ~fieldSchema=S.string),
+      mkField("abi_files_hash", String, ~fieldSchema=S.string),
     ],
   )
 }
@@ -387,7 +384,7 @@ module Checkpoints = {
   ]
 
   type t = {
-    id: int,
+    id: float,
     @as("chain_id")
     chainId: int,
     @as("block_number")
@@ -398,16 +395,16 @@ module Checkpoints = {
     eventsProcessed: int,
   }
 
-  let initialCheckpointId = 0
+  let initialCheckpointId = 0.
 
   let table = mkTable(
     "envio_checkpoints",
     ~fields=[
-      mkField((#id: field :> string), Integer, ~fieldSchema=S.int, ~isPrimaryKey),
-      mkField((#chain_id: field :> string), Integer, ~fieldSchema=S.int),
-      mkField((#block_number: field :> string), Integer, ~fieldSchema=S.int),
-      mkField((#block_hash: field :> string), Text, ~fieldSchema=S.null(S.string), ~isNullable),
-      mkField((#events_processed: field :> string), Integer, ~fieldSchema=S.int),
+      mkField((#id: field :> string), Int32, ~fieldSchema=S.int, ~isPrimaryKey),
+      mkField((#chain_id: field :> string), Int32, ~fieldSchema=S.int),
+      mkField((#block_number: field :> string), Int32, ~fieldSchema=S.int),
+      mkField((#block_hash: field :> string), String, ~fieldSchema=S.null(S.string), ~isNullable),
+      mkField((#events_processed: field :> string), Int32, ~fieldSchema=S.int),
     ],
   )
 
@@ -438,12 +435,12 @@ WHERE cp."${(#block_hash: field :> string)}" IS NOT NULL
   }
 
   let makeCommitedCheckpointIdQuery = (~pgSchema) => {
-    `SELECT COALESCE(MAX(${(#id: field :> string)}), ${initialCheckpointId->Belt.Int.toString}) AS id FROM "${pgSchema}"."${table.tableName}";`
+    `SELECT COALESCE(MAX(${(#id: field :> string)}), ${initialCheckpointId->Belt.Float.toString}) AS id FROM "${pgSchema}"."${table.tableName}";`
   }
 
   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::${(Integer :> string)}[],$2::${(Integer :> string)}[],$3::${(Integer :> string)}[],$4::${(Text :> string)}[],$5::${(Integer :> string)}[]);`
+SELECT * FROM unnest($1::${(Integer: Postgres.columnType :> string)}[],$2::${(Integer: Postgres.columnType :> string)}[],$3::${(Integer: Postgres.columnType :> string)}[],$4::${(Text: Postgres.columnType :> string)}[],$5::${(Integer: Postgres.columnType :> string)}[]);`
   }
 
   let insert = (
@@ -468,14 +465,14 @@ SELECT * FROM unnest($1::${(Integer :> string)}[],$2::${(Integer :> string)}[],$
         checkpointEventsProcessed,
       )->(
         Utils.magic: (
-          (array<int>, array<int>, array<int>, array<Js.Null.t<string>>, array<int>)
+          (array<float>, array<int>, array<int>, array<Js.Null.t<string>>, array<int>)
         ) => unknown
       ),
     )
     ->Promise.ignoreValue
   }
 
-  let rollback = (sql, ~pgSchema, ~rollbackTargetCheckpointId: int) => {
+  let rollback = (sql, ~pgSchema, ~rollbackTargetCheckpointId: Internal.checkpointId) => {
     sql
     ->Postgres.preparedUnsafe(
       `DELETE FROM "${pgSchema}"."${table.tableName}" WHERE "${(#id: field :> string)}" > $1;`,
@@ -488,7 +485,7 @@ SELECT * FROM unnest($1::${(Integer :> string)}[],$2::${(Integer :> string)}[],$
     `DELETE FROM "${pgSchema}"."${table.tableName}" WHERE "${(#id: field :> string)}" < $1;`
   }
 
-  let pruneStaleCheckpoints = (sql, ~pgSchema, ~safeCheckpointId: int) => {
+  let pruneStaleCheckpoints = (sql, ~pgSchema, ~safeCheckpointId: float) => {
     sql
     ->Postgres.preparedUnsafe(
       makePruneStaleCheckpointsQuery(~pgSchema),
@@ -517,7 +514,7 @@ LIMIT 1;`
       makeGetRollbackTargetCheckpointQuery(~pgSchema),
       (reorgChainId, lastKnownValidBlockNumber)->Obj.magic,
     )
-    ->(Utils.magic: promise<unknown> => promise<array<{"id": int}>>)
+    ->(Utils.magic: promise<unknown> => promise<array<{"id": Internal.checkpointId}>>)
   }
 
   let makeGetRollbackProgressDiffQuery = (~pgSchema) => {
@@ -530,7 +527,11 @@ WHERE "${(#id: field :> string)}" > $1
 GROUP BY "${(#chain_id: field :> string)}";`
   }
 
-  let getRollbackProgressDiff = (sql, ~pgSchema, ~rollbackTargetCheckpointId: int) => {
+  let getRollbackProgressDiff = (
+    sql,
+    ~pgSchema,
+    ~rollbackTargetCheckpointId: Internal.checkpointId,
+  ) => {
     sql
     ->Postgres.preparedUnsafe(
       makeGetRollbackProgressDiffQuery(~pgSchema),
@@ -584,18 +585,18 @@ module RawEvents = {
   let table = mkTable(
     "raw_events",
     ~fields=[
-      mkField("chain_id", Integer, ~fieldSchema=S.int),
-      mkField("event_id", Numeric, ~fieldSchema=S.bigint),
-      mkField("event_name", Text, ~fieldSchema=S.string),
-      mkField("contract_name", Text, ~fieldSchema=S.string),
-      mkField("block_number", Integer, ~fieldSchema=S.int),
-      mkField("log_index", Integer, ~fieldSchema=S.int),
-      mkField("src_address", Text, ~fieldSchema=Address.schema),
-      mkField("block_hash", Text, ~fieldSchema=S.string),
-      mkField("block_timestamp", Integer, ~fieldSchema=S.int),
-      mkField("block_fields", JsonB, ~fieldSchema=S.json(~validate=false)),
-      mkField("transaction_fields", JsonB, ~fieldSchema=S.json(~validate=false)),
-      mkField("params", JsonB, ~fieldSchema=S.json(~validate=false)),
+      mkField("chain_id", Int32, ~fieldSchema=S.int),
+      mkField("event_id", BigInt({}), ~fieldSchema=S.bigint),
+      mkField("event_name", String, ~fieldSchema=S.string),
+      mkField("contract_name", String, ~fieldSchema=S.string),
+      mkField("block_number", Int32, ~fieldSchema=S.int),
+      mkField("log_index", Int32, ~fieldSchema=S.int),
+      mkField("src_address", String, ~fieldSchema=Address.schema),
+      mkField("block_hash", String, ~fieldSchema=S.string),
+      mkField("block_timestamp", Int32, ~fieldSchema=S.int),
+      mkField("block_fields", Json, ~fieldSchema=S.json(~validate=false)),
+      mkField("transaction_fields", Json, ~fieldSchema=S.json(~validate=false)),
+      mkField("params", Json, ~fieldSchema=S.json(~validate=false)),
       mkField("serial", Serial, ~isNullable, ~isPrimaryKey, ~fieldSchema=S.null(S.int)),
     ],
   )